Revamp the game file updating logic

PD2Launcherv2.sln

@@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PD2Shared", "PD2Shared\PD2S
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SteamPD2", "SteamPD2\SteamPD2.csproj", "{6EA7B7D5-E28C-411E-973D-9B80946D3FBF}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "mkmpqmanifest", "mkmpqmanifest\mkmpqmanifest.csproj", "{D10451DF-BED1-4081-B9C7-04E0EA5A8EF5}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -43,6 +45,10 @@ Global
 		{6EA7B7D5-E28C-411E-973D-9B80946D3FBF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6EA7B7D5-E28C-411E-973D-9B80946D3FBF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6EA7B7D5-E28C-411E-973D-9B80946D3FBF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D10451DF-BED1-4081-B9C7-04E0EA5A8EF5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D10451DF-BED1-4081-B9C7-04E0EA5A8EF5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D10451DF-BED1-4081-B9C7-04E0EA5A8EF5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D10451DF-BED1-4081-B9C7-04E0EA5A8EF5}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

PD2Launcherv2/App.xaml

@@ -10,17 +10,13 @@
                 <ResourceDictionary Source="Resources/Styles/ControlStyles.xaml"/>
             </ResourceDictionary.MergedDictionaries>
 
-            <!-- Global Style to remove the focus visual style from all controls -->
-            <Style TargetType="{x:Type Control}">
-                <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
-            </Style>
             <conv:InverseBooleanConverter x:Key="InverseBool"/>
             <conv:BooleanToVisibilityConverter x:Key="BoolToVisConverter"/>
             <conv:StringToIntConverter x:Key="StringToIntConverter"/>
             <local:ViewModelLocator x:Key="ViewModelLocator"/>
 
             <!-- Font Family Resources -->
-            <FontFamily x:Key="BlizzHeavy">pack://application:,,,/Resources/Fonts/exocet-blizzard-heavy.otf#Exocet Blizzard OT Light Bold</FontFamily>
+            <FontFamily x:Key="BlizzHeavy">pack://application:,,,/Resources/Fonts/exocet-blizzard-heavy.ttf#Exocet Blizzard OT Light Bold</FontFamily>
             <FontFamily x:Key="BlizzLight">pack://application:,,,/Resources/Fonts/exocet-blizzard-light.ttf#Exocet Blizzard OT Light Regular</FontFamily>
             <FontFamily x:Key="BlizzMedium">pack://application:,,,/Resources/Fonts/exocet-blizzard-medium.ttf#Exocet Blizzard OT Medium Regular</FontFamily>
 

PD2Launcherv2/App.xaml.cs

@@ -10,6 +10,14 @@
 using System.Net.Http;
 using System.Text;
 using System.Windows;
+using PD2Launcherv2.Utils;
+using PD2Shared.GameFileUpdate;
+using PD2Shared.Logging;
+using static PD2Shared.Logging.LoggingStatic;
+using PD2Shared.Mpq;
+using PD2Shared.Utils;
+
+[assembly: System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows = true)]
 
 namespace PD2Launcherv2
 {
@@ -19,6 +27,8 @@ namespace PD2Launcherv2
     /// </summary>
     public partial class App : Application
     {
+        private readonly Stopwatch _bootStopwatch = Stopwatch.StartNew();
+
         /// <summary>
         /// Holds the service provider for dependency injection.
         /// </summary>
@@ -58,7 +68,7 @@ private static void ConfigureServices(ServiceCollection services)
             services.AddSingleton<LaunchGameHelpers>();
             services.AddSingleton<NewsHelpers>();
             services.AddSingleton<DDrawHelpers>();
-            services.AddSingleton<GameFileUpdateHelpers>();
+            services.AddSingleton<GameFileUpdater>();
             services.AddSingleton<FileUpdateHelpers>(provider =>
             new FileUpdateHelpers( provider.GetRequiredService<HttpClient>()));
             services.AddTransient<OptionsViewModel>();
@@ -98,7 +108,7 @@ protected override async void OnStartup(StartupEventArgs e)
 
                 try
                 {
-                    if (Process.GetProcessesByName("Game").Any())
+                    if (LaunchGameHelpers.IsGameRunning)
                     {
                         Debug.WriteLine("Game already running.");
                         return;
@@ -110,8 +120,8 @@ protected override async void OnStartup(StartupEventArgs e)
                         await filterHelpers.CheckAndUpdateFilterAsync(selected);
                     }
 
-                    var launcherArgs = localStorage.LoadSection<LauncherArgs>(StorageKey.LauncherArgs);
-                    if (!launcherArgs.disableAutoUpdate)
+                    var launcherOptions = localStorage.LoadSection<LauncherOptions>(StorageKey.LauncherOptions);
+                    if (!launcherOptions.DisableAutoUpdate)
                     {
                         try
                         {
@@ -136,23 +146,108 @@ protected override async void OnStartup(StartupEventArgs e)
                 return;
             }
 
+            // This is a bit meh, but let's keep the convention and make this case-insensitive
+            var createConsole = e.Args.Any(arg => arg.Equals("--console", StringComparison.OrdinalIgnoreCase));
+
+            // This is not expected to throw
+            Logging.SetUp(createConsole);
+
+            if (Wine.IsRunningUnderWine)
+            {
+                if (Wine.Version != null)
+                {
+                    string wineVersionStr = Wine.Version.ToString();
+
+                    if (Wine.BuildId != null)
+                    {
+                        wineVersionStr += $" ({Wine.BuildId})";
+                    }
+
+                    if (Wine.OsName != null)
+                    {
+                        wineVersionStr += $" on {Wine.OsName}";
+
+                        if (Wine.OsRelease != null)
+                        {
+                            wineVersionStr += $" {Wine.OsRelease}";
+                        }
+                    }
+
+                    L.CallerInformation($"Running under Wine {wineVersionStr}");
+                }
+                else
+                {
+                    L.CallerInformation($"Running under an undetermined Wine version");
+                }
+            }
+
+            L.CallerInformation($"Using StormLib {Mpq.StormLibVersionString}");
+            L.CallerInformation($"Using up to {Environment.ProcessorCount} concurrent task(s)");
+
+            if (!SanityChecks.Run())
+            {
+                L.CallerInformation($"Sanity checks failed and user declined to continue.");
+
+                this.Shutdown(1);
+                return;
+            }
+
             // Normal UI mode
             base.OnStartup(e);
             var mainWindow = _serviceProvider.GetService<MainWindow>();
+
+            if (mainWindow != null)
+            {
+                mainWindow.ContentRendered += MainWindow_ContentRendered;
+            }
+
             mainWindow?.Show();
         }
 
+        private void MainWindow_ContentRendered(object? sender, EventArgs e)
+        {
+            ((MainWindow)sender!).ContentRendered -= MainWindow_ContentRendered;
+
+            L.CallerDebug($"Time till {nameof(MainWindow)} rendered: {_bootStopwatch.Elapsed}.");
+        }
+
+        protected override void OnExit(ExitEventArgs e)
+        {
+            Logging.ShutDown(e.ApplicationExitCode);
+
+            base.OnExit(e);
+        }
+
         // Handle non-UI thread exceptions
         private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
         {
-            LogException(e.ExceptionObject as Exception);
+            // Blindly cast the object to Exception thanks to RuntimeCompatibilityAttribute (https://learn.microsoft.com/en-us/dotnet/api/system.unhandledexceptioneventargs.exceptionobject#remarks)
+            var ex = (Exception)e.ExceptionObject;
+
+            L.Fatal(ex, "Unhandled exception");
+
+            this.Dispatcher.Invoke(() =>
+            {
+                MsgBox.Exception(ex, "Unhandled exception:");
+
+                // Unlike DispatcherUnhandledException, WER will still kick in.
+                // However, due to reliance on task asynchronous programming model, it is very unlikely that this handler will ever be used.
+                this.Shutdown(1);
+            });
         }
 
         // Handle UI thread exceptions
         private void App_DispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
         {
-            LogException(e.Exception);
+            var ex = e.Exception;
+
+            L.Fatal(ex, "Unhandled exception");
+            MsgBox.Exception(ex, "Unhandled exception:");
+
             e.Handled = true; // Prevent application from crashing
+
+            // ...yet shut it down on our own terms now, knowing that we have prevented Windows Error Reporting from kicking in.
+            this.Shutdown(1);
         }
 
         private void CleanUpTempStorageFiles()
@@ -174,47 +269,5 @@ private void CleanUpTempStorageFiles()
                 }
             }
         }
-
-        private void LogException(Exception ex)
-        {
-            if (ex == null) return;
-
-            string logPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory);
-
-            string logFile = Path.Combine(logPath, $"pd2launcher_error__{DateTime.Now:yyyy-MM-dd_HH-mm-ss}.txt");
-
-            // Use StackTrace to get more detailed info about where the exception occurred
-            var stackTrace = new StackTrace(ex, true);
-            var frame = stackTrace.GetFrames()?.FirstOrDefault();
-            var method = frame?.GetMethod();
-            var declaringType = method?.DeclaringType;
-            var methodName = method?.Name;
-
-            // Prepare the log entry
-            var sb = new StringBuilder();
-            sb.AppendLine("==============================================================================");
-            sb.AppendLine($"Timestamp: {DateTime.Now}");
-            sb.AppendLine("Exception Class:");
-            sb.AppendLine(declaringType?.FullName ?? "N/A");
-            sb.AppendLine("Exception Method:");
-            sb.AppendLine($"{methodName ?? "N/A"}");
-            sb.AppendLine("Exception Message:");
-            sb.AppendLine(ex.Message);
-            sb.AppendLine("Stack Trace:");
-            sb.AppendLine(ex.StackTrace);
-
-            // Include inner exception details if available
-            if (ex.InnerException != null)
-            {
-                sb.AppendLine("Inner Exception Message:");
-                sb.AppendLine(ex.InnerException.Message);
-                sb.AppendLine("Inner Exception Stack Trace:");
-                sb.AppendLine(ex.InnerException.StackTrace);
-            }
-            sb.AppendLine("==============================================================================");
-
-            // Append the log entry to the file
-            File.AppendAllText(logFile, sb.ToString());
-        }
     }
 }

PD2Launcherv2/Constants.cs

@@ -4,6 +4,8 @@ namespace ProjectDiablo2Launcherv2
 {
     public static class Constants
     {
+        public const string DefaultDialogTitle = "Project Diablo 2 Launcher";
+
         public static readonly List<string> excludedFiles = new List<string>
         { "D2.LNG", "BnetLog.txt", "ProjectDiablo.cfg", "ddraw.ini", "default.filter", "loot.filter", "UI.ini", "d2gl.yaml"};
 

PD2Launcherv2/CustomControl/BlankButtonWithText.cs

@@ -0,0 +1,44 @@
+using System.Windows;
+using System.Windows.Controls;
+
+namespace PD2Launcherv2.CustomControl
+{
+    public class BlankButtonWithText : Button
+    {
+        public enum ButtonKindEnum
+        {
+            Normal,
+            SplitTop,
+            SplitBottom
+        }
+
+        static BlankButtonWithText()
+        {
+            DefaultStyleKeyProperty.OverrideMetadata(typeof(BlankButtonWithText), new FrameworkPropertyMetadata(typeof(BlankButtonWithText)));
+        }
+
+        public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
+            "Text",
+            typeof(string),
+            typeof(BlankButtonWithText),
+            new PropertyMetadata("..."));
+
+        public static readonly DependencyProperty ButtonKindProperty = DependencyProperty.Register(
+            "ButtonKind",
+            typeof(ButtonKindEnum),
+            typeof(BlankButtonWithText),
+            new PropertyMetadata(ButtonKindEnum.Normal));
+
+        public string Text
+        {
+            get => (string)GetValue(TextProperty);
+            set => SetValue(TextProperty, value);
+        }
+
+        public ButtonKindEnum ButtonKind
+        {
+            get => (ButtonKindEnum)GetValue(ButtonKindProperty);
+            set => SetValue(ButtonKindProperty, value);
+        }
+    }
+}

PD2Launcherv2/CustomControl/CustomImageButton.cs

@@ -1,11 +1,36 @@
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Media;
+using System.Windows.Media.Imaging;
 
 namespace PD2Launcherv2.CustomControl
 {
     public class CustomImageButton : Button
     {
+        private static RenderTargetBitmap _missingImage = null!;
+        private static BitmapSource MissingImage
+        {
+            get
+            {
+                if (_missingImage == null)
+                {
+                    Rect imageSize = new(new Size(100, 100));
+
+                    _missingImage = new RenderTargetBitmap((int)imageSize.Width, (int)imageSize.Height, 96, 96, PixelFormats.Pbgra32);
+
+                    DrawingVisual visual = new();
+                    using (DrawingContext context = visual.RenderOpen())
+                    {
+                        context.DrawRectangle(Brushes.Magenta, pen: null, imageSize);
+                    }
+
+                    _missingImage.Render(visual);
+                }
+
+                return _missingImage;
+            }
+        }
+
         static CustomImageButton()
         {
             DefaultStyleKeyProperty.OverrideMetadata(typeof(CustomImageButton), new FrameworkPropertyMetadata(typeof(CustomImageButton)));
@@ -23,6 +48,12 @@ static CustomImageButton()
             typeof(CustomImageButton),
             new PropertyMetadata(default(ImageSource)));
 
+        public static readonly DependencyProperty DisabledImageSourceProperty = DependencyProperty.Register(
+            "DisabledImageSource",
+            typeof(ImageSource),
+            typeof(CustomImageButton),
+            new PropertyMetadata(MissingImage));
+
         public ImageSource NormalImageSource
         {
             get => (ImageSource)GetValue(NormalImageSourceProperty);
@@ -34,5 +65,11 @@ public ImageSource PressedImageSource
             get => (ImageSource)GetValue(PressedImageSourceProperty);
             set => SetValue(PressedImageSourceProperty, value);
         }
+
+        public ImageSource DisabledImageSource
+        {
+            get => (ImageSource)GetValue(DisabledImageSourceProperty);
+            set => SetValue(DisabledImageSourceProperty, value);
+        }
     }
 }