Started creating scripting library/namespace and added sol2 for interfacing

8 files changed, 500 insertions, 114 deletions

diff --git a/src/engine.cpp b/src/engine.cpp
new file mode 100644
index 0000000..0a3b810
--- /dev/null
+++ b/src/engine.cpp
@@ -0,0 +1,77 @@
+/**
+ * @file engine.cpp
+ * Manages all game systems.
+ *
+ * Copyright (C) 2019 Clyne Sullivan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "engine.hpp"
+#include "gamerun.hpp"
+#include "input.hpp"
+#include "window.hpp"
+#include "script.hpp"
+
+int Engine::init(void)
+{
+	systems.add<GameRunSystem>();
+	systems.add<InputSystem>();
+	systems.add<WindowSystem>();
+    systems.add<ScriptSystem>();
+
+	systems.configure();
+	return 0;
+}
+
+void Engine::logicLoop(void)
+{
+	using namespace std::chrono_literals;
+
+	entityx::TimeDelta dt = 0;
+
+	while (shouldRun()) {
+		systems.update<InputSystem>(dt);
+		std::this_thread::sleep_for(100ms);
+	}
+}
+
+void Engine::renderLoop(void)
+{
+	while (shouldRun()) {
+		systems.update<WindowSystem>(0);
+		std::this_thread::yield();
+	}
+}
+
+void Engine::run(void)
+{
+	// Start logic thread
+	logicThread = std::thread([this](void) {
+		logicLoop();
+	});
+
+	// Keep render loop on main thread
+	renderLoop();
+
+	// Done, bring logic thread back
+	logicThread.join();
+}
+
+bool Engine::shouldRun(void)
+{
+	auto grs = systems.system<GameRunSystem>();
+	return grs ? grs->shouldRun() : true;
+}
+
diff --git a/src/engine.hpp b/src/engine.hpp
new file mode 100644
index 0000000..fb14093
--- /dev/null
+++ b/src/engine.hpp
@@ -0,0 +1,65 @@
+/**
+ * @file window.hpp
+ * Manages all game systems.
+ *
+ * Copyright (C) 2019 Clyne Sullivan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef ENGINE_HPP_
+#define ENGINE_HPP_
+
+#include <entityx/entityx.h>
+
+#include <thread>
+
+/**
+ * @class Engine
+ * Manages all game entities, events, and systems.
+ */
+class Engine
+{
+private:
+	entityx::EventManager events;
+	entityx::EntityManager entities;
+	entityx::SystemManager systems;
+
+	std::thread logicThread;
+
+	void logicLoop(void);
+	void renderLoop(void);
+
+	bool shouldRun(void);
+
+public:
+	Engine(void) :
+		entities(events),
+		systems(entities, events) {}
+
+	/**
+	 * Initializes the game engine.
+	 * @return Zero on success, non-zero otherwise
+	 */
+	int init(void);
+
+	/**
+	 * Runs the game engine.
+	 * Function returns when game is told to end/exit.
+	 */
+	void run(void);
+};
+
+#endif // ENGINE_HPP_
+
diff --git a/src/gamerun.hpp b/src/gamerun.hpp
new file mode 100644
index 0000000..efe6ed9
--- /dev/null
+++ b/src/gamerun.hpp
@@ -0,0 +1,76 @@
+/**
+ * @file window.hpp
+ * Handles key press for exiting the game.
+ *
+ * Copyright (C) 2019 Clyne Sullivan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef GAMERUN_HPP_
+#define GAMERUN_HPP_
+
+#include "input.hpp"
+
+#include <entityx/entityx.h>
+
+#include <atomic>
+#include <iostream>
+
+/**
+ * @class GameRunSystem
+ * Listens for a key event to tell the game to exit.
+ */
+class GameRunSystem : public entityx::System<GameRunSystem>,
+	public entityx::Receiver<GameRunSystem> {
+private:
+	std::atomic_bool shouldRunFlag;
+
+public:
+	/**
+	 * Configures the system to wait for the exit event.
+	 */
+	void configure([[maybe_unused]] entityx::EntityManager& entities,
+		entityx::EventManager& events) {
+		shouldRunFlag.store(true);
+
+		events.subscribe<KeyUpEvent>(*this);
+
+		std::cout << "Press escape to exit." << std::endl;
+	}
+
+	// Unused
+	void update([[maybe_unused]] entityx::EntityManager& entities,
+		[[maybe_unused]] entityx::EventManager& events,
+		[[maybe_unused]] entityx::TimeDelta dt) final {}
+
+	/**
+	 * Receiver for key release events, used to listen for game exit key.
+	 */
+	void receive(const KeyUpEvent& kue) {
+		if (kue.sym == SDLK_ESCAPE)
+			shouldRunFlag.store(false);
+	}
+
+	/**
+	 * Checks if the game exit key has been pressed.
+	 * @return True if the game should exit
+	 */
+	inline bool shouldRun(void) const {
+		return shouldRunFlag.load();
+	}
+};
+
+#endif // GAMERUN_HPP_
+
diff --git a/src/input.hpp b/src/input.hpp
new file mode 100644
index 0000000..39d4045
--- /dev/null
+++ b/src/input.hpp
@@ -0,0 +1,88 @@
+/**
+ * @file window.hpp
+ * Handles user input received from SDL.
+ *
+ * Copyright (C) 2019 Clyne Sullivan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef INPUT_HPP_
+#define INPUT_HPP_
+
+#include <entityx/entityx.h>
+#include <SDL2/SDL.h>
+
+/**
+ * @class KeyUpEvent
+ * Stores info regarding key releases.
+ */
+struct KeyUpEvent {
+	KeyUpEvent(const SDL_Keysym& keysym) :
+		sym(keysym.sym), mod(keysym.mod) {}
+
+	SDL_Keycode sym;
+	Uint16 mod;
+};
+
+/**
+ * @class KeyDownEvent
+ * Stores info regarding key presses.
+ */
+struct KeyDownEvent {
+	KeyDownEvent(const SDL_Keysym& keysym) :
+		sym(keysym.sym), mod(keysym.mod) {}
+
+	SDL_Keycode sym;
+	Uint16 mod;
+};
+
+/**
+ * @class InputSystem
+ * Listens for user input from SDL, and emits input events accordingly.
+ */
+class InputSystem : public entityx::System<InputSystem> {
+public:
+	/**
+	 * Prepares the system for running.
+	 */
+	void configure([[maybe_unused]] entityx::EntityManager& entities,
+		[[maybe_unused]] entityx::EventManager& events) final {
+	}
+
+	/**
+	 * Updates the system by checking for SDL events.
+	 */
+	void update([[maybe_unused]] entityx::EntityManager& entities,
+		[[maybe_unused]] entityx::EventManager& events,
+		[[maybe_unused]] entityx::TimeDelta dt) final {
+		for (SDL_Event event; SDL_PollEvent(&event);) {
+			switch (event.type) {
+			case SDL_KEYUP:
+				if (auto key = event.key; key.repeat == 0)
+					events.emit<KeyUpEvent>(key.keysym);
+				break;
+			case SDL_KEYDOWN:
+				if (auto key = event.key; key.repeat == 0)
+					events.emit<KeyDownEvent>(key.keysym);
+				break;
+			default:
+				break;
+			}
+		}
+	}
+};
+
+#endif // INPUT_HPP_
+
diff --git a/src/main.cpp b/src/main.cpp
index 23cfe2d..386aafc 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -22,69 +22,11 @@
 #include <entityx/entityx.h>
 #include <LuaBridge/LuaBridge.h>
 
+#include "engine.hpp"
+
 #include <SDL2/SDL.h>
 
-#include <atomic>
-#include <chrono>
 #include <iostream>
-#include <memory>
-#include <thread>
-
-#include <components/Position.hpp>
-#include <script.hpp>
-
-class Window {
-private:
-	constexpr static const char *title = "gamedev2";
-	constexpr static int width = 640;
-	constexpr static int height = 480;
-
-	static std::unique_ptr<SDL_Window, void (*)(SDL_Window *)> window;
-	static SDL_GLContext context;
-
-	static void destroyWindow(SDL_Window *w) {
-		SDL_GL_DeleteContext(context);
-		SDL_DestroyWindow(w);
-	}
-
-public:
-	static int init(void) {
-		if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
-			std::cerr << "SDL video failed to initialize: "
-				<< SDL_GetError() << std::endl;
-			return -1;
-		}
-
-		window.reset(SDL_CreateWindow(title,
-			SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
-			width, height,
-			SDL_WINDOW_OPENGL));
-
-		if (window.get() == nullptr) {
-			std::cerr << "SDL window creation failed: "
-				<< SDL_GetError() << std::endl;
-			return -1;
-		}
-
-		context = SDL_GL_CreateContext(window.get());
-
-		return 0;
-	}
-
-	static void render(void) {
-		SDL_GL_SwapWindow(window.get());
-	}
-};
-
-std::unique_ptr<SDL_Window, void (*)(SDL_Window *)> Window::window (nullptr,
-	Window::destroyWindow);
-SDL_GLContext Window::context;
-
-std::atomic_bool shouldRun;
-
-static void renderLoop(void);
-static void logicLoop(void);
-static void LuaTest(void);
 
 int main([[maybe_unused]] int argc, [[maybe_unused]] char *argv[])
 {
@@ -97,59 +39,19 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char *argv[])
 		atexit(SDL_Quit);
 	}
 
-    LuaTest();
+    //LuaTest();
 
-	// Create our window
-	Window::init();
+	// Create the engine
+	Engine engine;
+	engine.init();
 
-	// Start game
-	shouldRun.store(true);
-	std::thread logic (logicLoop);
-	renderLoop();
-	logic.join();
+	// Go go go!
+	engine.run();
 
 	return 0;
 }
 
-void renderLoop(void)
-{
-	while (shouldRun.load()) {
-		Window::render();
-		std::this_thread::yield();
-	}
-}
-
-void logicLoop(void)
-{
-	using namespace std::chrono_literals;
-
-	std::cout << "Press escape to exit." << std::endl;
-
-	while (shouldRun.load()) {
-		for (SDL_Event event; SDL_PollEvent(&event);) {
-			switch (event.type) {
-			case SDL_KEYUP:
-				// Exit game on escape
-				if (event.key.keysym.sym == SDLK_ESCAPE)
-					shouldRun.store(false);
-				break;
-			default:
-				break;
-			}
-		}
-
-		std::this_thread::sleep_for(100ms);
-	}
-}
-
-//struct Position : entityx::Component<Position>
-//{
-//    Position(float _x, float _y): x(_x), y(_y) {}
-//    Position(void){x = y = 0.0;}
-//    
-//    float x,y;
-//};
-
+/*
 using namespace entityx;
 namespace lb = luabridge;
 
@@ -230,3 +132,4 @@ void LuaTest(void)
 
     //lua_close(L);
 }
+*/
diff --git a/src/script.hpp b/src/script.hpp
index 1dc2df2..e9373c0 100644
--- a/src/script.hpp
+++ b/src/script.hpp
@@ -22,6 +22,7 @@
 #include <entityx/entityx.h>
 #include <lua.hpp>
 #include <LuaBridge/LuaBridge.h>
+#include <script/script.hpp>
 
 /****************
 *  COMPONENTS  *
@@ -31,10 +32,11 @@
 namespace lb = luabridge;
 
 struct EntitySpawnEvent {
-    EntitySpawnEvent (const lb::LuaRef ref)
-        : ref(ref){}
+    EntitySpawnEvent (lb::LuaRef ref)
+        : ref(ref), ret(nullptr){}
 
     lb::LuaRef ref;
+    lb::LuaRef ret;
 };
 
 /**
@@ -71,6 +73,11 @@ class ScriptSystem : public entityx::System<ScriptSystem>
         int init(void)
         {
             luaL_openlibs(state.get());
+            scriptExport();
+            //doFile();
+
+            Script::CreateNewState();
+
             return 0;
         }
 
@@ -82,7 +89,6 @@ class ScriptSystem : public entityx::System<ScriptSystem>
             events.subscribe<EntitySpawnEvent>(*this);
 
             init();
-            scriptExport();
         }
         
         void update([[maybe_unused]] entityx::EntityManager& entites,
@@ -98,8 +104,9 @@ class ScriptSystem : public entityx::System<ScriptSystem>
                 std::cout << "Lua error: " << lua_tostring(state.get(), -1) << std::endl;
             }
 
-            manager.each<Position>([&](entityx::Entity, Position& p){std::cout << p.x << "," << p.y << std::endl;});
-
+            manager.each<Position>(
+                    [&](entityx::Entity, Position& p)
+                    {std::cout << p.x << "," << p.y << std::endl;});
         }
 
         lb::LuaRef spawn(lb::LuaRef ref)
@@ -138,6 +145,10 @@ class ScriptSystem : public entityx::System<ScriptSystem>
                     .endClass()
                 .endNamespace();
 
+            lb::getGlobalNamespace(state.get())
+                .beginNamespace("game")
+                .endNamespace();
+
             // Functions export
             //lb::getGlobalNamespace(state.get())
             //    .beginNamespace("game")
@@ -145,9 +156,10 @@ class ScriptSystem : public entityx::System<ScriptSystem>
             //    .endNamespace();
         }
 
-        void receive (const EntitySpawnEvent &spawn)
+        void receive (const EntitySpawnEvent &toSpawn)
         {
-            lb::push(state.get(), this->spawn(spawn.ref));
+            //toSpawn.ret = spawn(toSpawn.ref);
+            (void)toSpawn;
         }
 };
 
diff --git a/src/script/script.hpp b/src/script/script.hpp
new file mode 100644
index 0000000..340fd6f
--- /dev/null
+++ b/src/script/script.hpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2019  Belle-Isle, Andrew <drumsetmonkey@gmail.com>
+ * Author: Belle-Isle, Andrew <drumsetmonkey@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SCRIPT_NAMESPACE_HPP_
+#define SCRIPT_NAMESPACE_HPP_
+
+#include <sol/sol.hpp>
+#include <entityx/entityx.h>
+
+#include <components/Position.hpp>
+
+#include <iostream>
+
+entityx::EventManager events;
+entityx::EntityManager manager(events);
+entityx::Entity e;
+
+namespace Script
+{
+    sol::state lua;
+
+    sol::table newPosition([[maybe_unused]]sol::table tab)
+    {
+        sol::table toRet = lua.create_table_with();
+
+        e.assign<Position>(4.5, 2.3).get();
+
+        toRet["Position"] = e.component<Position>().get();
+
+        return toRet;
+    }
+
+    void CreateNewState()
+    {
+        e = manager.create();
+
+        lua.open_libraries(sol::lib::base);
+
+        //lua["q"] = Position(4.5, 3.4);
+
+        lua.new_usertype<Position>("Position",
+                sol::constructors<Position(float x, float y), Position()>(),
+                "x", &Position::x,
+                "y", &Position::y);
+
+        auto gamespace = lua["game"].get_or_create<sol::table>();
+        gamespace.set_function("testfunc", newPosition);
+
+        lua.script_file("Scripts/init.lua");
+        auto p = e.component<Position>().get();
+        std::cout << p->x << "," << p->y << std::endl;
+    }
+}
+
+#endif//SCRIPT_NAMESPACE_HPP_
diff --git a/src/window.hpp b/src/window.hpp
new file mode 100644
index 0000000..ef6632a
--- /dev/null
+++ b/src/window.hpp
@@ -0,0 +1,95 @@
+/**
+ * @file window.hpp
+ * Manages window creation.
+ *
+ * Copyright (C) 2019 Clyne Sullivan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef WINDOW_HPP_
+#define WINDOW_HPP_
+
+#include <entityx/entityx.h>
+#include <SDL2/SDL.h>
+
+/**
+ * @class WindowSystem
+ * Handles the game's window.
+ */
+class WindowSystem : public entityx::System<WindowSystem> {
+private:
+	constexpr static const char *title = "gamedev2";
+	constexpr static int width = 640;
+	constexpr static int height = 480;
+
+	std::unique_ptr<SDL_Window, void (*)(SDL_Window *)> window;
+	SDL_GLContext context;
+
+public:
+	WindowSystem(void) :
+		window(nullptr, SDL_DestroyWindow) {}
+
+	~WindowSystem(void) {
+		SDL_GL_DeleteContext(context);
+	}
+
+	/**
+	 * Creates and initializes the window.
+	 * @return Zero on success, non-zero on error
+	 */
+	int init(void) {
+		if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
+			std::cerr << "SDL video failed to initialize: "
+				<< SDL_GetError() << std::endl;
+			return -1;
+		}
+
+		// Create window, managed by the unique_ptr
+		window.reset(SDL_CreateWindow(title,
+			SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+			width, height,
+			SDL_WINDOW_OPENGL));
+
+		if (window.get() == nullptr) {
+			std::cerr << "SDL window creation failed: "
+				<< SDL_GetError() << std::endl;
+			return -1;
+		}
+
+		context = SDL_GL_CreateContext(window.get());
+
+		return 0;
+	}
+
+	/**
+	 * Prepares the system for running.
+	 */
+	void configure([[maybe_unused]] entityx::EntityManager& entities,
+		[[maybe_unused]] entityx::EventManager& events) final {
+		init();
+	}
+
+	/**
+	 * Updates/refreshes the window.
+	 */
+	void update([[maybe_unused]] entityx::EntityManager& entities,
+		[[maybe_unused]] entityx::EventManager& events,
+		[[maybe_unused]] entityx::TimeDelta dt) final {
+		SDL_GL_SwapWindow(window.get());
+	}
+};
+
+#endif // WINDOW_HPP_
+