Merge branch 'master' into campaign

Author: Flamefire

external/languages

@@ -7,6 +7,7 @@
 #include "QuickStartGame.h"
 #include "RTTR_Version.h"
 #include "RttrConfig.h"
+#include "ai/random.h"
 #include "files.h"
 #include "random/Random.h"
 #include "s25util/System.h"
@@ -30,6 +31,7 @@ int main(int argc, char** argv)
     boost::optional<std::string> replay_path;
     boost::optional<std::string> savegame_path;
     unsigned random_init = static_cast<unsigned>(std::chrono::high_resolution_clock::now().time_since_epoch().count());
+    unsigned random_ai_init = random_init;
 
     po::options_description desc("Allowed options");
     // clang-format off
@@ -41,6 +43,7 @@ int main(int argc, char** argv)
         ("replay", po::value(&replay_path),"Filename to write replay to (optional)")
         ("save", po::value(&savegame_path),"Filename to write savegame to (optional)")
         ("random_init", po::value(&random_init),"Seed value for the random number generator (optional)")
+        ("random_ai_init", po::value(&random_ai_init),"Seed value for the AI random number generator (optional)")
         ("maxGF", po::value<unsigned>()->default_value(std::numeric_limits<unsigned>::max()),"Maximum number of game frames to run (optional)")
         ("version", "Show version information and exit")
         ;
@@ -85,10 +88,12 @@ int main(int argc, char** argv)
             bnw::cout << argv[i] << " ";
         bnw::cout << std::endl;
         bnw::cout << "random_init: " << random_init << std::endl;
+        bnw::cout << "random_ai_init: " << random_ai_init << std::endl;
         bnw::cout << std::endl;
 
         RTTRCONFIG.Init();
         RANDOM.Init(random_init);
+        AI::getRandomGenerator().seed(random_ai_init);
 
         const bfs::path mapPath = RTTRCONFIG.ExpandPath(options["map"].as<std::string>());
         const std::vector<AI::Info> ais = ParseAIOptions(options["ai"].as<std::vector<std::string>>());

extras/ai-battle/main.cpp

@@ -392,29 +392,43 @@ bool VideoSDL2::MessageLoop()
             case SDL_MOUSEBUTTONDOWN:
                 mouse_xy.pos = getGuiScale().screenToView(Position(ev.button.x, ev.button.y));
 
-                if(/*!mouse_xy.ldown && */ ev.button.button == SDL_BUTTON_LEFT)
+                switch(ev.button.button)
                 {
-                    mouse_xy.ldown = true;
-                    CallBack->Msg_LeftDown(mouse_xy);
-                }
-                if(/*!mouse_xy.rdown &&*/ ev.button.button == SDL_BUTTON_RIGHT)
-                {
-                    mouse_xy.rdown = true;
-                    CallBack->Msg_RightDown(mouse_xy);
+                    case SDL_BUTTON_LEFT:
+                        mouse_xy.ldown = true;
+                        CallBack->Msg_LeftDown(mouse_xy);
+                        break;
+
+                    case SDL_BUTTON_RIGHT:
+                        mouse_xy.rdown = true;
+                        CallBack->Msg_RightDown(mouse_xy);
+                        break;
+
+                    case SDL_BUTTON_MIDDLE:
+                        mouse_xy.mdown = true;
+                        CallBack->Msg_MiddleDown(mouse_xy);
+                        break;
                 }
                 break;
             case SDL_MOUSEBUTTONUP:
                 mouse_xy.pos = getGuiScale().screenToView(Position(ev.button.x, ev.button.y));
 
-                if(/*mouse_xy.ldown &&*/ ev.button.button == SDL_BUTTON_LEFT)
+                switch(ev.button.button)
                 {
-                    mouse_xy.ldown = false;
-                    CallBack->Msg_LeftUp(mouse_xy);
-                }
-                if(/*mouse_xy.rdown &&*/ ev.button.button == SDL_BUTTON_RIGHT)
-                {
-                    mouse_xy.rdown = false;
-                    CallBack->Msg_RightUp(mouse_xy);
+                    case SDL_BUTTON_LEFT:
+                        mouse_xy.ldown = false;
+                        CallBack->Msg_LeftUp(mouse_xy);
+                        break;
+
+                    case SDL_BUTTON_RIGHT:
+                        mouse_xy.rdown = false;
+                        CallBack->Msg_RightUp(mouse_xy);
+                        break;
+
+                    case SDL_BUTTON_MIDDLE:
+                        mouse_xy.mdown = false;
+                        CallBack->Msg_MiddleUp(mouse_xy);
+                        break;
                 }
                 break;
             case SDL_MOUSEWHEEL:

extras/videoDrivers/SDL2/VideoSDL2.cpp

@@ -85,8 +85,8 @@ const char* GetDriverName()
  *  @param[in] CallBack DriverCallback für Rückmeldungen.
  */
 VideoWinAPI::VideoWinAPI(VideoDriverLoaderInterface* CallBack)
-    : VideoDriver(CallBack), mouse_l(false), mouse_r(false), mouse_z(0), screen(nullptr), screen_dc(nullptr),
-      screen_rc(nullptr), isWindowResizable(false), isMinimized(true)
+    : VideoDriver(CallBack), mouse_z(0), screen(nullptr), screen_dc(nullptr), screen_rc(nullptr),
+      isWindowResizable(false), isMinimized(true)
 {
     pVideoWinAPI = this;
 }
@@ -665,25 +665,29 @@ LRESULT CALLBACK VideoWinAPI::WindowProc(HWND window, UINT msg, WPARAM wParam, L
             pVideoWinAPI->CallBack->Msg_MouseMove(pVideoWinAPI->mouse_xy);
             break;
         case WM_LBUTTONDOWN:
-            pVideoWinAPI->mouse_l = true;
             pVideoWinAPI->mouse_xy.ldown = true;
             pVideoWinAPI->CallBack->Msg_LeftDown(pVideoWinAPI->mouse_xy);
             break;
         case WM_LBUTTONUP:
-            pVideoWinAPI->mouse_l = false;
             pVideoWinAPI->mouse_xy.ldown = false;
             pVideoWinAPI->CallBack->Msg_LeftUp(pVideoWinAPI->mouse_xy);
             break;
         case WM_RBUTTONDOWN:
-            pVideoWinAPI->mouse_r = true;
             pVideoWinAPI->mouse_xy.rdown = true;
             pVideoWinAPI->CallBack->Msg_RightDown(pVideoWinAPI->mouse_xy);
             break;
         case WM_RBUTTONUP:
-            pVideoWinAPI->mouse_r = false;
             pVideoWinAPI->mouse_xy.rdown = false;
             pVideoWinAPI->CallBack->Msg_RightUp(pVideoWinAPI->mouse_xy);
             break;
+        case WM_MBUTTONDOWN:
+            pVideoWinAPI->mouse_xy.mdown = true;
+            pVideoWinAPI->CallBack->Msg_MiddleDown(pVideoWinAPI->mouse_xy);
+            break;
+        case WM_MBUTTONUP:
+            pVideoWinAPI->mouse_xy.mdown = false;
+            pVideoWinAPI->CallBack->Msg_MiddleUp(pVideoWinAPI->mouse_xy);
+            break;
         case WM_MOUSEWHEEL:
             // Obtain scrolling distance. For every multiple of WHEEL_DELTA, we have to fire an event, because we treat
             // the wheel like two buttons. One wheel "step" usually produces a mouse_z  of +/- WHEEL_DELTA. But there

extras/videoDrivers/WinAPI/WinAPI.cpp

@@ -84,8 +84,6 @@ class VideoWinAPI final : public VideoDriver
     static LRESULT CALLBACK WindowProc(HWND window, UINT msg, WPARAM wParam, LPARAM lParam);
 
 private:
-    bool mouse_l;    /// Status der Linken Maustaste.
-    bool mouse_r;    /// Status der Rechten Maustaste.
     int mouse_z;     /// Scrolling position for mousewheel.
     HWND screen;     /// Fensterhandle.
     HDC screen_dc;   /// Zeichenkontext des Fensters.

extras/videoDrivers/WinAPI/WinAPI.h

@@ -1,10 +1,11 @@
-// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
+// Copyright (C) 2005 - 2026 Settlers Freaks (sf-team at siedler25.org)
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
 #include "RTTR_Assert.h"
+#include <type_traits>
 
 /// Call a member function trough an object and a member function pointer
 #define CALL_MEMBER_FN(object, ptrToMember) ((object).*(ptrToMember))
@@ -24,14 +25,26 @@ inline T absDiff(T a, T b)
     return (a > b) ? a - b : b - a;
 }
 
-/// Same as static_cast<T> but assert that it actually can be casted via dynamic_cast
+/// Same as static_cast<T> but assert the correct dynamic type (in debug mode)
+/// Use like: checkedCast<Derived*>(basePtr)
 template<typename T, typename T_Src>
 inline T checkedCast(T_Src* src)
 {
+    static_assert(std::is_pointer_v<T>, "T must be a pointer type");
     RTTR_Assert(!src || dynamic_cast<T>(src));
     return static_cast<T>(src);
 }
 
+/// Same as static_cast<T&> but assert the correct dynamic type (in debug mode)
+/// Use like: checkedCast<Derived>(baseRef)
+template<typename T, typename T_Src>
+inline T& checkedCast(T_Src& src)
+{
+    static_assert(std::is_class_v<T>, "T must be a plain type");
+    RTTR_Assert(dynamic_cast<T*>(&src));
+    return static_cast<T&>(src);
+}
+
 // Fwd decl
 namespace boost {
 namespace filesystem {

libs/common/include/commonDefines.h

@@ -24,6 +24,17 @@ T randomValue(RandomT& rng, T min = std::numeric_limits<T>::min(), T max = std::
     return static_cast<T>(distr(rng));
 }
 
+/// Return a true in `chance` out of `total` cases:
+///   randomChance()       ... return true|false with 50% chance each
+///   randomChance(15)     ... return true in 1/15 of the cases
+///   randomChance(20, 5)  ... return true in 5 out of 20 cases, i.e. a probability of 25%. Sames as randomChance(4, 1)
+template<typename RandomT>
+bool randomChance(RandomT& rng, unsigned total = 2u, unsigned chance = 1u)
+{
+    RTTR_Assert(total > 0u);
+    return (chance >= total) || randomValue(rng, 1u, total) <= chance;
+}
+
 /// Return a random enumerator from the given enum
 template<typename T, typename RandomT>
 T randomEnum(RandomT& rng)

libs/common/include/helpers/random.h

@@ -16,6 +16,7 @@ struct MouseCoords
     Position pos = Position(0, 0);
     bool ldown = false;        /// left button down
     bool rdown = false;        /// right button down
+    bool mdown = false;        /// middle button down
     bool dbl_click = false;    /// double-click (left button)
     unsigned num_tfingers = 0; /// Count of fingers currently on touchscreen
 };

libs/driver/include/driver/MouseCoords.h

@@ -49,11 +49,12 @@ class VideoDriver : public IVideoDriver
     VideoMode FindClosestVideoMode(const VideoMode& mode) const;
     void SetNewSize(VideoMode windowSize, Extent renderSize);
 
-    VideoDriverLoaderInterface* CallBack; /// Das DriverCallback für Rückmeldungen.
-    bool initialized;                     /// Initialisierungsstatus.
-    MouseCoords mouse_xy;                 /// Status der Maus.
-    std::array<bool, 512> keyboard;       /// Status der Tastatur;
-    bool isFullscreen_;                   /// Vollbild an/aus?
+    VideoDriverLoaderInterface* CallBack; /// DriverCallback to notify on player input
+    bool initialized;
+    MouseCoords mouse_xy;           /// Mouse state
+    std::array<bool, 512> keyboard; /// Keyboard state
+    bool isFullscreen_;
+
 private:
     // cached as possibly used often
     VideoMode windowSize_;    ///< Size of the window or fullscreen resolution

libs/driver/include/driver/VideoDriver.h

@@ -17,6 +17,8 @@ class BOOST_SYMBOL_VISIBLE VideoDriverLoaderInterface
     virtual void Msg_LeftUp(MouseCoords mc) = 0;
     virtual void Msg_RightDown(const MouseCoords& mc) = 0;
     virtual void Msg_RightUp(const MouseCoords& mc) = 0;
+    virtual void Msg_MiddleDown(const MouseCoords& mc) = 0;
+    virtual void Msg_MiddleUp(const MouseCoords& mc) = 0;
     virtual void Msg_WheelUp(const MouseCoords& mc) = 0;
     virtual void Msg_WheelDown(const MouseCoords& mc) = 0;
     virtual void Msg_MouseMove(const MouseCoords& mc) = 0;