《游戏服务端架构·核心系统与契约》5.1 战斗服模型：房间内、旁路与托管

单帧预算 = 1000 ms / tick rate
模拟耗时 ≈ 实体数 × 单实体更新成本 + 裁决与广播成本
安全余量 = 单帧预算 - 模拟耗时 p99

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

import "errors"

// Model is the deployment shape of the match simulation.
type Model int

const (
	InRoom Model = iota
	Dedicated
	Managed
)

var (
	ErrBadWorkload = errors.New("battlemodels: invalid workload")
	ErrNoFit       = errors.New("battlemodels: no model satisfies constraints")
)

// Workload is the planning input. Async marks battles resolved offline.
type Workload struct {
	PlayersPerMatch int
	TickRate        int
	MatchMinutes    int
	PeakMatches     int
	NeedReplay      bool
	RegionCount     int
	Async           bool
}

func (w Workload) Validate() error {
	if w.PlayersPerMatch < 2 || w.TickRate <= 0 || w.MatchMinutes <= 0 ||
		w.PeakMatches <= 0 || w.RegionCount <= 0 {
		return ErrBadWorkload
	}
	return nil
}

// Team is who will operate the battle tier.
type Team struct {
	Engineers     int
	HasBattleTeam bool
}

// Profile values are example planning numbers, not production measurements.
type Profile struct {
	Model             Model
	TickBudgetMS      float64
	P99LatencyMS      float64
	CostPerMatchCents int
	BlastRadius       int
	ReplayFidelity    string
	OpsHoursPerMonth  int
}

var catalog = []Profile{
	{InRoom, 2, 8, 6, 1, "co-located, replay optional", 8},
	{Dedicated, 4, 4, 18, 8, "authoritative frame log", 40},
	{Managed, 10, 25, 11, 1, "recorded events only", 4},
}

func ProfileOf(m Model) (Profile, bool) {
	for _, p := range catalog {
		if p.Model == m {
			return p, true
		}
	}
	return Profile{}, false
}

type Decision struct {
	Model    Model
	Profile  Profile
	Reasons  []string
	Rejected []string
}

// Select applies hard limits, then replay needs, then cost. A no-fit result is
// a staffing answer, not a code failure.
func Select(w Workload, t Team) (Decision, error) {
	if err := w.Validate(); err != nil {
		return Decision{}, err
	}
	decide := func(m Model, why ...string) Decision {
		p, _ := ProfileOf(m)
		return Decision{m, p, why, []string{
			"in-room: shares the room loop; 10 players and 20 Hz at most",
			"dedicated: needs an on-call battle team",
			"managed: p99 latency example is 25 ms"}}
	}
	if w.Async {
		return decide(Managed, "battles resolve as offline batch jobs",
			"no tick loop and no dedicated tier to operate"), nil
	}
	if w.TickRate >= 30 || w.PlayersPerMatch >= 20 {
		if !t.HasBattleTeam || t.Engineers < 4 {
			return Decision{}, ErrNoFit
		}
		return decide(Dedicated, "tick budget exceeds the shared room loop",
			"the frame log is needed for disputes"), nil
	}
	if w.NeedReplay && t.HasBattleTeam {
		return decide(Dedicated, "competitive replay needs an authoritative frame log",
			"the team already carries a battle rotation"), nil
	}
	if t.Engineers == 0 {
		return decide(Managed, "no game-server engineer to own a runtime",
			"peak matches fit managed capacity"), nil
	}
	if w.PeakMatches <= 200 && w.PlayersPerMatch <= 10 && w.TickRate <= 20 {
		return decide(InRoom, "small matches share the room process",
			"latency stays inside the same host"), nil
	}
	if !t.HasBattleTeam {
		return decide(Managed, "peak matches exceed one shared room process",
			"no battle team to operate a separate tier"), nil
	}
	return decide(Dedicated, "peak matches exceed one shared room process",
		"a dedicated tier bounds the blast radius"), nil
}

type Recovery string

const (
	RestartMatch    Recovery = "restart"
	RestoreSnapshot Recovery = "restore-snapshot"
	Forfeit         Recovery = "forfeit"
)

// RecoveryFor prefers a snapshot; competitive matches that cannot be restored
// are voided rather than replayed with a different outcome.
func RecoveryFor(m Model, hasSnapshot, competitive bool) Recovery {
	if hasSnapshot && m != Managed {
		return RestoreSnapshot
	}
	if competitive {
		return Forfeit
	}
	return RestartMatch
}

// file: internal/battlemodels/battlemodels_test.go
// tier: L1
// verify: go test ./internal/battlemodels/
package battlemodels

import (
	"errors"
	"testing"
)

func TestCatalogProfilesAreConsistent(t *testing.T) {
	cases := []struct {
		model      Model
		found      bool
		maxLatency float64
		maxCost    int
	}{
		{InRoom, true, 10, 8}, {Dedicated, true, 5, 20}, {Managed, true, 30, 12}, {Model(99), false, 0, 0},
	}
	for _, c := range cases {
		p, ok := ProfileOf(c.model)
		if ok != c.found || (ok && (p.P99LatencyMS > c.maxLatency || p.CostPerMatchCents > c.maxCost)) {
			t.Errorf("%v: found=%v profile=%+v", c.model, ok, p)
		}
	}
}

func TestSelectPicksTheCheapestCoveringModel(t *testing.T) {
	cases := []struct {
		name    string
		w       Workload
		team    Team
		want    Model
		wantErr error
	}{
		{"casual room", Workload{8, 10, 6, 120, false, 1, false}, Team{2, false}, InRoom, nil},
		{"competitive replay", Workload{10, 30, 15, 400, true, 2, false}, Team{6, true}, Dedicated, nil},
		{"twenty players without a team", Workload{20, 20, 20, 50, false, 1, false}, Team{2, false}, 0, ErrNoFit},
		{"slg async", Workload{40, 10, 3, 300, false, 3, true}, Team{2, false}, Managed, nil},
		{"large casual peak", Workload{8, 20, 8, 800, false, 2, false}, Team{4, false}, Managed, nil},
		{"invalid tick rate", Workload{8, 0, 8, 10, false, 1, false}, Team{2, false}, 0, ErrBadWorkload},
	}
	for _, c := range cases {
		got, err := Select(c.w, c.team)
		if !errors.Is(err, c.wantErr) {
			t.Fatalf("%s: err=%v, want %v", c.name, err, c.wantErr)
		}
		if c.wantErr == nil && (got.Model != c.want || len(got.Reasons) == 0 || len(got.Rejected) != 3) {
			t.Errorf("%s: decision=%+v, want %v", c.name, got, c.want)
		}
	}
}

func TestRecoveryForUsesSnapshotBeforeForfeit(t *testing.T) {
	cases := []struct {
		name        string
		model       Model
		snapshot    bool
		competitive bool
		want        Recovery
	}{
		{"casual with snapshot", InRoom, true, false, RestoreSnapshot},
		{"competitive with snapshot", Dedicated, true, true, RestoreSnapshot},
		{"competitive without snapshot", Dedicated, false, true, Forfeit},
		{"casual without snapshot", InRoom, false, false, RestartMatch},
		{"managed never restores", Managed, true, false, RestartMatch},
	}
	for _, c := range cases {
		if got := RecoveryFor(c.model, c.snapshot, c.competitive); got != c.want {
			t.Errorf("%s: got %s, want %s", c.name, got, c.want)
		}
	}
}

func TestWorkloadValidate(t *testing.T) {
	cases := []struct {
		name string
		w    Workload
		ok   bool
	}{
		{"valid", Workload{8, 10, 6, 100, false, 1, false}, true},
		{"one player", Workload{1, 10, 6, 100, false, 1, false}, false},
		{"zero tick", Workload{8, 0, 6, 100, false, 1, false}, false},
		{"zero duration", Workload{8, 10, 0, 100, false, 1, false}, false},
		{"zero peak", Workload{8, 10, 6, 0, false, 1, false}, false},
		{"zero region", Workload{8, 10, 6, 100, false, 0, false}, false},
	}
	for _, c := range cases {
		if err := c.w.Validate(); (err == nil) != c.ok {
			t.Errorf("%s: err=%v, want ok=%v", c.name, err, c.ok)
		}
	}
}

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