《游戏服务端编程实践》10.2.3 社交互动与排行榜

// file: ch10/social/rank.go
// tier: L1
// verify: go test ./ch10/social/

package social

import (
	"sort"
	"sync"
)

// RankEntry 是排行榜对外返回的一行，Rank 采用密集名次：1、1、2，而不是 1、1、3。
type RankEntry struct {
	PlayerID uint64
	Score    int64
	Rank     int
}

type rankItem struct {
	playerID uint64
	score    int64
}

// RankBoard 用有序切片维护分数：写入 O(n)，读取 TopN 只遍历前 N 个元素。
type RankBoard struct {
	mu     sync.Mutex
	season string
	items  []rankItem // 按分数降序，同分按玩家 ID 升序
	scores map[uint64]int64
}

func NewRankBoard(season string) *RankBoard {
	return &RankBoard{season: season, scores: make(map[uint64]int64)}
}

// Update 覆盖玩家分数；已有记录先删除再按新分数插入，避免残留旧位置。
func (b *RankBoard) Update(playerID uint64, score int64) {
	b.mu.Lock()
	defer b.mu.Unlock()
	if i := b.indexOfLocked(playerID); i >= 0 {
		b.items = append(b.items[:i], b.items[i+1:]...)
	}
	b.insertLocked(rankItem{playerID: playerID, score: score})
	b.scores[playerID] = score
}

func (b *RankBoard) Add(playerID uint64, delta int64) int64 {
	b.mu.Lock()
	b.scores[playerID] += delta
	score := b.scores[playerID]
	if i := b.indexOfLocked(playerID); i >= 0 {
		b.items = append(b.items[:i], b.items[i+1:]...)
	}
	b.insertLocked(rankItem{playerID: playerID, score: score})
	b.mu.Unlock()
	return score
}

func (b *RankBoard) Score(playerID uint64) (int64, bool) {
	b.mu.Lock()
	defer b.mu.Unlock()
	score, ok := b.scores[playerID]
	return score, ok
}

// Rank 返回密集名次：同分同名次，下一名只加一。
func (b *RankBoard) Rank(playerID uint64) (int, bool) {
	b.mu.Lock()
	defer b.mu.Unlock()
	rank := 0
	var prev int64
	for i, item := range b.items {
		if i == 0 || item.score != prev {
			rank++
			prev = item.score
		}
		if item.playerID == playerID {
			return rank, true
		}
	}
	return 0, false
}

// Top 返回前 n 名；n 小于等于 0 时返回 nil，n 超过总人数时返回全部。
func (b *RankBoard) Top(n int) []RankEntry {
	b.mu.Lock()
	defer b.mu.Unlock()
	if n <= 0 {
		return nil
	}
	if n > len(b.items) {
		n = len(b.items)
	}
	out := make([]RankEntry, 0, n)
	rank := 0
	var prev int64
	for i, item := range b.items {
		if len(out) == n {
			break
		}
		if i == 0 || item.score != prev {
			rank++
			prev = item.score
		}
		out = append(out, RankEntry{PlayerID: item.playerID, Score: item.score, Rank: rank})
	}
	return out
}

func (b *RankBoard) Len() int {
	b.mu.Lock()
	defer b.mu.Unlock()
	return len(b.items)
}

func (b *RankBoard) Season() string {
	b.mu.Lock()
	defer b.mu.Unlock()
	return b.season
}

// Reset 切换赛季时同时清空分数索引，避免旧赛季分数被下一次 Add 读出来。
func (b *RankBoard) Reset(season string) {
	b.mu.Lock()
	b.season = season
	b.items = nil
	b.scores = make(map[uint64]int64)
	b.mu.Unlock()
}

func (b *RankBoard) indexOfLocked(playerID uint64) int {
	for i := range b.items {
		if b.items[i].playerID == playerID {
			return i
		}
	}
	return -1
}

func (b *RankBoard) insertLocked(item rankItem) {
	i := sort.Search(len(b.items), func(i int) bool {
		if b.items[i].score != item.score {
			return b.items[i].score < item.score
		}
		return b.items[i].playerID > item.playerID
	})
	b.items = append(b.items, rankItem{})
	copy(b.items[i+1:], b.items[i:])
	b.items[i] = item
}

// file: ch10/social/rank_test.go
// tier: L1
// verify: go test ./ch10/social/

package social

import (
	"reflect"
	"testing"
)

func rankIDs(entries []RankEntry) []uint64 {
	out := make([]uint64, len(entries))
	for i, e := range entries {
		out[i] = e.PlayerID
	}
	return out
}

func TestRankTiesUseDenseRanking(t *testing.T) {
	b := NewRankBoard("s1")
	b.Update(1, 100)
	b.Update(2, 100)
	b.Update(3, 90)
	b.Update(4, 90)
	b.Update(5, 80)

	top := b.Top(10)
	if got, want := rankIDs(top), []uint64{1, 2, 3, 4, 5}; !reflect.DeepEqual(got, want) {
		t.Fatalf("order = %v, want %v", got, want)
	}
	wantRanks := []int{1, 1, 2, 2, 3}
	for i, want := range wantRanks {
		if top[i].Rank != want {
			t.Fatalf("rank[%d] = %d, want %d", i, top[i].Rank, want)
		}
	}
	if rank, ok := b.Rank(3); !ok || rank != 2 {
		t.Fatalf("rank(3) = %d, %v", rank, ok)
	}
	if _, ok := b.Rank(99); ok {
		t.Fatal("unknown player should not have a rank")
	}
}

func TestRankUpdateMovesEntry(t *testing.T) {
	b := NewRankBoard("s1")
	b.Update(1, 100)
	b.Update(2, 90)
	b.Update(3, 80)
	b.Update(3, 120)

	if score, _ := b.Score(3); score != 120 {
		t.Fatalf("score(3) = %d, want 120", score)
	}
	if got, want := rankIDs(b.Top(3)), []uint64{3, 1, 2}; !reflect.DeepEqual(got, want) {
		t.Fatalf("order after update = %v, want %v", got, want)
	}
	if rank, _ := b.Rank(1); rank != 2 {
		t.Fatalf("rank(1) = %d, want 2", rank)
	}
	if b.Len() != 3 {
		t.Fatalf("len = %d, want 3", b.Len())
	}
	if got := b.Add(2, 50); got != 140 {
		t.Fatalf("add(2, 50) = %d, want 140", got)
	}
	if got := b.Top(1)[0].PlayerID; got != 2 {
		t.Fatalf("top player = %d, want 2", got)
	}
}

func TestRankTopBounds(t *testing.T) {
	b := NewRankBoard("s1")
	b.Update(1, 10)
	b.Update(2, 20)
	if len(b.Top(0)) != 0 || b.Top(-1) != nil {
		t.Fatal("non-positive n should return nil")
	}
	if got := len(b.Top(100)); got != 2 {
		t.Fatalf("top(100) len = %d, want 2", got)
	}
}

func TestRankResetClearsSeasonData(t *testing.T) {
	b := NewRankBoard("s1")
	b.Update(1, 100)
	b.Reset("s2")
	if b.Season() != "s2" {
		t.Fatalf("season = %q, want s2", b.Season())
	}
	if b.Len() != 0 || len(b.Top(10)) != 0 {
		t.Fatal("reset left entries behind")
	}
	if _, ok := b.Score(1); ok {
		t.Fatal("reset left score index behind")
	}
	if got := b.Add(1, 5); got != 5 {
		t.Fatalf("first add after reset = %d, want 5", got)
	}
}

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

ok  	gspractice/ch10/social	0.293s