Added periods to MOSR method comments. These belong in the header, but I'll leave that be til we reformat MOSR completely.

Removed MovableMan::ScriptedEntity and just used LuaMan::TempEntity. They serve the same functionality and it makes more sense for that bridge between cpp and lua to be in LuaMan.
Reorganized RunScriptedFunction methods, and simplified UpdateScripts and UpdateScriptedAI by pulling some logic out.

Author: garethyr

Entities/Actor.cpp

@@ -1289,36 +1289,13 @@ bool Actor::UpdateAIScripted() {
         return false;
     }
 
-    // Check to make sure the preset of this is still defined in the Lua state. If not, re-create it and recover gracefully
-    if (!g_LuaMan.ExpressionIsTrue(m_ScriptPresetName, false)) {
-        RTEAbort("Trying to run UpdateAIScripted with no ScriptPresetName. This shouldn't happen, please let a dev know.")
-        //ReloadScripts(); //TODO test if this should be here, I think it's junk cause for any cases where there's AI, update will always be called first. If it shouldn't, change the early return above.
-    }
-
-    // If we don't have a Lua representation for this object instance, create one and call the Lua Create function on it
-    if (m_ScriptObjectName.empty()) {
-        RTEAbort("Trying to run UpdateAIScripted with no ScriptObjectName. This shouldn't happen, please let a dev know.")
-        /*//TODO test if this should be here, I think it's junk cause for any cases where there's AI, update will always be called first. If it shouldn't, change the early return above.
-        m_ScriptObjectName = GetClassName() + "s." + g_LuaMan.GetNewObjectID();
-
-        // Give Lua access to this object, then use that access to set up the object's Lua representation
-        g_MovableMan.SetScriptedEntity(this);
-        if (g_LuaMan.RunScriptString(m_ScriptObjectName + " = To" + GetClassName() + "(MovableMan.ScriptedEntity);") < 0) {
-            return false;
-        }
-
-        for (std::pair<std::string, bool> scriptEntry : m_LoadedScripts) {
-            if (g_LuaMan.RunFunctionInPresetScript("Create", scriptEntry.first, m_ScriptPresetName, m_ScriptObjectName) < 0) {
-                return -3;
-            }
-        }*/
-    }
-
-	g_FrameMan.StartPerformanceMeasurement(FrameMan::PERF_ACTORS_AI);
-    bool aiUpdateSucceeded = RunScriptedFunctionInAppropriateScripts("UpdateAI", false, true) < 0;
-	g_FrameMan.StopPerformanceMeasurement(FrameMan::PERF_ACTORS_AI);
+    int status = !g_LuaMan.ExpressionIsTrue(m_ScriptPresetName, false) ? ReloadScripts() : 0;
+    status = (status >= 0 && m_ScriptObjectName.empty()) ? SetupScriptObjectNameAndRunLuaCreateFunctions() : status;
+    g_FrameMan.StartPerformanceMeasurement(FrameMan::PERF_ACTORS_AI);
+    status = (status >= 0) ? RunScriptedFunctionInAppropriateScripts("UpdateAI", false, true) : status;
+    g_FrameMan.StopPerformanceMeasurement(FrameMan::PERF_ACTORS_AI);
 
-    return aiUpdateSucceeded;
+    return status >= 0;
 }
 
 

Entities/MOSRotating.cpp

@@ -1756,9 +1756,9 @@ void MOSRotating::UpdateChildMOIDs(vector<MovableObject *> &MOIDIndex,
 
 
 /// <summary>
-/// Attaches the passed in Attachable and adds it to the list of attachables, not changing its parent offset and not treating it as hardcoded
+/// Attaches the passed in Attachable and adds it to the list of attachables, not changing its parent offset and not treating it as hardcoded.
 /// </summary>
-/// <param name="pAttachable">The Attachable to attach</param>
+/// <param name="pAttachable">The Attachable to attach.</param>
 void MOSRotating::AddAttachable(Attachable *pAttachable)
 {
 	if (pAttachable)
@@ -1769,21 +1769,21 @@ void MOSRotating::AddAttachable(Attachable *pAttachable)
 
 
 /// <summary>
-/// Attaches the passed in Attachable and adds it to the list of attachables, changing its parent offset to the passed in Vector but not treating it as hardcoded
+/// Attaches the passed in Attachable and adds it to the list of attachables, changing its parent offset to the passed in Vector but not treating it as hardcoded.
 /// </summary>
-/// <param name="pAttachable">The Attachable to add</param>
-/// <param name="parentOffsetToSet">The vector to set as the Attachable's parent offset</param>
+/// <param name="pAttachable">The Attachable to add.</param>
+/// <param name="parentOffsetToSet">The vector to set as the Attachable's parent offset.</param>
 void MOSRotating::AddAttachable(Attachable *pAttachable, const Vector& parentOffsetToSet)
 {
 	AddAttachable(pAttachable, parentOffsetToSet, false);
 }
 
 
 /// <summary>
-/// Attaches the passed in Attachable and adds it to the list of attachables, not changing its parent offset but treating it as hardcoded depending on the passed in boolean
+/// Attaches the passed in Attachable and adds it to the list of attachables, not changing its parent offset but treating it as hardcoded depending on the passed in boolean.
 /// </summary>
-/// <param name="pAttachable">The Attachable to add</param>
-/// <param name="isHardcodedAttachable">Whether or not the Attachable should be treated as hardcoded</param>
+/// <param name="pAttachable">The Attachable to add.</param>
+/// <param name="isHardcodedAttachable">Whether or not the Attachable should be treated as hardcoded.</param>
 void MOSRotating::AddAttachable(Attachable *pAttachable, bool isHardcodedAttachable)
 {
 	if (pAttachable)
@@ -1796,9 +1796,9 @@ void MOSRotating::AddAttachable(Attachable *pAttachable, bool isHardcodedAttacha
 /// <summary>
 /// Attaches the passed in Attachable and adds it to the list of attachables, changing its parent offset to the passed in Vector and treating it as hardcoded depending on the passed in boolean.
 /// </summary>
-/// <param name="pAttachable">The Attachable to add</param>
-/// <param name="parentOffsetToSet">The vector to set as the Attachable's parent offset</param>
-/// <param name="isHardcodedAttachable">Whether or not the Attachable should be treated as hardcoded</param>
+/// <param name="pAttachable">The Attachable to add.</param>
+/// <param name="parentOffsetToSet">The vector to set as the Attachable's parent offset.</param>
+/// <param name="isHardcodedAttachable">Whether or not the Attachable should be treated as hardcoded.</param>
 void MOSRotating::AddAttachable(Attachable *pAttachable, const Vector & parentOffsetToSet, bool isHardcodedAttachable)
 {
 	if (pAttachable)

Entities/MovableObject.cpp

@@ -467,6 +467,24 @@ void MovableObject::Destroy(bool notInherited) {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+int MovableObject::SetupScriptObjectNameAndRunLuaCreateFunctions() {
+    m_ScriptObjectName = GetClassName() + "s." + g_LuaMan.GetNewObjectID();
+
+    // Give Lua access to this object, then use that access to set up the object's Lua representation
+    g_LuaMan.SetTempEntity(this);
+
+    if (g_LuaMan.RunScriptString(m_ScriptObjectName + " = To" + GetClassName() + "(LuaMan.TempEntity);") < 0) {
+        return -2;
+    }
+
+    if (RunScriptedFunctionInAppropriateScripts("Create", true, true) < 0) {
+        return -3;
+    }
+    return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 int MovableObject::LoadScript(std::string const &scriptPath, bool loadAsEnabledScript) {
     // Return an error if the script path is empty or already there
     if (scriptPath.empty()) {
@@ -638,25 +656,6 @@ bool MovableObject::DisableScript(std::string const &scriptPath) {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-int MovableObject::RunScriptedFunctionInAppropriateScripts(std::string const &functionName, bool runOnDisabledScripts, bool stopOnError, std::vector<Entity *> functionEntityArguments, std::vector<std::string> functionLiteralArguments) {
-    if (m_LoadedScripts.empty() || m_ScriptPresetName.empty() || m_ScriptObjectName.empty()) {
-        return -1;
-    }
-
-    int status = 0;
-    for (std::pair<std::string, bool> scriptEntry : m_LoadedScripts) {
-        if (runOnDisabledScripts || scriptEntry.second == true) {
-            status = RunScriptedFunction(scriptEntry.first, functionName, functionEntityArguments, functionLiteralArguments);
-            if (status < 0 && stopOnError) {
-                return status;
-            }
-        }
-    }
-    return status;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
 int MovableObject::RunScriptedFunction(std::string const &scriptPath, std::string const &functionName, std::vector<Entity *> functionEntityArguments, std::vector<std::string> functionLiteralArguments) {
     if (m_LoadedScripts.empty() || m_ScriptPresetName.empty() || m_ScriptObjectName.empty()) {
         return -1;
@@ -694,6 +693,25 @@ int MovableObject::RunScriptedFunction(std::string const &scriptPath, std::strin
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+int MovableObject::RunScriptedFunctionInAppropriateScripts(std::string const &functionName, bool runOnDisabledScripts, bool stopOnError, std::vector<Entity *> functionEntityArguments, std::vector<std::string> functionLiteralArguments) {
+    if (m_LoadedScripts.empty() || m_ScriptPresetName.empty() || m_ScriptObjectName.empty()) {
+        return -1;
+    }
+
+    int status = 0;
+    for (std::pair<std::string, bool> scriptEntry : m_LoadedScripts) {
+        if (runOnDisabledScripts || scriptEntry.second == true) {
+            status = RunScriptedFunction(scriptEntry.first, functionName, functionEntityArguments, functionLiteralArguments);
+            if (status < 0 && stopOnError) {
+                return status;
+            }
+        }
+    }
+    return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 /*
 //////////////////////////////////////////////////////////////////////////////////////////
 // Constructor:     MovableObject
@@ -956,30 +974,11 @@ int MovableObject::UpdateScripts() {
         return -1;
     }
 
-    // Check to make sure the preset of this is still defined in the Lua state. If not, re-create it and recover gracefully
-    if (!g_LuaMan.ExpressionIsTrue(m_ScriptPresetName, false)) { ReloadScripts(); }
-
-    // If we don't have a Lua representation for this object instance, create one and call the Lua Create function on it
-    if (m_ScriptObjectName.empty()) {
-        m_ScriptObjectName = GetClassName() + "s." + g_LuaMan.GetNewObjectID();
-
-        // Give Lua access to this object, then use that access to set up the object's Lua representation
-        g_MovableMan.SetScriptedEntity(this);
+    int status = !g_LuaMan.ExpressionIsTrue(m_ScriptPresetName, false) ? ReloadScripts() : 0;
+    status = (status >= 0 && m_ScriptObjectName.empty()) ? SetupScriptObjectNameAndRunLuaCreateFunctions() : status;
+    status = (status >= 0) ? RunScriptedFunctionInAppropriateScripts("Update", false, true) : status;
 
-        if (g_LuaMan.RunScriptString(m_ScriptObjectName + " = To" + GetClassName() + "(MovableMan.ScriptedEntity);") < 0) {
-            return -2;
-        }
-
-        if (RunScriptedFunctionInAppropriateScripts("Create", true, true) < 0) {
-            return -3;
-        }
-    }
-
-    if (RunScriptedFunctionInAppropriateScripts("Update", false, true) < 0) {
-        return -3;
-    }
-
-    return 0;
+    return status;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Entities/MovableObject.h

@@ -242,27 +242,27 @@ ENTITYALLOCATION(MovableObject)
     virtual bool DisableScript(std::string const &scriptPath);
 
     /// <summary>
-    /// Runs the given function in all scripts that have it, with the given arguments, with the ability to not run on disabled scripts and to cease running if there's an error.
-    /// The first argument to the function will always be 'self'. If either argument list is not emtpy, its entries will be passed into the Lua function in order, with entity arguments first.
+    /// Runs the given function for the given script, with the given arguments. The first argument to the function will always be 'self'.
+    /// If either argument list is not emtpy, its entries will be passed into the Lua function in order, with entity arguments first.
     /// </summary>
+    /// <param name="scriptPath">The path to the script to run.</param>
     /// <param name="functionName">The name of the function to run.</param>
-    /// <param name="runOnDisabledScripts">Whether to run the function on disabled scripts. Defaults to false.</param>
-    /// <param name="stopOnError">Whether to stop if there's an error running any script, or simply print it to the console and continue. Defaults to false.</param>
     /// <param name="functionEntityArguments">Optional vector of entity pointers that should be passed into the Lua function. Their internal Lua states will not be accessible. Defaults to empty.</param>
     /// <param name="functionLiteralArguments">Optional vector of strings, that should be passed into the Lua function. Entries must be surrounded with escaped quotes (i.e.`\"`) they'll be passed in as-is, allowing them to act as booleans, etc.. Defaults to empty.</param>
     /// <returns>An error return value signaling sucess or any particular failure. Anything below 0 is an error signal.</returns>
-    int RunScriptedFunctionInAppropriateScripts(std::string const &functionName, bool runOnDisabledScripts = false, bool stopOnError = false, std::vector<Entity *> functionEntityArguments = std::vector<Entity *>(), std::vector<std::string> functionLiteralArguments = std::vector<std::string>());
+    int RunScriptedFunction(std::string const &scriptPath, std::string const &functionName, std::vector<Entity *> functionEntityArguments = std::vector<Entity *>(), std::vector<std::string> functionLiteralArguments = std::vector<std::string>());
 
     /// <summary>
-    /// Runs the given function for the given script, with the given arguments. The first argument to the function will always be 'self'.
-    /// If either argument list is not emtpy, its entries will be passed into the Lua function in order, with entity arguments first.
+    /// Runs the given function in all scripts that have it, with the given arguments, with the ability to not run on disabled scripts and to cease running if there's an error.
+    /// The first argument to the function will always be 'self'. If either argument list is not emtpy, its entries will be passed into the Lua function in order, with entity arguments first.
     /// </summary>
-    /// <param name="scriptPath">The path to the script to run.</param>
     /// <param name="functionName">The name of the function to run.</param>
+    /// <param name="runOnDisabledScripts">Whether to run the function on disabled scripts. Defaults to false.</param>
+    /// <param name="stopOnError">Whether to stop if there's an error running any script, or simply print it to the console and continue. Defaults to false.</param>
     /// <param name="functionEntityArguments">Optional vector of entity pointers that should be passed into the Lua function. Their internal Lua states will not be accessible. Defaults to empty.</param>
     /// <param name="functionLiteralArguments">Optional vector of strings, that should be passed into the Lua function. Entries must be surrounded with escaped quotes (i.e.`\"`) they'll be passed in as-is, allowing them to act as booleans, etc.. Defaults to empty.</param>
     /// <returns>An error return value signaling sucess or any particular failure. Anything below 0 is an error signal.</returns>
-    int RunScriptedFunction(std::string const &scriptPath, std::string const &functionName, std::vector<Entity *> functionEntityArguments = std::vector<Entity *>(), std::vector<std::string> functionLiteralArguments = std::vector<std::string>());
+    int RunScriptedFunctionInAppropriateScripts(std::string const &functionName, bool runOnDisabledScripts = false, bool stopOnError = false, std::vector<Entity *> functionEntityArguments = std::vector<Entity *>(), std::vector<std::string> functionLiteralArguments = std::vector<std::string>());
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  GetClass
@@ -1776,6 +1776,12 @@ ENTITYALLOCATION(MovableObject)
     /// <returns>A vector containing the script function names this class supports.</returns>
     virtual const std::vector<std::string> GetSupportedScriptFunctionNames() { return std::vector<std::string> {"Create", "Destroy", "Update", "OnPieMenu", "OnScriptRemoveOrDisable", "OnScriptEnable"}; }
 
+    /// <summary>
+    /// Does necessary work to setup a script object name for this object, allowing it to be accessed in Lua, then runs all of the MO's scripts' Create functions in Lua.
+    /// </summary>
+    /// <returns>0 on success, -2 if it fails to setup the script object in Lua, and -3 if it fails to run any Create function.</returns>
+    int SetupScriptObjectNameAndRunLuaCreateFunctions();
+
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  UpdateChildMOIDs
 //////////////////////////////////////////////////////////////////////////////////////////

Managers/LuaMan.cpp

@@ -394,6 +394,8 @@ void LuaMan::Clear()
     m_NextPresetID = 0;
     m_NextObjectID = 0;
     m_pTempEntity = 0;
+    m_TempEntityVector.clear();
+    m_TempEntityVector.shrink_to_fit();
 
 	//Clear files list
 	for (int i = 0; i < MAX_OPEN_FILES; ++i)
@@ -2157,7 +2159,6 @@ int LuaMan::Create()
             .def("GetAGResolution", &MovableMan::GetAGResolution)
             .def("GetSplashRatio", &MovableMan::GetSplashRatio)
             .property("MaxDroppedItems", &MovableMan::GetMaxDroppedItems, &MovableMan::SetMaxDroppedItems)
-            .property("ScriptedEntity", &MovableMan::GetScriptedEntity, &MovableMan::SetScriptedEntity)
             .def("SortTeamRoster", &MovableMan::SortTeamRoster)
 			.def("ChangeActorTeam", &MovableMan::ChangeActorTeam)
 			.def("AddMO", &AddMO, adopt(_2))

Managers/LuaMan.h

@@ -401,7 +401,7 @@ enum ServerResult
     // The next unique object ID to hand out to the next scripted Entity instance that wants to run its preset's scripts
     // This gets incremented each time a new one is requested to give unique ID's to all scripted objects
     long m_NextObjectID;
-    // Temporary holder for an Entity object that we want to pass into the Lua state without fuss
+    // Temporary holder for an Entity object that we want to pass into the Lua state without fuss. Lets you export objects to lua easily.
     Entity *m_pTempEntity;
     // 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::vector<Entity *> m_TempEntityVector;

Managers/MovableMan.cpp

@@ -70,7 +70,6 @@ void MovableMan::Clear()
     m_SloMoDuration = 1000;
     m_SettlingEnabled = true;
     m_MOSubtractionEnabled = true;
-    m_pObjectToScriptUpdate = 0;
 }
 
 
@@ -1658,9 +1657,6 @@ void MovableMan::Update()
     if (g_TimerMan.SimUpdatesSinceDrawn() == 0)
         g_SceneMan.ClearPostEffects();
 
-    // Lua transfer pointer needs to be cleared, what was set here last update isn't valid anymore
-    m_pObjectToScriptUpdate = 0;
-
     // Reset the draw HUD roster line settings
     m_SortTeamRoster[Activity::TEAM_1] = false;
     m_SortTeamRoster[Activity::TEAM_2] = false;