behavior.h

#pragma once
 
#include <exception>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "logger.h"
 
#include "core/reflect.h"
#include "debug/engine_error_log.h"
 
#include "ecs/entity.h"
#include "ecs/scene.h"
#include "ecs/component/core/name.h"
#include "ecs/hierarchy_operations.h"
#include "platform/window/window_manager.h"
#include "system/render/render_settings.h"
#include "core/event/event_bus.h"
#include "net/net_session.h"
#include "system/physics/physics_events.h"
#include "platform/input/input_map.h"
 
namespace Vkm::Engine {
 
class Behavior;
class Clock;
class ResourceManager;
class BehaviorSystem;
class BehaviorFieldVisitor;

struct BehaviorContext {
    Scene*                 scene            = nullptr;
    ResourceManager*       resources        = nullptr;

    WindowManager*         window           = nullptr;
 
    EventBus*              events           = nullptr;
    InputMap*              input            = nullptr;
    NetSession*            net              = nullptr;
    Clock*                 clock            = nullptr;
    RenderSettings*        render           = nullptr;
    std::vector<EntityId>* pendingDestroy   = nullptr;
    std::string*           pendingSceneLoad = nullptr;
};
 
namespace detail {

template<typename Fn>
struct ListenerEvent : ListenerEvent<decltype(&Fn::operator())> {};
 
template<typename C, typename R, typename A>
struct ListenerEvent<R (C::*)(A) const> {
    using type = std::decay_t<A>;
};
 
template<typename C, typename R, typename A>
struct ListenerEvent<R (C::*)(A)> {
    using type = std::decay_t<A>;
};
 
template<typename R, typename A>
struct ListenerEvent<R (*)(A)> {
    using type = std::decay_t<A>;
};

template<typename EventT, typename Fn>
struct SubscribedEvent {
    using type = EventT;
};
 
template<typename Fn>
struct SubscribedEvent<void, Fn> {
    using type = typename ListenerEvent<Fn>::type;
};
 
} // namespace detail

Behavior* findBehaviorNamed(Scene& scene, EntityId entity, std::string_view typeName);

const Behavior* findBehaviorNamed(const Scene& scene, EntityId entity, std::string_view typeName);

template<typename T>
T* findBehavior(Scene& scene, EntityId entity) {
    return static_cast<T*>(findBehaviorNamed(scene, entity, Reflect::Traits<T>::NAME));
}

template<typename T>
const T* findBehavior(const Scene& scene, EntityId entity) {
    return static_cast<const T*>(findBehaviorNamed(scene, entity, Reflect::Traits<T>::NAME));
}

class Behavior {
    public:
        Behavior() = default;
        virtual ~Behavior() { clearSubscriptions(); }
 
        Behavior(const Behavior& other) = delete;
        Behavior& operator=(const Behavior& other) = delete;
 
        Behavior(Behavior && other) = delete;
        Behavior& operator=(Behavior && other) = delete;
 
    public:
        virtual void onStart() {}

        virtual void onUpdate(float dt) {}

        virtual void onRealtimeUpdate(float dt) {}

        virtual void onFixedUpdate(float dt) {}

        virtual void onCollisionEnter(const Collision& hit) {}

        virtual void onCollisionStay(const Collision& hit) {}

        virtual void onCollisionExit(const Collision& hit) {}

        virtual void onTriggerEnter(EntityId other) {}

        virtual void onTriggerStay(EntityId other) {}

        virtual void onTriggerExit(EntityId other) {}

        virtual void onDestroy() {}

        virtual const char* typeName() const = 0;

        virtual void visitFields(BehaviorFieldVisitor& visitor) {}

        virtual std::unique_ptr<Behavior> clone() const = 0;
 
    protected:
        EntityId entity() const { return m_entity; }

        template<typename T>
        T* tryGet() { return m_ctx->scene->tryGet<T>(m_entity); }

        template<typename T>
        const T* tryGet() const { return m_ctx->scene->tryGet<T>(m_entity); }

        template<typename T>
        T& get() { return m_ctx->scene->get<T>(m_entity); }

        template<typename T>
        const T& get() const { return m_ctx->scene->get<T>(m_entity); }

        template<typename T>
        bool has() const { return m_ctx->scene->has<T>(m_entity); }

        template<typename T>
        auto& add(T && component) {
            return m_ctx->scene->add(m_entity, std::forward<T>(component));
        }

        template<typename T>
        T* findBehavior() { return findBehavior<T>(m_entity); }

        template<typename T>
        T* findBehavior(EntityId other) { return Vkm::Engine::findBehavior<T>(*m_ctx->scene, other); }

        template<typename T>
        static T* findBehavior(Scene& world, EntityId entity) {
            return Vkm::Engine::findBehavior<T>(world, entity);
        }

        template<typename T>
        static const T* findBehavior(const Scene& world, EntityId entity) {
            return Vkm::Engine::findBehavior<T>(world, entity);
        }

        Scene& scene() { return *m_ctx->scene; }

        ResourceManager& resources() { return *m_ctx->resources; }

        EventSender events() { return EventSender(*m_ctx->events); }

        RenderSettings& render() { return *m_ctx->render; }

        InputMap& input() { return *m_ctx->input; }

        NetSession& net() { return *m_ctx->net; }

        Clock& clock() { return *m_ctx->clock; }
        const Clock& clock() const { return *m_ctx->clock; }

        WindowManager* window() { return m_ctx->window; }

        bool isSimulated() const {
            return m_ctx->net->simulates(m_entity);
        }

        bool isMine() const {
            return m_ctx->net->isMine(m_entity);
        }

        bool isReplaying() const { return m_ctx->net->replaying(); }

        const InputCommand& command() const {
            return m_ctx->net->commandFor(m_entity);
        }

        EntityId spawn() {
            if (m_ctx->net->role() == NetRole::Client) warnSpawnOnClient();
            return m_ctx->scene->createEntity();
        }

        EntityId spawn(const char* name) {
            const EntityId entity = spawn();
            m_ctx->scene->add(entity, makeName(name));
            return entity;
        }

        EntityId spawn(const char* name, EntityId parent) {
            const EntityId entity = spawn(name);
            HierarchyOperations::setParent(*m_ctx->scene, entity, parent);
            return entity;
        }

        void destroy(EntityId target) { m_ctx->pendingDestroy->push_back(target); }

        void destroy() { destroy(m_entity); }

        void loadScene(const std::string& scenePath) { *m_ctx->pendingSceneLoad = scenePath; }

        template<typename EventT = void, typename Fn>
        void subscribe(Fn&& callback) {
            using Event = typename detail::SubscribedEvent<EventT, std::decay_t<Fn>>::type;
            std::function<void(const Event&)> listener = std::forward<Fn>(callback);
            // Null only before binding, so this is a subscribe from a constructor.
            if (!m_ctx) {
                LOG_ERROR(
                    "A behavior subscribed before it started; "
                    "subscribe() belongs in onStart(), not the constructor"
                );
                return;
            }
            // Guarded, or a throw would unwind through the bus and out of the frame.
            EventBus* events = m_ctx->events;
            const ListenerId id = events->subscribe<Event>(
                [this, listener = std::move(listener)](const Event& event) {
                    runGuarded("event listener", [&] { listener(event); });
                }
            );
            m_subscriptions.push_back([events, id]() { events->unsubscribe<Event>(id); });
        }
 
    private:
        friend class BehaviorSystem;

        template<typename Fn>
        bool runGuarded(const char* hookName, Fn&& fn) {
            try {
                fn();
                return false;
            } catch (const std::exception& e) {
                reportError("Behavior", hookLabel(hookName), e.what());
            } catch (...) {
                reportError("Behavior", hookLabel(hookName), "non-std exception");
            }
            return true;
        }

        std::string hookLabel(const char* hookName) const {
            return std::string(typeName()) + " / " + hookName;
        }

        void bindContext(EntityId entity, BehaviorContext& context) {
            m_entity = entity;
            m_ctx    = &context;
        }

        void clearSubscriptions() {
            for (auto& unsubscribe : m_subscriptions) unsubscribe();
            m_subscriptions.clear();
        }

        static void warnSpawnOnClient();
 
    private:
        EntityId         m_entity{};
        BehaviorContext* m_ctx = nullptr;
 
        std::vector<std::function<void()>> m_subscriptions;
        bool m_started  = false;
        bool m_disabled = false;
};
 
} // namespace Vkm::Engine