《MMO 服务器开发》1.3 本书范围与站内架构文章的分工

// file: internal/scope/scope.go
// tier: L1
// verify: go test ./internal/scope/
// Package scope encodes the division of labour between three bodies of work:
// the site's existing architecture articles ("practice"), volume one's network
// kernel, and this volume's gameplay systems. Section 1.3 explains the split in
// prose; this file makes it queryable, so "which one covers this topic" is an
// assertion a test can fail on rather than a rule nobody re-reads.
package scope

import "strings"

// Volume names which body of work owns a topic.
type Volume string

const (
	// VolumePractice is the site's existing game-server articles: they answer
	// "what should the architecture be, and why", with no runnable code.
	VolumePractice Volume = "practice"
	// VolumeNet is volume one《网络与并发内核》: the wire, codec and transport
	// built from scratch.
	VolumeNet Volume = "vol1-net"
	// VolumeSingle is this volume《单服架构与玩法系统》: gameplay systems built
	// from scratch, with numbers.
	VolumeSingle Volume = "vol2-single"
)

// Rule maps a topic keyword to the volume that owns it. First match wins, so
// order is priority.
type Rule struct {
	Keyword string
	Volume  Volume
}

// rules is the 1.3 split, in code.
var rules = []Rule{
	// Architecture-only topics stay with the existing articles.
	{"分层方案", VolumePractice},
	{"状态归属方案", VolumePractice},
	{"选型对比", VolumePractice},
	{"部署拓扑", VolumePractice},
	// Wire-level topics belong to volume one.
	{"编解码", VolumeNet},
	{"KCP", VolumeNet},
	{"帧切分", VolumeNet},
	{"时间轮", VolumeNet},
	// Gameplay systems belong to this volume.
	{"背包", VolumeSingle},
	{"任务", VolumeSingle},
	{"公会", VolumeSingle},
	{"交易", VolumeSingle},
	{"匹配", VolumeSingle},
	{"掉落", VolumeSingle},
}

// Owner returns the volume responsible for a topic. A topic that matches no
// rule falls back to this volume: its job is exactly "the gameplay systems
// nobody else wrote from scratch", so the default must point here, never away.
func Owner(topic string) Volume {
	for _, r := range rules {
		if strings.Contains(topic, r.Keyword) {
			return r.Volume
		}
	}
	return VolumeSingle
}

// DeferredPaths returns the site paths this volume defers to for a given
// volume. Only section paths under /posts/ are ever returned, because a bare
// single-segment path is a dead link once articles are flattened to /<slug>/.
func DeferredPaths(v Volume) []string {
	switch v {
	case VolumePractice:
		return []string{"/posts/game/server/practice/"}
	case VolumeNet:
		return []string{"/posts/books/网络与并发内核/"}
	default:
		return nil
	}
}

// file: internal/scope/scope_test.go
// tier: L1
// verify: go test ./internal/scope/
package scope

import (
	"strings"
	"testing"
)

func TestOwnerRoutesToPractice(t *testing.T) {
	for _, topic := range []string{"分层方案怎么写", "状态归属方案", "引擎选型对比"} {
		if got := Owner(topic); got != VolumePractice {
			t.Errorf("Owner(%q) = %s, want practice", topic, got)
		}
	}
}

func TestOwnerRoutesToVolumeOne(t *testing.T) {
	for _, topic := range []string{"KCP 重传", "帧切分", "时间轮级联"} {
		if got := Owner(topic); got != VolumeNet {
			t.Errorf("Owner(%q) = %s, want vol1-net", topic, got)
		}
	}
}

func TestOwnerRoutesToThisVolume(t *testing.T) {
	for _, topic := range []string{"背包并发修改", "公会仓库", "交易行竞价"} {
		if got := Owner(topic); got != VolumeSingle {
			t.Errorf("Owner(%q) = %s, want vol2-single", topic, got)
		}
	}
}

func TestFallbackIsThisVolume(t *testing.T) {
	// A topic nobody else claimed is exactly what this volume is for.
	if got := Owner("一个没人写过的话题 xyz"); got != VolumeSingle {
		t.Fatalf("fallback = %s, want vol2-single", got)
	}
}

func TestDeferredPathsAreSectionPaths(t *testing.T) {
	for _, v := range []Volume{VolumePractice, VolumeNet} {
		paths := DeferredPaths(v)
		if len(paths) == 0 {
			t.Fatalf("DeferredPaths(%s) is empty", v)
		}
		for _, p := range paths {
			if !strings.HasPrefix(p, "/posts/") || !strings.HasSuffix(p, "/") {
				t.Errorf("path %q must be a section path under /posts/ ending in /", p)
			}
		}
	}
	// This volume defers to nothing: it is where the from-scratch work lives.
	if got := DeferredPaths(VolumeSingle); got != nil {
		t.Fatalf("DeferredPaths(vol2-single) = %v, want nil", got)
	}
}

=== RUN   TestOwnerRoutesToPractice
--- PASS: TestOwnerRoutesToPractice (0.00s)
=== RUN   TestOwnerRoutesToVolumeOne
--- PASS: TestOwnerRoutesToVolumeOne (0.00s)
=== RUN   TestOwnerRoutesToThisVolume
--- PASS: TestOwnerRoutesToThisVolume (0.00s)
=== RUN   TestFallbackIsThisVolume
--- PASS: TestFallbackIsThisVolume (0.00s)
=== RUN   TestDeferredPathsAreSectionPaths
--- PASS: TestDeferredPathsAreSectionPaths (0.00s)
PASS
ok  	aegis/internal/scope	0.207s