Allow disabling current script without needing to supply filepath

Author: Causeless

Entities/MovableObject.cpp

@@ -719,7 +719,7 @@ int MovableObject::RunScriptedFunctionInAppropriateScripts(const std::string &fu
             const LuabindObjectWrapper *luabindObjectWrapper = luaFunction.m_LuaFunction.get();
             if (runOnDisabledScripts || luaFunction.m_ScriptIsEnabled) {
                 LuaStateWrapper& usedState = GetAndLockStateForScript(luabindObjectWrapper->GetFilePath(), &luaFunction);
-                std::lock_guard<std::recursive_mutex> lock(usedState.GetMutex(), std::adopt_lock);   
+                std::lock_guard<std::recursive_mutex> lock(usedState.GetMutex(), std::adopt_lock);
 				status = usedState.RunScriptFunctionObject(luabindObjectWrapper, "_ScriptedObjects", std::to_string(m_UniqueID), functionEntityArguments, functionLiteralArguments, functionObjectArguments);
                 if (status < 0 && stopOnError) {
                     return status;

Lua/LuaAdapterDefinitions.h

@@ -354,7 +354,8 @@ namespace RTE {
 		static bool HasScript(MovableObject *luaSelfObject, const std::string &scriptPath);
 		static bool AddScript(MovableObject *luaSelfObject, const std::string &scriptPath);
 		static bool EnableScript(MovableObject *luaSelfObject, const std::string &scriptPath);
-		static bool DisableScript(MovableObject *luaSelfObject, const std::string &scriptPath);
+		static bool DisableScript1(MovableObject *luaSelfObject);
+		static bool DisableScript2(MovableObject *luaSelfObject, const std::string &scriptPath);
 		static void SendMessage1(MovableObject *luaSelfObject, const std::string &message);
 		static void SendMessage2(MovableObject *luaSelfObject, const std::string &message, luabind::object context);
 	};

Lua/LuaAdapters.cpp

@@ -401,9 +401,17 @@ namespace RTE {
 		return luaSelfObject->EnableOrDisableScript(g_PresetMan.GetFullModulePath(scriptPath), true);
 	}
 
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	bool LuaAdaptersMovableObject::DisableScript1(MovableObject* luaSelfObject) {
+		std::string currentScriptFilePath(g_LuaMan.GetThreadCurrentLuaState()->GetCurrentlyRunningScriptFilePath());
+		return luaSelfObject->EnableOrDisableScript(currentScriptFilePath, false);
+	}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	bool LuaAdaptersMovableObject::DisableScript(MovableObject *luaSelfObject, const std::string &scriptPath) {
+	bool LuaAdaptersMovableObject::DisableScript2(MovableObject *luaSelfObject, const std::string &scriptPath) {
 		return luaSelfObject->EnableOrDisableScript(g_PresetMan.GetFullModulePath(scriptPath), false);
 	}
 

Lua/LuaBindingsEntities.cpp

@@ -1041,7 +1041,8 @@ namespace RTE {
 		.def("AddScript", &LuaAdaptersMovableObject::AddScript)
 		.def("ScriptEnabled", &MovableObject::ScriptEnabled)
 		.def("EnableScript", &LuaAdaptersMovableObject::EnableScript)
-		.def("DisableScript", &LuaAdaptersMovableObject::DisableScript)
+		.def("DisableScript", &LuaAdaptersMovableObject::DisableScript1)
+		.def("DisableScript", &LuaAdaptersMovableObject::DisableScript2)
 		.def("EnableOrDisableAllScripts", &MovableObject::EnableOrDisableAllScripts)
 		.def("GetStringValue", &MovableObject::GetStringValue)
 		.def("GetEncodedStringValue", &MovableObject::GetEncodedStringValue)

Managers/LuaMan.cpp

@@ -18,6 +18,7 @@ namespace RTE {
 		m_TempEntity = nullptr;
 		m_TempEntityVector.clear();
 		m_LastError.clear();
+		m_CurrentlyRunningScriptPath = "";
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -571,6 +572,7 @@ namespace RTE {
 
 		std::lock_guard<std::recursive_mutex> lock(m_Mutex);
 		s_currentLuaState = this;
+		m_CurrentlyRunningScriptPath = functionObject->GetFilePath();
 
 		lua_pushcfunction(m_State, &AddFileAndLineToError);
 		functionObject->GetLuabindObject()->push(m_State);
@@ -634,6 +636,7 @@ namespace RTE {
 
 		lua_pop(m_State, 1);
 
+		m_CurrentlyRunningScriptPath = "";
 		return status;
 	}
 
@@ -659,6 +662,7 @@ namespace RTE {
 
 		std::lock_guard<std::recursive_mutex> lock(m_Mutex);
 		s_currentLuaState = this;
+		m_CurrentlyRunningScriptPath = filePath;
 
 		const int stackStart = lua_gettop(m_State);
 
@@ -709,6 +713,7 @@ namespace RTE {
 		// Pop the line error handler off the stack to clean it up
 		lua_pop(m_State, 1);
 
+		m_CurrentlyRunningScriptPath = "";
 		RTEAssert(lua_gettop(m_State) == stackStart, "Malformed lua stack!");
 		return error;
 	}

Managers/LuaMan.h

@@ -88,6 +88,12 @@ namespace RTE {
 		/// </summary>
 		/// <returns>m_ScriptTimings.</returns>
 		const std::unordered_map<std::string, PerformanceMan::ScriptTiming> & GetScriptTimings() const;
+
+		/// <summary>
+		/// Gets the currently running script filepath, if applicable.
+		/// </summary>
+		/// <returns>The currently running script filepath. May return inaccurate values for non-MO scripts due to weirdness in setup.</returns>
+		std::string_view GetCurrentlyRunningScriptFilePath() const { return m_CurrentlyRunningScriptPath; }
 #pragma endregion
 
 #pragma region Script Responsibility Handling
@@ -307,6 +313,7 @@ namespace RTE {
 		Entity *m_TempEntity; //!< Temporary holder for an Entity object that we want to pass into the Lua state without fuss. Lets you export objects to lua easily.
 		std::vector<Entity *> m_TempEntityVector; //!< Temporary holder for a vector of Entities that we want to pass into the Lua state without a fuss. Usually used to pass arguments to special Lua functions.
 		std::string m_LastError; //!< Description of the last error that occurred in the script execution.
+		std::string_view m_CurrentlyRunningScriptPath; //!< The currently running script filepath.
 
 		// This mutex is more for safety, and with new script/AI architecture we shouldn't ever be locking on a mutex. As such we use this primarily to fire asserts.
 		std::recursive_mutex m_Mutex; //!< Mutex to ensure multiple threads aren't running something in this lua state simultaneously.