《游戏服务端架构·品类、状态与拓扑》13.2 品类与拓扑决策矩阵

推荐 = 2 分，可选 = 1 分，不推荐 = 0 分
总分 = Σ（特征强度 × 格子分数）

// file: internal/matrix/matrix.go
// tier: L1
// verify: go test ./internal/matrix/
package matrix

import "sort"

type Feature string

const (
	Realtime    Feature = "realtime"
	SharedWorld Feature = "shared-world"
	RoomBased   Feature = "room-based"
	LargeState  Feature = "large-state"
	CrossRegion Feature = "cross-region"
)

var Features = []Feature{Realtime, SharedWorld, RoomBased, LargeState, CrossRegion}

type Topology string

const (
	ModularMonolith Topology = "modular-monolith"
	LobbyRoom       Topology = "lobby-room"
	ShardedWorld    Topology = "sharded-world"
	GlobalShard     Topology = "global-shard"
	DedicatedPool   Topology = "dedicated-server-pool"
)

var Topologies = []Topology{ModularMonolith, LobbyRoom, ShardedWorld, GlobalShard, DedicatedPool}

type Fit int

const (
	NotRecommended Fit = iota
	Optional
	Recommended
)

func (f Fit) String() string {
	return [...]string{"不推荐", "可选", "推荐"}[f]
}

// Cell is one feature/topology intersection. Reason says why the topology does
// or does not support the feature; Cost is paid even when the fit is good.
type Cell struct {
	Fit    Fit
	Reason string
	Cost   string
}

// capability is the reviewed matrix. It is a capability view, not a final
// recommendation: a product combines several rows, and cost breaks ties.
var capability = map[Feature]map[Topology]Cell{
	Realtime: {
		ModularMonolith: {Optional, "单进程也能跑 tick，但没有房间级隔离", "一次停顿影响全部对局"},
		LobbyRoom:       {Recommended, "每间房独占 tick 与输入窗口", "分配器、暖池与排空发布"},
		ShardedWorld:    {Optional, "世界 tick 可以很粗，操作反馈不跟手", "边界迁移与热区扩容"},
		GlobalShard:     {NotRecommended, "跨地域 RTT 直接进入帧预算", "无法承诺对局公平"},
		DedicatedPool:   {Recommended, "独占 CPU 与网络，延迟最稳", "池化、冷启动与空闲成本"},
	},
	SharedWorld: {
		ModularMonolith: {Optional, "小世界可以放在单进程", "只能纵向扩容，故障域大"},
		LobbyRoom:       {NotRecommended, "房间结束即销毁，没有持久世界", "世界状态无处安放"},
		ShardedWorld:    {Recommended, "按地图范围切分持久世界", "跨片交互与迁移协议"},
		GlobalShard:     {Recommended, "逻辑一张图，物理多套数据", "地域路由与数据驻留"},
		DedicatedPool:   {NotRecommended, "实例按局回收，世界不连续", "无法承载长期世界"},
	},
	RoomBased: {
		ModularMonolith: {Recommended, "房间可以作为清晰模块先内聚", "扩容与发布仍绑在一起"},
		LobbyRoom:       {Recommended, "大厅无状态、房间有状态是原生分工", "多一层分配与调用"},
		ShardedWorld:    {Optional, "房间可以挂在世界分片里", "房间生命周期受分片影响"},
		GlobalShard:     {Optional, "全球匹配，房间仍要就近落地", "匹配与开房跨层"},
		DedicatedPool:   {Recommended, "每局独占实例，天然隔离", "实例利用率与调度成本"},
	},
	LargeState: {
		ModularMonolith: {NotRecommended, "单库单进程很快碰到容量上限", "拆分时边界已被代码绑死"},
		LobbyRoom:       {Optional, "单房间状态小，总量随房间数增长", "需要独立持久化与归档"},
		ShardedWorld:    {Recommended, "状态跟着地图范围走", "热区与再均衡"},
		GlobalShard:     {Recommended, "按赛区与地图分片分摊状态", "全球索引与事件同步"},
		DedicatedPool:   {NotRecommended, "实例状态随对局回收，不能当长期存储", "持久化仍要另建"},
	},
	CrossRegion: {
		ModularMonolith: {NotRecommended, "单部署单元只能选一个地域", "跨区只能靠数据库复制"},
		LobbyRoom:       {Optional, "房间按赛区就近创建", "跨区匹配与组队要额外设计"},
		ShardedWorld:    {Optional, "地图分片可以按地域部署", "跨区行军需要显式协议"},
		GlobalShard:     {Recommended, "地域路由是全球同服的前置条件", "数据驻留与结算时间线"},
		DedicatedPool:   {Optional, "各地区分别建池", "池容量规划翻倍"},
	},
}

type Level int

const (
	Absent Level = iota
	Low
	Medium
	High
)

type Profile map[Feature]Level

type Verdict struct {
	Topology Topology
	Score    int
	Fit      Fit
	Reason   string
	Cost     string
}

var opsCost = map[Topology]int{
	ModularMonolith: 0,
	LobbyRoom:       1,
	ShardedWorld:    2,
	DedicatedPool:   2,
	GlobalShard:     3,
}

func CellFor(f Feature, t Topology) (Cell, bool) {
	row, ok := capability[f]
	if !ok {
		return Cell{}, false
	}
	cell, ok := row[t]
	return cell, ok
}

func dominant(p Profile) Feature {
	best := Feature("")
	level := Absent
	for _, f := range Features {
		if p[f] > level {
			best, level = f, p[f]
		}
	}
	return best
}

func classify(score int) Fit {
	switch {
	case score >= 14:
		return Recommended
	case score >= 6:
		return Optional
	default:
		return NotRecommended
	}
}

// Evaluate scores every topology against a product profile. Score is the sum
// of level times cell fit; ties break on operations cost, then on name, so the
// result is deterministic and explainable.
func Evaluate(p Profile) []Verdict {
	out := make([]Verdict, 0, len(Topologies))
	for _, t := range Topologies {
		score := 0
		for _, f := range Features {
			score += int(p[f]) * int(capability[f][t].Fit)
		}
		v := Verdict{Topology: t, Score: score, Fit: classify(score)}
		if f := dominant(p); f != "" {
			cell := capability[f][t]
			v.Reason, v.Cost = cell.Reason, cell.Cost
		} else {
			v.Reason, v.Cost = "没有强特征，按最低运维成本起步", "功能增长后仍要复审"
		}
		out = append(out, v)
	}
	sort.SliceStable(out, func(i, j int) bool {
		if out[i].Score != out[j].Score {
			return out[i].Score > out[j].Score
		}
		if opsCost[out[i].Topology] != opsCost[out[j].Topology] {
			return opsCost[out[i].Topology] < opsCost[out[j].Topology]
		}
		return out[i].Topology < out[j].Topology
	})
	return out
}

// Top returns the first verdict after scoring and tie-breaking.
func Top(p Profile) Verdict {
	return Evaluate(p)[0]
}

$ cd .local/checks/gsarch-lab
$ gofmt -l internal/matrix
$ go vet ./internal/matrix/
$ go test -count=1 ./internal/matrix/
ok  	gsarchlab/internal/matrix	0.256s