《游戏服务端编程实践》思考02：从 Go 工程视角看有状态架构的实现与演化

type Message struct {
    Type string
    Data any
}

func playerLoop(id int, inbox chan Message) {
    for msg := range inbox {
        handleMessage(id, msg)
    }
}

// Vector3 表示三维空间中的位置/速度/朝向等。
// 采用 float64 以满足服务器侧精度；客户端可在渲染层做 float32 降精。
type Vector3 struct {
	X float64 `json:"x" db:"x"` // East-West / right (+)
	Y float64 `json:"y" db:"y"` // Up-Down / up (+)（如为 2D 地图可固定 0）
	Z float64 `json:"z" db:"z"` // North-South / forward (+)
}

type PlayerState struct {
    ID         int64
    Name       string
    HP         int
    MP         int
    Position   Vector3
    Inventory  []Item
    Conn       net.Conn
    Inbox      chan Message
    LastActive time.Time
}

func (p *PlayerState) Run() {
    ticker := time.NewTicker(50 * time.Millisecond)
    for {
        select {
        case msg := <-p.Inbox:
            p.handleMessage(msg)
        case <-ticker.C:
            p.update()
        }
    }
}

type Actor interface {
    Receive(msg Message)
}

type BaseActor struct {
    inbox chan Message
}

func NewBaseActor() *BaseActor {
    a := &BaseActor{inbox: make(chan Message, 100)}
    go func() {
        for msg := range a.inbox {
            a.Receive(msg)
        }
    }()
    return a
}

type PlayerActor struct {
    *BaseActor
    State PlayerState
}

func (p *PlayerActor) Receive(msg Message) {
    switch msg.Type {
    case "Move":
        pos := msg.Data.(Vector3)
        p.State.Position = pos
    case "Attack":
        target := msg.Data.(int64)
        p.handleAttack(target)
    }
}

func SavePlayerState(ctx context.Context, p *PlayerState) error {
    data, _ := json.Marshal(p)
    return redisClient.Set(ctx, fmt.Sprintf("player:%d", p.ID), data, time.Hour).Err()
}

func (p *PlayerState) Snapshot() {
    snapshot := Snapshot{
        ID:        p.ID,
        HP:        p.HP,
        Position:  p.Position,
        Timestamp: time.Now(),
    }
    persistSnapshot(snapshot)
}

type BattleRoom struct {
    ID        int64
    Players   map[int64]*PlayerState
    StartTime time.Time
    Tick      *time.Ticker
    State     RoomState // 当前状态
    StateChanged time.Time   // 最近一次状态变化时间
    EndReason    EndReason   // 终止/结束原因
}

// RoomState 房间状态机（单维度主状态）
// 典型流转：Waiting → Matching → Loading → Countdown → Running → (Paused) → Ending → Closed
type RoomState uint8

const (
	RoomStateUnknown   RoomState = iota
	RoomStateWaiting             // 等待中：可加入/退出，尚未满员或未开局
	RoomStateMatching            // 匹配中：锁定席位，调度/分配中
	RoomStateLoading             // 载入中：下发场景/资源/出生点，等待客户端ready
	RoomStateCountdown           // 倒计时：房间已就绪，开始前读秒
	RoomStateRunning             // 进行中：Tick 驱动逻辑帧
	RoomStatePaused              // 暂停：一般用于裁判、维护或战术暂停（可选）
	RoomStateEnding              // 结算中：停止接收输入，统计结果/写入日志
	RoomStateClosed              // 关闭：终态，释放资源
	RoomStateFailed              // 失败：异常终止（崩溃/校验失败/资源异常），终态
	RoomStateDisbanded           // 解散：管理员/系统解散，终态
)

// EndReason 结束/中止原因（写战报/审计/BI）
type EndReason uint8

const (
	EndReasonNone EndReason = iota
	EndReasonNormalWin        // 正常胜负
	EndReasonTimeout          // 超时结束
	EndReasonNoShow           // 有人未进入/未就绪
	EndReasonAbortByAdmin     // 管理员终止
	EndReasonServerError      // 服务器错误
	EndReasonRuleViolation    // 规则/反作弊触发
	EndReasonDisband          // 解散
)

func (r *BattleRoom) Run() {
    r.Tick = time.NewTicker(50 * time.Millisecond)
    for range r.Tick.C {
        r.updateFrame()
        if r.State == RoomEnded {
            break
        }
    }
}

func (p *PlayerState) Heartbeat() {
    p.LastActive = time.Now()
}

if time.Since(p.LastActive) > 60*time.Second {
    disconnect(p)
}

SavePlayerState(ctx, p)
redisClient.Set(ctx, fmt.Sprintf("reconnect:%d", p.ID), true, 5*time.Minute)

func restorePlayer(id int64) (*PlayerState, error) {
    data, err := redisClient.Get(ctx, fmt.Sprintf("player:%d", id)).Result()
    if err != nil { return nil, err }
    var p PlayerState
    json.Unmarshal([]byte(data), &p)
    return &p, nil
}

var persistChan = make(chan *PlayerState, 1000)

func asyncPersister() {
    for p := range persistChan {
        saveToDB(p)
    }
}

func persistSnapshot(snapshot Snapshot) {
    db.Save(snapshot)
}

func loadSnapshot(id int64) Snapshot {
    var s Snapshot
    db.Where("id = ?", id).Last(&s)
    return s
}

node := consistentHash.GetNode(playerID)
routeTo(node, msg)