behavior_system.h

#pragma once
 
#include <type_traits>
#include <vector>
 
#include "core/system.h"
#include "ecs/entity.h"
#include "ecs/scene_observer.h"
#include "system/physics/physics_events.h"
#include "system/script/behavior.h"
 
namespace Vkm::Engine {
 
class Scene;
class ResourceManager;
class EventBus;

class BehaviorSystem : public System, public ISceneObserver {
    public:
        BehaviorSystem() {
            m_context.pendingDestroy   = &m_pendingDestroy;
            m_context.pendingSceneLoad = &m_pendingSceneLoad;
        }
        ~BehaviorSystem() override = default;
 
        BehaviorSystem(const BehaviorSystem& other) = delete;
        BehaviorSystem& operator=(const BehaviorSystem& other) = delete;
 
        BehaviorSystem(BehaviorSystem && other) = delete;
        BehaviorSystem& operator=(BehaviorSystem && other) = delete;
 
    public:
        void init(FrameContext& ctx) override;
        void update(FrameContext& ctx) override;
        void fixedUpdate(FrameContext& ctx) override;

        bool isReplayed() const override { return true; }
 
        void shutdown() override;

        void onEntityDestroyed(EntityId entity) override;

        void endSession(Scene& scene);

        static void destroyEntityBehaviors(Scene& scene, EntityId entity);
 
    private:
        void ensureStarted(Behavior& behavior, EntityId entity);

        void tickBehaviors(
            FrameContext& ctx,
            float dt,
            const char* hookName,
            void (Behavior::*hook)(float),
            bool startIfNeeded
        );

        template<typename Arg>
        void dispatchEntityHook(
            Scene& scene,
            EntityId target,
            const std::remove_reference_t<Arg>& arg,
            const char* hookName,
            void (Behavior::*hook)(Arg)
        );

        void drainPendingDestroy(Scene& scene);

        void drainPendingSceneLoad(FrameContext& ctx);

        template<typename Fn>
        static void guard(Behavior& behavior, const char* hookName, Fn&& fn);

        static void fireDestroy(Behavior& behavior);
 
    private:
        std::vector<CollisionEvent> m_collisions;
        std::vector<TriggerEvent>   m_triggers;

        std::vector<CollisionEvent> m_dispatchCollisions;
        std::vector<TriggerEvent>   m_dispatchTriggers;

        ListenerId m_collisionListener = 0;
        ListenerId m_triggerListener   = 0;

        std::vector<EntityId> m_tickList;
 
        std::vector<EntityId> m_pendingDestroy;
        std::vector<EntityId> m_destroying;
        std::string           m_pendingSceneLoad;  
 
        BehaviorContext m_context;
};
 
} // namespace Vkm::Engine