游戏开发中的有限状态机：以三国杀回合流程为例

class FSM {
  constructor(initial, table) {
    this.state = initial;
    this.table = table; // { 状态: { 事件: { to, action } } }
  }
  send(event) {
    const t = this.table[this.state]?.[event];
    if (!t) return;      // 未定义的事件直接忽略
    t.action?.(event);   // 先执行动作
    this.state = t.to;   // 再切换状态
  }
}

void UpdateAI() {
  switch (state) {
    case Patrol:
      if (sawEnemy()) state = Chase;
      break;
    case Chase:
      if (lostTarget()) state = Patrol;
      break;
    // 每个 switch 都要照顾所有状态，状态一多必漏
  }
}

enum Phase {
  Prepare,   // 准备阶段：技能触发点（观星、英魂）
  Judgment,  // 判定阶段：结算判定区的延时锦囊（乐不思蜀、闪电）
  Draw,      // 摸牌阶段：摸牌堆顶两张
  Play,      // 出牌阶段：使用手牌
  Discard,   // 弃牌阶段：手牌弃至体力值
  End        // 结束阶段：闭月、据守等
}

Prepare   --[准备完成]--> Judgment
Judgment  --[判定完成]--> Draw
Judgment  --[无判定牌]--> Draw      // 旁路：直接跳过判定阶段
Draw      --[摸牌完成]--> Play
Play      --[结束出牌]--> Discard
Discard   --[弃牌完成]--> End
End       --[回合结束]--> (下一名角色重新走一遍)

interface IPhase {
  void OnEnter();   // 进入阶段：发事件、触发技能
  void OnUpdate();  // 阶段内逐帧逻辑
  void OnExit();    // 退出阶段：清理
}

class PreparePhase : IPhase {
  public void OnEnter() {
    // 观星、英魂等「准备阶段」技能逐个触发
    foreach (var skill in player.Skills)
      if (skill.TriggerAt == Phase.Prepare)
        skill.TryTrigger(player);
    // 技能可能要求跳过本阶段（如神速），直接请求转移
    if (player.SkipPrepare)
      fsm.Request(Event.PrepareDone);
  }
}

var fsm = new TurnFSM(Phase.Prepare, turnTable);
while (game.IsRunning) {
  fsm.Update();           // 驱动当前阶段的 OnUpdate
  if (fsm.Current.Done)   // 阶段内部自报完成
    fsm.Advance();        // 沿当前状态的出口转移
}

import { createMachine } from 'xstate';

const turnMachine = createMachine({
  id: 'turn',
  initial: 'prepare',
  states: {
    prepare:  { on: { DONE: 'judgment' } },
    judgment: { on: { DONE: 'draw', SKIP: 'draw' } }, // 无判定牌，跳过
    draw:     { on: { DONE: 'play' } },
    play:     { on: { FINISH: 'discard' } },
    discard:  { on: { DONE: 'end' } },
    end:      { on: { NEXT: 'prepare' } },            // 下一名玩家
  },
});

const turn = new StateMachine({
  init: 'prepare',
  transitions: [
    { name: 'step',    from: 'prepare',  to: 'judgment' },
    { name: 'judge',   from: 'judgment', to: 'draw' },
    { name: 'draw',    from: 'draw',     to: 'play' },
    { name: 'finish',  from: 'play',     to: 'discard' },
    { name: 'discard', from: 'discard',  to: 'end' },
  ],
  methods: {
    onStep:  () => console.log('准备完成'),
    onJudge: () => console.log('判定完成'),
  },
});

turn.step(); // 转移方法由配置自动生成

var turn = new StateMachine<Phase, string>();

turn.AddState(Phase.Prepare,  onEnter: _ => TriggerPrepareSkills());
turn.AddState(Phase.Judgment, onEnter: _ => ResolveJudgments());
turn.AddState(Phase.Draw,     onEnter: _ => DrawCards(2));
turn.AddState(Phase.Play,     onLogic: _ => HandlePlayerInput());
turn.AddState(Phase.Discard,  onEnter: _ => DiscardToHandLimit());
turn.AddState(Phase.End,      onEnter: _ => ResolveEndSkills());

turn.AddTransition(Phase.Prepare,  Phase.Judgment);
turn.AddTransition(Phase.Judgment, Phase.Draw);
turn.AddTransition(Phase.Draw,     Phase.Play);
turn.AddTransition(Phase.Play,     Phase.Discard);
turn.AddTransition(Phase.Discard,  Phase.End);

turn.Init();