《游戏服务端架构·品类、状态与拓扑》1.1 游戏服务端到底在为谁做架构

// 反面示例：仅用于说明职责混杂，未纳入 gsarch-lab 编译。
type GameService struct {
    mu    sync.Mutex
    rooms map[string]*Room
    db    *sql.DB
}

func (s *GameService) Handle(w http.ResponseWriter, r *http.Request) {
    s.mu.Lock()
    defer s.mu.Unlock()

    switch r.URL.Path {
    case "/login":
        s.login(w, r)
    case "/room/join":
        s.joinRoom(w, r)
    case "/battle/settle":
        s.settle(w, r) // 同步写库，持有全局锁
    }
}

// file: internal/room/state.go
// tier: L1
// verify: go test ./internal/room/
package room

import "fmt"

// State is the lifecycle state of one match room.
type State string

const (
	StateCreated  State = "CREATED"
	StateMatching State = "MATCHING"
	StateLoading  State = "LOADING"
	StateRunning  State = "RUNNING"
	StateSettling State = "SETTLING"
	StateClosed   State = "CLOSED"
)

// allowed is the only place that decides which room transitions are legal.
var allowed = map[State][]State{
	StateCreated:  {StateMatching, StateClosed},
	StateMatching: {StateLoading, StateClosed},
	StateLoading:  {StateRunning, StateClosed},
	StateRunning:  {StateSettling, StateClosed},
	StateSettling: {StateClosed},
	StateClosed:   {},
}

// Room is the minimal state machine shared by the three Northstar products.
type Room struct {
	ID      string
	State   State
	Version int64
}

func New(id string) *Room {
	return &Room{ID: id, State: StateCreated}
}

func (r *Room) CanTransition(to State) bool {
	for _, s := range allowed[r.State] {
		if s == to {
			return true
		}
	}
	return false
}

func (r *Room) Transition(to State) error {
	if !r.CanTransition(to) {
		return fmt.Errorf("room %s: illegal transition %s -> %s", r.ID, r.State, to)
	}
	r.State = to
	r.Version++
	return nil
}

// file: internal/room/state_test.go
// tier: L1
// verify: go test ./internal/room/
package room

import "testing"

func TestTransitionTableIsExhaustive(t *testing.T) {
	states := []State{
		StateCreated, StateMatching, StateLoading,
		StateRunning, StateSettling, StateClosed,
	}
	for _, from := range states {
		for _, to := range states {
			r := New("r-1")
			r.State = from
			want := false
			for _, s := range allowed[from] {
				if s == to {
					want = true
					break
				}
			}
			if got := r.CanTransition(to); got != want {
				t.Fatalf("%s -> %s: got %v, want %v", from, to, got, want)
			}
		}
	}
}

func TestTransitionBumpsVersionOnlyOnSuccess(t *testing.T) {
	r := New("r-1")
	if err := r.Transition(StateRunning); err == nil {
		t.Fatal("CREATED -> RUNNING must fail")
	}
	if r.Version != 0 {
		t.Fatalf("failed transition changed version to %d", r.Version)
	}
	if err := r.Transition(StateMatching); err != nil {
		t.Fatalf("CREATED -> MATCHING: %v", err)
	}
	if r.State != StateMatching || r.Version != 1 {
		t.Fatalf("got state=%s version=%d", r.State, r.Version)
	}
}

func TestHappyPath(t *testing.T) {
	r := New("r-1")
	for _, s := range []State{
		StateMatching, StateLoading, StateRunning, StateSettling, StateClosed,
	} {
		if err := r.Transition(s); err != nil {
			t.Fatalf("transition to %s: %v", s, err)
		}
	}
	if r.Version != 5 {
		t.Fatalf("version=%d, want 5", r.Version)
	}
}

$ cd .local/checks/gsarch-lab
$ gofmt -l .
$ go vet ./...
$ go test ./internal/room/
ok  	gsarchlab/internal/room	0.4s