First pass scriptable subsystems that has the same lifetime of the engine

Nuake/Engine.cpp

@@ -14,6 +14,7 @@
 #include "src/Threading/JobSystem.h"
 #include "src/Core/RegisterCoreTypes.h"
 #include "src/Modules/Modules.h"
+#include "src/Subsystems/EngineSubsystemScriptable.h"
 
 #include <GLFW/glfw3.h>
 #include <imgui/imgui_impl_glfw.h>
@@ -39,6 +40,8 @@ namespace Nuake
 
 	void Engine::Init()
 	{
+		ScriptingEngineNet::Get().AddListener<ScriptingEngineNet::GameAssemblyLoadedDelegate>(&Engine::OnScriptingEngineGameAssemblyLoaded);
+
 		AudioManager::Get().Initialize();
 		PhysicsManager::Get().Init();
 		NavManager::Get().Initialize();
@@ -53,6 +56,8 @@ namespace Nuake
 		RegisterCoreTypes::RegisterCoreComponents();
 
 		Modules::StartupModules();
+
+		InitializeCoreSubsystems();
 	}
 
 	void Engine::Tick()
@@ -91,11 +96,27 @@ namespace Nuake
 
 			}
 		}
+
+		float scaledTimeStep = timeStep * timeScale;
+
+		// Tick all subsystems
+		if (Engine::IsPlayMode())
+		{
+			for (auto subsystem : subsystems)
+			{
+				if (subsystem == nullptr)
+					continue;
+
+				if (subsystem->CanEverTick())
+				{
+					subsystem->Tick(scaledTimeStep);
+				}
+			}
+		}
 
 		// Dont update if no scene is loaded.
 		if (currentWindow->GetScene())
 		{
-			float scaledTimeStep = timeStep * timeScale;
 			currentWindow->Update(scaledTimeStep);
 
 			// Play mode update all the entities, Editor does not.
@@ -124,11 +145,13 @@ namespace Nuake
 		lastFrameTime = (float)glfwGetTime(); // Reset timestep timer.
 
 		// Dont trigger init if already in player mode.
-		if (GetGameState() == GameState::Playing)
+		if (GetGameState() == GameState::Playing || GetGameState() == GameState::Loading)
 		{
-			Logger::Log("Cannot enter play mode if is already in play mode.", "engine", WARNING);
+			Logger::Log("Cannot enter play mode if is already in play mode or is loading.", "engine", WARNING);
 			return;
 		}
+
+		SetGameState(GameState::Loading);
 
 		PhysicsManager::Get().ReInit();
 
@@ -216,6 +239,63 @@ namespace Nuake
 		return currentProject;
 	}
 
+	Ref<EngineSubsystemScriptable> Engine::GetScriptedSubsystem(const std::string& subsystemName)
+	{
+		if (scriptedSubsystemMap.contains(subsystemName))
+		{
+			return scriptedSubsystemMap[subsystemName];
+		}
+		return nullptr;
+	}
+
+	Ref<EngineSubsystemScriptable> Engine::GetScriptedSubsystem(const int subsystemId)
+	{
+		if (subsystemId >= subsystems.size())
+		{
+			return nullptr;
+		}
+		return std::reinterpret_pointer_cast<EngineSubsystemScriptable>(subsystems[subsystemId]);
+	}
+
+	void Engine::InitializeCoreSubsystems()
+	{
+	}
+
+	void Engine::OnScriptingEngineGameAssemblyLoaded()
+	{
+		if (!Engine::IsPlayMode() && Engine::GetGameState() != GameState::Loading)
+		{
+			return;
+		}
+
+		subsystems.clear();
+		scriptedSubsystemMap.clear();
+
+		const Coral::ManagedAssembly& gameAssembly = ScriptingEngineNet::Get().GetGameAssembly();
+
+		const auto scriptTypeEngineSubsystem = gameAssembly.GetType("Nuake.Net.EngineSubsystem");
+
+		const auto& types = gameAssembly.GetTypes();
+		for (const auto& type : types)
+		{
+			// Initialize all subsystems
+			if (type->IsSubclassOf(scriptTypeEngineSubsystem))
+			{
+				const std::string typeName = std::string(type->GetFullName());
+				Logger::Log("Creating Scripted Subsystem " + typeName);
+
+				Coral::ManagedObject scriptedSubsystem = type->CreateInstance();
+				scriptedSubsystem.SetPropertyValue("EngineSubsystemID", subsystems.size());
+				Ref<EngineSubsystemScriptable> subsystemScript = CreateRef<EngineSubsystemScriptable>(scriptedSubsystem);
+				subsystems.push_back(subsystemScript);
+
+				scriptedSubsystemMap[typeName] = subsystemScript;
+
+				subsystemScript->Initialize();
+			}
+		}
+	}
+
 	bool Engine::LoadProject(Ref<Project> project)
 	{
 		currentProject = project;
@@ -236,4 +316,4 @@ namespace Nuake
 	{
 		return currentWindow;
 	}
-}
+}

Nuake/Engine.h

@@ -1,4 +1,5 @@
 #pragma once
+
 #include "src/Core/Core.h"
 #include "src/Core/Logger.h"
 #include "src/Window.h"
@@ -8,9 +9,12 @@ namespace Nuake
 {
 	class Project;
 	class Scene;
+	class EngineSubsystem;
+	class EngineSubsystemScriptable;
 
 	enum GameState
 	{
+		Loading,
 		Playing,
 		Paused,
 		Stopped
@@ -50,12 +54,22 @@ namespace Nuake
 		static bool LoadProject(Ref<Project> project);
 		static Ref<Project> GetProject();
 
+		static Ref<EngineSubsystemScriptable> GetScriptedSubsystem(const std::string& subsystemName);
+		static Ref<EngineSubsystemScriptable> GetScriptedSubsystem(const int subsystemId);
+
+	protected:
+		static void InitializeCoreSubsystems();
+		static void OnScriptingEngineGameAssemblyLoaded();
+
 	private:
 		static Ref<Window> currentWindow;
 		static Ref<Project> currentProject;
 		static Ref<Scene> currentScene;
 		static std::string queuedScene;
 
+		static inline std::vector<Ref<EngineSubsystem>> subsystems;
+		static inline std::unordered_map<std::string, Ref<EngineSubsystemScriptable>> scriptedSubsystemMap;
+
 		static GameState gameState;
 
 		static float lastFrameTime;

Nuake/src/Scripting/NetModules/EngineNetAPI.cpp

@@ -1,10 +1,15 @@
 #include "EngineNetAPI.h"
-#include <Coral/String.hpp>
-#include <src/Core/Maths.h>
-#include <Engine.h>
+
+#include "src/Core/Maths.h"
 #include "src/Rendering/SceneRenderer.h"
+#include "Engine.h"
+#include "src/Physics/PhysicsManager.h"
+
+#include <Coral/String.hpp>
+#include <Coral/ManagedObject.hpp>
 #include <Coral/Array.hpp>
-#include <src/Physics/PhysicsManager.h>
+#include "Coral/Type.hpp"
+#include "..\..\Subsystems\EngineSubsystemScriptable.h"
 
 namespace Nuake {
 
@@ -112,10 +117,22 @@ namespace Nuake {
 		Engine::QueueSceneSwitch(std::string(path));
 	}
 
+	Coral::ManagedObject GetEngineSubsystemByName(Coral::String subsystemName)
+	{
+		const Ref<EngineSubsystemScriptable> scriptedSubsystem = Engine::GetScriptedSubsystem(subsystemName);
+		if (scriptedSubsystem == nullptr)
+		{
+			return {};
+		}
+
+		return scriptedSubsystem->GetManagedObjectInstance();
+	}
+
 	void EngineNetAPI::RegisterMethods()
 	{
 		RegisterMethod("Engine.LoadSceneIcall", &LoadScene);
 		RegisterMethod("Engine.LoggerLogIcall", (void*)(&Log));
+		RegisterMethod("Engine.GetSubsystemByNameIcall", &GetEngineSubsystemByName);
 
 		// Debug renderer
 		RegisterMethod("Debug.DrawLineIcall", &DrawLine);

Nuake/src/Scripting/NetModules/EngineSubsystemNetAPI.cpp

@@ -0,0 +1,37 @@
+#include "EngineSubsystemNetAPI.h"
+
+#include "Engine.h"
+#include "src/Subsystems/EngineSubsystemScriptable.h"
+
+namespace Nuake
+{
+    void SetCanTick(int subsystemId, bool tick)
+    {
+        auto subsystem = Engine::GetScriptedSubsystem(subsystemId);
+        if (subsystem == nullptr)
+        {
+            Logger::Log("Subsystem isn't a valid scripted subsystem", "EngineSubsystemNetAPI", WARNING);
+            return;
+        }
+
+        subsystem->SetCanTick(tick);
+    }
+
+    bool GetCanTick(int subsystemId)
+    {
+        auto subsystem = Engine::GetScriptedSubsystem(subsystemId);
+        if (subsystem == nullptr)
+        {
+            Logger::Log("Subsystem isn't a valid scripted subsystem", "EngineSubsystemNetAPI", WARNING);
+            return false;
+        }
+
+        return subsystem->CanEverTick();
+    }
+
+    void EngineSubsystemNetAPI::RegisterMethods()
+    {
+        RegisterMethod("EngineSubsystem.SetCanTickIcall", &SetCanTick);
+        RegisterMethod("EngineSubsystem.GetCanTickIcall", &GetCanTick);
+    }
+}

Nuake/src/Scripting/NetModules/EngineSubsystemNetAPI.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "NetAPIModule.h"
+
+namespace Nuake
+{
+    class EngineSubsystemNetAPI : public Nuake::NetAPIModule
+    {
+    public:
+        virtual const std::string GetModuleName() const override { return "EngineSubsystem"; }
+        virtual void RegisterMethods() override;
+    };
+}
+

Nuake/src/Scripting/ScriptingEngineNet.cpp

@@ -8,6 +8,7 @@
 #include "src/Scene/Components/NetScriptComponent.h"
 
 #include "NetModules/EngineNetAPI.h"
+#include "NetModules/EngineSubsystemNetAPI.h"
 #include "NetModules/InputNetAPI.h"
 #include "NetModules/SceneNetAPI.h"
 #include "NetModules/UINetAPI.h"
@@ -53,6 +54,7 @@ namespace Nuake
 		modules =
 		{
 			CreateRef<EngineNetAPI>(),
+			CreateRef<EngineSubsystemNetAPI>(),
 			CreateRef<InputNetAPI>(),
 			CreateRef<SceneNetAPI>(),
 			CreateRef<UINetAPI>()
@@ -324,6 +326,15 @@ namespace Nuake
 		return widgetUUIDToManagedObjects[std::make_pair(canvasUUID, uuid)];
 	}
 
+	template<class T>
+	void ScriptingEngineNet::AddListener(const T& delegate)	{}
+
+	template <>
+	void ScriptingEngineNet::AddListener<ScriptingEngineNet::GameAssemblyLoadedDelegate>(const GameAssemblyLoadedDelegate& delegate)
+	{
+		listenersGameAssemblyLoaded.push_back(delegate);
+	}
+
 	std::vector<CompilationError> ScriptingEngineNet::BuildProjectAssembly(Ref<Project> project)
 	{
 		const std::string sanitizedProjectName = String::Sanitize(project->Name);
@@ -525,6 +536,11 @@ namespace Nuake
 					}
 				}
 			}
+
+			for (auto& delegate : listenersGameAssemblyLoaded)
+			{
+				delegate();
+			}
 		}
 	}
 

Nuake/src/Scripting/ScriptingEngineNet.h

@@ -73,6 +73,9 @@ namespace Nuake
 
 	class ScriptingEngineNet
 	{
+	public:
+		using GameAssemblyLoadedDelegate = std::function<void()>; 
+
 	public:
 		static ScriptingEngineNet& Get();
 
@@ -83,6 +86,7 @@ namespace Nuake
 		Coral::HostInstance* GetHostInstance() { return hostInstance; }
 		Coral::AssemblyLoadContext& GetLoadContext() { return loadContext; }
 		Coral::ManagedAssembly GetNuakeAssembly() const { return nuakeAssembly; }
+		Coral::ManagedAssembly& GetGameAssembly() { return gameAssembly; }
 
 		Coral::ManagedAssembly ReloadEngineAPI(Coral::AssemblyLoadContext & context);
 
@@ -110,6 +114,9 @@ namespace Nuake
 		std::unordered_map<std::string, NetGameScriptObject> GetPointEntities() const { return pointEntityTypes; }
 		std::unordered_map<std::string, UIWidgetObject> GetUIWidgets() const { return uiWidgets; }
 
+		template<class T> void AddListener(const T& delegate);
+		template<> void AddListener(const GameAssemblyLoadedDelegate& delegate);
+
 	private:
 		const std::string m_Scope = "Nuake.Net";
 		const std::string m_EngineAssemblyName = "NuakeNet.dll";
@@ -140,6 +147,8 @@ namespace Nuake
 
 		std::unordered_map<uint32_t, Coral::ManagedObject> entityToManagedObjects;
 		std::map<std::pair<UUID, UUID>, Coral::ManagedObject> widgetUUIDToManagedObjects;
+
+		std::vector<GameAssemblyLoadedDelegate> listenersGameAssemblyLoaded;
 
 		ScriptingEngineNet();
 		~ScriptingEngineNet();
@@ -148,4 +157,4 @@ namespace Nuake
 		std::string GenerateGUID();
 		std::vector<CompilationError> ExtractErrors(const std::string& input);
 	};
-}
+}

Nuake/src/Subsystems/EngineSubsystem.cpp

@@ -0,0 +1,11 @@
+#include "EngineSubsystem.h"
+
+void Nuake::EngineSubsystem::SetCanTick(bool canTick)
+{
+    canEverTick = canTick;
+}
+
+bool Nuake::EngineSubsystem::CanEverTick() const
+{
+    return canEverTick;
+}