Begin adding Lua scripting

Author: ThePixelMoon

CHANGELOG

@@ -11,6 +11,10 @@ General
 * Added Dear ImGui support for debug UI's
 * Replaced the normal .pak archives with .gpak (NEW!!!!!!!!!)
 
+Scripting
+=========
+* Added Lua scripting support
+
 AppBase
 ===========
 * Replaced the Windows API input parsing with SDL3 events.

CMakeLists.txt

@@ -141,6 +141,12 @@ FetchContent_Declare(
     GIT_TAG main
 )
 
+FetchContent_Declare(
+    Lua
+    GIT_REPOSITORY https://github.com/walterschell/Lua
+    GIT_TAG master
+)
+
 # the most hackiest hacks i've ever done
 if(APPLE)
     find_library(OPENAL_LIBRARY OpenAL REQUIRED)
@@ -206,7 +212,7 @@ FetchContent_Declare(
     GIT_TAG master
 )
 
-FetchContent_MakeAvailable(SDL3 SDL3_TTF miniaudio ogg vorbis curl zlib discordrpc glm)
+FetchContent_MakeAvailable(SDL3 SDL3_TTF miniaudio ogg vorbis curl zlib discordrpc glm Lua)
 
 add_subdirectory(external/misc EXCLUDE_FROM_ALL)
 add_subdirectory(PopLib)

PopLib/CMakeLists.txt

@@ -157,6 +157,7 @@ target_link_libraries(${PROJECT_NAME} PUBLIC
     zlibstatic
     glm
     misc
+	lua_static
 	${OPENMPT_LIBRARIES}
 )
 

PopLib/appbase.cpp

@@ -14,6 +14,7 @@
 #include "math/mtrand.hpp"
 #include "readwrite/modval.hpp"
 #include "debug/sehcatcher.hpp"
+#include "scripting/scripting_base.hpp"
 #ifdef _WIN32
 #include <direct.h>
 #else
@@ -219,6 +220,8 @@ AppBase::AppBase()
 	mWindowAspect.Set(4, 3);
 	mIsWideWindow = false;
 
+	m_pScriptingBase = nullptr;
+
 	int i;
 
 	using underlying = std::underlying_type_t<CursorType>;
@@ -1385,6 +1388,9 @@ void AppBase::ShutdownHook()
 
 void AppBase::Shutdown()
 {
+	if (m_pScriptingBase)
+		m_pScriptingBase->Shutdown();
+
 	if ((mPrimaryThreadId != 0) && (SDL_GetCurrentThreadID() != mPrimaryThreadId))
 	{
 		mLoadingFailed = true;
@@ -2243,6 +2249,12 @@ void AppBase::MakeWindow()
 		}
 	}
 
+	if (!m_pScriptingBase)
+	{
+		m_pScriptingBase = new ScriptingBase();
+		m_pScriptingBase->Initialize();
+	}
+
 	int aResult = InitInterface();
 
 	bool isActive = mActive;
@@ -3377,6 +3389,10 @@ void AppBase::Init()
 
 	InitHook();
 
+	// ok, i assume here
+	m_pScriptingBase->SetScriptFolder("scripts/");
+	m_pScriptingBase->ExecuteFolder("");
+
 	mInitialized = true;
 }
 

PopLib/appbase.hpp

@@ -17,6 +17,8 @@
 #include <SDL3/SDL.h>
 #include <SDL3_ttf/SDL_ttf.h>
 
+class ScriptingBase;
+
 /**
  * @brief registry types, but json
  */
@@ -409,6 +411,9 @@ class AppBase : public ButtonListener, public DialogListener
 	/// @brief true if widescreen window
 	bool mIsWideWindow;
 
+	/// @brief Scripting interface
+	ScriptingBase* m_pScriptingBase;
+
 	/// @brief the number of loading thread tasks
 	int mNumLoadingThreadTasks;
 	/// @brief the number of completed loading thread tasks

PopLib/math/rect.hpp

@@ -5,7 +5,7 @@
 
 #include "common.hpp"
 #include "point.hpp"
-
+#include <algorithm>
 #include <list>
 
 #ifndef _WIN32
@@ -56,10 +56,10 @@ template <class _T> class TRect
 
 	TRect<_T> Union(const TRect<_T> &theTRect)
 	{
-		_T x1 = min(mX, theTRect.mX);
-		_T x2 = max(mX + mWidth, theTRect.mX + theTRect.mWidth);
-		_T y1 = min(mY, theTRect.mY);
-		_T y2 = max(mY + mHeight, theTRect.mY + theTRect.mHeight);
+		_T x1 = std::min(mX, theTRect.mX);
+		_T x2 = std::max(mX + mWidth, theTRect.mX + theTRect.mWidth);
+		_T y1 = std::min(mY, theTRect.mY);
+		_T y2 = std::max(mY + mHeight, theTRect.mY + theTRect.mHeight);
 		return TRect<_T>(x1, y1, x2 - x1, y2 - y1);
 	}
 

PopLib/scripting/lua/lpoplib.cpp

@@ -0,0 +1,6 @@
+#include "lpoplib.hpp"
+
+void pop_openlibs(sol::state &lua)
+{
+	open_rect(lua);
+}

PopLib/scripting/lua/lpoplib.hpp

@@ -0,0 +1,13 @@
+#ifndef LPOPLIB_HPP
+#define LPOPLIB_HPP
+
+#pragma once
+
+#include <sol/sol.hpp>
+#include "../scripting_base.hpp"
+
+void(open_rect)(sol::state_view lua);
+
+void(pop_openlibs)(sol::state &lua);
+
+#endif

PopLib/scripting/lua/lrect.cpp

@@ -0,0 +1,59 @@
+#include "lpoplib.hpp"
+#include "math/rect.hpp"
+
+using namespace PopLib;
+
+void open_rect(sol::state_view lua)
+{
+	sol::table poplib;
+	if (lua["PopLib"].valid() && lua["PopLib"].get_type() == sol::type::table)
+	{
+		poplib = lua["PopLib"];
+	}
+	else
+	{
+		poplib = lua.create_table();
+		lua["PopLib"] = poplib;
+	}
+
+	poplib.new_usertype<PopLib::Rect>(
+		"Rect",
+		sol::constructors<PopLib::Rect(), PopLib::Rect(int, int, int, int), PopLib::Rect(const PopLib::Rect &)>(), "mX",
+		&PopLib::Rect::mX, "mY", &PopLib::Rect::mY, "mWidth", &PopLib::Rect::mWidth, "mHeight", &PopLib::Rect::mHeight,
+
+		"Intersects", &PopLib::Rect::Intersects, "Intersection", &PopLib::Rect::Intersection, "Union",
+		static_cast<PopLib::Rect (PopLib::Rect::*)(const PopLib::Rect &)>(&PopLib::Rect::Union), "Contains",
+		sol::overload(static_cast<bool (PopLib::Rect::*)(int, int) const>(&PopLib::Rect::Contains),
+					  static_cast<bool (PopLib::Rect::*)(const PopLib::TPoint<int> &) const>(&PopLib::Rect::Contains)),
+		"Offset",
+		sol::overload(static_cast<void (PopLib::Rect::*)(int, int)>(&PopLib::Rect::Offset),
+					  static_cast<void (PopLib::Rect::*)(const PopLib::TPoint<int> &)>(&PopLib::Rect::Offset)),
+		"Inflate", &PopLib::Rect::Inflate, sol::meta_function::to_string,
+		[](const PopLib::Rect &r) {
+			return "Rect(" + std::to_string(r.mX) + "," + std::to_string(r.mY) + "," + std::to_string(r.mWidth) + "," +
+				   std::to_string(r.mHeight) + ")";
+		},
+		sol::meta_function::equal_to, &PopLib::Rect::operator==);
+
+	poplib.new_usertype<PopLib::FRect>(
+		"FRect",
+		sol::constructors<PopLib::FRect(), PopLib::FRect(double, double, double, double),
+						  PopLib::FRect(const PopLib::FRect &)>(),
+		"mX", &PopLib::FRect::mX, "mY", &PopLib::FRect::mY, "mWidth", &PopLib::FRect::mWidth, "mHeight",
+		&PopLib::FRect::mHeight,
+
+		"Intersects", &PopLib::FRect::Intersects, "Intersection", &PopLib::FRect::Intersection, "Union",
+		static_cast<PopLib::FRect (PopLib::FRect::*)(const PopLib::FRect &)>(&PopLib::FRect::Union), "Contains",
+		sol::overload(
+			static_cast<bool (PopLib::FRect::*)(double, double) const>(&PopLib::FRect::Contains),
+			static_cast<bool (PopLib::FRect::*)(const PopLib::TPoint<double> &) const>(&PopLib::FRect::Contains)),
+		"Offset",
+		sol::overload(static_cast<void (PopLib::FRect::*)(double, double)>(&PopLib::FRect::Offset),
+					  static_cast<void (PopLib::FRect::*)(const PopLib::TPoint<double> &)>(&PopLib::FRect::Offset)),
+		"Inflate", &PopLib::FRect::Inflate, sol::meta_function::to_string,
+		[](const PopLib::FRect &r) {
+			return "FRect(" + std::to_string(r.mX) + "," + std::to_string(r.mY) + "," + std::to_string(r.mWidth) + "," +
+				   std::to_string(r.mHeight) + ")";
+		},
+		sol::meta_function::equal_to, &PopLib::FRect::operator==);
+}

PopLib/scripting/scripting_base.cpp

@@ -0,0 +1,137 @@
+#include "scripting_base.hpp"
+#include "debug/log.hpp"
+#include "lua/lpoplib.hpp"
+#include <filesystem>
+
+using namespace PopLib;
+
+bool ScriptingBase::Initialize()
+{
+	lua.open_libraries(sol::lib::base, sol::lib::package, sol::lib::os, sol::lib::string, sol::lib::math,
+					   sol::lib::table);
+
+	LOG_INFO("Lua scripting initialized");
+
+	pop_openlibs(lua);
+
+	// replace print
+	lua["print"] = [](sol::variadic_args va) {
+		std::string combined;
+		bool first = true;
+		for (auto v : va)
+		{
+			if (!first)
+				combined += "\t";
+			first = false;
+
+			if (v.is<std::string>())
+			{
+				combined += v.as<std::string>();
+			}
+			else if (v.is<bool>())
+			{
+				combined += (v.as<bool>() ? "true" : "false");
+			}
+			else if (v.is<double>())
+			{
+				combined += std::to_string(v.as<double>());
+			}
+			else if (v.is<int>())
+			{
+				combined += std::to_string(v.as<int>());
+			}
+			else
+			{
+				combined += "<non-printable>";
+			}
+		}
+		LOG_INFO(combined.c_str());
+	};
+
+	return true;
+}
+
+void ScriptingBase::Shutdown()
+{
+	lua.collect_garbage();
+	LOG_INFO("Lua scripting shut down");
+}
+
+bool ScriptingBase::ExecuteFile(const PopString &fileName)
+{
+	std::filesystem::path fullPath = std::filesystem::path(scriptFolder) / fileName;
+
+	if (!std::filesystem::exists(fullPath))
+	{
+		LOG_ERROR("Lua file not found: %s", fullPath.c_str());
+		return false;
+	}
+
+	auto result = lua.safe_script_file(
+		fullPath.string(), [](lua_State * /*L*/, sol::protected_function_result pfr) -> sol::protected_function_result {
+			if (!pfr.valid())
+			{
+				sol::error err = pfr;
+				LOG_ERROR("Lua execution error: %s", err.what());
+			}
+			return pfr;
+		});
+
+	if (!result.valid())
+	{
+		sol::error err = result;
+		LOG_ERROR("Failed to execute file '%s': %s", fullPath.string().c_str(), err.what());
+		return false;
+	}
+
+	LOG_INFO("Executed Lua file: %s", fullPath.string().c_str());
+	return true;
+}
+
+bool ScriptingBase::ExecuteString(const PopString &code)
+{
+	auto result = lua.safe_script(
+		std::string(code), [](lua_State * /*L*/, sol::protected_function_result pfr) -> sol::protected_function_result {
+			if (!pfr.valid())
+			{
+				sol::error err = pfr;
+				LOG_ERROR("Lua execution error: %s", err.what());
+			}
+			return pfr;
+		});
+
+	if (!result.valid())
+	{
+		sol::error err = result;
+		LOG_ERROR("Failed to execute Lua string: %s", err.what());
+		return false;
+	}
+
+	return true;
+}
+
+bool ScriptingBase::ExecuteFolder(const PopString &folderPath)
+{
+	std::filesystem::path fullPath = folderPath.empty() ? scriptFolder : folderPath;
+
+	if (!std::filesystem::exists(fullPath) || !std::filesystem::is_directory(fullPath))
+	{
+		LOG_ERROR("Lua folder not found: %s", fullPath.string().c_str());
+		return false;
+	}
+
+	for (auto &entry : std::filesystem::directory_iterator(fullPath))
+	{
+		if (entry.is_regular_file() && entry.path().extension() == ".lua")
+		{
+			LOG_INFO("Executing Lua file: %s", entry.path().string().c_str());
+			if (!ExecuteFile(entry.path().filename().string()))
+			{
+				LOG_ERROR("Failed to execute Lua file: %s", entry.path().string().c_str());
+				return false;
+			}
+		}
+	}
+
+	return true;
+}