Merge branch 'master' into removeElementData

Author: FileEX

.github/workflows/clang-format.yml

@@ -5,11 +5,53 @@ on: [push, pull_request, workflow_dispatch]
 jobs:
   clang-format:
     runs-on: ubuntu-24.04
+    permissions:
+      contents: write
 
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
 
       - name: Run clang-format
+        id: clang_format
+        continue-on-error: true
         shell: pwsh
         run: ./utils/clang-format.ps1 -Verbose
+
+      - name: Auto-fix formatting issues
+        if: |
+          steps.clang_format.outcome == 'failure' &&
+          github.ref == 'refs/heads/master' &&
+          github.event_name == 'push'
+        shell: bash
+        run: |
+          # Stage the formatted files (clang-format.ps1 already ran in-place)
+          git add -u
+
+          # Verify idempotency: run clang-format again on the staged files
+          # and check that no further changes are produced
+          ./Build/tmp/clang-format -i $(git diff --name-only --cached)
+
+          if ! git diff --quiet; then
+            echo "::error::clang-format is not idempotent - cannot auto-fix"
+            exit 1
+          fi
+
+          # Allow commit to work
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+          # Append a commit with a fix applied
+          git commit -m "Fix formatting issues introduced by ${GITHUB_SHA}
+
+          cc @${GITHUB_ACTOR} please make sure to run clang-format locally before pushing changes to avoid this in the future."
+
+          # And we're off to the races!
+          git push
+
+      - name: Report formatting issues
+        if: |
+          steps.clang_format.outcome == 'failure' &&
+          !(github.ref == 'refs/heads/master' && github.event_name == 'push')
+        shell: bash
+        run: exit 1

.github/workflows/tests.yml

@@ -0,0 +1,41 @@
+name: "Tests"
+
+on:
+  push:
+    branches: ["master", "tests"]
+  pull_request:
+    branches: ["master"]
+  workflow_dispatch:
+
+jobs:
+  client-tests:
+    name: Client Tests (x86 Debug)
+    runs-on: windows-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup MSBuild
+        uses: microsoft/setup-msbuild@v2
+
+      - name: Generate project files
+        shell: cmd
+        run: |
+          utils\premake5.exe install_cef
+          utils\premake5.exe install_unifont
+          utils\premake5.exe install_discord
+          utils\premake5.exe vs2026
+
+      - name: Build Tests_Client
+        shell: cmd
+        run: msbuild Build\Tests_Client.vcxproj /p:Configuration=Debug /p:Platform=Win32 /p:PlatformToolset=v143 /nologo /v:minimal
+
+      - name: Run tests
+        run: Bin\tests\Tests_Client_d.exe --gtest_output=xml:Bin\tests\test_results.xml
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results
+          path: Bin/tests/test_results.xml

AGENTS.md

@@ -0,0 +1,13 @@
+## Dev environment tips
+
+Run ./utils/clang-format.ps1 after making changes to C++ files, to ensure that the changes are correctly formatted.
+
+## Code comments
+
+When making code changes, explain *why* the code you're written should exist and the motivation behind the changes. This ensures that future engineers don't have to read between the lines.
+
+## Steer the user towards writing clear commit messages
+
+Tell the user to include details about the prompt / goals / motivation / "why"s / how they tested their changes.
+
+Don't assume the user will include this information in the commit messages, proactively tell them to include this information in their commit messages.

Client/core/CCore.cpp

@@ -39,8 +39,22 @@ using namespace std;
 namespace fs = std::filesystem;
 
 // Set to true to enable the freeze watchdog (monitors main thread responsiveness)
+// Do NOT enable it unless you run a QA testing cycle (see commit desc: 3e54dcb2742bccf0319b9552b2ed5a2c0a012425)
 constexpr bool bFreezeWatchdogEnabled = false;
 
+// Watchdog active in debug builds
+// In debug builds, the contributor should get an early heads up if their changes are this level of blocking (it can't make it in).
+// If you freeze beyond 20 secs in a debug build, not due to a bug in your code changes but due to your local server assets, you have 2 options:
+// 1. Disable the watchdog
+// 2. Fix your mess (imagine what that would do to players in release builds)
+#ifdef MTA_DEBUG
+constexpr bool  bFreezeWatchdogEnabledInCurrentBuild = true;
+constexpr DWORD uiFreezeWatchdogTimeoutSeconds = 20;  // Already unacceptable. Strikes a balance: you'll still be able to a load heavy asseted local server
+#else
+constexpr bool  bFreezeWatchdogEnabledInCurrentBuild = bFreezeWatchdogEnabled;
+constexpr DWORD uiFreezeWatchdogTimeoutSeconds = 40;  // Player won't be patient beyond this; we get no info
+#endif
+
 static float fTest = 1;
 
 extern CCore* g_pCore;
@@ -186,7 +200,7 @@ CCore::~CCore()
 {
     WriteDebugEvent("CCore::~CCore");
 
-    if constexpr (bFreezeWatchdogEnabled)
+    if constexpr (bFreezeWatchdogEnabledInCurrentBuild)
         StopWatchdogThread();
 
     // Reset Discord rich presence
@@ -1303,7 +1317,7 @@ void CCore::DoPreFramePulse()
 {
     TIMING_CHECKPOINT("+CorePreFrame");
 
-    if constexpr (bFreezeWatchdogEnabled)
+    if constexpr (bFreezeWatchdogEnabledInCurrentBuild)
         UpdateWatchdogHeartbeat();
 
     m_pKeyBinds->DoPreFramePulse();
@@ -1363,10 +1377,9 @@ void CCore::DoPostFramePulse()
             WatchDogCompletedSection("L3");  // No hang on startup
 
             // Start watchdog thread now that initial loading is complete
-            // Use 120 second timeout to allow for large mod asset loading
-            if constexpr (bFreezeWatchdogEnabled)
+            if constexpr (bFreezeWatchdogEnabledInCurrentBuild)
             {
-                if (!StartWatchdogThread(GetCurrentThreadId(), 120))
+                if (!StartWatchdogThread(GetCurrentThreadId(), uiFreezeWatchdogTimeoutSeconds))
                 {
                     WriteDebugEvent("CCore: WARNING - Failed to start watchdog thread");
                 }

Client/core/CMessageLoopHook.cpp

@@ -22,6 +22,8 @@ UCHAR  CMessageLoopHook::m_LastScanCode = NULL;
 BYTE*  CMessageLoopHook::m_LastKeyboardState = new BYTE[256];
 bool   ms_bIgnoreNextEscapeCharacter = false;
 
+#define WM_CUSTOMFOCUS_FIX WM_APP + 1
+
 CMessageLoopHook::CMessageLoopHook()
 {
     WriteDebugEvent("CMessageLoopHook::CMessageLoopHook");
@@ -132,6 +134,17 @@ LRESULT CALLBACK CMessageLoopHook::ProcessMessage(HWND hwnd, UINT uMsg, WPARAM w
             if (pModManager && pModManager->IsLoaded())
             {
                 bool bFocus = (wState == WA_CLICKACTIVE) || (wState == WA_ACTIVE);
+
+                // Fix for the Windows behavior that removes focus from a window if it was minimized during startup
+                // (you have to double-click the icon or alt+tab to regain focus despite the window being visible).
+                // GitHub issue #4233
+                static bool fixFirstTimeFocus = false;
+                if (!fixFirstTimeFocus && !bFocus && GetForegroundWindow() != hwnd && GetFocus() == hwnd && !IsIconic(hwnd))
+                {
+                    fixFirstTimeFocus = true;
+                    PostMessage(hwnd, WM_CUSTOMFOCUS_FIX, 0, 0);
+                }
+
                 pModManager->GetClient()->OnWindowFocusChange(bFocus);
             }
 
@@ -150,6 +163,30 @@ LRESULT CALLBACK CMessageLoopHook::ProcessMessage(HWND hwnd, UINT uMsg, WPARAM w
             }
         }
 
+        // When updating m_bFocused in CClientGame from CPacketHandler (to fix another bug — see the note there),
+        // the window might not actually have focus at that moment (even though Windows reports it as focused).
+        // In this case, isMTAWindowFocused returns false even though the window has focus.
+        // Therefore, we need to intercept the window return operation and manually set the focus in CClientGame.
+        if (uMsg == WM_WINDOWPOSCHANGING)
+        {
+            WINDOWPOS* wp = reinterpret_cast<WINDOWPOS*>(lParam);
+            if (wp->flags & SWP_NOMOVE && wp->flags & SWP_NOSIZE && !(wp->flags & SWP_NOZORDER))
+            {
+                if (GetForegroundWindow() == hwnd && !IsIconic(hwnd))
+                {
+                    CModManager* pModManager = CModManager::GetSingletonPtr();
+                    if (pModManager && pModManager->IsLoaded())
+                        pModManager->GetClient()->OnWindowFocusChange(true);
+                }
+            }
+        }
+
+        if (uMsg == WM_CUSTOMFOCUS_FIX)
+        {
+            AllowSetForegroundWindow(ASFW_ANY);
+            SetForegroundWindow(hwnd);
+        }
+
         if (uMsg == WM_PAINT)
         {
             GetVideoModeManager()->OnPaint();

Client/core/CrashHandler.cpp

@@ -48,6 +48,7 @@
 #include <stdio.h>
 #include <string>
 #include <string_view>
+#include <TlHelp32.h>
 #include <variant>
 #include <vector>
 #if defined(_MSC_VER)
@@ -3027,7 +3028,21 @@ namespace
 
     inline WatchdogState g_watchdogState{};
 
-    [[nodiscard]] static bool TriggerWatchdogException(HANDLE targetThread, DWORD targetThreadId)
+    static bool TryGenerateWatchdogDump(EXCEPTION_POINTERS* pExPtrs, CExceptionInformation_Impl* pExInfo)
+    {
+        __try
+        {
+            CCrashDumpWriter::DumpCoreLog(pExPtrs, pExInfo);
+            CCrashDumpWriter::DumpMiniDump(pExPtrs, pExInfo);
+            return true;
+        }
+        __except (EXCEPTION_EXECUTE_HANDLER)
+        {
+            return false;
+        }
+    }
+
+    [[nodiscard]] static bool TriggerWatchdogException(HANDLE targetThread, DWORD targetThreadId, bool dumpOnly = false)
     {
         AddReportLog(9300, SString("Watchdog freeze detected after %u seconds (thread %u)", g_watchdogState.timeoutSeconds.load(std::memory_order_relaxed),
                                    targetThreadId));
@@ -3079,6 +3094,7 @@ namespace
         // Now we can safely resume the thread - we have everything we need
         if (ResumeThread(targetThread) == static_cast<DWORD>(-1))
         {
+            OutputDebugStringA("WATCHDOG: Failed to resume thread after stack capture\n");
             AddReportLog(9304, SString("Watchdog failed to resume thread %u after stack capture", targetThreadId));
             // Continue anyway - we still want the crash dump even if resume failed
         }
@@ -3151,6 +3167,25 @@ namespace
             }
         }
 
+        if (dumpOnly)
+        {
+            // Write dump without dialog or termination so the
+            // contributor can continue debugging after a breakpoint pause.
+            auto* pExInfo = new (std::nothrow) CExceptionInformation_Impl;
+            if (pExInfo)
+            {
+                pExInfo->Set(exceptionRecord.ExceptionCode, &exceptionPointers);
+
+                if (!TryGenerateWatchdogDump(&exceptionPointers, pExInfo))
+                {
+                    AddReportLog(9316, "Watchdog: SEH exception caught during dump generation");
+                }
+
+                delete pExInfo;
+            }
+            return true;
+        }
+
         // Trigger the global exception handler
         CCrashDumpWriter::HandleExceptionGlobal(&exceptionPointers);
 
@@ -3190,14 +3225,57 @@ namespace
             if (elapsed.count() >= static_cast<std::chrono::seconds::rep>(timeoutSecs))
             {
 #ifdef MTA_DEBUG
-                if (IsDebuggerPresent() == TRUE)
+                BOOL isDebuggerAttached = FALSE;
+                if (IsDebuggerPresent() != FALSE)
+                    isDebuggerAttached = TRUE;
+
+                if (isDebuggerAttached == FALSE)
+                    CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebuggerAttached);
+
+                if (isDebuggerAttached == FALSE)
+                {
+                    // Check if parent process (e.g. VS attached to the launcher) has a debugger
+                    if (HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); hSnapshot != INVALID_HANDLE_VALUE)
+                    {
+                        PROCESSENTRY32 pe32{};
+                        pe32.dwSize = sizeof(pe32);
+                        if (Process32First(hSnapshot, &pe32))
+                        {
+                            const DWORD currentPid = GetCurrentProcessId();
+                            do
+                            {
+                                if (pe32.th32ProcessID == currentPid)
+                                {
+                                    if (HANDLE hParent = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pe32.th32ParentProcessID))
+                                    {
+                                        CheckRemoteDebuggerPresent(hParent, &isDebuggerAttached);
+                                        CloseHandle(hParent);
+                                    }
+                                    break;
+                                }
+                            } while (Process32Next(hSnapshot, &pe32));
+                        }
+                        CloseHandle(hSnapshot);
+                    }
+                }
+
+                if (isDebuggerAttached != FALSE)
                 {
+                    // In debug builds with a debugger attached, the stall may just be a breakpoint pause.
+                    // Generate a dump so the frozen stack is collected, then
+                    // reset the heartbeat and keep monitoring instead of terminating.
+                    OutputDebugStringA("WATCHDOG: Freeze detected - generating dump (no termination)\n");
+
+                    AddReportLog(9311, SString("Watchdog detected freeze after %lld seconds (threshold %u, debugger attached)",
+                                               static_cast<long long>(elapsed.count()), timeoutSecs));
+
+                    TriggerWatchdogException(targetThread.get(), targetThreadId, true);
+
                     g_watchdogState.lastHeartbeat.store(std::chrono::steady_clock::now(), std::memory_order_release);
                     std::this_thread::sleep_for(kCheckInterval);
                     continue;
                 }
 #endif
-
                 AddReportLog(9311, SString("Watchdog detected freeze after %lld seconds (threshold %u)", static_cast<long long>(elapsed.count()), timeoutSecs));
 
                 const bool triggered = TriggerWatchdogException(targetThread.get(), targetThreadId);

Client/core/ServerBrowser/CServerBrowser.RemoteMasterServer.cpp

@@ -349,6 +349,8 @@ bool CRemoteMasterServer::ParseListVer0(CServerListItemList& itemList)
     uint uiNumServersBefore = itemList.size();
 #endif
 
+    uint uiTieBreakCounter = 0;
+
     while (!stream.AtEnd(6) && usCount--)
     {
         in_addr        Address;      // IP-address
@@ -363,6 +365,14 @@ bool CRemoteMasterServer::ParseListVer0(CServerListItemList& itemList)
         // Add or find item to update
         CServerListItem* pItem = GetServerListItem(itemList, Address, usQueryPort - SERVER_LIST_QUERY_PORT_OFFSET);
 
+        if (pItem->uiTieBreakPosition != uiTieBreakCounter)
+        {
+            pItem->uiTieBreakPosition = uiTieBreakCounter;
+            pItem->strTieBreakSortKey = SString("%04d", pItem->uiTieBreakPosition);
+            pItem->uiRevision++;
+        }
+        uiTieBreakCounter++;
+
         if (pItem->ShouldAllowDataQuality(SERVER_INFO_ASE_0))
         {
             pItem->SetDataQuality(SERVER_INFO_ASE_0);
@@ -445,6 +455,8 @@ bool CRemoteMasterServer::ParseListVer2(CServerListItemList& itemList)
     uint uiNumServersBefore = itemList.size();
 #endif
 
+    uint uiTieBreakCounter = 0;
+
     // Add all servers until we hit the count or run out of data
     while (!stream.AtEnd(6) && uiCount--)
     {
@@ -461,6 +473,14 @@ bool CRemoteMasterServer::ParseListVer2(CServerListItemList& itemList)
         // Add or find item to update
         CServerListItem* pItem = GetServerListItem(itemList, Address, usGamePort);
 
+        if (pItem->uiTieBreakPosition != uiTieBreakCounter)
+        {
+            pItem->uiTieBreakPosition = uiTieBreakCounter;
+            pItem->strTieBreakSortKey = SString("%04d", pItem->uiTieBreakPosition);
+            pItem->uiRevision++;
+        }
+        uiTieBreakCounter++;
+
         if (pItem->ShouldAllowDataQuality(uiDataQuality))
         {
             pItem->SetDataQuality(uiDataQuality);