Merge 9356b68f26 into 11e4d8f970

add ?

src/Ryujinx.Horizon/HorizonStatic.cs

@@ -2,36 +2,35 @@ using MsgPack;
 using Ryujinx.Horizon.Common;
 using Ryujinx.Memory;
 using System;
-using System.Threading;
 
 namespace Ryujinx.Horizon
 {
     public static class HorizonStatic
     {
-        internal static void HandlePlayReport(MessagePackObject report) => 
-            new Thread(() => PlayReport?.Invoke(report))
-            {
-                Name = "HLE.PlayReportEvent", 
-                IsBackground = true,
-                Priority = ThreadPriority.AboveNormal
-            }.Start();
+        internal static void HandlePlayReport(MessagePackObject report) => PlayReportPrinted?.Invoke(report);
         
-        public static event Action<MessagePackObject> PlayReport;
+        public static event Action<MessagePackObject> PlayReportPrinted;
+        
+        [ThreadStatic]
+        private static HorizonOptions _options;
 
-        [field: ThreadStatic]
-        public static HorizonOptions Options { get; private set; }
+        [ThreadStatic]
+        private static ISyscallApi _syscall;
 
-        [field: ThreadStatic]
-        public static ISyscallApi Syscall { get; private set; }
+        [ThreadStatic]
+        private static IVirtualMemoryManager _addressSpace;
 
-        [field: ThreadStatic]
-        public static IVirtualMemoryManager AddressSpace { get; private set; }
+        [ThreadStatic]
+        private static IThreadContext _threadContext;
 
-        [field: ThreadStatic]
-        public static IThreadContext ThreadContext { get; private set; }
+        [ThreadStatic]
+        private static int _threadHandle;
 
-        [field: ThreadStatic]
-        public static int CurrentThreadHandle { get; private set; }
+        public static HorizonOptions Options => _options;
+        public static ISyscallApi Syscall => _syscall;
+        public static IVirtualMemoryManager AddressSpace => _addressSpace;
+        public static IThreadContext ThreadContext => _threadContext;
+        public static int CurrentThreadHandle => _threadHandle;
 
         public static void Register(
             HorizonOptions options,
@@ -40,11 +39,11 @@ namespace Ryujinx.Horizon
             IThreadContext threadContext,
             int threadHandle)
         {
-            Options = options;
-            Syscall = syscallApi;
-            AddressSpace = addressSpace;
-            ThreadContext = threadContext;
-            CurrentThreadHandle = threadHandle;
+            _options = options;
+            _syscall = syscallApi;
+            _addressSpace = addressSpace;
+            _threadContext = threadContext;
+            _threadHandle = threadHandle;
         }
     }
 }

src/Ryujinx.Horizon/Prepo/Ipc/PrepoService.cs

@@ -1,4 +1,3 @@
-using Gommon;
 using MsgPack;
 using MsgPack.Serialization;
 using Ryujinx.Common.Logging;
@@ -12,7 +11,6 @@ using Ryujinx.Horizon.Sdk.Sf;
 using Ryujinx.Horizon.Sdk.Sf.Hipc;
 using System;
 using System.Text;
-using System.Threading;
 using ApplicationId = Ryujinx.Horizon.Sdk.Ncm.ApplicationId;
 
 namespace Ryujinx.Horizon.Prepo.Ipc

src/Ryujinx.Input.SDL2/SDL2GamepadDriver.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.SDL2.Common;
 using System;
 using System.Collections.Generic;
@@ -36,6 +37,7 @@ namespace Ryujinx.Input.SDL2
             SDL2Driver.Instance.Initialize();
             SDL2Driver.Instance.OnJoyStickConnected += HandleJoyStickConnected;
             SDL2Driver.Instance.OnJoystickDisconnected += HandleJoyStickDisconnected;
+            SDL2Driver.Instance.OnJoyBatteryUpdated += HandleJoyBatteryUpdated;
 
             // Add already connected gamepads
             int numJoysticks = SDL_NumJoysticks();
@@ -83,19 +85,30 @@ namespace Ryujinx.Input.SDL2
 
         private void HandleJoyStickDisconnected(int joystickInstanceId)
         {
+            bool joyConPairDisconnected = false;
             if (!_gamepadsInstanceIdsMapping.Remove(joystickInstanceId, out string id))
                 return;
 
             lock (_lock)
             {
                 _gamepadsIds.Remove(id);
+                if (!SDL2JoyConPair.IsCombinable(_gamepadsIds))
+                {
+                    _gamepadsIds.Remove(SDL2JoyConPair.Id);
+                    joyConPairDisconnected = true;
+                }
             }
 
             OnGamepadDisconnected?.Invoke(id);
+            if (joyConPairDisconnected)
+            {
+                OnGamepadDisconnected?.Invoke(SDL2JoyConPair.Id);
+            }
         }
 
         private void HandleJoyStickConnected(int joystickDeviceId, int joystickInstanceId)
         {
+            bool joyConPairConnected = false;
             if (SDL_IsGameController(joystickDeviceId) == SDL_bool.SDL_TRUE)
             {
                 if (_gamepadsInstanceIdsMapping.ContainsKey(joystickInstanceId))
@@ -120,13 +133,29 @@ namespace Ryujinx.Input.SDL2
                             _gamepadsIds.Insert(joystickDeviceId, id);
                         else
                             _gamepadsIds.Add(id);
+                        if (SDL2JoyConPair.IsCombinable(_gamepadsIds))
+                        {
+                            _gamepadsIds.Remove(SDL2JoyConPair.Id);
+                            _gamepadsIds.Add(SDL2JoyConPair.Id);
+                            joyConPairConnected = true;
+                        }
                     }
 
                     OnGamepadConnected?.Invoke(id);
+                    if (joyConPairConnected)
+                    {
+                        OnGamepadConnected?.Invoke(SDL2JoyConPair.Id);
+                    }
                 }
             }
         }
 
+        private void HandleJoyBatteryUpdated(int joystickDeviceId, SDL_JoystickPowerLevel powerLevel)
+        {
+            Logger.Info?.Print(LogClass.Hid,
+                $"{SDL_GameControllerNameForIndex(joystickDeviceId)} power level: {powerLevel}");
+        }
+
         protected virtual void Dispose(bool disposing)
         {
             if (disposing)
@@ -157,6 +186,14 @@ namespace Ryujinx.Input.SDL2
 
         public IGamepad GetGamepad(string id)
         {
+            if (id == SDL2JoyConPair.Id)
+            {
+                lock (_lock)
+                {
+                    return SDL2JoyConPair.GetGamepad(_gamepadsIds);
+                }
+            }
+
             int joystickIndex = GetJoystickIndexByGamepadId(id);
 
             if (joystickIndex == -1)
@@ -165,12 +202,16 @@ namespace Ryujinx.Input.SDL2
             }
 
             nint gamepadHandle = SDL_GameControllerOpen(joystickIndex);
-
             if (gamepadHandle == nint.Zero)
             {
                 return null;
             }
 
+            if (SDL_GameControllerName(gamepadHandle).StartsWith(SDL2JoyCon.Prefix))
+            {
+                return new SDL2JoyCon(gamepadHandle, id);    
+            }
+
             return new SDL2Gamepad(gamepadHandle, id);
         }
 

src/Ryujinx.Input.SDL2/SDL2JoyCon.cs

@@ -0,0 +1,409 @@
+using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.Configuration.Hid.Controller;
+using Ryujinx.Common.Logging;
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Threading;
+using static SDL2.SDL;
+
+namespace Ryujinx.Input.SDL2
+{
+    internal class SDL2JoyCon : IGamepad
+    {
+        private bool HasConfiguration => _configuration != null;
+
+        private readonly record struct ButtonMappingEntry(GamepadButtonInputId To, GamepadButtonInputId From)
+        {
+            public bool IsValid => To is not GamepadButtonInputId.Unbound && From is not GamepadButtonInputId.Unbound;
+        }
+
+        private StandardControllerInputConfig _configuration;
+
+        private readonly Dictionary<GamepadButtonInputId,SDL_GameControllerButton> _leftButtonsDriverMapping = new()
+        {
+            { GamepadButtonInputId.LeftStick , SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSTICK },
+             {GamepadButtonInputId.DpadUp ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_Y},
+             {GamepadButtonInputId.DpadDown ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_A},
+             {GamepadButtonInputId.DpadLeft ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_B},
+             {GamepadButtonInputId.DpadRight ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_X},
+             {GamepadButtonInputId.Minus ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_START},
+             {GamepadButtonInputId.LeftShoulder,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE2},
+             {GamepadButtonInputId.LeftTrigger,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE4},
+             {GamepadButtonInputId.SingleRightTrigger0,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
+             {GamepadButtonInputId.SingleLeftTrigger0,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
+        };
+        private readonly Dictionary<GamepadButtonInputId,SDL_GameControllerButton> _rightButtonsDriverMapping = new()
+        {
+             {GamepadButtonInputId.RightStick,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSTICK},
+             {GamepadButtonInputId.A,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_B},
+             {GamepadButtonInputId.B,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_Y},
+             {GamepadButtonInputId.X,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_A},
+             {GamepadButtonInputId.Y,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_X},
+             {GamepadButtonInputId.Plus,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_START},
+             {GamepadButtonInputId.RightShoulder,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE1},
+             {GamepadButtonInputId.RightTrigger,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE3},
+             {GamepadButtonInputId.SingleRightTrigger1,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
+             {GamepadButtonInputId.SingleLeftTrigger1,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSHOULDER}
+        };
+
+        private readonly Dictionary<GamepadButtonInputId, SDL_GameControllerButton> _buttonsDriverMapping;
+        private readonly Lock _userMappingLock = new();
+
+        private readonly List<ButtonMappingEntry> _buttonsUserMapping;
+
+        private readonly StickInputId[] _stickUserMapping = new StickInputId[(int)StickInputId.Count]
+        {
+            StickInputId.Unbound, StickInputId.Left, StickInputId.Right,
+        };
+
+        public GamepadFeaturesFlag Features { get; }
+
+        private nint _gamepadHandle;
+
+        private enum JoyConType
+        {
+            Left, Right
+        }
+
+        public const string Prefix = "Nintendo Switch Joy-Con";
+        public const string LeftName = "Nintendo Switch Joy-Con (L)";
+        public const string RightName = "Nintendo Switch Joy-Con (R)";
+
+        private readonly JoyConType _joyConType;
+
+        public SDL2JoyCon(nint gamepadHandle, string driverId)
+        {
+            _gamepadHandle = gamepadHandle;
+            _buttonsUserMapping = new List<ButtonMappingEntry>(10);
+
+            Name = SDL_GameControllerName(_gamepadHandle);
+            Id = driverId;
+            Features = GetFeaturesFlag();
+
+            // Enable motion tracking
+            if (Features.HasFlag(GamepadFeaturesFlag.Motion))
+            {
+                if (SDL_GameControllerSetSensorEnabled(_gamepadHandle, SDL_SensorType.SDL_SENSOR_ACCEL,
+                        SDL_bool.SDL_TRUE) != 0)
+                {
+                    Logger.Error?.Print(LogClass.Hid,
+                        $"Could not enable data reporting for SensorType {SDL_SensorType.SDL_SENSOR_ACCEL}.");
+                }
+
+                if (SDL_GameControllerSetSensorEnabled(_gamepadHandle, SDL_SensorType.SDL_SENSOR_GYRO,
+                        SDL_bool.SDL_TRUE) != 0)
+                {
+                    Logger.Error?.Print(LogClass.Hid,
+                        $"Could not enable data reporting for SensorType {SDL_SensorType.SDL_SENSOR_GYRO}.");
+                }
+            }
+
+            switch (Name)
+            {
+                case LeftName:
+                    {
+                        _buttonsDriverMapping = _leftButtonsDriverMapping;
+                        _joyConType = JoyConType.Left;
+                        break;
+                    }
+                case RightName:
+                    {
+                        _buttonsDriverMapping = _rightButtonsDriverMapping;
+                        _joyConType = JoyConType.Right;
+                        break;
+                    }
+            }
+        }
+
+        private GamepadFeaturesFlag GetFeaturesFlag()
+        {
+            GamepadFeaturesFlag result = GamepadFeaturesFlag.None;
+
+            if (SDL_GameControllerHasSensor(_gamepadHandle, SDL_SensorType.SDL_SENSOR_ACCEL) == SDL_bool.SDL_TRUE &&
+                SDL_GameControllerHasSensor(_gamepadHandle, SDL_SensorType.SDL_SENSOR_GYRO) == SDL_bool.SDL_TRUE)
+            {
+                result |= GamepadFeaturesFlag.Motion;
+            }
+
+            int error = SDL_GameControllerRumble(_gamepadHandle, 0, 0, 100);
+
+            if (error == 0)
+            {
+                result |= GamepadFeaturesFlag.Rumble;
+            }
+
+            return result;
+        }
+
+        public string Id { get; }
+        public string Name { get; }
+        public bool IsConnected => SDL_GameControllerGetAttached(_gamepadHandle) == SDL_bool.SDL_TRUE;
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing && _gamepadHandle != nint.Zero)
+            {
+                SDL_GameControllerClose(_gamepadHandle);
+
+                _gamepadHandle = nint.Zero;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+
+        public void SetTriggerThreshold(float triggerThreshold)
+        {
+
+        }
+
+        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        {
+            if (!Features.HasFlag(GamepadFeaturesFlag.Rumble))
+                return;
+
+            ushort lowFrequencyRaw = (ushort)(lowFrequency * ushort.MaxValue);
+            ushort highFrequencyRaw = (ushort)(highFrequency * ushort.MaxValue);
+
+            if (durationMs == uint.MaxValue)
+            {
+                if (SDL_GameControllerRumble(_gamepadHandle, lowFrequencyRaw, highFrequencyRaw, SDL_HAPTIC_INFINITY) !=
+                    0)
+                    Logger.Error?.Print(LogClass.Hid, "Rumble is not supported on this game controller.");
+            }
+            else if (durationMs > SDL_HAPTIC_INFINITY)
+            {
+                Logger.Error?.Print(LogClass.Hid, $"Unsupported rumble duration {durationMs}");
+            }
+            else
+            {
+                if (SDL_GameControllerRumble(_gamepadHandle, lowFrequencyRaw, highFrequencyRaw, durationMs) != 0)
+                    Logger.Error?.Print(LogClass.Hid, "Rumble is not supported on this game controller.");
+            }
+        }
+
+        public Vector3 GetMotionData(MotionInputId inputId)
+        {
+            SDL_SensorType sensorType = inputId switch
+            {
+                MotionInputId.Accelerometer => SDL_SensorType.SDL_SENSOR_ACCEL,
+                MotionInputId.Gyroscope => SDL_SensorType.SDL_SENSOR_GYRO,
+                _ => SDL_SensorType.SDL_SENSOR_INVALID
+            };
+
+            if (!Features.HasFlag(GamepadFeaturesFlag.Motion) || sensorType is SDL_SensorType.SDL_SENSOR_INVALID)
+                return Vector3.Zero;
+
+            const int ElementCount = 3;
+
+            unsafe
+            {
+                float* values = stackalloc float[ElementCount];
+
+                int result = SDL_GameControllerGetSensorData(_gamepadHandle, sensorType, (nint)values, ElementCount);
+
+                if (result != 0)
+                    return Vector3.Zero;
+
+                Vector3 value = _joyConType switch
+                {
+                    JoyConType.Left => new Vector3(-values[2], values[1], values[0]),
+                    JoyConType.Right => new Vector3(values[2], values[1], -values[0])
+                };
+
+                return inputId switch
+                {
+                    MotionInputId.Gyroscope => RadToDegree(value),
+                    MotionInputId.Accelerometer => GsToMs2(value),
+                    _ => value
+                };
+            }
+        }
+
+        private static Vector3 RadToDegree(Vector3 rad) => rad * (180 / MathF.PI);
+
+        private static Vector3 GsToMs2(Vector3 gs) => gs / SDL_STANDARD_GRAVITY;
+
+        public void SetConfiguration(InputConfig configuration)
+        {
+            lock (_userMappingLock)
+            {
+                _configuration = (StandardControllerInputConfig)configuration;
+
+                _buttonsUserMapping.Clear();
+
+                // First update sticks
+                _stickUserMapping[(int)StickInputId.Left] = (StickInputId)_configuration.LeftJoyconStick.Joystick;
+                _stickUserMapping[(int)StickInputId.Right] = (StickInputId)_configuration.RightJoyconStick.Joystick;
+
+
+                switch (_joyConType)
+                {
+                    case JoyConType.Left:
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftStick, (GamepadButtonInputId)_configuration.LeftJoyconStick.StickButton));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadUp, (GamepadButtonInputId)_configuration.LeftJoycon.DpadUp));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadDown, (GamepadButtonInputId)_configuration.LeftJoycon.DpadDown));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadLeft, (GamepadButtonInputId)_configuration.LeftJoycon.DpadLeft));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadRight, (GamepadButtonInputId)_configuration.LeftJoycon.DpadRight));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Minus, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonMinus));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftShoulder, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonL));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftTrigger, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonZl));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger0, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonSr));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger0, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonSl));
+                        break;
+                    case JoyConType.Right:
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightStick, (GamepadButtonInputId)_configuration.RightJoyconStick.StickButton));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.A, (GamepadButtonInputId)_configuration.RightJoycon.ButtonA));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.B, (GamepadButtonInputId)_configuration.RightJoycon.ButtonB));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.X, (GamepadButtonInputId)_configuration.RightJoycon.ButtonX));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Y, (GamepadButtonInputId)_configuration.RightJoycon.ButtonY));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Plus, (GamepadButtonInputId)_configuration.RightJoycon.ButtonPlus));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightShoulder, (GamepadButtonInputId)_configuration.RightJoycon.ButtonR));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightTrigger, (GamepadButtonInputId)_configuration.RightJoycon.ButtonZr));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger1, (GamepadButtonInputId)_configuration.RightJoycon.ButtonSr));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger1, (GamepadButtonInputId)_configuration.RightJoycon.ButtonSl));
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+                
+                SetTriggerThreshold(_configuration.TriggerThreshold);
+            }
+        }
+
+        public GamepadStateSnapshot GetStateSnapshot()
+        {
+            return IGamepad.GetStateSnapshot(this);
+        }
+
+        public GamepadStateSnapshot GetMappedStateSnapshot()
+        {
+            GamepadStateSnapshot rawState = GetStateSnapshot();
+            GamepadStateSnapshot result = default;
+
+            lock (_userMappingLock)
+            {
+                if (_buttonsUserMapping.Count == 0)
+                    return rawState;
+
+
+                // ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
+                foreach (ButtonMappingEntry entry in _buttonsUserMapping)
+                {
+                    if (!entry.IsValid)
+                        continue;
+
+                    // Do not touch state of button already pressed
+                    if (!result.IsPressed(entry.To))
+                    {
+                        result.SetPressed(entry.To, rawState.IsPressed(entry.From));
+                    }
+                }
+
+                (float leftStickX, float leftStickY) = rawState.GetStick(_stickUserMapping[(int)StickInputId.Left]);
+                (float rightStickX, float rightStickY) = rawState.GetStick(_stickUserMapping[(int)StickInputId.Right]);
+
+                result.SetStick(StickInputId.Left, leftStickX, leftStickY);
+                result.SetStick(StickInputId.Right, rightStickX, rightStickY);
+            }
+
+            return result;
+        }
+
+
+        private static float ConvertRawStickValue(short value)
+        {
+            const float ConvertRate = 1.0f / (short.MaxValue + 0.5f);
+
+            return value * ConvertRate;
+        }
+
+        private JoyconConfigControllerStick<GamepadInputId, Common.Configuration.Hid.Controller.StickInputId>
+            GetLogicalJoyStickConfig(StickInputId inputId)
+        {
+            switch (inputId)
+            {
+                case StickInputId.Left:
+                    if (_configuration.RightJoyconStick.Joystick ==
+                        Common.Configuration.Hid.Controller.StickInputId.Left)
+                        return _configuration.RightJoyconStick;
+                    else
+                        return _configuration.LeftJoyconStick;
+                case StickInputId.Right:
+                    if (_configuration.LeftJoyconStick.Joystick ==
+                        Common.Configuration.Hid.Controller.StickInputId.Right)
+                        return _configuration.LeftJoyconStick;
+                    else
+                        return _configuration.RightJoyconStick;
+            }
+
+            return null;
+        }
+
+
+        public (float, float) GetStick(StickInputId inputId)
+        {
+            if (inputId == StickInputId.Unbound)
+                return (0.0f, 0.0f);
+
+            if (inputId == StickInputId.Left && _joyConType == JoyConType.Right || inputId == StickInputId.Right && _joyConType == JoyConType.Left)
+            {
+                return (0.0f, 0.0f);
+            }
+            
+            (short stickX, short stickY) = GetStickXY();
+
+            float resultX = ConvertRawStickValue(stickX);
+            float resultY = -ConvertRawStickValue(stickY);
+
+            if (HasConfiguration)
+            {
+                var joyconStickConfig = GetLogicalJoyStickConfig(inputId);
+
+                if (joyconStickConfig != null)
+                {
+                    if (joyconStickConfig.InvertStickX)
+                        resultX = -resultX;
+
+                    if (joyconStickConfig.InvertStickY)
+                        resultY = -resultY;
+
+                    if (joyconStickConfig.Rotate90CW)
+                    {
+                        float temp = resultX;
+                        resultX = resultY;
+                        resultY = -temp;
+                    }
+                }
+            }
+
+            return inputId switch
+            {
+                StickInputId.Left when _joyConType == JoyConType.Left => (resultY, -resultX),
+                StickInputId.Right when _joyConType == JoyConType.Right => (-resultY, resultX),
+                _ => (0.0f, 0.0f)
+            };
+        }
+
+        private (short, short) GetStickXY()
+        {
+            return (
+                SDL_GameControllerGetAxis(_gamepadHandle, SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTX),
+                SDL_GameControllerGetAxis(_gamepadHandle, SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTY));
+        }
+        
+        public bool IsPressed(GamepadButtonInputId inputId)
+        {
+            if (!_buttonsDriverMapping.TryGetValue(inputId, out var button))
+            {
+                return false;
+            }
+
+            return SDL_GameControllerGetButton(_gamepadHandle, button) == 1;
+        }
+    }
+}

src/Ryujinx.Input.SDL2/SDL2JoyConPair.cs

@@ -0,0 +1,142 @@
+using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.Configuration.Hid.Controller;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using static SDL2.SDL;
+
+namespace Ryujinx.Input.SDL2
+{
+    internal class SDL2JoyConPair(IGamepad left, IGamepad right) : IGamepad
+    {
+        private StandardControllerInputConfig _configuration;
+
+        private readonly StickInputId[] _stickUserMapping =
+        [
+            StickInputId.Unbound,
+            StickInputId.Left,
+            StickInputId.Right
+        ];
+
+        public GamepadFeaturesFlag Features => (left?.Features ?? GamepadFeaturesFlag.None) |
+                                               (right?.Features ?? GamepadFeaturesFlag.None);
+
+        public const string Id = "JoyConPair";
+        string IGamepad.Id => Id;
+
+        public string Name => "* Nintendo Switch Joy-Con (L/R)";
+        public bool IsConnected => left is { IsConnected: true } && right is { IsConnected: true };
+
+        public void Dispose()
+        {
+            left?.Dispose();
+            right?.Dispose();
+        }
+
+        public GamepadStateSnapshot GetMappedStateSnapshot()
+        {
+            return GetStateSnapshot();
+        }
+
+        public Vector3 GetMotionData(MotionInputId inputId)
+        {
+            return inputId switch
+            {
+                MotionInputId.Accelerometer or
+                    MotionInputId.Gyroscope => left.GetMotionData(inputId),
+                MotionInputId.SecondAccelerometer => right.GetMotionData(MotionInputId.Accelerometer),
+                MotionInputId.SecondGyroscope => right.GetMotionData(MotionInputId.Gyroscope),
+                _ => Vector3.Zero
+            };
+        }
+
+        public GamepadStateSnapshot GetStateSnapshot()
+        {
+            return IGamepad.GetStateSnapshot(this);
+        }
+
+        public (float, float) GetStick(StickInputId inputId)
+        {
+            return inputId switch
+            {
+                StickInputId.Left => left.GetStick(StickInputId.Left),
+                StickInputId.Right => right.GetStick(StickInputId.Right),
+                _ => (0, 0)
+            };
+        }
+
+        public bool IsPressed(GamepadButtonInputId inputId)
+        {
+            return left.IsPressed(inputId) || right.IsPressed(inputId);
+        }
+
+        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        {
+            if (lowFrequency != 0)
+            {
+                right.Rumble(lowFrequency, lowFrequency, durationMs);
+            }
+
+            if (highFrequency != 0)
+            {
+                left.Rumble(highFrequency, highFrequency, durationMs);
+            }
+
+            if (lowFrequency == 0 && highFrequency == 0)
+            {
+                left.Rumble(0, 0, durationMs);
+                right.Rumble(0, 0, durationMs);
+            }
+        }
+
+        public void SetConfiguration(InputConfig configuration)
+        {
+            left.SetConfiguration(configuration);
+            right.SetConfiguration(configuration);
+        }
+
+        public void SetTriggerThreshold(float triggerThreshold)
+        {
+            left.SetTriggerThreshold(triggerThreshold);
+            right.SetTriggerThreshold(triggerThreshold);
+        }
+
+        public static bool IsCombinable(List<string> gamepadsIds)
+        {
+            (int leftIndex, int rightIndex) = DetectJoyConPair(gamepadsIds);
+            return leftIndex >= 0 && rightIndex >= 0;
+        }
+
+        private static (int leftIndex, int rightIndex) DetectJoyConPair(List<string> gamepadsIds)
+        {
+            var gamepadNames = gamepadsIds.Where(gamepadId => gamepadId != Id)
+                .Select((_, index) => SDL_GameControllerNameForIndex(index)).ToList();
+            int leftIndex = gamepadNames.IndexOf(SDL2JoyCon.LeftName);
+            int rightIndex = gamepadNames.IndexOf(SDL2JoyCon.RightName);
+
+            return (leftIndex, rightIndex);
+        }
+
+        public static IGamepad GetGamepad(List<string> gamepadsIds)
+        {
+            (int leftIndex, int rightIndex) = DetectJoyConPair(gamepadsIds);
+            if (leftIndex == -1 || rightIndex == -1)
+            {
+                return null;
+            }
+
+            nint leftGamepadHandle = SDL_GameControllerOpen(leftIndex);
+            nint rightGamepadHandle = SDL_GameControllerOpen(rightIndex);
+
+            if (leftGamepadHandle == nint.Zero || rightGamepadHandle == nint.Zero)
+            {
+                return null;
+            }
+
+
+            return new SDL2JoyConPair(new SDL2JoyCon(leftGamepadHandle, gamepadsIds[leftIndex]),
+                new SDL2JoyCon(rightGamepadHandle, gamepadsIds[rightIndex]));
+        }
+    }
+}

src/Ryujinx.Input/HLE/NpadController.cs

@@ -269,6 +269,7 @@ namespace Ryujinx.Input.HLE
             if (motionConfig.MotionBackend != MotionInputBackendType.CemuHook)
             {
                 _leftMotionInput = new MotionInput();
+                _rightMotionInput = new MotionInput();
             }
             else
             {
@@ -301,7 +302,20 @@ namespace Ryujinx.Input.HLE
 
                             if (controllerConfig.ControllerType == ConfigControllerType.JoyconPair)
                             {
-                                _rightMotionInput = _leftMotionInput;
+                                if (gamepad.Id== "JoyConPair")
+                                {
+                                    Vector3 rightAccelerometer = gamepad.GetMotionData(MotionInputId.SecondAccelerometer);
+                                    Vector3 rightGyroscope = gamepad.GetMotionData(MotionInputId.SecondGyroscope);
+
+                                    rightAccelerometer = new Vector3(rightAccelerometer.X, -rightAccelerometer.Z, rightAccelerometer.Y);
+                                    rightGyroscope = new Vector3(rightGyroscope.X, -rightGyroscope.Z, rightGyroscope.Y);
+
+                                    _rightMotionInput.Update(rightAccelerometer, rightGyroscope, (ulong)PerformanceCounter.ElapsedNanoseconds / 1000, controllerConfig.Motion.Sensitivity, (float)controllerConfig.Motion.GyroDeadzone);
+                                }
+                                else
+                                {
+                                    _rightMotionInput = _leftMotionInput;
+                                }
                             }
                         }
                     }
@@ -336,6 +350,7 @@ namespace Ryujinx.Input.HLE
                 // Reset states
                 State = default;
                 _leftMotionInput = null;
+                _rightMotionInput = null;
             }
         }
 

src/Ryujinx.Input/MotionInputId.cs

@@ -21,5 +21,17 @@ namespace Ryujinx.Input
         /// </summary>
         /// <remarks>Values are in degrees</remarks>
         Gyroscope,
+
+        /// <summary>
+        /// Second accelerometer.
+        /// </summary>
+        /// <remarks>Values are in m/s^2</remarks>
+        SecondAccelerometer,
+
+        /// <summary>
+        /// Second gyroscope.
+        /// </summary>
+        /// <remarks>Values are in degrees</remarks>
+        SecondGyroscope
     }
 }

src/Ryujinx.SDL2.Common/SDL2Driver.cs

@@ -25,14 +25,17 @@ namespace Ryujinx.SDL2.Common
 
         public static Action<Action> MainThreadDispatcher { get; set; }
 
-        private const uint SdlInitFlags = SDL_INIT_EVENTS | SDL_INIT_GAMECONTROLLER | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO | SDL_INIT_VIDEO;
+        private const uint SdlInitFlags = SDL_INIT_EVENTS | SDL_INIT_GAMECONTROLLER | SDL_INIT_JOYSTICK |
+                                          SDL_INIT_AUDIO | SDL_INIT_VIDEO;
 
         private bool _isRunning;
         private uint _refereceCount;
         private Thread _worker;
 
+        private const uint SDL_JOYBATTERYUPDATED = 1543;
         public event Action<int, int> OnJoyStickConnected;
         public event Action<int> OnJoystickDisconnected;
+        public event Action<int, SDL_JoystickPowerLevel> OnJoyBatteryUpdated;
 
         private ConcurrentDictionary<uint, Action<SDL_Event>> _registeredWindowHandlers;
 
@@ -78,12 +81,14 @@ namespace Ryujinx.SDL2.Common
                 // First ensure that we only enable joystick events (for connected/disconnected).
                 if (SDL_GameControllerEventState(SDL_IGNORE) != SDL_IGNORE)
                 {
-                    Logger.Error?.PrintMsg(LogClass.Application, "Couldn't change the state of game controller events.");
+                    Logger.Error?.PrintMsg(LogClass.Application,
+                        "Couldn't change the state of game controller events.");
                 }
 
                 if (SDL_JoystickEventState(SDL_ENABLE) < 0)
                 {
-                    Logger.Error?.PrintMsg(LogClass.Application, $"Failed to enable joystick event polling: {SDL_GetError()}");
+                    Logger.Error?.PrintMsg(LogClass.Application,
+                        $"Failed to enable joystick event polling: {SDL_GetError()}");
                 }
 
                 // Disable all joysticks information, we don't need them no need to flood the event queue for that.
@@ -143,7 +148,12 @@ namespace Ryujinx.SDL2.Common
 
                 OnJoystickDisconnected?.Invoke(evnt.cbutton.which);
             }
-            else if (evnt.type is SDL_EventType.SDL_WINDOWEVENT or SDL_EventType.SDL_MOUSEBUTTONDOWN or SDL_EventType.SDL_MOUSEBUTTONUP)
+            else if ((uint)evnt.type == SDL_JOYBATTERYUPDATED)
+            {
+                OnJoyBatteryUpdated?.Invoke(evnt.cbutton.which, (SDL_JoystickPowerLevel)evnt.user.code);
+            }
+            else if (evnt.type is SDL_EventType.SDL_WINDOWEVENT or SDL_EventType.SDL_MOUSEBUTTONDOWN
+                     or SDL_EventType.SDL_MOUSEBUTTONUP)
             {
                 if (_registeredWindowHandlers.TryGetValue(evnt.window.windowID, out Action<SDL_Event> handler))
                 {

src/Ryujinx/Assets/locales.json

@@ -1524,156 +1524,6 @@
     },
     {
       "ID": "GameListHeaderDeveloper",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "",
-        "en_US": "Developed by {0}",
-        "es_ES": "",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "",
-        "ja_JP": "",
-        "ko_KR": "",
-        "no_NO": "",
-        "pl_PL": "",
-        "pt_BR": "",
-        "ru_RU": "",
-        "sv_SE": "",
-        "th_TH": "",
-        "tr_TR": "",
-        "uk_UA": "",
-        "zh_CN": "",
-        "zh_TW": ""
-      }
-    },
-    {
-      "ID": "GameListHeaderVersion",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "Έκδοση: {0}",
-        "en_US": "Version: {0}",
-        "es_ES": "Versión: {0}",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "Versione: {0}",
-        "ja_JP": "バージョン: {0}",
-        "ko_KR": "버전: {0}",
-        "no_NO": "Versjon: {0}",
-        "pl_PL": "Wersja: {0}",
-        "pt_BR": "Versão: {0}",
-        "ru_RU": "Версия: {0}",
-        "sv_SE": "",
-        "th_TH": "เวอร์ชั่น: {0}",
-        "tr_TR": "Sürüm: {0}",
-        "uk_UA": "Версія: {0}",
-        "zh_CN": "版本: {0}",
-        "zh_TW": "版本: {0}"
-      }
-    },
-    {
-      "ID": "GameListHeaderTimePlayed",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "Spielzeit: {0}",
-        "el_GR": "Χρόνος: {0}",
-        "en_US": "Play Time: {0}",
-        "es_ES": "Tiempo jugado: {0}",
-        "fr_FR": "Temps de jeu: {0}",
-        "he_IL": "",
-        "it_IT": "Tempo di gioco: {0}",
-        "ja_JP": "プレイ時間: {0}",
-        "ko_KR": "플레이 타임: {0}",
-        "no_NO": "Spilletid: {0}",
-        "pl_PL": "Czas w grze: {0}",
-        "pt_BR": "Tempo de jogo: {0}",
-        "ru_RU": "Время в игре: {0}",
-        "sv_SE": "Speltid: {0}",
-        "th_TH": "เล่นไปแล้ว: {0}",
-        "tr_TR": "Oynama Süresi: {0}",
-        "uk_UA": "Зіграно часу: {0}",
-        "zh_CN": "游玩时长: {0}",
-        "zh_TW": "遊玩時數: {0}"
-      }
-    },
-    {
-      "ID": "GameListHeaderLastPlayed",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "Zuletzt gespielt: {0}",
-        "el_GR": "Παίχτηκε: {0}",
-        "en_US": "Last Played: {0}",
-        "es_ES": "Jugado por última vez: {0}",
-        "fr_FR": "Dernière partie jouée: {0}",
-        "he_IL": "",
-        "it_IT": "Ultima partita: {0}",
-        "ja_JP": "最終プレイ日時: {0}",
-        "ko_KR": "마지막 플레이: {0}",
-        "no_NO": "Sist Spilt: {0}",
-        "pl_PL": "Ostatnio grane: {0}",
-        "pt_BR": "Último jogo: {0}",
-        "ru_RU": "Последний запуск: {0}",
-        "sv_SE": "Senast spelad: {0}",
-        "th_TH": "เล่นล่าสุด: {0}",
-        "tr_TR": "Son Oynama Tarihi: {0}",
-        "uk_UA": "Востаннє зіграно: {0}",
-        "zh_CN": "最近游玩: {0}",
-        "zh_TW": "最近遊玩: {0}"
-      }
-    },
-    {
-      "ID": "GameListHeaderFileExtension",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "Dateiformat: {0}",
-        "el_GR": "Κατάληξη: {0}",
-        "en_US": "Extension: {0}",
-        "es_ES": "Extensión: {0}",
-        "fr_FR": "Extension du Fichier: {0}",
-        "he_IL": "",
-        "it_IT": "Estensione: {0}",
-        "ja_JP": "ファイル拡張子: {0}",
-        "ko_KR": "파일 확장자: {0}",
-        "no_NO": "Fil Eks.: {0}",
-        "pl_PL": "Rozszerzenie pliku: {0}",
-        "pt_BR": "Extensão: {0}",
-        "ru_RU": "Расширение файла: {0}",
-        "sv_SE": "Filänd: {0}",
-        "th_TH": "นามสกุลไฟล์: {0}",
-        "tr_TR": "Dosya Uzantısı: {0}",
-        "uk_UA": "Розширення файлу: {0}",
-        "zh_CN": "扩展名: {0}",
-        "zh_TW": "副檔名: {0}"
-      }
-    },
-    {
-      "ID": "GameListHeaderFileSize",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "Dateigröße: {0}",
-        "el_GR": "Μέγεθος Αρχείου: {0}",
-        "en_US": "File Size: {0}",
-        "es_ES": "Tamaño del archivo: {0}",
-        "fr_FR": "Taille du Fichier: {0}",
-        "he_IL": "",
-        "it_IT": "Dimensione file: {0}",
-        "ja_JP": "ファイルサイズ: {0}",
-        "ko_KR": "파일 크기: {0}",
-        "no_NO": "Fil Størrelse: {0}",
-        "pl_PL": "Rozmiar pliku: {0}",
-        "pt_BR": "Tamanho: {0}",
-        "ru_RU": "Размер файла: {0}",
-        "sv_SE": "Filstorlek: {0}",
-        "th_TH": "ขนาดไฟล์: {0}",
-        "tr_TR": "Dosya Boyutu: {0}",
-        "uk_UA": "Розмір файлу: {0}",
-        "zh_CN": "大小: {0}",
-        "zh_TW": "檔案大小: {0}"
-      }
-    },
-    {
-      "ID": "GameListSortDeveloper",
       "Translations": {
         "ar_SA": "المطور",
         "de_DE": "Entwickler",
@@ -1698,7 +1548,32 @@
       }
     },
     {
-      "ID": "GameListSortTimePlayed",
+      "ID": "GameListHeaderVersion",
+      "Translations": {
+        "ar_SA": "الإصدار",
+        "de_DE": "",
+        "el_GR": "Έκδοση",
+        "en_US": "Version",
+        "es_ES": "Versión",
+        "fr_FR": "",
+        "he_IL": "גרסה",
+        "it_IT": "Versione",
+        "ja_JP": "バージョン",
+        "ko_KR": "버전",
+        "no_NO": "Versjon",
+        "pl_PL": "Wersja",
+        "pt_BR": "Versão",
+        "ru_RU": "Версия",
+        "sv_SE": "",
+        "th_TH": "เวอร์ชั่น",
+        "tr_TR": "Sürüm",
+        "uk_UA": "Версія",
+        "zh_CN": "版本",
+        "zh_TW": "版本"
+      }
+    },
+    {
+      "ID": "GameListHeaderTimePlayed",
       "Translations": {
         "ar_SA": "وقت اللعب",
         "de_DE": "Spielzeit",
@@ -1723,7 +1598,7 @@
       }
     },
     {
-      "ID": "GameListSortLastPlayed",
+      "ID": "GameListHeaderLastPlayed",
       "Translations": {
         "ar_SA": "آخر مرة لُعبت",
         "de_DE": "Zuletzt gespielt",
@@ -1748,7 +1623,7 @@
       }
     },
     {
-      "ID": "GameListSortFileExtension",
+      "ID": "GameListHeaderFileExtension",
       "Translations": {
         "ar_SA": "صيغة الملف",
         "de_DE": "Dateiformat",
@@ -1773,7 +1648,7 @@
       }
     },
     {
-      "ID": "GameListSortFileSize",
+      "ID": "GameListHeaderFileSize",
       "Translations": {
         "ar_SA": "حجم الملف",
         "de_DE": "Dateigröße",
@@ -1798,7 +1673,7 @@
       }
     },
     {
-      "ID": "GameListSortPath",
+      "ID": "GameListHeaderPath",
       "Translations": {
         "ar_SA": "المسار",
         "de_DE": "Pfad",
@@ -1822,106 +1697,6 @@
         "zh_TW": "路徑"
       }
     },
-    {
-      "ID": "GameListHeaderCompatibilityStatus",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "",
-        "en_US": "Compatibility:",
-        "es_ES": "",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "",
-        "ja_JP": "",
-        "ko_KR": "",
-        "no_NO": "",
-        "pl_PL": "",
-        "pt_BR": "",
-        "ru_RU": "",
-        "sv_SE": "",
-        "th_TH": "",
-        "tr_TR": "",
-        "uk_UA": "",
-        "zh_CN": "",
-        "zh_TW": ""
-      }
-    },
-    {
-      "ID": "GameListHeaderTitleId",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "",
-        "en_US": "Title ID:",
-        "es_ES": "",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "",
-        "ja_JP": "",
-        "ko_KR": "",
-        "no_NO": "",
-        "pl_PL": "",
-        "pt_BR": "",
-        "ru_RU": "",
-        "sv_SE": "",
-        "th_TH": "",
-        "tr_TR": "",
-        "uk_UA": "",
-        "zh_CN": "",
-        "zh_TW": ""
-      }
-    },
-    {
-      "ID": "GameListHeaderHostedGames",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "",
-        "en_US": "Hosted Games: {0}",
-        "es_ES": "",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "",
-        "ja_JP": "",
-        "ko_KR": "",
-        "no_NO": "",
-        "pl_PL": "",
-        "pt_BR": "",
-        "ru_RU": "",
-        "sv_SE": "",
-        "th_TH": "",
-        "tr_TR": "",
-        "uk_UA": "",
-        "zh_CN": "",
-        "zh_TW": ""
-      }
-    },
-    {
-      "ID": "GameListHeaderPlayerCount",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "",
-        "en_US": "Online Players: {0}",
-        "es_ES": "",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "",
-        "ja_JP": "",
-        "ko_KR": "",
-        "no_NO": "",
-        "pl_PL": "",
-        "pt_BR": "",
-        "ru_RU": "",
-        "sv_SE": "",
-        "th_TH": "",
-        "tr_TR": "",
-        "uk_UA": "",
-        "zh_CN": "",
-        "zh_TW": ""
-      }
-    },
     {
       "ID": "GameListContextMenuOpenUserSaveDirectory",
       "Translations": {
@@ -2747,106 +2522,6 @@
         "zh_TW": "在 macOS 的應用程式資料夾中建立捷徑，啟動選取的應用程式"
       }
     },
-    {
-      "ID": "GameListContextMenuShowCompatEntry",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "",
-        "en_US": "Show Compatibility Entry",
-        "es_ES": "",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "",
-        "ja_JP": "",
-        "ko_KR": "",
-        "no_NO": "",
-        "pl_PL": "",
-        "pt_BR": "",
-        "ru_RU": "",
-        "sv_SE": "",
-        "th_TH": "",
-        "tr_TR": "",
-        "uk_UA": "",
-        "zh_CN": "",
-        "zh_TW": ""
-      }
-    },
-    {
-      "ID": "GameListContextMenuShowCompatEntryToolTip",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "",
-        "en_US": "Show the selected game in the Compatibility List you can normally access via the Help menu.",
-        "es_ES": "",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "",
-        "ja_JP": "",
-        "ko_KR": "",
-        "no_NO": "",
-        "pl_PL": "",
-        "pt_BR": "",
-        "ru_RU": "",
-        "sv_SE": "",
-        "th_TH": "",
-        "tr_TR": "",
-        "uk_UA": "",
-        "zh_CN": "",
-        "zh_TW": ""
-      }
-    },
-    {
-      "ID": "GameListContextMenuShowGameData",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "",
-        "en_US": "Show Game Info",
-        "es_ES": "",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "",
-        "ja_JP": "",
-        "ko_KR": "",
-        "no_NO": "",
-        "pl_PL": "",
-        "pt_BR": "",
-        "ru_RU": "",
-        "sv_SE": "",
-        "th_TH": "",
-        "tr_TR": "",
-        "uk_UA": "",
-        "zh_CN": "",
-        "zh_TW": ""
-      }
-    },
-    {
-      "ID": "GameListContextMenuShowGameDataToolTip",
-      "Translations": {
-        "ar_SA": "",
-        "de_DE": "",
-        "el_GR": "",
-        "en_US": "Show stats & details about the currently selected game.",
-        "es_ES": "",
-        "fr_FR": "",
-        "he_IL": "",
-        "it_IT": "",
-        "ja_JP": "",
-        "ko_KR": "",
-        "no_NO": "",
-        "pl_PL": "",
-        "pt_BR": "",
-        "ru_RU": "",
-        "sv_SE": "",
-        "th_TH": "",
-        "tr_TR": "",
-        "uk_UA": "",
-        "zh_CN": "",
-        "zh_TW": ""
-      }
-    },
     {
       "ID": "GameListContextMenuOpenModsDirectory",
       "Translations": {
@@ -23394,7 +23069,7 @@
         "tr_TR": "",
         "uk_UA": "",
         "zh_CN": "可游玩",
-        "zh_TW": "可暢順遊玩"
+        "zh_TW": "可暢順遊玩 (Playable)"
       }
     },
     {
@@ -23419,7 +23094,7 @@
         "tr_TR": "",
         "uk_UA": "",
         "zh_CN": "进入游戏",
-        "zh_TW": "大致可遊玩"
+        "zh_TW": "大致可遊玩 (Ingame)"
       }
     },
     {
@@ -23444,7 +23119,7 @@
         "tr_TR": "",
         "uk_UA": "",
         "zh_CN": "菜单",
-        "zh_TW": "只開啟至遊戲開始功能表"
+        "zh_TW": "只開啟至遊戲開始功能表 (Menus)"
       }
     },
     {
@@ -23469,7 +23144,7 @@
         "tr_TR": "",
         "uk_UA": "",
         "zh_CN": "启动",
-        "zh_TW": "只能啟動"
+        "zh_TW": "只能啟動 (Boots)"
       }
     },
     {
@@ -23494,7 +23169,7 @@
         "tr_TR": "",
         "uk_UA": "",
         "zh_CN": "什么都没有",
-        "zh_TW": "無法啟動"
+        "zh_TW": "無法啟動 (Nothing)"
       }
     },
     {

src/Ryujinx/DiscordIntegrationModule.cs

@@ -56,7 +56,7 @@ namespace Ryujinx.Ava
 
             ConfigurationState.Instance.EnableDiscordIntegration.Event += Update;
             TitleIDs.CurrentApplication.Event += (_, e) => Use(e.NewValue);
-            HorizonStatic.PlayReport += HandlePlayReport;
+            HorizonStatic.PlayReportPrinted += HandlePlayReport;
         }
 
         private static void Update(object sender, ReactiveEventArgs<bool> evnt)
@@ -117,6 +117,11 @@ namespace Ryujinx.Ava
             _currentApp = appMeta;
         }
 
+        private static void UpdatePlayingState()
+        {
+            _discordClient?.SetPresence(_discordPresencePlaying);
+        }
+
         private static void SwitchToMainState()
         {
             _discordClient?.SetPresence(_discordPresenceMain);
@@ -130,20 +135,21 @@ namespace Ryujinx.Ava
             if (!TitleIDs.CurrentApplication.Value.HasValue) return;
             if (_discordPresencePlaying is null) return;
 
-            PlayReportAnalyzer.FormattedValue formattedValue =
-                PlayReport.Analyzer.Format(TitleIDs.CurrentApplication.Value, _currentApp, playReport);
+            PlayReportFormattedValue value = PlayReport.Analyzer.Run(TitleIDs.CurrentApplication.Value, _currentApp, playReport);
 
-            if (!formattedValue.Handled) return;
+            if (!value.Handled) return;
 
-            _discordPresencePlaying.Details = formattedValue.Reset 
-                ? $"Playing {_currentApp.Title}" 
-                : formattedValue.FormattedString;
-
-            if (_discordClient.CurrentPresence.Details.Equals(_discordPresencePlaying.Details))
-                return; //don't trigger an update if the set presence Details are identical to current
-
-            _discordClient.SetPresence(_discordPresencePlaying);
-            Logger.Info?.Print(LogClass.UI, "Updated Discord RPC based on a supported play report.");
+            if (value.Reset)
+            {
+                _discordPresencePlaying.Details = $"Playing {_currentApp.Title}";
+                Logger.Info?.Print(LogClass.UI, "Reset Discord RPC based on a supported play report value formatter.");
+            }
+            else
+            {
+                _discordPresencePlaying.Details = value.FormattedString;
+                Logger.Info?.Print(LogClass.UI, "Updated Discord RPC based on a supported play report.");
+            }
+            UpdatePlayingState();
         }
 
         private static string TruncateToByteLength(string input)

src/Ryujinx/RyujinxApp.axaml.cs

@@ -32,9 +32,6 @@ namespace Ryujinx.Ava
         public static MainWindow MainWindow => Current!
             .ApplicationLifetime.Cast<IClassicDesktopStyleApplicationLifetime>()
             .MainWindow.Cast<MainWindow>();
-        
-        public static IClassicDesktopStyleApplicationLifetime AppLifetime => Current!
-            .ApplicationLifetime.Cast<IClassicDesktopStyleApplicationLifetime>();
 
         public static bool IsClipboardAvailable(out IClipboard clipboard)
         {

src/Ryujinx/UI/Controls/ApplicationContextMenu.axaml

@@ -19,17 +19,6 @@
         Header="{ext:Locale GameListContextMenuCreateShortcut}"
         Icon="{ext:Icon fa-solid fa-bookmark}"
         ToolTip.Tip="{OnPlatform Default={ext:Locale GameListContextMenuCreateShortcutToolTip}, macOS={ext:Locale GameListContextMenuCreateShortcutToolTipMacOS}}" />
-    <MenuItem
-        IsVisible="{Binding HasCompatibilityEntry}"
-        Click="OpenApplicationCompatibility_Click"
-        Header="{ext:Locale GameListContextMenuShowCompatEntry}"
-        Icon="{ext:Icon mdi-gamepad}"
-        ToolTip.Tip="{ext:Locale GameListContextMenuShowCompatEntryToolTip}"/>
-    <MenuItem
-        Click="OpenApplicationData_Click"
-        Header="{ext:Locale GameListContextMenuShowGameData}"
-        Icon="{ext:Icon mdi-chart-line}"
-        ToolTip.Tip="{ext:Locale GameListContextMenuShowGameDataToolTip}"/>
     <Separator />
     <MenuItem
         Click="OpenUserSaveDirectory_Click"
@@ -85,6 +74,7 @@
 		Header="{ext:Locale GameListContextMenuTrimXCI}"
         IsEnabled="{Binding TrimXCIEnabled}"
 		ToolTip.Tip="{ext:Locale GameListContextMenuTrimXCIToolTip}" />
+    <Separator />
     <MenuItem Header="{ext:Locale GameListContextMenuCacheManagement}" Icon="{ext:Icon mdi-cached}">
         <MenuItem
             Click="PurgePtcCache_Click"
@@ -122,7 +112,6 @@
             Header="{ext:Locale GameListContextMenuExtractDataRomFS}"
             ToolTip.Tip="{ext:Locale GameListContextMenuExtractDataRomFSToolTip}" />
         <MenuItem
-            IsVisible="{Binding HasDlc}"
             Click="ExtractAocRomFs_Click"
             Header="{ext:Locale GameListContextMenuExtractDataAocRomFS}"
             ToolTip.Tip="{ext:Locale GameListContextMenuExtractDataAocRomFSToolTip}" />

src/Ryujinx/UI/Controls/ApplicationContextMenu.axaml.cs

@@ -12,7 +12,6 @@ using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.UI.Windows;
 using Ryujinx.Ava.Utilities;
 using Ryujinx.Ava.Utilities.AppLibrary;
-using Ryujinx.Ava.Utilities.Compat;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Helper;
 using Ryujinx.HLE.HOS;
@@ -334,7 +333,7 @@ namespace Ryujinx.Ava.UI.Controls
             if (sender is not MenuItem { DataContext: MainWindowViewModel { SelectedApplication: not null } viewModel })
                 return;
 
-            DownloadableContentModel selectedDlc = await DlcSelectView.Show(viewModel.SelectedApplication.Id, viewModel.ApplicationLibrary);
+            DownloadableContentModel selectedDlc = await DlcSelectView.Show(viewModel.SelectedApplication.IdBase, viewModel.ApplicationLibrary);
             
             if (selectedDlc is not null)
             {
@@ -386,18 +385,6 @@ namespace Ryujinx.Ava.UI.Controls
                     viewModel.SelectedApplication.Icon
                 );
         }
-        
-        public async void OpenApplicationCompatibility_Click(object sender, RoutedEventArgs args)
-        {
-            if (sender is MenuItem { DataContext: MainWindowViewModel { SelectedApplication: not null } viewModel })
-                await CompatibilityList.Show(viewModel.SelectedApplication.IdString);
-        }
-        
-        public async void OpenApplicationData_Click(object sender, RoutedEventArgs args)
-        {
-            if (sender is MenuItem { DataContext: MainWindowViewModel { SelectedApplication: not null } viewModel })
-                await ApplicationDataView.Show(viewModel.SelectedApplication);
-        }
 
         public async void RunApplication_Click(object sender, RoutedEventArgs args)
         {
@@ -407,8 +394,12 @@ namespace Ryujinx.Ava.UI.Controls
 
         public async void TrimXCI_Click(object sender, RoutedEventArgs args)
         {
-            if (sender is MenuItem { DataContext: MainWindowViewModel { SelectedApplication: not null } viewModel })
+            MainWindowViewModel viewModel = (sender as MenuItem)?.DataContext as MainWindowViewModel;
+
+            if (viewModel?.SelectedApplication != null)
+            {
                 await viewModel.TrimXCIFile(viewModel.SelectedApplication.Path);
+            }
         }
     }
 }

src/Ryujinx/UI/Controls/ApplicationDataView.axaml

@@ -1,114 +0,0 @@
-<UserControl xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-             xmlns:helpers="clr-namespace:Ryujinx.Ava.UI.Helpers"
-             xmlns:ext="using:Ryujinx.Ava.Common.Markup"
-             xmlns:viewModels="using:Ryujinx.Ava.UI.ViewModels"
-             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
-             x:Class="Ryujinx.Ava.UI.Controls.ApplicationDataView"
-             x:DataType="viewModels:ApplicationDataViewModel">
-    <StackPanel Orientation="Horizontal">
-        <Image Margin="0"
-               MaxWidth="256"
-               MinWidth="256"
-               Source="{Binding AppData.Icon, Converter={x:Static helpers:BitmapArrayValueConverter.Instance}}" />
-        <Border Margin="5, 0" Width="1" Height="256" BorderBrush="Gray" Background="Gray" />
-        <StackPanel Orientation="Vertical">
-            <Grid
-                RowDefinitions="Auto,Auto,Auto"
-                ColumnDefinitions="*">
-                <StackPanel Grid.Row="0">
-                    <TextBlock HorizontalAlignment="Left"
-                               Text="{Binding FormattedVersion}"
-                               TextAlignment="Start"
-                               TextWrapping="Wrap" />
-                    <TextBlock HorizontalAlignment="Left"
-                               Text="{Binding FormattedDeveloper}"
-                               TextAlignment="Start"
-                               TextWrapping="Wrap" />
-                    <TextBlock HorizontalAlignment="Stretch"
-                               Text="{Binding FormattedFileExtension}"
-                               TextAlignment="Start"
-                               TextWrapping="Wrap" />
-                    <TextBlock HorizontalAlignment="Stretch"
-                               Text="{Binding FormattedFileSize}"
-                               TextAlignment="Start"
-                               TextWrapping="Wrap" />
-                </StackPanel>
-                <Separator Grid.Row="1" Margin="0, 10, 0, 10" Height="1" BorderBrush="Gray" Background="Gray" />
-                <StackPanel Grid.Row="2"
-                            HorizontalAlignment="Left"
-                            Orientation="Vertical"
-                            Spacing="5">
-                    <StackPanel Orientation="Horizontal">
-                        <TextBlock Padding="0, 0, 5, 0" Text="{ext:Locale GameListHeaderCompatibilityStatus}" />
-                        <Button
-                            Click="PlayabilityStatus_OnClick"
-                            HorizontalContentAlignment="Left"
-                            VerticalAlignment="Center"
-                            IsVisible="{Binding AppData.HasPlayabilityInfo}"
-                            Background="{DynamicResource AppListBackgroundColor}"
-                            Padding="0">
-                            <TextBlock
-                                Margin="1.5"
-                                Tag="{Binding AppData.IdString}"
-                                Text="{Binding AppData.LocalizedStatus}"
-                                Foreground="{Binding AppData.PlayabilityStatus, Converter={x:Static helpers:PlayabilityStatusConverter.Shared}}"
-                                TextAlignment="Start"
-                                TextWrapping="Wrap" />
-                            <Button.Styles>
-                                <Style Selector="Button">
-                                    <Setter Property="MinWidth"
-                                            Value="0" />
-                                    <!-- avoids very wide buttons from the overall project avalonia style -->
-                                </Style>
-                            </Button.Styles>
-                        </Button>
-                    </StackPanel>
-                    <StackPanel Orientation="Horizontal">
-                        <TextBlock Padding="0, 0, 5, 0" Text="{ext:Locale GameListHeaderTitleId}" />
-                        <Button
-                            Click="IdString_OnClick"
-                            HorizontalContentAlignment="Left"
-                            VerticalAlignment="Center"
-                            Background="{DynamicResource AppListBackgroundColor}"
-                            Padding="0">
-                            <TextBlock
-                                Margin="1.5"
-                                HorizontalAlignment="Stretch"
-                                Text="{Binding AppData.IdString}"
-                                TextAlignment="Start"
-                                TextWrapping="Wrap" />
-                        </Button>
-                    </StackPanel>
-                </StackPanel>
-            </Grid>
-            <Separator Margin="0, 10, 0, 10" Height="1" BorderBrush="Gray" Background="Gray" />
-            <TextBlock
-                HorizontalAlignment="Stretch"
-                IsVisible="{Binding AppData.HasLdnGames}"
-                Text="{Binding FormattedLdnInfo}"
-                TextAlignment="Start"
-                TextWrapping="Wrap" />
-            <Separator IsVisible="{Binding AppData.HasLdnGames}" Margin="0, 10, 0, 10" Height="1" BorderBrush="Gray" Background="Gray" />
-            <StackPanel
-                HorizontalAlignment="Left"
-                VerticalAlignment="Top"
-                Orientation="Vertical"
-                Spacing="5">
-                <TextBlock
-                    HorizontalAlignment="Stretch"
-                    Text="{Binding FormattedLastPlayed}"
-                    TextAlignment="Start"
-                    TextWrapping="Wrap" />
-                <TextBlock
-                    HorizontalAlignment="Stretch"
-                    Text="{Binding FormattedPlayTime}"
-                    IsVisible="{Binding AppData.HasPlayedPreviously}"
-                    TextAlignment="Start"
-                    TextWrapping="Wrap" />
-            </StackPanel>
-        </StackPanel>
-    </StackPanel>
-</UserControl>

src/Ryujinx/UI/Controls/ApplicationDataView.axaml.cs

@@ -1,86 +0,0 @@
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Input.Platform;
-using Avalonia.Interactivity;
-using Avalonia.Styling;
-using FluentAvalonia.UI.Controls;
-using Ryujinx.Ava;
-using Ryujinx.Ava.Common.Locale;
-using Ryujinx.Ava.UI.Controls;
-using Ryujinx.Ava.UI.Helpers;
-using Ryujinx.Ava.UI.ViewModels;
-using Ryujinx.Ava.UI.Windows;
-using Ryujinx.Ava.Utilities.AppLibrary;
-using Ryujinx.Ava.Utilities.Compat;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace Ryujinx.Ava.UI.Controls
-{
-    public partial class ApplicationDataView : UserControl
-    {
-        public static async Task Show(ApplicationData appData)
-        {
-            ContentDialog contentDialog = new()
-            {
-                Title = appData.Name,
-                PrimaryButtonText = string.Empty,
-                SecondaryButtonText = string.Empty,
-                CloseButtonText = LocaleManager.Instance[LocaleKeys.SettingsButtonClose],
-                MinWidth = 256,
-                Content = new ApplicationDataView { DataContext = new ApplicationDataViewModel(appData) }
-            };
-
-            Style closeButton = new(x => x.Name("CloseButton"));
-            closeButton.Setters.Add(new Setter(WidthProperty, 160d));
-
-            Style closeButtonParent = new(x => x.Name("CommandSpace"));
-            closeButtonParent.Setters.Add(new Setter(HorizontalAlignmentProperty,
-                Avalonia.Layout.HorizontalAlignment.Center));
-
-            contentDialog.Styles.Add(closeButton);
-            contentDialog.Styles.Add(closeButtonParent);
-
-            await ContentDialogHelper.ShowAsync(contentDialog);
-        }
-        
-        public ApplicationDataView()
-        {
-            InitializeComponent();
-        }
-        
-        private async void PlayabilityStatus_OnClick(object sender, RoutedEventArgs e)
-        {
-            if (sender is not Button { Content: TextBlock playabilityLabel })
-                return;
-
-            if (RyujinxApp.AppLifetime.Windows.TryGetFirst(x => x is ContentDialogOverlayWindow, out Window window))
-                window.Close(ContentDialogResult.None);
-            
-            await CompatibilityList.Show((string)playabilityLabel.Tag);
-        }
-
-        private async void IdString_OnClick(object sender, RoutedEventArgs e)
-        {
-            if (DataContext is not MainWindowViewModel mwvm)
-                return;
-            
-            if (sender is not Button { Content: TextBlock idText })
-                return;
-
-            if (!RyujinxApp.IsClipboardAvailable(out IClipboard clipboard))
-                return;
-            
-            ApplicationData appData = mwvm.Applications.FirstOrDefault(it => it.IdString == idText.Text);
-            if (appData is null)
-                return;
-            
-            await clipboard.SetTextAsync(appData.IdString);
-                
-            NotificationHelper.ShowInformation(
-                "Copied Title ID", 
-                $"{appData.Name} ({appData.IdString})");
-        }
-    }
-}
-

src/Ryujinx/UI/Controls/ApplicationListView.axaml

@@ -86,29 +86,6 @@
                                             Text="{Binding Version}"
                                             TextAlignment="Start"
                                             TextWrapping="Wrap" />
-                                        <Button 
-                                            Click="PlayabilityStatus_OnClick" 
-                                            HorizontalContentAlignment="Left"
-                                            VerticalAlignment="Center"
-                                            IsVisible="{Binding HasPlayabilityInfo}"
-                                            Background="{DynamicResource AppListBackgroundColor}"
-                                            Margin="-1, 0, 0, 0"
-                                            Padding="0" >
-                                            <TextBlock
-                                                Margin="1.5"
-                                                Tag="{Binding IdString}"
-                                                Text="{Binding LocalizedStatus}"
-                                                Foreground="{Binding PlayabilityStatus, Converter={x:Static helpers:PlayabilityStatusConverter.Shared}}"
-                                                TextAlignment="Start"
-                                                TextWrapping="Wrap" />
-                                            <Button.Styles>
-                                                <Style Selector="Button">
-                                                    <Setter Property="MinWidth"
-                                                            Value="0" /> 
-                                <!-- avoids very wide buttons from the overall project avalonia style -->
-                                                </Style>
-                                            </Button.Styles>
-                                        </Button>
                                     </StackPanel>
                                 </Border>
                                 <StackPanel
@@ -140,8 +117,7 @@
                                         TextWrapping="Wrap" />
                                     <TextBlock
                                         HorizontalAlignment="Stretch"
-                                        IsVisible="{Binding HasLdnGames}"
-                                        Text="{Binding Converter={x:Static helpers:MultiplayerInfoConverter.Instance}}"
+                                        Text="{Binding Converter={helpers:MultiplayerInfoConverter}}"
                                         TextAlignment="Start"
                                         TextWrapping="Wrap"/>
                                 </StackPanel>

src/Ryujinx/UI/Controls/ApplicationListView.axaml.cs

@@ -5,9 +5,7 @@ using Avalonia.Interactivity;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.Utilities.AppLibrary;
-using Ryujinx.Ava.Utilities.Compat;
 using System;
-using System.Globalization;
 using System.Linq;
 
 namespace Ryujinx.Ava.UI.Controls
@@ -30,17 +28,6 @@ namespace Ryujinx.Ava.UI.Controls
             if (sender is ListBox { SelectedItem: ApplicationData selected })
                 RaiseEvent(new ApplicationOpenedEventArgs(selected, ApplicationOpenedEvent));
         }
-        
-        private async void PlayabilityStatus_OnClick(object sender, RoutedEventArgs e)
-        {
-            if (DataContext is not MainWindowViewModel mwvm)
-                return;
-            
-            if (sender is not Button { Content: TextBlock playabilityLabel })
-                return;
-
-            await CompatibilityList.Show((string)playabilityLabel.Tag);
-        }
 
         private async void IdString_OnClick(object sender, RoutedEventArgs e)
         {

src/Ryujinx/UI/Helpers/Converters/MultiplayerInfoConverter.cs

@@ -1,31 +1,27 @@
 using Avalonia.Data.Converters;
 using Avalonia.Markup.Xaml;
-using Gommon;
-using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.Utilities.AppLibrary;
 using System;
 using System.Globalization;
-using System.Text;
 
 namespace Ryujinx.Ava.UI.Helpers
 {
     internal class MultiplayerInfoConverter : MarkupExtension, IValueConverter
     {
-        public static readonly MultiplayerInfoConverter Instance = new();
+        private static readonly MultiplayerInfoConverter _instance = new();
 
         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
-            if (value is not ApplicationData { HasLdnGames: true } applicationData)
-                return "";
+            if (value is ApplicationData applicationData)
+            {
+                if (applicationData.PlayerCount != 0 && applicationData.GameCount != 0)
+                {
+                    return $"Hosted Games: {applicationData.GameCount}\nOnline Players: {applicationData.PlayerCount}";
+                }
+            }
+            
+            return "";
             
-            return new StringBuilder()
-                .AppendLine(
-                    LocaleManager.Instance[LocaleKeys.GameListHeaderHostedGames]
-                        .Format(applicationData.GameCount))
-                .Append(
-                    LocaleManager.Instance[LocaleKeys.GameListHeaderPlayerCount]
-                        .Format(applicationData.PlayerCount))
-                .ToString();
         }
 
         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
@@ -35,7 +31,7 @@ namespace Ryujinx.Ava.UI.Helpers
 
         public override object ProvideValue(IServiceProvider serviceProvider)
         {
-            return Instance;
+            return _instance;
         }
     }
 }

src/Ryujinx/UI/ViewModels/ApplicationDataViewModel.cs

@@ -1,26 +0,0 @@
-using Gommon;
-using Ryujinx.Ava.Common.Locale;
-using Ryujinx.Ava.Utilities.AppLibrary;
-
-namespace Ryujinx.Ava.UI.ViewModels
-{
-    public class ApplicationDataViewModel : BaseModel
-    {
-        public ApplicationData AppData { get; }
-
-        public ApplicationDataViewModel(ApplicationData appData) => AppData = appData;
-
-        public string FormattedVersion => LocaleManager.Instance[LocaleKeys.GameListHeaderVersion].Format(AppData.Version);
-        public string FormattedDeveloper => LocaleManager.Instance[LocaleKeys.GameListHeaderDeveloper].Format(AppData.Developer);
-        
-        public string FormattedFileExtension => LocaleManager.Instance[LocaleKeys.GameListHeaderFileExtension].Format(AppData.FileExtension);
-        public string FormattedLastPlayed => LocaleManager.Instance[LocaleKeys.GameListHeaderLastPlayed].Format(AppData.LastPlayedString);
-        public string FormattedPlayTime => LocaleManager.Instance[LocaleKeys.GameListHeaderTimePlayed].Format(AppData.TimePlayedString);
-        public string FormattedFileSize => LocaleManager.Instance[LocaleKeys.GameListHeaderFileSize].Format(AppData.FileSizeString);
-        
-        public string FormattedLdnInfo => 
-            $"{LocaleManager.Instance[LocaleKeys.GameListHeaderHostedGames].Format(AppData.GameCount)}" +
-            $"\n" +
-            $"{LocaleManager.Instance[LocaleKeys.GameListHeaderPlayerCount].Format(AppData.PlayerCount)}";
-    }
-}

src/Ryujinx/UI/ViewModels/DlcSelectViewModel.cs

@@ -14,7 +14,9 @@ namespace Ryujinx.Ava.UI.ViewModels
         
         public DlcSelectViewModel(ulong titleId, ApplicationLibrary appLibrary)
         {
-            _dlcs = appLibrary.FindDlcsFor(titleId)
+            _dlcs = appLibrary.DownloadableContents.Items
+                .Where(x => x.Dlc.TitleIdBase == titleId)
+                .Select(x => x.Dlc)
                 .OrderBy(it => it.IsBundled ? 0 : 1)
                 .ThenBy(it => it.TitleId)
                 .ToArray();

src/Ryujinx/UI/ViewModels/DownloadableContentManagerViewModel.cs

@@ -69,7 +69,8 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         private void LoadDownloadableContents()
         {
-            (DownloadableContentModel Dlc, bool IsEnabled)[] dlcs = _applicationLibrary.FindDlcConfigurationFor(_applicationData.Id);
+            IEnumerable<(DownloadableContentModel Dlc, bool IsEnabled)> dlcs = _applicationLibrary.DownloadableContents.Items
+                .Where(it => it.Dlc.TitleIdBase == _applicationData.IdBase);
 
             bool hasBundledContent = false;
             foreach ((DownloadableContentModel dlc, bool isEnabled) in dlcs)

src/Ryujinx/UI/ViewModels/MainWindowViewModel.cs

@@ -349,10 +349,6 @@ namespace Ryujinx.Ava.UI.ViewModels
             }
         }
 
-        public bool HasCompatibilityEntry => SelectedApplication.HasPlayabilityInfo;
-
-        public bool HasDlc => ApplicationLibrary.HasDlcs(SelectedApplication.Id);
-
         public bool OpenUserSaveDirectoryEnabled => SelectedApplication.HasControlHolder && SelectedApplication.ControlHolder.Value.UserAccountSaveDataSize > 0;
 
         public bool OpenDeviceSaveDirectoryEnabled => SelectedApplication.HasControlHolder && SelectedApplication.ControlHolder.Value.DeviceSaveDataSize > 0;
@@ -633,15 +629,15 @@ namespace Ryujinx.Ava.UI.ViewModels
             {
                 return SortMode switch
                 {
+                    ApplicationSort.Title => LocaleManager.Instance[LocaleKeys.GameListHeaderApplication],
+                    ApplicationSort.Developer => LocaleManager.Instance[LocaleKeys.GameListHeaderDeveloper],
+                    ApplicationSort.LastPlayed => LocaleManager.Instance[LocaleKeys.GameListHeaderLastPlayed],
+                    ApplicationSort.TotalTimePlayed => LocaleManager.Instance[LocaleKeys.GameListHeaderTimePlayed],
+                    ApplicationSort.FileType => LocaleManager.Instance[LocaleKeys.GameListHeaderFileExtension],
+                    ApplicationSort.FileSize => LocaleManager.Instance[LocaleKeys.GameListHeaderFileSize],
+                    ApplicationSort.Path => LocaleManager.Instance[LocaleKeys.GameListHeaderPath],
                     ApplicationSort.Favorite => LocaleManager.Instance[LocaleKeys.CommonFavorite],
                     ApplicationSort.TitleId => LocaleManager.Instance[LocaleKeys.DlcManagerTableHeadingTitleIdLabel],
-                    ApplicationSort.Title => LocaleManager.Instance[LocaleKeys.GameListHeaderApplication],
-                    ApplicationSort.Developer => LocaleManager.Instance[LocaleKeys.GameListSortDeveloper],
-                    ApplicationSort.LastPlayed => LocaleManager.Instance[LocaleKeys.GameListSortLastPlayed],
-                    ApplicationSort.TotalTimePlayed => LocaleManager.Instance[LocaleKeys.GameListSortTimePlayed],
-                    ApplicationSort.FileType => LocaleManager.Instance[LocaleKeys.GameListSortFileExtension],
-                    ApplicationSort.FileSize => LocaleManager.Instance[LocaleKeys.GameListSortFileSize],
-                    ApplicationSort.Path => LocaleManager.Instance[LocaleKeys.GameListSortPath],
                     _ => string.Empty,
                 };
             }

src/Ryujinx/UI/ViewModels/TitleUpdateViewModel.cs

@@ -41,7 +41,8 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         private void LoadUpdates()
         {
-            (TitleUpdateModel TitleUpdate, bool IsSelected)[] updates = ApplicationLibrary.FindUpdateConfigurationFor(ApplicationData.Id);
+            IEnumerable<(TitleUpdateModel TitleUpdate, bool IsSelected)> updates = ApplicationLibrary.TitleUpdates.Items
+                .Where(it => it.TitleUpdate.TitleIdBase == ApplicationData.IdBase);
 
             bool hasBundledContent = false;
             SelectedUpdate = new TitleUpdateViewModelNoUpdate();

src/Ryujinx/UI/Views/Main/MainMenuBarView.axaml.cs

@@ -50,7 +50,7 @@ namespace Ryujinx.Ava.UI.Views.Main
             UninstallFileTypesMenuItem.Command = Commands.Create(UninstallFileTypes);
             XciTrimmerMenuItem.Command = Commands.Create(XCITrimmerWindow.Show);
             AboutWindowMenuItem.Command = Commands.Create(AboutWindow.Show);
-            CompatibilityListMenuItem.Command = Commands.Create(() => CompatibilityList.Show());
+            CompatibilityListMenuItem.Command = Commands.Create(CompatibilityList.Show);
             
             UpdateMenuItem.Command = Commands.Create(async () =>
             {

src/Ryujinx/UI/Views/Main/MainViewControls.axaml

@@ -113,37 +113,37 @@
                                 Tag="TitleId" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListSortDeveloper}"
+                                Content="{ext:Locale GameListHeaderDeveloper}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByDeveloper, Mode=OneTime}"
                                 Tag="Developer" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListSortTimePlayed}"
+                                Content="{ext:Locale GameListHeaderTimePlayed}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByTimePlayed, Mode=OneTime}"
                                 Tag="TotalTimePlayed" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListSortLastPlayed}"
+                                Content="{ext:Locale GameListHeaderLastPlayed}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByLastPlayed, Mode=OneTime}"
                                 Tag="LastPlayed" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListSortFileExtension}"
+                                Content="{ext:Locale GameListHeaderFileExtension}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByType, Mode=OneTime}"
                                 Tag="FileType" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListSortFileSize}"
+                                Content="{ext:Locale GameListHeaderFileSize}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedBySize, Mode=OneTime}"
                                 Tag="FileSize" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListSortPath}"
+                                Content="{ext:Locale GameListHeaderPath}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByPath, Mode=OneTime}"
                                 Tag="Path" />

src/Ryujinx/Utilities/AppLibrary/ApplicationData.cs

@@ -7,8 +7,6 @@ using LibHac.Ns;
 using LibHac.Tools.Fs;
 using LibHac.Tools.FsSystem;
 using LibHac.Tools.FsSystem.NcaUtils;
-using Ryujinx.Ava.Common.Locale;
-using Ryujinx.Ava.Utilities.Compat;
 using Ryujinx.Common.Logging;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.Loaders.Processes.Extensions;
@@ -23,35 +21,11 @@ namespace Ryujinx.Ava.Utilities.AppLibrary
         public bool Favorite { get; set; }
         public byte[] Icon { get; set; }
         public string Name { get; set; } = "Unknown";
-
-        private ulong _id;
-
-        public ulong Id
-        {
-            get => _id;
-            set
-            {
-                _id = value;
-                PlayabilityStatus = CompatibilityCsv.GetStatus(Id);
-            }
-        }
+        public ulong Id { get; set; }
         public string Developer { get; set; } = "Unknown";
         public string Version { get; set; } = "0";
-
-        public bool HasPlayabilityInfo => PlayabilityStatus != null;
-
-        public string LocalizedStatus =>
-            PlayabilityStatus.HasValue 
-                ? LocaleManager.Instance[PlayabilityStatus!.Value] 
-                : string.Empty;
-
-        public LocaleKeys? PlayabilityStatus { get; set; }
-        
         public int PlayerCount { get; set; }
         public int GameCount { get; set; }
-
-        public bool HasLdnGames => PlayerCount != 0 && GameCount != 0;
-        
         public TimeSpan TimePlayed { get; set; }
         public DateTime? LastPlayed { get; set; }
         public string FileExtension { get; set; }

src/Ryujinx/Utilities/AppLibrary/ApplicationLibrary.cs

@@ -128,50 +128,13 @@ namespace Ryujinx.Ava.Utilities.AppLibrary
             DynamicData.Kernel.Optional<ApplicationData> appData = Applications.Lookup(id);
             if (appData.HasValue)
                 return appData.Value.Name;
-
-            if (!DownloadableContents.Keys.FindFirst(x => x.TitleId == id).TryGet(out DownloadableContentModel dlcData))
-                return id.ToString("X16");
             
-            string name = Path.GetFileNameWithoutExtension(dlcData.FileName)!;
-            int idx = name.IndexOf('[');
-            if (idx != -1)
-                name = name[..idx];
+            if (DownloadableContents.Keys.FindFirst(x => x.TitleId == id).TryGet(out DownloadableContentModel dlcData))
+                return Path.GetFileNameWithoutExtension(dlcData.FileName);
 
-            return name;
+            return id.ToString("X16");
         }
 
-        public bool FindApplication(ulong id, out ApplicationData foundData)
-        {
-            DynamicData.Kernel.Optional<ApplicationData> appData = Applications.Lookup(id);
-            foundData = appData.HasValue ? appData.Value : null;
-
-            return appData.HasValue;
-        }
-        
-        public bool FindUpdate(ulong id, out TitleUpdateModel foundData)
-        {
-            Gommon.Optional<TitleUpdateModel> appData = 
-                TitleUpdates.Keys.FindFirst(x => x.TitleId == id);
-            foundData = appData.HasValue ? appData.Value : null;
-
-            return appData.HasValue;
-        }
-        
-        public TitleUpdateModel[] FindUpdatesFor(ulong id)
-            => TitleUpdates.Keys.Where(x => x.TitleIdBase == (id & ~0x1FFFUL)).ToArray();
-        
-        public (TitleUpdateModel TitleUpdate, bool IsSelected)[] FindUpdateConfigurationFor(ulong id)
-            => TitleUpdates.Items.Where(x => x.TitleUpdate.TitleIdBase == (id & ~0x1FFFUL)).ToArray();
-        
-        public DownloadableContentModel[] FindDlcsFor(ulong id)
-            => DownloadableContents.Keys.Where(x => x.TitleIdBase == (id & ~0x1FFFUL)).ToArray();
-        
-        public (DownloadableContentModel Dlc, bool IsEnabled)[] FindDlcConfigurationFor(ulong id)
-            => DownloadableContents.Items.Where(x => x.Dlc.TitleIdBase == (id & ~0x1FFFUL)).ToArray();
-        
-        public bool HasDlcs(ulong id)
-            => DownloadableContents.Keys.Any(x => x.TitleIdBase == (id & ~0x1FFFUL));
-
         /// <exception cref="LibHac.Common.Keys.MissingKeyException">The configured key set is missing a key.</exception>
         /// <exception cref="InvalidDataException">The NCA header could not be decrypted.</exception>
         /// <exception cref="NotSupportedException">The NCA version is not supported.</exception>

src/Ryujinx/Utilities/Compat/CompatibilityCsv.cs

@@ -47,6 +47,11 @@ namespace Ryujinx.Ava.Utilities.Compat
             Logger.Debug?.Print(LogClass.UI, "Compatibility CSV loaded.", "LoadCompatibility");
         }
 
+        public static void Unload()
+        {
+            _entries = null;
+        }
+
         private static CompatibilityEntry[] _entries;
         
         public static CompatibilityEntry[] Entries 
@@ -59,11 +64,6 @@ namespace Ryujinx.Ava.Utilities.Compat
                 return _entries;
             }
         }
-
-        public static LocaleKeys? GetStatus(string titleId)
-            => Entries.FirstOrDefault(x => x.TitleId.HasValue && x.TitleId.Value.EqualsIgnoreCase(titleId))?.Status;
-        
-        public static LocaleKeys? GetStatus(ulong titleId) => GetStatus(titleId.ToString("X16"));
     }
 
     public class CompatibilityEntry
@@ -113,17 +113,20 @@ namespace Ryujinx.Ava.Utilities.Compat
             .Select(FormatLabelName)
             .JoinToString(", ");
 
-        public override string ToString() =>
-            new StringBuilder("CompatibilityEntry: {")
-                .Append($"{nameof(GameName)}=\"{GameName}\", ")
-                .Append($"{nameof(TitleId)}={TitleId}, ")
-                .Append($"{nameof(Labels)}={
-                    Labels.FormatCollection(it => $"\"{it}\"", separator: ", ", prefix: "[", suffix: "]")
-                }, ")
-                .Append($"{nameof(Status)}=\"{Status}\", ")
-                .Append($"{nameof(LastUpdated)}=\"{LastUpdated}\"")
-                .Append('}')
-                .ToString();
+        public override string ToString()
+        {
+            StringBuilder sb = new("CompatibilityEntry: {");
+            sb.Append($"{nameof(GameName)}=\"{GameName}\", ");
+            sb.Append($"{nameof(TitleId)}={TitleId}, ");
+            sb.Append($"{nameof(Labels)}={
+                Labels.FormatCollection(it => $"\"{it}\"", separator: ", ", prefix: "[", suffix: "]")
+            }, ");
+            sb.Append($"{nameof(Status)}=\"{Status}\", ");
+            sb.Append($"{nameof(LastUpdated)}=\"{LastUpdated}\"");
+            sb.Append('}');
+
+            return sb.ToString();
+        }
 
         public static string FormatLabelName(string labelName) => labelName.ToLower() switch
         {

src/Ryujinx/Utilities/Compat/CompatibilityList.axaml

@@ -34,7 +34,7 @@
                 Text="{ext:Locale CompatibilityListWarning}" />
         </Grid>
         <Grid Grid.Row="1" ColumnDefinitions="*,Auto,Auto">
-            <TextBox Name="SearchBox" Grid.Column="0" HorizontalAlignment="Stretch" Watermark="{ext:Locale CompatibilityListSearchBoxWatermark}" TextChanged="TextBox_OnTextChanged" />
+            <TextBox Grid.Column="0" HorizontalAlignment="Stretch" Watermark="{ext:Locale CompatibilityListSearchBoxWatermark}" TextChanged="TextBox_OnTextChanged" />
             <CheckBox Grid.Column="1" Margin="7, 0, 0, 0" IsChecked="{Binding OnlyShowOwnedGames}" />
             <TextBlock Grid.Column="2" Margin="-10, 0, 0, 0" Text="{ext:Locale CompatibilityListOnlyShowOwnedGames}" />
         </Grid>

src/Ryujinx/Utilities/Compat/CompatibilityList.axaml.cs

@@ -9,7 +9,7 @@ namespace Ryujinx.Ava.Utilities.Compat
 {
     public partial class CompatibilityList : UserControl
     {
-        public static async Task Show(string titleId = null)
+        public static async Task Show()
         {
             ContentDialog contentDialog = new()
             {
@@ -18,10 +18,7 @@ namespace Ryujinx.Ava.Utilities.Compat
                 CloseButtonText = LocaleManager.Instance[LocaleKeys.SettingsButtonClose],
                 Content = new CompatibilityList
                 {
-                    DataContext = new CompatibilityViewModel(RyujinxApp.MainWindow.ViewModel.ApplicationLibrary), 
-                    SearchBox = {
-                        Text = titleId ?? ""
-                    }
+                    DataContext = new CompatibilityViewModel(RyujinxApp.MainWindow.ViewModel.ApplicationLibrary)
                 }
             };
 
@@ -35,6 +32,8 @@ namespace Ryujinx.Ava.Utilities.Compat
             contentDialog.Styles.Add(closeButtonParent);
 
             await ContentDialogHelper.ShowAsync(contentDialog);
+            
+            CompatibilityCsv.Unload();
         }
         
         public CompatibilityList()

src/Ryujinx/Utilities/PlayReport.cs

@@ -1,4 +1,10 @@
-using PlayReportFormattedValue = Ryujinx.Ava.Utilities.PlayReportAnalyzer.FormattedValue;
+using Gommon;
+using MsgPack;
+using Ryujinx.Ava.Utilities.AppLibrary;
+using Ryujinx.Common.Helper;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Ryujinx.Ava.Utilities
 {
@@ -7,55 +13,41 @@ namespace Ryujinx.Ava.Utilities
         public static PlayReportAnalyzer Analyzer { get; } = new PlayReportAnalyzer()
             .AddSpec(
                 "01007ef00011e000",
-                spec => spec
-                    .AddValueFormatter("IsHardMode", BreathOfTheWild_MasterMode)
-                    // reset to normal status when switching between normal & master mode in title screen
-                    .AddValueFormatter("AoCVer", PlayReportFormattedValue.AlwaysResets)
+                spec => spec.AddValueFormatter("IsHardMode", BreathOfTheWild_MasterMode)
             )
-            .AddSpec(
-                "0100f2c0115b6000",
-                spec => spec.AddValueFormatter("PlayerPosY", TearsOfTheKingdom_CurrentField))
-            .AddSpec(
+            .AddSpec( // Super Mario Odyssey
                 "0100000000010000",
                 spec =>
                     spec.AddValueFormatter("is_kids_mode", SuperMarioOdyssey_AssistMode)
             )
-            .AddSpec(
-                "010075000ecbe000",
+            .AddSpec( // Super Mario Odyssey (China)
+                "010075000ECBE000",
                 spec =>
                     spec.AddValueFormatter("is_kids_mode", SuperMarioOdysseyChina_AssistMode)
             )
-            .AddSpec(
-                "010028600ebda000",
+            .AddSpec( // Super Mario 3D World + Bowser's Fury
+                "010028600EBDA000",
                 spec => spec.AddValueFormatter("mode", SuperMario3DWorldOrBowsersFury)
             )
-            .AddSpec( // Global & China IDs
-                ["0100152000022000", "010075100e8ec000"],
+            .AddSpec( // Mario Kart 8 Deluxe, Mario Kart 8 Deluxe (China)
+                ["0100152000022000", "010075100E8EC000"],
                 spec => spec.AddValueFormatter("To", MarioKart8Deluxe_Mode)
             );
 
-        private static PlayReportFormattedValue BreathOfTheWild_MasterMode(PlayReportValue value)
+        private static PlayReportFormattedValue BreathOfTheWild_MasterMode(ref PlayReportValue value)
             => value.BoxedValue is 1 ? "Playing Master Mode" : PlayReportFormattedValue.ForceReset;
 
-        private static PlayReportFormattedValue TearsOfTheKingdom_CurrentField(PlayReportValue value) =>
-            value.DoubleValue switch
-            {
-                > 800d => "Exploring the Sky Islands",
-                < -201d => "Exploring the Depths",
-                _ => "Roaming Hyrule"
-            };
-
-        private static PlayReportFormattedValue SuperMarioOdyssey_AssistMode(PlayReportValue value)
+        private static PlayReportFormattedValue SuperMarioOdyssey_AssistMode(ref PlayReportValue value)
             => value.BoxedValue is 1 ? "Playing in Assist Mode" : "Playing in Regular Mode";
 
-        private static PlayReportFormattedValue SuperMarioOdysseyChina_AssistMode(PlayReportValue value)
+        private static PlayReportFormattedValue SuperMarioOdysseyChina_AssistMode(ref PlayReportValue value)
             => value.BoxedValue is 1 ? "Playing in 帮助模式" : "Playing in 普通模式";
 
-        private static PlayReportFormattedValue SuperMario3DWorldOrBowsersFury(PlayReportValue value)
+        private static PlayReportFormattedValue SuperMario3DWorldOrBowsersFury(ref PlayReportValue value)
             => value.BoxedValue is 0 ? "Playing Super Mario 3D World" : "Playing Bowser's Fury";
         
-        private static PlayReportFormattedValue MarioKart8Deluxe_Mode(PlayReportValue value) 
-            => value.StringValue switch
+        private static PlayReportFormattedValue MarioKart8Deluxe_Mode(ref PlayReportValue value) 
+            => value.BoxedValue switch
             {
                 // Single Player
                 "Single" => "Single Player",
@@ -82,4 +74,125 @@ namespace Ryujinx.Ava.Utilities
                 _ => PlayReportFormattedValue.ForceReset
             };
     }
+
+    #region Analyzer implementation
+    
+    public class PlayReportAnalyzer
+    {
+        private readonly List<PlayReportGameSpec> _specs = [];
+
+        public PlayReportAnalyzer AddSpec(string titleId, Func<PlayReportGameSpec, PlayReportGameSpec> transform)
+        {
+            _specs.Add(transform(new PlayReportGameSpec { TitleIds = [titleId] }));
+            return this;
+        }
+        
+        public PlayReportAnalyzer AddSpec(string titleId, Action<PlayReportGameSpec> transform)
+        {
+            _specs.Add(new PlayReportGameSpec { TitleIds = [titleId] }.Apply(transform));
+            return this;
+        }
+        
+        public PlayReportAnalyzer AddSpec(IEnumerable<string> titleIds, Func<PlayReportGameSpec, PlayReportGameSpec> transform)
+        {
+            _specs.Add(transform(new PlayReportGameSpec { TitleIds = [..titleIds] }));
+            return this;
+        }
+        
+        public PlayReportAnalyzer AddSpec(IEnumerable<string> titleIds, Action<PlayReportGameSpec> transform)
+        {
+            _specs.Add(new PlayReportGameSpec { TitleIds = [..titleIds] }.Apply(transform));
+            return this;
+        }
+
+        public PlayReportFormattedValue Run(string runningGameId, ApplicationMetadata appMeta, MessagePackObject playReport)
+        {
+            if (!playReport.IsDictionary) 
+                return PlayReportFormattedValue.Unhandled;
+
+            if (!_specs.TryGetFirst(s => runningGameId.EqualsAnyIgnoreCase(s.TitleIds), out PlayReportGameSpec spec))
+                return PlayReportFormattedValue.Unhandled;
+
+            foreach (PlayReportValueFormatterSpec formatSpec in spec.Analyses.OrderBy(x => x.Priority))
+            {
+                if (!playReport.AsDictionary().TryGetValue(formatSpec.ReportKey, out MessagePackObject valuePackObject))
+                    continue;
+
+                PlayReportValue value = new()
+                {
+                    Application = appMeta, 
+                    BoxedValue = valuePackObject.ToObject()
+                };
+
+                return formatSpec.ValueFormatter(ref value);
+            }
+            
+            return PlayReportFormattedValue.Unhandled;
+        }
+        
+    }
+
+    public class PlayReportGameSpec
+    {
+        public required string[] TitleIds { get; init; }
+        public List<PlayReportValueFormatterSpec> Analyses { get; } = [];
+
+        public PlayReportGameSpec AddValueFormatter(string reportKey, PlayReportValueFormatter valueFormatter)
+        {
+            Analyses.Add(new PlayReportValueFormatterSpec
+            {
+                Priority = Analyses.Count,
+                ReportKey = reportKey, 
+                ValueFormatter = valueFormatter
+            });
+            return this;
+        }
+        
+        public PlayReportGameSpec AddValueFormatter(int priority, string reportKey, PlayReportValueFormatter valueFormatter)
+        {
+            Analyses.Add(new PlayReportValueFormatterSpec
+            {
+                Priority = priority,
+                ReportKey = reportKey, 
+                ValueFormatter = valueFormatter
+            });
+            return this;
+        }
+    }
+
+    public struct PlayReportValue
+    {
+        public ApplicationMetadata Application { get; init; }
+        public object BoxedValue { get; init; }
+    }
+
+    public struct PlayReportFormattedValue
+    {
+        public bool Handled { get; private init; }
+        
+        public bool Reset { get; private init; }
+        
+        public string FormattedString { get; private init; }
+
+        public static implicit operator PlayReportFormattedValue(string formattedValue)
+            => new() { Handled = true, FormattedString = formattedValue };
+
+        public static PlayReportFormattedValue Unhandled => default;
+        public static PlayReportFormattedValue ForceReset => new() { Handled = true, Reset = true };
+
+        public static PlayReportValueFormatter AlwaysResets = AlwaysResetsImpl;
+        
+        private static PlayReportFormattedValue AlwaysResetsImpl(ref PlayReportValue _) => ForceReset;
+    }
+
+    public struct PlayReportValueFormatterSpec
+    {
+        public required int Priority { get; init; }
+        public required string ReportKey { get; init; }
+        public PlayReportValueFormatter ValueFormatter { get; init; }
+    }
+
+    public delegate PlayReportFormattedValue PlayReportValueFormatter(ref PlayReportValue value);
+
+    #endregion
 }

src/Ryujinx/Utilities/PlayReportAnalyzer.cs

@@ -1,282 +0,0 @@
-using Gommon;
-using MsgPack;
-using Ryujinx.Ava.Utilities.AppLibrary;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-
-namespace Ryujinx.Ava.Utilities
-{
-    /// <summary>
-    /// The entrypoint for the Play Report analysis system.
-    /// </summary>
-    public class PlayReportAnalyzer
-    {
-        private readonly List<PlayReportGameSpec> _specs = [];
-
-        /// <summary>
-        /// Add an analysis spec matching a specific game by title ID, with the provided spec configuration.
-        /// </summary>
-        /// <param name="titleId">The ID of the game to listen to Play Reports in.</param>
-        /// <param name="transform">The configuration function for the analysis spec.</param>
-        /// <returns>The current <see cref="PlayReportAnalyzer"/>, for chaining convenience.</returns>
-        public PlayReportAnalyzer AddSpec(string titleId, Func<PlayReportGameSpec, PlayReportGameSpec> transform)
-        {
-            Guard.Ensure(ulong.TryParse(titleId, NumberStyles.HexNumber, null, out _),
-                $"Cannot use a non-hexadecimal string as the Title ID for a {nameof(PlayReportGameSpec)}.");
-
-            _specs.Add(transform(new PlayReportGameSpec { TitleIds = [titleId] }));
-            return this;
-        }
-
-        /// <summary>
-        /// Add an analysis spec matching a specific game by title ID, with the provided spec configuration.
-        /// </summary>
-        /// <param name="titleId">The ID of the game to listen to Play Reports in.</param>
-        /// <param name="transform">The configuration function for the analysis spec.</param>
-        /// <returns>The current <see cref="PlayReportAnalyzer"/>, for chaining convenience.</returns>
-        public PlayReportAnalyzer AddSpec(string titleId, Action<PlayReportGameSpec> transform)
-        {
-            Guard.Ensure(ulong.TryParse(titleId, NumberStyles.HexNumber, null, out _),
-                $"Cannot use a non-hexadecimal string as the Title ID for a {nameof(PlayReportGameSpec)}.");
-
-            _specs.Add(new PlayReportGameSpec { TitleIds = [titleId] }.Apply(transform));
-            return this;
-        }
-
-        /// <summary>
-        /// Add an analysis spec matching a specific set of games by title IDs, with the provided spec configuration.
-        /// </summary>
-        /// <param name="titleIds">The IDs of the games to listen to Play Reports in.</param>
-        /// <param name="transform">The configuration function for the analysis spec.</param>
-        /// <returns>The current <see cref="PlayReportAnalyzer"/>, for chaining convenience.</returns>
-        public PlayReportAnalyzer AddSpec(IEnumerable<string> titleIds,
-            Func<PlayReportGameSpec, PlayReportGameSpec> transform)
-        {
-            string[] tids = titleIds.ToArray();
-            Guard.Ensure(tids.All(x => ulong.TryParse(x, NumberStyles.HexNumber, null, out _)),
-                $"Cannot use a non-hexadecimal string as the Title ID for a {nameof(PlayReportGameSpec)}.");
-
-            _specs.Add(transform(new PlayReportGameSpec { TitleIds = [..tids] }));
-            return this;
-        }
-
-        /// <summary>
-        /// Add an analysis spec matching a specific set of games by title IDs, with the provided spec configuration.
-        /// </summary>
-        /// <param name="titleIds">The IDs of the games to listen to Play Reports in.</param>
-        /// <param name="transform">The configuration function for the analysis spec.</param>
-        /// <returns>The current <see cref="PlayReportAnalyzer"/>, for chaining convenience.</returns>
-        public PlayReportAnalyzer AddSpec(IEnumerable<string> titleIds, Action<PlayReportGameSpec> transform)
-        {
-            string[] tids = titleIds.ToArray();
-            Guard.Ensure(tids.All(x => ulong.TryParse(x, NumberStyles.HexNumber, null, out _)),
-                $"Cannot use a non-hexadecimal string as the Title ID for a {nameof(PlayReportGameSpec)}.");
-
-            _specs.Add(new PlayReportGameSpec { TitleIds = [..tids] }.Apply(transform));
-            return this;
-        }
-
-        
-        /// <summary>
-        /// Runs the configured <see cref="PlayReportGameSpec.FormatterSpec"/> for the specified game title ID.
-        /// </summary>
-        /// <param name="runningGameId">The game currently running.</param>
-        /// <param name="appMeta">The Application metadata information, including localized game name and play time information.</param>
-        /// <param name="playReport">The Play Report received from HLE.</param>
-        /// <returns>A struct representing a possible formatted value.</returns>
-        public FormattedValue Format(
-            string runningGameId,
-            ApplicationMetadata appMeta,
-            MessagePackObject playReport
-        )
-        {
-            if (!playReport.IsDictionary)
-                return FormattedValue.Unhandled;
-
-            if (!_specs.TryGetFirst(s => runningGameId.EqualsAnyIgnoreCase(s.TitleIds), out PlayReportGameSpec spec))
-                return FormattedValue.Unhandled;
-
-            foreach (PlayReportGameSpec.FormatterSpec formatSpec in spec.SimpleValueFormatters.OrderBy(x => x.Priority))
-            {
-                if (!playReport.AsDictionary().TryGetValue(formatSpec.ReportKey, out MessagePackObject valuePackObject))
-                    continue;
-
-                return formatSpec.ValueFormatter(new PlayReportValue
-                {
-                    Application = appMeta, PackedValue = valuePackObject
-                });
-            }
-
-            return FormattedValue.Unhandled;
-        }
-
-        /// <summary>
-        /// A potential formatted value returned by a <see cref="PlayReportValueFormatter"/>.
-        /// </summary>
-        public readonly struct FormattedValue
-        {
-            /// <summary>
-            /// Was any handler able to match anything in the Play Report?
-            /// </summary>
-            public bool Handled { get; private init; }
-
-            /// <summary>
-            /// Did the handler request the caller of the <see cref="PlayReportAnalyzer"/> to reset the existing value?
-            /// </summary>
-            public bool Reset { get; private init; }
-
-            /// <summary>
-            /// The formatted value, only present if <see cref="Handled"/> is true, and <see cref="Reset"/> is false.
-            /// </summary>
-            public string FormattedString { get; private init; }
-
-            /// <summary>
-            /// The intended path of execution for having a string to return: simply return the string.
-            /// This implicit conversion will make the struct for you.<br/><br/>
-            ///
-            /// If the input is null, <see cref="Unhandled"/> is returned.
-            /// </summary>
-            /// <param name="formattedValue">The formatted string value.</param>
-            /// <returns>The automatically constructed <see cref="FormattedValue"/> struct.</returns>
-            public static implicit operator FormattedValue(string formattedValue)
-                => formattedValue is not null 
-                    ? new FormattedValue { Handled = true, FormattedString = formattedValue }
-                    : Unhandled;
-
-            /// <summary>
-            /// Return this to tell the caller there is no value to return.
-            /// </summary>
-            public static FormattedValue Unhandled => default;
-            
-            /// <summary>
-            /// Return this to suggest the caller reset the value it's using the <see cref="PlayReportAnalyzer"/> for.
-            /// </summary>
-            public static FormattedValue ForceReset => new() { Handled = true, Reset = true };
-
-            /// <summary>
-            /// A delegate singleton you can use to always return <see cref="ForceReset"/> in a <see cref="PlayReportValueFormatter"/>.
-            /// </summary>
-            public static readonly PlayReportValueFormatter AlwaysResets = _ => ForceReset;
-
-            /// <summary>
-            /// A delegate factory you can use to always return the specified
-            /// <paramref name="formattedValue"/> in a <see cref="PlayReportValueFormatter"/>.
-            /// </summary>
-            /// <param name="formattedValue">The string to always return for this delegate instance.</param>
-            public static PlayReportValueFormatter AlwaysReturns(string formattedValue) => _ => formattedValue;
-        }
-    }
-
-    /// <summary>
-    /// A mapping of title IDs to value formatter specs.
-    ///
-    /// <remarks>Generally speaking, use the <see cref="PlayReportAnalyzer"/>.AddSpec(...) methods instead of creating this class yourself.</remarks>
-    /// </summary>
-    public class PlayReportGameSpec
-    {
-        public required string[] TitleIds { get; init; }
-        public List<FormatterSpec> SimpleValueFormatters { get; } = [];
-
-        /// <summary>
-        /// Add a value formatter to the current <see cref="PlayReportGameSpec"/>
-        /// matching a specific key that could exist in a Play Report for the previously specified title IDs.
-        /// </summary>
-        /// <param name="reportKey">The key name to match.</param>
-        /// <param name="valueFormatter">The function which can return a potential formatted value.</param>
-        /// <returns>The current <see cref="PlayReportGameSpec"/>, for chaining convenience.</returns>
-        public PlayReportGameSpec AddValueFormatter(string reportKey, PlayReportValueFormatter valueFormatter)
-        {
-            SimpleValueFormatters.Add(new FormatterSpec
-            {
-                Priority = SimpleValueFormatters.Count, ReportKey = reportKey, ValueFormatter = valueFormatter
-            });
-            return this;
-        }
-
-        /// <summary>
-        /// Add a value formatter at a specific priority to the current <see cref="PlayReportGameSpec"/>
-        /// matching a specific key that could exist in a Play Report for the previously specified title IDs.
-        /// </summary>
-        /// <param name="priority">The resolution priority of this value formatter. Higher resolves sooner.</param>
-        /// <param name="reportKey">The key name to match.</param>
-        /// <param name="valueFormatter">The function which can return a potential formatted value.</param>
-        /// <returns>The current <see cref="PlayReportGameSpec"/>, for chaining convenience.</returns>
-        public PlayReportGameSpec AddValueFormatter(int priority, string reportKey,
-            PlayReportValueFormatter valueFormatter)
-        {
-            SimpleValueFormatters.Add(new FormatterSpec
-            {
-                Priority = priority, ReportKey = reportKey, ValueFormatter = valueFormatter
-            });
-            return this;
-        }
-
-        /// <summary>
-        /// A struct containing the data for a mapping of a key in a Play Report to a formatter for its potential value.
-        /// </summary>
-        public struct FormatterSpec
-        {
-            public required int Priority { get; init; }
-            public required string ReportKey { get; init; }
-            public PlayReportValueFormatter ValueFormatter { get; init; }
-        }
-    }
-
-    /// <summary>
-    /// The input data to a <see cref="PlayReportValueFormatter"/>,
-    /// containing the currently running application's <see cref="ApplicationMetadata"/>,
-    /// and the matched <see cref="MessagePackObject"/> from the Play Report.
-    /// </summary>
-    public class PlayReportValue
-    {
-        /// <summary>
-        /// The currently running application's <see cref="ApplicationMetadata"/>.
-        /// </summary>
-        public ApplicationMetadata Application { get; init; }
-
-        /// <summary>
-        /// The matched value from the Play Report.
-        /// </summary>
-        public MessagePackObject PackedValue { get; init; }
-
-        /// <summary>
-        /// Access the <see cref="PackedValue"/> as its underlying .NET type.<br/>
-        /// 
-        /// Does not seem to work well with comparing numeric types,
-        /// so use <see cref="PackedValue"/> and the AsX (where X is a numerical type name i.e. Int32) methods for that.
-        /// </summary>
-        public object BoxedValue => PackedValue.ToObject();
-
-        #region AsX accessors
-
-        public bool BooleanValue => PackedValue.AsBoolean();
-        public byte ByteValye => PackedValue.AsByte();
-        public sbyte SByteValye => PackedValue.AsSByte();
-        public short ShortValye => PackedValue.AsInt16();
-        public ushort UShortValye => PackedValue.AsUInt16();
-        public int IntValye => PackedValue.AsInt32();
-        public uint UIntValye => PackedValue.AsUInt32();
-        public long LongValye => PackedValue.AsInt64();
-        public ulong ULongValye => PackedValue.AsUInt64();
-        public float FloatValue => PackedValue.AsSingle();
-        public double DoubleValue => PackedValue.AsDouble();
-        public string StringValue => PackedValue.AsString();
-        public Span<byte> BinaryValue => PackedValue.AsBinary();
-
-        #endregion
-    }
-
-    /// <summary>
-    /// The delegate type that powers the entire analysis system (as it currently is).<br/>
-    /// Takes in the result value from the Play Report, and outputs:
-    /// <br/>
-    /// a formatted string,
-    /// <br/>
-    /// a signal that nothing was available to handle it,
-    /// <br/>
-    /// OR a signal to reset the value that the caller is using the <see cref="PlayReportAnalyzer"/> for. 
-    /// </summary>
-    public delegate PlayReportAnalyzer.FormattedValue PlayReportValueFormatter(PlayReportValue value);
-}