状态机学习笔记#

enum class State
{
    Idle,
    CoinInserted,
    Dispensing,
    Refunding
};

State currentState = State::Idle;

void handleEvent(Event event)
{
    switch (currentState)
    {
        case State::Idle:
            if (event == Event::InsertCoin)
            {
                currentState = State::CoinInserted;
            }
            break;
        case State::CoinInserted:
            if (event == Event::SelectProduct)
            {
                currentState = State::Dispensing;
            }
            else if (event == Event::Refund)
            {
                currentState = State::Idle;
            }
            break;
        case State::Dispensing:
            if (event == Event::DispenseComplete)
            {
                currentState = State::Idle;
            }
            else if (event == Event::OutOfStock)
            {
                currentState = State::Refunding;
            }
            break;
        case State::Refunding:
            if (event == Event::RefundComplete)
            {
                currentState = State::Idle;
            }
            break;
    }
}

// 状态枚举：列出所有可能的状态
// enum class 是 C++11 强类型枚举，不会隐式转 int，更安全
enum class State
{
    Idle,          // 待机：等待投币（初始状态）
    CoinInserted,   // 已投币：等待选商品或退币
    Dispensing,     // 出货中：等待出货完成或报缺货
    Refunding,     // 退款中：等待退款完成
    StateCount     // 哨兵值：不是真实状态，值为 4，用于确定二维数组的行数
                   // 放在最后，新增状态只需在它前面插一行，数组自动扩容
};

// 事件枚举：列出所有可能的事件
enum class Event
{
    InsertCoin,       // 投币：用户投入硬币
    SelectProduct,    // 选商品：用户按下商品按钮
    DispenseComplete, // 出货完成：传感器检测到商品已掉落
    Refund,           // 退币：用户按下退币按钮
    OutOfStock,       // 缺货：传感器检测到商品售罄
    RefundComplete,   // 退款完成：退款机制执行完毕
    EventCount        // 哨兵值：不是真实事件，值为 6，用于确定二维数组的列数
};

struct Transition
{
    State next;              // 跳到哪个状态
    void (*action)(void);    // 执行什么动作（函数指针，可为空）
};

Transition table[(int)State::StateCount][(int)Event::EventCount] = {};

void initTable()
{
    // 先把所有格子设为"留在原状态，无动作"（即忽略未定义的组合）
    for (int s = 0; s < (int)State::StateCount; s++)
    {
        for (int e = 0; e < (int)Event::EventCount; e++)
        {
            table[s][e] = { (State)s, nullptr };  // 花括号初始化（C++11）：按顺序给 next 和 action 赋值
        }
    }

    // 然后填入实际的转移规则
    table[(int)State::Idle][(int)Event::InsertCoin]
        = { State::CoinInserted, nullptr };
    table[(int)State::CoinInserted][(int)Event::SelectProduct]
        = { State::Dispensing, startMotor };
    table[(int)State::CoinInserted][(int)Event::Refund]
        = { State::Idle, returnCoin };
    table[(int)State::Dispensing][(int)Event::DispenseComplete]
        = { State::Idle, nullptr };
    table[(int)State::Dispensing][(int)Event::OutOfStock]
        = { State::Refunding, nullptr };
    table[(int)State::Refunding][(int)Event::RefundComplete]
        = { State::Idle, returnCoin };
}

State currentState = State::Idle;  // 全局当前状态

void handleEvent(Event event)
{
    Transition& t = table[(int)currentState][(int)event];
    if (t.action)
    {
        t.action();           // 有动作就执行
    }
    currentState = t.next;    // 切换状态
}

class VendingMachine;  // 前向声明：State 的成员函数需要引用机器类，但此时机器类还没定义

class State
{
public:
    virtual ~State() = default;  // 虚析构：保证通过基类指针删除派生类对象时能正确析构

    // 6 个事件接口，全部给空实现 {}
    // 含义："这个事件不归我管" → 子类只需重写自己关心的事件，其余自动忽略
    // 对比 switch-case 的 default: break;，这里基类帮你兜底了
    virtual void insertCoin(VendingMachine& m) {}       // 投币事件
    virtual void selectProduct(VendingMachine& m) {}    // 选商品事件
    virtual void dispenseComplete(VendingMachine& m) {} // 出货完成事件
    virtual void refund(VendingMachine& m) {}           // 退币事件
    virtual void outOfStock(VendingMachine& m) {}        // 缺货事件
    virtual void refundComplete(VendingMachine& m) {}    // 退款完成事件

    // 纯虚函数：子类必须实现，返回状态名（用于调试/打印）
    // = 0 表示纯虚，State 是抽象类，不能直接实例化
    virtual const char* name() const = 0;
};

class VendingMachine
{
public:
    VendingMachine();  // 构造函数在类外定义（见第三部分），初始状态设为 IdleState

    // setState：唯一能切换状态的方法
    // 当前状态对象处理完事件后调用它，相当于说"下一个客户去找某某"
    // std::move 转移 unique_ptr 所有权，旧状态对象自动析构
    void setState(std::unique_ptr<State> s)
    {
        currentState = std::move(s);  // 换人：旧状态销毁，新状态上岗
    }

    // 对外接口：6 个事件函数，每个只有一行
    // 机器类不自作主张，把事件连同自身引用(*this)转交给当前状态对象
    // *this 传给状态对象，让它能调用 setState() 来切换状态
    void insertCoin()       { currentState->insertCoin(*this); }       // 用户投币 → 转给当前状态
    void selectProduct()    { currentState->selectProduct(*this); }    // 用户选商品 → 转给当前状态
    void dispenseComplete() { currentState->dispenseComplete(*this); } // 出货完成 → 转给当前状态
    void refund()           { currentState->refund(*this); }           // 用户退币 → 转给当前状态
    void outOfStock()       { currentState->outOfStock(*this); }       // 传感器报缺货 → 转给当前状态
    void refundComplete()   { currentState->refundComplete(*this); }   // 退款完成 → 转给当前状态

    // 查询当前状态名（调试用）
    const char* stateName() const { return currentState->name(); }

private:
    std::unique_ptr<State> currentState;  // 当前值班的人：指向当前状态对象的智能指针
};

// 待机状态：只关心"投币"这一个事件
class IdleState : public State  // 继承 State，获得所有事件的空实现
{
public:
    // 只重写 insertCoin，其余 5 个事件走基类空实现（自动忽略）
    //
    // ⚠️ 关键：参数 m 是什么？
    // 回顾机器类的转发代码：void insertCoin() { currentState->insertCoin(*this); }
    // *this 就是机器自己 → 所以 m 就是机器本身的引用
    // 状态对象自己没有任何成员变量，它通过 m.setState() 改的是【机器的】currentState
    void insertCoin(VendingMachine& m) override
    {
        // 收到投币 → 帮机器切换到"已投币"状态
        // 相当于前台说："投币的事我办完了，你去找已投币那边的客服"
        // make_unique 创建新状态对象，setState 接管并销毁旧状态
        // 注意：改的是 m（机器）的 currentState，不是 IdleState 自己的什么变量
        m.setState(std::make_unique<CoinInsertedState>());
    }
    const char* name() const override { return "Idle"; }  // 返回状态名，调试用
};

// 已投币状态：关心"选商品"和"退币"两个事件
class CoinInsertedState : public State
{
public:
    void selectProduct(VendingMachine& m) override  // m 就是机器本身（机器通过 *this 传进来的）
    {
        // 选了商品 → 帮机器切换到出货中（机器开始出货）
        m.setState(std::make_unique<DispensingState>());  // 改的是机器的 currentState
    }
    void refund(VendingMachine& m) override  // m 就是机器本身
    {
        // 要退币 → 帮机器回到待机（钱退回去，重新等投币）
        m.setState(std::make_unique<IdleState>());  // 改的是机器的 currentState
    }
    // insertCoin？不归我管——已经投过币了，再投一次无效（基类空实现）
    // dispenseComplete？不归我管——还没选商品呢（基类空实现）
    const char* name() const override { return "CoinInserted"; }
};

// 出货中状态：关心"出货完成"和"缺货"两个事件
class DispensingState : public State
{
public:
    void dispenseComplete(VendingMachine& m) override  // m 就是机器本身
    {
        m.setState(std::make_unique<IdleState>());  // 出完了 → 帮机器回待机，等下一个客户
    }
    void outOfStock(VendingMachine& m) override  // m 就是机器本身
    {
        m.setState(std::make_unique<RefundingState>());  // 没货 → 帮机器去退款流程
    }
    // selectProduct？不归我管——已经在出货了（基类空实现）
    const char* name() const override { return "Dispensing"; }
};

// 退款中状态：只关心"退款完成"这一个事件
class RefundingState : public State
{
public:
    void refundComplete(VendingMachine& m) override  // m 就是机器本身
    {
        m.setState(std::make_unique<IdleState>());  // 退完了 → 帮机器回待机
    }
    // 其余事件一律忽略——退款中不接受任何操作（基类空实现）
    const char* name() const override { return "Refunding"; }
};

// 机器启动时，初始状态是"待机"
// 构造函数在类外定义（因为 IdleState 的完整定义在上面才能用）
// make_unique<IdleState>() 创建待机状态对象，赋给 currentState
VendingMachine::VendingMachine()
    : currentState(std::make_unique<IdleState>())
{
}

#include <QStateMachine>
#include <QState>

// Qt 状态机：自动售货机示例
// 对比 3.3 的手写状态模式，Qt 帮你把"委托 + 状态切换"的基础设施全做好了
// 你只需声明"有哪些状态"和"谁连谁"，不用写 State 基类和 VendingMachine 转发代码

// 机器类：继承 QObject 才能用信号槽
// 对比 3.3：不再需要 State 基类、不再需要 currentState 指针、不再需要 setState()
// QStateMachine 框架把这些全做了
class VendingMachine : public QObject
{
    Q_OBJECT  // Qt 宏：启用信号槽机制（必须放在类声明中）
public:
    VendingMachine(QObject *parent = nullptr);

    // 对外接口：用户/传感器调用这些方法来触发事件
    // 对比 3.3 的 insertCoin() { currentState->insertCoin(*this); }
    // 这里更简单——直接发信号，状态机自动处理转移
    void insertCoin()       { emit coinInserted(); }       // 用户投币
    void selectProduct()    { emit productSelected(); }    // 用户选商品
    void dispenseComplete() { emit dispenseDone(); }       // 出货完成
    void refund()           { emit refundRequested(); }    // 用户退币
    void outOfStock()       { emit outOfStockSignal(); }   // 传感器报缺货
    void refundComplete()   { emit refundDone(); }         // 退款完成

    // 查询当前状态名（调试用）
    // activeState() 返回当前活跃状态的 QObject，objectName() 就是状态名
    QString stateName() const { return machine.activeState()->objectName(); }

signals:
    // 6 个信号：对应 6 个事件
    // 信号就是事件——状态机监听这些信号，收到后自动按连线规则切换状态
    // 对比 3.3：3.3 用虚函数转发事件，Qt 用信号触发转移
    void coinInserted();        // 投币事件
    void productSelected();     // 选商品事件
    void dispenseDone();        // 出货完成事件
    void refundRequested();     // 退币事件
    void outOfStockSignal();    // 缺货事件（注意：outOfStock 和成员函数同名，所以信号加 Signal 后缀）
    void refundDone();          // 退款完成事件

private slots:
    // ★ 执行逻辑：进入每个状态时做什么
    // QState 有个 entered() 信号，状态机切到该状态时自动发
    // 我们把这些槽函数连到 entered() 上，实现"进入状态 → 执行动作"
    // 对比 3.3：3.3 在状态类构造函数里写动作，Qt 用 entered() 信号触发
    void onEnterIdle()      { qDebug() << "[待机] 请投币";          coinSlot.unlock();    }
    void onEnterCoin()      { qDebug() << "[已投币] 请选择商品";     coinSlot.lock();      }
    void onEnterDispense()  { qDebug() << "[出货中] 启动电机";       motor.start();        }
    void onEnterRefund()    { qDebug() << "[退款中] 执行退款";       coinRefunder.refund(); }

private:
    QStateMachine machine;      // Qt 状态机——等价于 3.3 的 VendingMachine 自身状态管理
    QState *s_idle;             // 待机状态
    QState *s_coin;             // 已投币状态
    QState *s_dispense;         // 出货中状态
    QState *s_refund;           // 退款中状态

    // 硬件接口（实际项目中这些是驱动层对象）
    CoinSlot    coinSlot;       // 投币口（lock/unlock 控制是否接受硬币）
    Motor       motor;          // 出货电机
    CoinRefunder coinRefunder;  // 退币器
};

// 构造函数：创建状态、连线、启动——所有状态机逻辑集中在这里
VendingMachine::VendingMachine(QObject *parent)
    : QObject(parent)
{
    // 1. 创建状态对象（this 作为父对象，Qt 自动管理内存）
    //    对比 3.3 的 make_unique<IdleState>()——这里用 QState 代替自定义状态类
    s_idle     = new QState();       // 待机状态
    s_coin     = new QState();       // 已投币状态
    s_dispense = new QState();       // 出货中状态
    s_refund   = new QState();       // 退款中状态

    // 2. 给状态起名（调试用，等价于 3.3 的 name() 返回值）
    s_idle->setObjectName("Idle");
    s_coin->setObjectName("CoinInserted");
    s_dispense->setObjectName("Dispensing");
    s_refund->setObjectName("Refunding");

    // 把状态加入状态机
    machine.addState(s_idle);
    machine.addState(s_coin);
    machine.addState(s_dispense);
    machine.addState(s_refund);

    // 3. 连线：定义转移规则——等价于 3.3 里每个状态类的 if/setState 逻辑
    //    addTransition 三个参数：信号发送者, 信号地址, 目标状态
    //    this 是谁？就是 VendingMachine 实例本身（这段代码在构造函数里，this 指向正在构造的机器）
    //    意思是："当 this（机器）发出 coinInserted 信号时，自动从当前状态切到 s_coin"
    //    对比手写模式：不用自己调 setState()，Qt 信号一触发就自动切

    // 待机 → 投币 → 已投币
    s_idle->addTransition(this, &VendingMachine::coinInserted, s_coin);  // this=机器, 机器发coinInserted → 切到已投币
    // 已投币 → 选商品 → 出货中
    s_coin->addTransition(this, &VendingMachine::productSelected, s_dispense);  // 机器发productSelected → 切到出货中
    // 已投币 → 退币 → 待机
    s_coin->addTransition(this, &VendingMachine::refundRequested, s_idle);  // 机器发refundRequested → 切回待机
    // 出货中 → 出货完成 → 待机
    s_dispense->addTransition(this, &VendingMachine::dispenseDone, s_idle);  // 机器发dispenseDone → 切回待机
    // 出货中 → 缺货 → 退款中
    s_dispense->addTransition(this, &VendingMachine::outOfStockSignal, s_refund);  // 机器发outOfStockSignal → 切到退款中
    // 退款中 → 退款完成 → 待机
    s_refund->addTransition(this, &VendingMachine::refundDone, s_idle);  // 机器发refundDone → 切回待机

    // 4. 连接 entered() 信号到执行槽——进入状态时自动执行动作
    //    这是 Qt 状态机的"执行"部分：不光是切换状态，还能在切换时做事
    //    对比 3.3：3.3 在 setState() 里 new 新状态对象，构造函数里执行动作
    //    Qt 更简洁：entered() 信号 → 槽函数，一行 connect 搞定
    connect(s_idle,     &QState::entered, this, &VendingMachine::onEnterIdle);
    connect(s_coin,     &QState::entered, this, &VendingMachine::onEnterCoin);
    connect(s_dispense, &QState::entered, this, &VendingMachine::onEnterDispense);
    connect(s_refund,   &QState::entered, this, &VendingMachine::onEnterRefund);

    // 5. 设置初始状态并启动
    machine.setInitialState(s_idle);   // 等价于 3.3 构造函数里的 make_unique<IdleState>()
    machine.start();                    // 状态机开始运行，等待信号
}

// 使用：
// VendingMachine m;
// m.insertCoin();        // 用户投币 → emit coinInserted() → 状态机自动从 Idle 切到 CoinInserted
//                        → entered() 触发 onEnterCoin()：锁定投币口，显示"请选择商品"
// m.selectProduct();     // 用户选商品 → emit productSelected() → 自动切到 Dispensing
//                        → entered() 触发 onEnterDispense()：启动电机出货
// m.dispenseComplete();  // 出货完成 → emit dispenseDone() → 自动切回 Idle
//                        → entered() 触发 onEnterIdle()：解锁投币口，显示"请投币"
// qDebug() << m.stateName();  // 输出 "Idle"

// 手写：状态必须拍平，组合爆炸
enum State { Stopped, Playing_Normal, Playing_Buffering, Paused_Normal, Paused_Seeking };

void handleEvent(State& state, Event event)
{
    switch (state)
    {
    case Stopped:
        if (event == Play)  state = Playing_Normal;
        break;
    case Playing_Normal:
        if (event == Pause)       state = Paused_Normal;
        if (event == Stop)        state = Stopped;       // 父状态规则
        if (event == Buffering)   state = Playing_Buffering;
        break;
    case Playing_Buffering:
        if (event == Buffered)    state = Playing_Normal;
        if (event == Pause)       state = Paused_Normal;  // 缓冲中也能暂停？
        if (event == Stop)        state = Stopped;        // 父状态规则，重复写
        break;
    case Paused_Normal:
        if (event == Play)        state = Playing_Normal;
        if (event == Stop)        state = Stopped;        // 父状态规则，又重复写
        if (event == Seek)        state = Paused_Seeking;
        break;
    case Paused_Seeking:
        if (event == SeekDone)    state = Paused_Normal;
        if (event == Play)        state = Playing_Normal;  // 搜索完直接播？
        if (event == Stop)        state = Stopped;         // 父状态规则，第三次写
        break;
    }
}

// Qt：层次状态机，父状态规则自动被子状态继承
class Player : public QObject
{
    Q_OBJECT
public:
    Player(QObject *parent = nullptr);

signals:
    void playClicked();
    void pauseClicked();
    void stopClicked();
    void bufferingStarted();
    void bufferingDone();
    void seekStarted();
    void seekDone();

private slots:
    // ★ 执行逻辑：进入每个状态时做什么
    // 对比售货机例子：这里展示了 onEntry/onExit 的实际用途
    void onEnterStopped()    { qDebug() << "[停止] 停止播放，重置进度";     mediaPlayer.stop();    }
    void onEnterPlaying()    { qDebug() << "[播放中] 开始解码";              mediaPlayer.play();    }
    void onEnterBuffering()  { qDebug() << "[缓冲中] 显示加载动画";          ui.showLoading();       }
    void onExitBuffering()   { qDebug() << "[缓冲完成] 隐藏加载动画";        ui.hideLoading();       }
    void onEnterPaused()     { qDebug() << "[暂停] 暂停解码";                mediaPlayer.pause();   }
    void onEnterSeeking()    { qDebug() << "[搜索中] 跳转到新位置";          ui.showSeekBar();      }
    void onExitSeeking()     { qDebug() << "[搜索完成] 隐藏搜索条";          ui.hideSeekBar();      }

private:
    QStateMachine machine;

    // 顶层状态
    QState *s_stopped;      // 停止
    QState *s_playing;      // 播放中（父状态）
    QState *s_paused;       // 暂停（父状态）

    // s_playing 的子状态
    QState *s_normal_play;  // 正常播放
    QState *s_buffering;    // 缓冲中

    // s_paused 的子状态
    QState *s_normal_pause; // 正常暂停
    QState *s_seeking;      // 搜索中

    // 硬件/业务接口
    MediaPlayer mediaPlayer;   // 播放引擎
    PlayerUI     ui;           // 播放器界面
};

Player::Player(QObject *parent)
    : QObject(parent)
{
    // 1. 创建状态，建立层次关系
    s_stopped = new QState();
    s_playing = new QState();       // 父状态：播放中
    s_paused = new QState();       // 父状态：暂停

    // 子状态的构造参数是父状态——这就建立了嵌套关系
    // Qt 自动处理：子状态继承父状态的所有转移规则
    s_normal_play = new QState(s_playing);   // 正常播放 → 属于播放中
    s_buffering = new QState(s_playing);   // 缓冲中 → 属于播放中
    s_normal_pause = new QState(s_paused);    // 正常暂停 → 属于暂停
    s_seeking = new QState(s_paused);    // 搜索中 → 属于暂停

    s_playing->setInitialState(s_normal_play);   // 进入"播放中"默认是"正常播放"
    s_paused->setInitialState(s_normal_pause);   // 进入"暂停"默认是"正常暂停"

    // 2. 加入状态机
    machine.addState(s_stopped);
    machine.addState(s_playing);
    machine.addState(s_paused);

    // 3. 连线——注意：父状态上的规则，子状态自动继承！

    // 顶层转移：停止 → 播放
    s_stopped->addTransition(this, &Player::playClicked, s_playing);
    // 顶层转移：播放 → 暂停（不管在正常播放还是缓冲中，暂停都生效）
    s_playing->addTransition(this, &Player::pauseClicked, s_paused);
    // 顶层转移：暂停 → 播放
    s_paused->addTransition(this, &Player::playClicked, s_playing);

    // ★ 关键：在父状态 s_playing 上加 Stop 规则
    //   不管当前在 s_normal_play 还是 s_buffering，Stop 都回到 Stopped
    //   只写一次！不用在每个子状态上重复！
    s_playing->addTransition(this, &Player::stopClicked, s_stopped);
    // 同理：暂停状态下 Stop 也只写一次
    s_paused->addTransition(this, &Player::stopClicked, s_stopped);

    // 子状态之间的转移
    s_normal_play->addTransition(this, &Player::bufferingStarted, s_buffering);
    s_buffering->addTransition(this, &Player::bufferingDone, s_normal_play);
    s_normal_pause->addTransition(this, &Player::seekStarted, s_seeking);
    s_seeking->addTransition(this, &Player::seekDone, s_normal_pause);

    // 4. 连接 entered()/exited() 信号到执行槽——进入/退出状态时自动执行动作
    //    entered() = onEntry：进入状态时触发
    //    exited()  = onExit：离开状态时触发
    //    对比手写：不用在每个 case 里手动调"进入动作"和"退出动作"
    connect(s_stopped,    &QState::entered, this, &Player::onEnterStopped);
    connect(s_playing,    &QState::entered, this, &Player::onEnterPlaying);
    connect(s_buffering,  &QState::entered, this, &Player::onEnterBuffering);
    connect(s_buffering,  &QState::exited,  this, &Player::onExitBuffering);
    connect(s_paused,     &QState::entered, this, &Player::onEnterPaused);
    connect(s_seeking,    &QState::entered, this, &Player::onEnterSeeking);
    connect(s_seeking,    &QState::exited,  this, &Player::onExitSeeking);

    // 5. 启动
    machine.setInitialState(s_stopped);
    machine.start();
}

// 使用：
// Player p;
// emit p.playClicked();       // 停止 → 播放中（自动进入 NormalPlayback）
//                             → entered() 触发 onEnterPlaying()：开始解码
// emit p.bufferingStarted();  // 正常播放 → 缓冲中
//                             → entered() 触发 onEnterBuffering()：显示加载动画
// emit p.bufferingDone();     // 缓冲中 → 正常播放
//                             → exited() 触发 onExitBuffering()：隐藏加载动画
// emit p.stopClicked();       // 缓冲中 → 停止（父状态规则，自动生效！）
//                             → entered() 触发 onEnterStopped()：停止播放，重置进度
// emit p.playClicked();       // 停止 → 播放中
// emit p.pauseClicked();      // 播放中 → 暂停（自动进入 NormalPaused）
//                             → entered() 触发 onEnterPaused()：暂停解码
// emit p.seekStarted();       // 正常暂停 → 搜索中
//                             → entered() 触发 onEnterSeeking()：显示搜索条
// emit p.seekDone();          // 搜索中 → 正常暂停
//                             → exited() 触发 onExitSeeking()：隐藏搜索条
// emit p.stopClicked();       // 搜索中 → 停止（父状态规则，自动生效！）

class HierarchicalState
{
public:
    virtual ~HierarchicalState() = default;
    virtual void handleEvent(Event e) = 0;

    // 事件先交给当前子状态处理，子状态不处理才上升到父状态
    void handleEventRecursive(Event e)
    {
        if (subState && subState->handleEventRecursive(e))
        {
            return;  // 子状态处理了
        }
        handleEvent(e);  // 父状态自己处理
    }

    std::unique_ptr<HierarchicalState> subState;
};

enum class CharacterState
{
    Idle,
    Moving,
    Attacking,
    Stunned,
    Dead
};

// 角色状态机：每帧 update 驱动
void Character::update(float dt)
{
    switch (m_state)
    {
        case CharacterState::Idle:
            if (m_input.moveRequested())
            {
                m_state = CharacterState::Moving;
            }
            else if (m_input.attackRequested())
            {
                m_state = CharacterState::Attacking;
                m_attackTimer = 0.5f;
            }
            break;
        case CharacterState::Moving:
            moveTowardsTarget(dt);
            if (!m_input.moveRequested())
            {
                m_state = CharacterState::Idle;
            }
            break;
        case CharacterState::Attacking:
            m_attackTimer -= dt;
            if (m_attackTimer <= 0)
            {
                m_state = CharacterState::Idle;
            }
            break;
        case CharacterState::Stunned:
            m_stunTimer -= dt;
            if (m_stunTimer <= 0)
            {
                m_state = CharacterState::Idle;
            }
            break;
        case CharacterState::Dead:
            // 等待复活逻辑
            break;
    }
}

void handleEvent(Event event)
{
    Transition& t = table[(int)currentState][(int)event];
    if (t.next == currentState && t.action == nullptr)
    {
        // 未定义的转移
        LOG_WARN("Unexpected event %d in state %d",
                 (int)event, (int)currentState);
        return;
    }
    if (t.action)
    {
        t.action();
    }
    currentState = t.next;
}

class State
{
public:
    virtual void onEnter() {}
    virtual void onExit() {}
    virtual void handleEvent(Event e) = 0;
};

void VendingMachine::setState(std::unique_ptr<State> s)
{
    if (currentState)
    {
        currentState->onExit();
    }
    currentState = std::move(s);
    currentState->onEnter();
}