🍿 Иерархический FSM (HFSM)

FSM (конечный автомат) — это не rocket science. Это просто способ явно описать: «в каком состоянии я нахожусь» и «что происходит при событии X». Пригодится везде: парсеры протоколов, UI-логика, игровые NPC, сетевые соединения.

Самая простая реализация — enum + switch и в большинстве случаев этого может быть достаточно. Но, если состояний становится много, то пользоваться им становится не удобно и самое время задуматься об иерархическом автомате.

HFSM позволяет группировать состояния. Применяется в игровых движках (вложенные состояния NPC), UI-фреймворках, протоколах с retry-логикой.

🧋 Реализация

#include <iostream>
#include <functional>
#include <map>
#include <optional>

enum class State { Idle, Running, Paused, Active, Stopped };
enum class Event { Start, Pause, Resume, Stop };

// Состояние может иметь родителя — тогда необработанные события
// делегируются вверх по иерархии
struct StateNode {
    std::optional<State>  parent;
    std::function<void()> onEnter;
    std::function<void()> onExit;
};

class HierarchicalFSM {
    State current_;
    std::map<State, StateNode>                 nodes_;
    std::map<std::pair<State,Event>, State>    transitions_;

public:
    explicit HierarchicalFSM(State init) : current_(init) {}

    void defState(State s,
                  std::optional<State> parent = std::nullopt,
                  std::function<void()> enter = {},
                  std::function<void()> exit  = {}) {
        nodes_[s] = {parent, std::move(enter), std::move(exit)};
    }

    void addTransition(State from, Event ev, State to) {
        transitions_[{from, ev}] = to;
    }

    bool process(Event ev) {
        // Ищем переход от текущего состояния вверх по иерархии
        std::optional<State> search = current_;
        while (search) {
            auto it = transitions_.find({*search, ev});
            if (it != transitions_.end()) {
                exitState(current_);
                current_ = it->second;
                enterState(current_);
                return true;
            }
            // Поднимаемся к родителю
            auto nodeIt = nodes_.find(*search);
            search = (nodeIt != nodes_.end()) ? nodeIt->second.parent
                                               : std::nullopt;
        }
        return false; // переход не найден
    }

    State state() const { return current_; }

private:
    void enterState(State s) {
        if (auto it = nodes_.find(s); it != nodes_.end())
            if (it->second.onEnter) it->second.onEnter();
    }
    void exitState(State s) {
        if (auto it = nodes_.find(s); it != nodes_.end())
            if (it->second.onExit) it->second.onExit();
    }
};

int main() {
    HierarchicalFSM fsm(State::Idle);

    // Active — виртуальный родитель для Running и Paused
    fsm.defState(State::Active);
    fsm.defState(State::Idle);
    fsm.defState(State::Running, State::Active,
        [] { std::cout << "[ENTER] Running\n"; },
        [] { std::cout << "[EXIT]  Running\n"; });
    fsm.defState(State::Paused, State::Active);
    fsm.defState(State::Stopped, std::nullopt,
        [] { std::cout << "[ENTER] Stopped\n"; });

    fsm.addTransition(State::Idle, Event::Start, State::Running);
    fsm.addTransition(State::Running, Event::Pause, State::Paused);
    fsm.addTransition(State::Paused, Event::Resume, State::Running);
    // Stop работает из любого Active-состояния
    fsm.addTransition(State::Active, Event::Stop, State::Stopped);

    fsm.process(Event::Start);
    fsm.process(Event::Pause);
    fsm.process(Event::Stop); // делегируется к Active -> Stopped
    return 0;
}

❗️ Добавь состояние — и оно автоматически наследует все переходы родителя. Не нужно дублировать Stop в каждое дочернее состояние.


✏️ Используешь FSM в продакшне?


🔥 Успейте на курс по ИИ-агентам! До 30 апреля осталось всего 4 места.
👉 Занять место по ссылке


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#шаблонный_код