Merge pull request #109 from cortex-command-community/CF104-Multiple-Scripts-On-MOs

Cf104 multiple scripts on m os

Author: garethyr

Activities/GAScripted.cpp

@@ -269,55 +269,34 @@ bool GAScripted::SceneIsCompatible(Scene *pScene, int teams)
     return g_LuaMan.GlobalIsDefined("TestScene");
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual Method:  EnteredOrbit
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Indicates an Actor as having left the game scene and entered orbit.
-//                  OWNERSHIP IS NOT transferred, as the Actor's inventory is just 'unloaded'.
-
-void GAScripted::EnteredOrbit(Actor *pActor)
-{
-    GameActivity::EnteredOrbit(pActor);
-
-    // Save the ACraft actor temporarily to member so the lua function can access it
-    m_pOrbitedCraft = pActor;
+void GAScripted::EnteredOrbit(Actor *orbitedCraft) {
+    GameActivity::EnteredOrbit(orbitedCraft);
 
-    if (m_pOrbitedCraft && g_MovableMan.IsActor(m_pOrbitedCraft))
-    {
-        // Call the defined function, but only after first checking if it exists
-        g_LuaMan.RunScriptString("if " + m_LuaClassName + ".CraftEnteredOrbit then " + m_LuaClassName + ":CraftEnteredOrbit(); end");
-
-		// Trigger orbited craft for all global scripts
-		for (std::vector<GlobalScript *>::iterator sItr = m_GlobalScriptsList.begin(); sItr < m_GlobalScriptsList.end(); ++sItr)
-			if ((*sItr)->IsActive())
-				(*sItr)->EnteredOrbit(m_pOrbitedCraft);
+    if (orbitedCraft && g_MovableMan.IsActor(orbitedCraft)) {
+        g_LuaMan.RunScriptedFunction(m_LuaClassName + ".CraftEnteredOrbit", m_LuaClassName, {m_LuaClassName, m_LuaClassName + ".CraftEnteredOrbit"}, {orbitedCraft});
+        for (GlobalScript *globalScript : m_GlobalScriptsList) {
+            if (globalScript->IsActive()) { globalScript->EnteredOrbit(orbitedCraft); }
+        }
     }
-
-    // Let go because it's about to be deleted later this frame
-    m_pOrbitedCraft = 0;
 }
 
-void GAScripted::OnPieMenu(Actor *pActor)
-{
-	m_pPieMenuActor = pActor;
-	if (pActor && g_MovableMan.IsActor(pActor))
-	{
-		m_pPieMenuActor->OnPieMenu(pActor);
-
-		g_MovableMan.OnPieMenu(pActor);
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-		// Call the defined function, but only after first checking if it exists
-		g_LuaMan.RunScriptString("if " + m_LuaClassName + ".OnPieMenu then " + m_LuaClassName + ":OnPieMenu(); end");
-
-		// Trigger pie menu for all global scripts
-		for (std::vector<GlobalScript *>::iterator sItr = m_GlobalScriptsList.begin(); sItr < m_GlobalScriptsList.end(); ++sItr)
-			if ((*sItr)->IsActive())
-				(*sItr)->OnPieMenu(m_pPieMenuActor);
+void GAScripted::OnPieMenu(Actor *pieMenuActor) {
+	if (pieMenuActor && g_MovableMan.IsActor(pieMenuActor)) {
+        pieMenuActor->OnPieMenu(pieMenuActor);
+		g_MovableMan.OnPieMenu(pieMenuActor);
+        g_LuaMan.RunScriptedFunction(m_LuaClassName + ".OnPieMenu", m_LuaClassName, {m_LuaClassName, m_LuaClassName + ".OnPieMenu"}, {pieMenuActor});
+        for (GlobalScript *globalScript : m_GlobalScriptsList) {
+            if (globalScript->IsActive()) { globalScript->OnPieMenu(pieMenuActor); }
+        }
 	}
-
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  Start
 //////////////////////////////////////////////////////////////////////////////////////////

Activities/GAScripted.h

@@ -209,15 +209,11 @@ ENTITYALLOCATION(GAScripted)
     virtual bool SceneIsCompatible(Scene *pScene, int teams = -1);
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  EnteredOrbit
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Indicates an Actor as having left the game scene and entered orbit.
-//                  OWNERSHIP IS NOT transferred, as the Actor's inventory is just 'unloaded'.
-// Arguments:       The actor instance. Ownership IS NOT TRANSFERRED!
-// Return value:    None.
-
-    virtual void EnteredOrbit(Actor *pActor);
+    /// <summary>
+    /// Indicates an Actor as having left the game scene and entered orbit.  OWNERSHIP IS NOT transferred, as the Actor's inventory is just 'unloaded'.
+    /// </summary>
+    /// <param name="orbitedCraft">The actor instance that entered orbit. Ownership IS NOT TRANSFERRED!</param>
+    virtual void EnteredOrbit(Actor *orbitedCraft);
 
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -283,14 +279,11 @@ ENTITYALLOCATION(GAScripted)
 	virtual void UpdateGlobalScripts(bool lateUpdate);
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Method:          OnPieMenu
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Calls this to be processed by derived classes to enable pie-menu dynamic change
-// Arguments:       None.
-// Return value:    None.
-
-	virtual void OnPieMenu(Actor *pActor);
+    /// <summary>
+    /// Calls this to be processed by derived classes to enable pie-menu dynamic change.
+    /// </summary>
+    /// <param name="pieMenuActor">The actor which triggered the pie menu event.</param>
+	virtual void OnPieMenu(Actor *pieMenuActor);
 
 
 //////////////////////////////////////////////////////////////////////////////////////////

Activities/GameActivity.cpp

@@ -114,8 +114,6 @@ void GameActivity::Clear()
     m_GameOverTimer.Reset();
     m_GameOverPeriod = 5000;
     m_WinnerTeam = -1;
-    m_pOrbitedCraft = 0;
-	m_pPieMenuActor = 0;
 }
 
 

Activities/GameActivity.h

@@ -916,15 +916,7 @@ ENTITYALLOCATION(GameActivity)
 
 	void SetNetworkPlayerName(int player, std::string name);
 
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// Method:          OnPieMenu
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Calls this to be processed by derived classes to enable pie-menu dynamic change
-// Arguments:       None.
-// Return value:    None.
-
-	virtual void OnPieMenu(Actor *pActor) { m_pPieMenuActor = pActor; };
+    virtual void OnPieMenu(Actor *actor) { /* Does nothing, kept here for program control flow. Method is not pure virtual to avoid a bunch of junk implementations in non-scritped activities. */};
 
 	virtual void AddPieMenuSlice(std::string description, std::string functionName, PieMenuGUI::Slice::SliceDirection direction, bool isEnabled)
 	{ 
@@ -1187,10 +1179,6 @@ ENTITYALLOCATION(GameActivity)
     long m_GameOverPeriod;
     // The winning team number, when the game is over
     int m_WinnerTeam;
-    // Temporary member for whatever craft goes into orbit, so Lua can access it. Not owned by this
-    Actor *m_pOrbitedCraft;
-	// Temporary member for whatever actor has enabled the pie menu. Not owned by this
-	Actor *m_pPieMenuActor;
 
 	std::vector<PieMenuGUI::Slice *> m_CurrentPieMenuSlices;
 

Entities/AHuman.cpp

@@ -3141,22 +3141,20 @@ void AHuman::UpdateAI()
     }
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  OnPieMenu
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Executes the Lua-defined OnPieMenu event handler.
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-int AHuman::OnPieMenu(Actor * pActor)
-{
-	int error = Actor::OnPieMenu(pActor);
+int AHuman::OnPieMenu(Actor *pieMenuActor) {
+	int status = Actor::OnPieMenu(pieMenuActor);
 
-	// Call OnPieMenu handlers for a currently held device if any
-	if (m_pFGArm && m_pFGArm->IsAttached() && m_pFGArm->HoldsDevice())
-		return m_pFGArm->GetHeldDevice()->OnPieMenu(pActor);
+    if (status >= 0 && m_pFGArm && m_pFGArm->IsAttached() && m_pFGArm->HoldsDevice()) {
+        return m_pFGArm->GetHeldDevice()->OnPieMenu(pieMenuActor);
+    }
 
-	return 0;
+	return status;
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  Update
 //////////////////////////////////////////////////////////////////////////////////////////

Entities/AHuman.h

@@ -916,16 +916,12 @@ ENTITYALLOCATION(AHuman)
 
     virtual void Update();
 
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  OnPieMenu
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Executes the Lua-defined OnPieMenu event handler.
-// Arguments:       Actor which triggered the pie menu event
-// Return value:    An error return value signaling sucess or any particular failure.
-//                  Anything below 0 is an error signal.
-
-	virtual int OnPieMenu(Actor * pActor);
+    /// <summary>
+    /// Executes the Lua-defined OnPieMenu event handler for this AHuman.
+    /// </summary>
+    /// <param name="pieMenuActor">The actor which triggered the pie menu event.</param>
+    /// <returns>An error return value signaling sucess or any particular failure. Anything below 0 is an error signal.</returns>
+	virtual int OnPieMenu(Actor *pieMenuActor);
 
 
 //////////////////////////////////////////////////////////////////////////////////////////

Entities/Actor.cpp

@@ -487,41 +487,22 @@ void Actor::Destroy(bool notInherited)
     Clear();
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  LoadScripts
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Loads the preset scripts of this object, from a specified path.
-
-int Actor::LoadScripts(string scriptPath)
-{
-    if (scriptPath.empty())
-        return -1;
-
-    int error = 0;
-
-    // Clear the temporary variable names that will hold the functions read in from the file
-    if ((error = g_LuaMan.RunScriptString("UpdateAI = nil;")) < 0)
-        return error;
-
-    // Read in the Lua script function definitions for this preset
-    if ((error = MovableObject::LoadScripts(scriptPath)) < 0)
-        return error;
-
-    // Add the UpdateAI function, if it exists.. if it doesn't, that's not a problem! We'll just be using the old C++ implementation
-    if (g_LuaMan.GlobalIsDefined("UpdateAI"))
-    {
-        // Mark that we have a Lua override for the UpdateAI function
-        m_ScriptedAIUpdate = true;
-        if ((error = g_LuaMan.RunScriptString("if UpdateAI then " + m_ScriptPresetName + ".UpdateAI = UpdateAI; end;")) < 0)
-            return error;
+int Actor::LoadScript(std::string const &scriptPath, bool loadAsEnabledScript) {
+    int status = MOSRotating::LoadScript(scriptPath, loadAsEnabledScript);
+    if (status < 0) {
+        return status;
     }
-    else
-        m_ScriptedAIUpdate = false;
 
-    return error;
+    // If UpdateAI existed it'll be in the lua global namespace, so we can check that to know whether or not to use Lua AI
+    m_ScriptedAIUpdate = g_LuaMan.GlobalIsDefined("UpdateAI");
+
+    return status;
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  GetMass
@@ -1301,52 +1282,20 @@ bool Actor::UpdateMovePath()
     return true;
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  UpdateAIScripted
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Updates this' AI state with the provided scripted AI Update function.
-
-bool Actor::UpdateAIScripted()
-{
-    // This preset doesn't seem to have any script file defined, so then just report we couldn't run scripted AI
-    if (!m_ScriptedAIUpdate || m_ScriptPath.empty() || m_ScriptPresetName.empty())
+bool Actor::UpdateAIScripted() {
+    if (!m_ScriptedAIUpdate || m_LoadedScripts.empty() || m_ScriptPresetName.empty()) {
         return false;
-
-    int error = 0;
-
-    // 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();
-
-    // First see if we even have a representation stored in the Lua state, and if not, create one
-    if (m_ScriptObjectName.empty())
-    {
-        // Get the unique object identifier for this object and construct the object isntance name in Lua that points to this object so we can pass it into the preset functions
-        m_ScriptObjectName = GetClassName() + "s." + g_LuaMan.GetNewObjectID();
-
-        // Give access to this in the Lua state
-        g_MovableMan.SetScriptedEntity(this);
-        // Create the Lua variable which will hold the object instance of this instance for as long as it exists
-        if ((error = g_LuaMan.RunScriptString(m_ScriptObjectName + " = To" + GetClassName() + "(MovableMan.ScriptedEntity);")) < 0)
-            return false;
-
-        // Call the scripted creation function, but only after first checking if it and this instance's Lua representation really exists
-        if ((error = g_LuaMan.RunScriptString("if " + m_ScriptPresetName + ".Create and " + m_ScriptObjectName + " then " + m_ScriptPresetName + ".Create(" + m_ScriptObjectName + "); end")) < 0)
-            return false;
     }
 
-    // Call the defined function, but only after first checking if it and this instance's Lua representation exists
-
-	g_FrameMan.StartPerformanceMeasurement(FrameMan::PERF_ACTORS_AI);
-	error = g_LuaMan.RunScriptString("if " + m_ScriptPresetName + ".UpdateAI and " + m_ScriptObjectName + " then " + m_ScriptPresetName + ".UpdateAI(" + m_ScriptObjectName + "); end");
-	g_FrameMan.StopPerformanceMeasurement(FrameMan::PERF_ACTORS_AI);
+    int status = !g_LuaMan.ExpressionIsTrue(m_ScriptPresetName, false) ? ReloadScripts() : 0;
+    status = (status >= 0 && !ObjectScriptsInitialized()) ? InitializeObjectScripts() : status;
+    g_FrameMan.StartPerformanceMeasurement(FrameMan::PERF_ACTORS_AI);
+    status = (status >= 0) ? RunScriptedFunctionInAppropriateScripts("UpdateAI", false, true) : status;
+    g_FrameMan.StopPerformanceMeasurement(FrameMan::PERF_ACTORS_AI);
 
-    if (error < 0)
-        return false;
-
-    // We made a successful scripted AI update!
-    return true;
+    return status >= 0;
 }
 
 

Entities/Actor.h

@@ -72,6 +72,7 @@ class Actor:
 
 // Concrete allocation and cloning definitions
 ENTITYALLOCATION(Actor)
+ADD_SCRIPT_FUNCTION_NAMES(MOSRotating, "UpdateAI")
 
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -192,16 +193,13 @@ ENTITYALLOCATION(Actor)
 
     virtual void Destroy(bool notInherited = false);
 
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  LoadScripts
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Loads the preset scripts of this object, from a specified path.
-// Arguments:       None.
-// Return value:    An error return value signaling sucess or any particular failure.
-//                  Anything below 0 is an error signal.
-
-    virtual int LoadScripts(std::string scriptPath);
+    /// <summary>
+    /// Loads the script at the given script path onto the object, checking for appropriately named functions within it.
+    /// </summary>
+    /// <param name="scriptPath">The path to the script to load.</param>
+    /// <param name="loadAsEnabledScript">Whether or not the script should load as enabled. Defaults to true.</param>
+    /// <returns>An error return value signaling sucess or any particular failure. Anything below 0 is an error signal.</returns>
+    virtual int LoadScript(std::string const &scriptPath, bool loadAsEnabledScript = false);
 
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1330,7 +1328,6 @@ ENTITYALLOCATION(Actor)
 
 protected:
 
-
     // Member variables
     static Entity::ClassInfo m_sClass;