Merge branch 'development' into zip-save-files

Author: Causeless

.github/parameters/macports.yml

@@ -0,0 +1,14 @@
+version: "2.8.1"
+prefix: "/opt/local"
+ports:
+  - name: gcc13
+  - name: pkgconfig
+  - name: meson
+  - name: libsdl2
+  - name: onetbb
+  - name: lz4
+  - name: libpng
+  - name: minizip
+  - name: luajit
+  - name: flac
+  - name: dylibbundler

.github/workflows/meson.yml

@@ -122,9 +122,10 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v3
 
-      - name: Install Dependencies
-        run: |
-          brew install pkg-config tbb sdl2 minizip lz4 flac luajit [email protected] libpng gcc@${{env.GCC_VERSION}} ninja meson dylibbundler tree
+      - name: "Install Dependencies"
+        uses: melusina-org/setup-macports@v1
+        with: 
+          parameters:  ".github/parameters/macports.yml"
 
       - name: Setup Meson
         env:

Activities/GAScripted.cpp

@@ -35,6 +35,8 @@
 #include "BuyMenuGUI.h"
 #include "SceneEditorGUI.h"
 
+#include "tracy/Tracy.hpp"
+
 namespace RTE {
 
 ConcreteClassInfo(GAScripted, GameActivity, 0);
@@ -204,17 +206,30 @@ int GAScripted::ReloadScripts() {
         }
     }
 
-    std::unordered_map<std::string, LuabindObjectWrapper*> scriptFileFunctions;
-    if ((error = g_LuaMan.GetMasterScriptState().RunScriptFileAndRetrieveFunctions(m_ScriptPath, m_LuaClassName, GetSupportedScriptFunctionNames(), scriptFileFunctions, true)) < 0) {
+    if ((error = g_LuaMan.GetMasterScriptState().RunScriptFile(m_ScriptPath, true, false)) < 0) {
         return error;
     }
 
+    RefreshActivityFunctions();
+
+    return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void GAScripted::RefreshActivityFunctions() {
     m_ScriptFunctions.clear();
+    if (m_ScriptPath.empty()) {
+        return;
+    }
+
+    // We use m_LuaClassName here, because we ran the script file in the global state instead of in an environment
+    std::unordered_map<std::string, LuabindObjectWrapper*> scriptFileFunctions;
+    g_LuaMan.GetMasterScriptState().RetrieveFunctions(m_LuaClassName, GetSupportedScriptFunctionNames(), scriptFileFunctions);
+
     for (const auto& [functionName, functionObject] : scriptFileFunctions) {
         m_ScriptFunctions[functionName] = std::unique_ptr<LuabindObjectWrapper>(functionObject);
     }
-
-    return 0;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -281,8 +296,8 @@ void GAScripted::HandleCraftEnteringOrbit(ACraft *orbitedCraft) {
 
     if (orbitedCraft && g_MovableMan.IsActor(orbitedCraft)) {
         g_LuaMan.GetMasterScriptState().RunScriptFunctionString(m_LuaClassName + ".CraftEnteredOrbit", m_LuaClassName, {m_LuaClassName, m_LuaClassName + ".CraftEnteredOrbit"}, {orbitedCraft});
-        for (const GlobalScript *globalScript : m_GlobalScriptsList) {
-            if (globalScript->IsActive()) { globalScript->HandleCraftEnteringOrbit(orbitedCraft); }
+        for (GlobalScript *globalScript : m_GlobalScriptsList) {
+            globalScript->HandleCraftEnteringOrbit(orbitedCraft);
         }
     }
 }
@@ -333,18 +348,11 @@ int GAScripted::Start() {
 	g_PresetMan.GetAllOfType(globalScripts, "GlobalScript");
 
 	for (std::list<Entity *>::iterator sItr = globalScripts.begin(); sItr != globalScripts.end(); ++sItr) {
-		GlobalScript * script = dynamic_cast<GlobalScript *>(*sItr);
-        if (script && g_SettingsMan.IsGlobalScriptEnabled(script->GetModuleAndPresetName())) {
-            m_GlobalScriptsList.push_back(dynamic_cast<GlobalScript*>(script->Clone()));
-        }
+        m_GlobalScriptsList.push_back(dynamic_cast<GlobalScript*>((*sItr)->Clone()));
 	}
 
 	// Start all global scripts
 	for (std::vector<GlobalScript *>::iterator sItr = m_GlobalScriptsList.begin(); sItr < m_GlobalScriptsList.end(); ++sItr) {
-		if (g_SettingsMan.PrintDebugInfo()) {
-			g_ConsoleMan.PrintString("DEBUG: Start Global Script: " + (*sItr)->GetPresetName());
-        }
-
 		(*sItr)->Start();
 	}
 
@@ -364,9 +372,7 @@ void GAScripted::SetPaused(bool pause) {
 
 	// Pause all global scripts
 	for (std::vector<GlobalScript *>::iterator sItr = m_GlobalScriptsList.begin(); sItr < m_GlobalScriptsList.end(); ++sItr) {
-		if ((*sItr)->IsActive()) {
-			(*sItr)->Pause(pause);
-        }
+		(*sItr)->Pause(pause);
     }
 }
 
@@ -383,12 +389,7 @@ void GAScripted::End() {
 
 	// End all global scripts
 	for (std::vector<GlobalScript *>::iterator sItr = m_GlobalScriptsList.begin(); sItr < m_GlobalScriptsList.end(); ++sItr) {
-		if ((*sItr)->IsActive()) {
-			if (g_SettingsMan.PrintDebugInfo()) {
-				g_ConsoleMan.PrintString("DEBUG: End Global Script: " + (*sItr)->GetPresetName());
-            }
-			(*sItr)->End();
-		}
+		(*sItr)->End();
     }
 
 	// Delete all global scripts, in case destructor is not called when activity restarts
@@ -436,6 +437,9 @@ void GAScripted::Update() {
     if (m_ActivityState != ActivityState::Over) {
 		AddPieSlicesToActiveActorPieMenus();
 
+        // Need to call this continually unfortunately, as something might change due to dofile()
+        RefreshActivityFunctions();
+
         RunLuaFunction("UpdateActivity");
 
         UpdateGlobalScripts(false);
@@ -449,9 +453,11 @@ void GAScripted::Update() {
 // Description:     Updates globals scripts loaded with this activity.
 
 void GAScripted::UpdateGlobalScripts(bool lateUpdate) {
+    ZoneScoped;
+
 	// Update all global scripts
 	for (std::vector<GlobalScript *>::iterator sItr = m_GlobalScriptsList.begin(); sItr < m_GlobalScriptsList.end(); ++sItr) {
-		if ((*sItr)->IsActive() && (*sItr)->ShouldLateUpdate() == lateUpdate) {
+		if ((*sItr)->ShouldLateUpdate() == lateUpdate) {
 			(*sItr)->Update();
         }
     }
@@ -485,7 +491,9 @@ int GAScripted::RunLuaFunction(const std::string& functionName, const std::vecto
         return 0;
     }
 
-    return g_LuaMan.GetMasterScriptState().RunScriptFunctionObject(funcItr->second.get(), "_G", m_LuaClassName, functionEntityArguments, functionLiteralArguments, functionObjectArguments);
+    int error = g_LuaMan.GetMasterScriptState().RunScriptFunctionObject(funcItr->second.get(), "_G", m_LuaClassName, functionEntityArguments, functionLiteralArguments, functionObjectArguments);
+
+    return error;
 }
 
 
@@ -562,10 +570,8 @@ void GAScripted::AddPieSlicesToActiveActorPieMenus() {
 					controlledActorPieMenu->AddPieSliceIfPresetNameIsUnique(pieSlice.get(), this, true);
 				}
 				for (const GlobalScript *globalScript : m_GlobalScriptsList) {
-					if (globalScript->IsActive()) {
-						for (const std::unique_ptr<PieSlice> &pieSlice : globalScript->GetPieSlicesToAdd()) {
-							controlledActorPieMenu->AddPieSliceIfPresetNameIsUnique(pieSlice.get(), globalScript, true);
-						}
+					for (const std::unique_ptr<PieSlice> &pieSlice : globalScript->GetPieSlicesToAdd()) {
+						controlledActorPieMenu->AddPieSliceIfPresetNameIsUnique(pieSlice.get(), globalScript, true);
 					}
 				}
 			}

Activities/GAScripted.h

@@ -139,6 +139,11 @@ ClassInfoGetters;
 
 	int ReloadScripts() override;
 
+	/// <summary>
+	/// Refreshes our activity functions to find any changes from script.
+	/// </summary>
+	void RefreshActivityFunctions();
+
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  GetLuaClassName

Activities/GameActivity.cpp

@@ -75,6 +75,8 @@ void GameActivity::Clear()
         m_InventoryMenuGUI[player] = nullptr;
         m_pBuyGUI[player] = 0;
         m_pEditorGUI[player] = 0;
+        m_LuaLockActor[player] = false;
+        m_LuaLockActorMode[player] = Controller::InputMode::CIM_AI;
         m_pBannerRed[player] = 0;
         m_pBannerYellow[player] = 0;
         m_BannerRepeats[player] = 0;
@@ -174,6 +176,8 @@ int GameActivity::Create(const GameActivity &reference)
         m_InventoryMenuGUI[player] = new InventoryMenuGUI;
         m_pBuyGUI[player] = new BuyMenuGUI;
         m_pEditorGUI[player] = new SceneEditorGUI;
+        m_LuaLockActor[player] = reference.m_LuaLockActor[player];
+        m_LuaLockActorMode[player] = reference.m_LuaLockActorMode[player];
         m_pBannerRed[player] = new GUIBanner();
         m_pBannerYellow[player] = new GUIBanner();
         m_ReadyToStart[player] = reference.m_ReadyToStart[player];
@@ -396,6 +400,18 @@ bool GameActivity::IsBuyGUIVisible(int which) const {
 
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool GameActivity::LockControlledActor(Players player, bool lock, Controller::InputMode lockToMode) {
+	if (player >= Players::PlayerOne && player < Players::MaxPlayerCount) {
+		bool prevLock = m_LuaLockActor[player];
+		m_LuaLockActor[player] = lock;
+		m_LuaLockActorMode[player] = lockToMode;
+		return true;
+	}
+	return false;
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  SwitchToActor
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1424,7 +1440,7 @@ void GameActivity::Update()
             m_ViewState[player] = ViewState::Normal;
         }
         // Switch to next actor if the player wants to. Don't do it while the buy menu is open
-        else if (m_PlayerController[player].IsState(ACTOR_NEXT) && m_ViewState[player] != ViewState::ActorSelect && !m_pBuyGUI[player]->IsVisible())
+        else if (m_PlayerController[player].IsState(ACTOR_NEXT) && m_ViewState[player] != ViewState::ActorSelect && !m_pBuyGUI[player]->IsVisible() && !m_LuaLockActor[player])
         {
 			if (m_ControlledActor[player] && m_ControlledActor[player]->GetPieMenu()) {
 				m_ControlledActor[player]->GetPieMenu()->SetEnabled(false);
@@ -1444,7 +1460,7 @@ void GameActivity::Update()
             g_FrameMan.ClearScreenText(ScreenOfPlayer(player));
         }
         // Go into manual actor select mode if either actor switch buttons are held for a duration
-        else if (m_ViewState[player] != ViewState::ActorSelect && !m_pBuyGUI[player]->IsVisible() && (m_PlayerController[player].IsState(ACTOR_NEXT_PREP) || m_PlayerController[player].IsState(ACTOR_PREV_PREP)))
+        else if (m_ViewState[player] != ViewState::ActorSelect && !m_pBuyGUI[player]->IsVisible() && !m_LuaLockActor[player] && (m_PlayerController[player].IsState(ACTOR_NEXT_PREP) || m_PlayerController[player].IsState(ACTOR_PREV_PREP)))
         {
             if (m_ActorSelectTimer[player].IsPastRealMS(250))
             {
@@ -1967,7 +1983,7 @@ void GameActivity::Update()
         }
 
         // Trap the mouse if we're in gameplay and not in menus
-		g_UInputMan.TrapMousePos(!m_pBuyGUI[player]->IsEnabled() && !m_InventoryMenuGUI[player]->IsEnabledAndNotCarousel(), player);
+		g_UInputMan.TrapMousePos(!m_pBuyGUI[player]->IsEnabled() && !m_InventoryMenuGUI[player]->IsEnabledAndNotCarousel() && !m_LuaLockActor[player], player);
 
         // Start LZ picking mode if a purchase was made
         if (m_pBuyGUI[player]->PurchaseMade())
@@ -2015,6 +2031,8 @@ void GameActivity::Update()
                 m_ControlledActor[player]->GetController()->SetInputMode(Controller::CIM_AI);
             } else if (m_InventoryMenuGUI[player]->IsEnabledAndNotCarousel()) {
                 m_ControlledActor[player]->GetController()->SetInputMode(Controller::CIM_DISABLED);
+            } else if (m_LuaLockActor[player]) {
+                m_ControlledActor[player]->GetController()->SetInputMode(m_LuaLockActorMode[player]);
             } else {
                 m_ControlledActor[player]->GetController()->SetInputMode(Controller::CIM_PLAYER);
             }

Activities/GameActivity.h

@@ -252,6 +252,15 @@ class GameActivity : public Activity {
 
     SceneEditorGUI * GetEditorGUI(unsigned int which = 0) const { return m_pEditorGUI[which]; }
 
+	/// <summary>
+	/// Locks a player controlled actor to a specific controller mode.
+	/// Locking the actor will disable player input, including switching actors.
+	/// </summary>
+	/// <param name="player">Which player to lock the actor for.</param>
+	/// <param name="lock">Whether to lock or unlock the actor. (Default: true)</param>
+	/// <param name="lockToMode">Which controller mode to lock the actor to. (Default: `CIM_AI`)</param>
+	/// <returns>Whether the (un)lock was performed.</returns>
+	bool LockControlledActor(Players player, bool lock = true, Controller::InputMode lockToMode = Controller::InputMode::CIM_AI);
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  SwitchToActor
@@ -1035,6 +1044,8 @@ class GameActivity : public Activity {
     BuyMenuGUI *m_pBuyGUI[Players::MaxPlayerCount];
     // The in-game scene editor GUI for each player
     SceneEditorGUI *m_pEditorGUI[Players::MaxPlayerCount];
+    bool m_LuaLockActor[Players::MaxPlayerCount]; //!< Whether or not to lock input for each player while lua has control.
+    Controller::InputMode m_LuaLockActorMode[Players::MaxPlayerCount]; //!< The input mode to lock to while lua has control.
     // The in-game important message banners for each player
     GUIBanner *m_pBannerRed[Players::MaxPlayerCount];
     GUIBanner *m_pBannerYellow[Players::MaxPlayerCount];

Activities/GibEditor.cpp

@@ -511,7 +511,7 @@ void GibEditor::Update()
                     std::list<MovableObject *> *pEditedGibList = m_pEditorGUI->GetPlacedGibs();
                     MovableObject *pGibCopy = 0;
 
-                    for (std::list<Gib>::iterator gItr = pLoadedGibList->begin(); gItr != pLoadedGibList->end(); ++gItr)
+                    for (auto gItr = pLoadedGibList->begin(); gItr != pLoadedGibList->end(); ++gItr)
                     {
                         pGibCopy = dynamic_cast<MovableObject *>((*gItr).GetParticlePreset()->Clone());
                         if (pGibCopy)