StateManager.hh

#pragma once
 
#include "game/field/obj/ObjectBase.hh"
 
namespace Kinoko::Field {
 
struct StateManagerEntry {
    u16 id;
    void (*onEnter)(void *);
    void (*onCalc)(void *);
};
 
template <typename T, void (T::*Enter)(), void (T::*Calc)()>
constexpr StateManagerEntry StateEntry(u16 id) {
    auto enter = [](void *obj) { (reinterpret_cast<T *>(obj)->*Enter)(); };
    auto calc = [](void *obj) { (reinterpret_cast<T *>(obj)->*Calc)(); };
    return {id, enter, calc};
}

class StateManager {
protected:
    StateManager(void *obj, const std::span<const StateManagerEntry> &entries)
        : m_currentStateId(0), m_nextStateId(-1), m_currentFrame(0), m_entries(entries),
          m_obj(obj) {
        m_entryIds = std::span(static_cast<u16 *>(EGG::egg_alloc(m_entries.size() * sizeof(u16))),
                m_entries.size());
 
        // The base game initializes all entries to 0xffff, possibly to avoid an uninitialized value
        memset(m_entryIds.data(), 0xff, m_entryIds.size());
 
        for (size_t i = 0; i < m_entryIds.size(); ++i) {
            m_entryIds[m_entries[i].id] = i;
        }
    }
 
    virtual ~StateManager() {
        EGG::egg_free(m_entryIds.data());
    }
 
    void calc() {
        if (m_nextStateId >= 0) {
            m_currentStateId = m_nextStateId;
            m_nextStateId = -1;
            m_currentFrame = 0;
 
            auto enterFunc = m_entries[m_entryIds[m_currentStateId]].onEnter;
            enterFunc(m_obj);
        } else {
            ++m_currentFrame;
        }
 
        auto calcFunc = m_entries[m_entryIds[m_currentStateId]].onCalc;
        calcFunc(m_obj);
    }
 
    u16 m_currentStateId;
    s32 m_nextStateId;
    u32 m_currentFrame;
    std::span<u16> m_entryIds;
    std::span<const StateManagerEntry> m_entries;
    void *m_obj;
};
 
} // namespace Kinoko::Field