#ifndef MSP_GAME_SYSTEM_H_
#define MSP_GAME_SYSTEM_H_
+#include <functional>
#include <msp/time/timedelta.h>
+#include "accessguard.h"
+#include "component.h"
+#include "reflection.h"
+#include "stage.h"
namespace Msp::Game {
-class Stage;
-
class System
{
+public:
+ enum DependencyFlags
+ {
+ NO_DEPENDENCY = 0,
+ READ_OLD = 1,
+ READ_FRESH = 3,
+ WRITE = 4,
+ UPDATE = READ_OLD | WRITE,
+ CHAINED_UPDATE = READ_FRESH | WRITE
+ };
+
+ struct Dependency
+ {
+ DependencyFlags flags = NO_DEPENDENCY;
+ const Reflection::ClassBase &type;
+ void (*prepare)(Stage &) = nullptr;
+ void (*commit)(Stage &) = nullptr;
+ void (*unblock)(DependencyFlags) = nullptr;
+ void (*block)(DependencyFlags) = nullptr;
+
+ Dependency(const Reflection::ClassBase &t): type(t) { }
+ };
+
+ class Activator: public NonCopyable
+ {
+ private:
+ System &system;
+
+ public:
+ Activator(System &s): system(s) { system.begin_tick(); }
+ ~Activator() { system.end_tick(); }
+ };
+
protected:
Stage &stage;
+ std::vector<std::function<void()>> deferred_queue;
+ std::vector<Dependency> dependencies;
+
+ static thread_local System *active;
System(Stage &s): stage(s) { }
public:
virtual ~System() = default;
+ Stage &get_stage() const { return stage; }
+
+protected:
+ template<typename T>
+ void declare_dependency(DependencyFlags);
+
+public:
+ void begin_tick();
virtual void tick(Time::TimeDelta) = 0;
+ void end_tick();
+ virtual void deferred_tick();
+
+protected:
+ template<typename F>
+ void defer(F &&f) { deferred_queue.emplace_back(std::forward<F>(f)); }
};
+
+template<typename T>
+inline void System::declare_dependency(DependencyFlags flags)
+{
+ if(!std::is_base_of_v<Component, T>)
+ throw std::invalid_argument("System::declare_dependency");
+
+ const Reflection::ClassBase &type = stage.get_reflector().get_or_create_class<T>();
+ auto i = find_if(dependencies, [&type](const Dependency &d){ return &d.type==&type; });
+
+ if(i!=dependencies.end())
+ flags = static_cast<DependencyFlags>(flags|i->flags);
+
+ Dependency &dep = (i!=dependencies.end() ? *i : dependencies.emplace_back(type));
+ dep.flags = flags;
+ if constexpr(requires(T &c) { typename T::Data; c.prepare_tick(); c.commit_tick(); })
+ {
+#ifdef DEBUG
+ dep.unblock = +[](DependencyFlags f){
+ if(f&READ_OLD) AccessGuard::get_instance().unblock<AccessGuard::Read<typename T::Data>>();
+ if(f&WRITE) AccessGuard::get_instance().unblock<AccessGuard::Write<typename T::Data>>();
+ };
+ dep.block = +[](DependencyFlags f){
+ if(f&READ_OLD) AccessGuard::get_instance().block<AccessGuard::Read<typename T::Data>>();
+ if(f&WRITE) AccessGuard::get_instance().block<AccessGuard::Write<typename T::Data>>();
+ };
+#endif
+ if(flags&WRITE)
+ {
+ dep.prepare = +[](Stage &s){ s.iterate_objects<T>([](T &c){ c.prepare_tick(); }); };
+ dep.commit = +[](Stage &s){ s.iterate_objects<T>([](T &c){ c.commit_tick(); }); };
+ }
+ }
+}
+
} // namespace Msp::Game
#endif