v0.1.16: hotkeys + heartbeat + session ended

Made-with: Cursor

Author: youssof20

src/PassTheStick.Guest/MainWindow.xaml

@@ -12,6 +12,7 @@
         <TextBox x:Name="NameBox" MaxLength="32" Width="200" HorizontalAlignment="Left" Margin="0,0,0,12"/>
         <Button x:Name="JoinButton" Content="Join" Click="JoinButton_Click" Width="100" HorizontalAlignment="Left"/>
         <TextBlock x:Name="StickStatusText" Text="Not connected" Foreground="#666" FontSize="12" Margin="0,12,0,0" TextWrapping="Wrap"/>
+        <TextBlock x:Name="LatencyText" Text="Latency: —" Foreground="#666" FontSize="12" Margin="0,6,0,0" TextWrapping="Wrap"/>
         <TextBlock x:Name="StatusText" Text="" Foreground="#666" FontSize="12" Margin="0,16,0,0" TextWrapping="Wrap"/>
     </StackPanel>
 </Window>

src/PassTheStick.Guest/MainWindow.xaml.cs

@@ -10,6 +10,8 @@ public partial class MainWindow : Window
     private ControllerCapture? _controllerCapture;
     private bool _haveStick;
     private List<PlayerInfo> _players = new();
+    private int _lastLatencyMs;
+    private bool _sessionEnded;
 
     public MainWindow()
     {
@@ -24,6 +26,7 @@ public MainWindow()
 
     private async void JoinButton_Click(object sender, RoutedEventArgs e)
     {
+        _sessionEnded = false;
         var code = RoomCodeBox.Text.Trim().ToUpperInvariant();
         var name = NameBox.Text.Trim();
         if (string.IsNullOrEmpty(code) || string.IsNullOrEmpty(name))
@@ -34,6 +37,7 @@ private async void JoinButton_Click(object sender, RoutedEventArgs e)
         JoinButton.IsEnabled = false;
         StatusText.Text = "Connecting…";
         StickStatusText.Text = "Connecting…";
+        LatencyText.Text = "Latency: —";
         while (true)
         {
             try
@@ -66,14 +70,62 @@ private async void JoinButton_Click(object sender, RoutedEventArgs e)
                             : $"Waiting — {holder} has the stick";
                     });
                 };
+                _relay.SessionEnded += reason =>
+                {
+                    _sessionEnded = true;
+                    Dispatcher.BeginInvoke(() =>
+                    {
+                        _haveStick = false;
+                        try { _keyboardCapture?.Dispose(); _keyboardCapture = null; } catch { }
+                        try { _controllerCapture?.Dispose(); _controllerCapture = null; } catch { }
+                        try { _relay?.Dispose(); } catch { }
+                        _relay = null;
+
+                        StatusText.Text = "Session ended — enter a new room code to rejoin.";
+                        StickStatusText.Text = "Not connected";
+                        LatencyText.Text = "Latency: —";
+                        RoomCodeBox.Text = "";
+                        _players = new List<PlayerInfo>();
+                        JoinButton.IsEnabled = true;
+                    });
+                };
+                _relay.LatencyUpdatedMs += ms =>
+                {
+                    Dispatcher.BeginInvoke(() =>
+                    {
+                        _lastLatencyMs = ms;
+                        if (ms > 200)
+                            LatencyText.Text = $"High latency ({ms}ms) — input may feel delayed";
+                        else
+                            LatencyText.Text = $"Connected — {ms}ms";
+                    });
+                };
                 _relay.Disconnected += _ =>
                 {
+                    _sessionEnded = true;
                     _haveStick = false;
-                    Dispatcher.Invoke(() => { StatusText.Text = "Connection lost."; JoinButton.IsEnabled = true; });
-                    Dispatcher.Invoke(() => { StickStatusText.Text = "Not connected"; });
+                    Dispatcher.Invoke(() =>
+                    {
+                        StatusText.Text = "Connection lost. You can rejoin by entering a room code.";
+                        JoinButton.IsEnabled = true;
+                        StickStatusText.Text = "Not connected";
+                        LatencyText.Text = "Latency: —";
+                        RoomCodeBox.Text = "";
+                        _players = new List<PlayerInfo>();
+                    });
+
+                    try { _keyboardCapture?.Dispose(); } catch { }
+                    try { _controllerCapture?.Dispose(); } catch { }
+                    _keyboardCapture = null;
+                    _controllerCapture = null;
+
+                    try { _relay?.Dispose(); } catch { }
+                    _relay = null;
                 };
                 await _relay.ConnectAsync();
                 await _relay.JoinRoomAsync(code, name);
+                if (_sessionEnded)
+                    continue;
                 _keyboardCapture = new KeyboardCapture(
                     () => _haveStick,
                     async (vk, sc, down) =>

src/PassTheStick.Host/GameWindowTracker.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using PassTheStick.Shared;
 
@@ -28,6 +29,13 @@ public void PinWindow(nint hwnd)
             throw new InvalidOperationException("Selected window is no longer available.");
 
         GetWindowThreadProcessId(hwnd, out uint pid);
+        if (pid == 0)
+            throw new InvalidOperationException("Selected window is not associated with a process.");
+
+        // Validate process still exists.
+        try { _ = Process.GetProcessById((int)pid); }
+        catch { throw new InvalidOperationException("Selected game process is no longer running."); }
+
         _gameHwnd = hwnd;
         _gameProcessId = pid;
     }
@@ -53,6 +61,20 @@ public bool IsGameForeground()
         return fg == _gameHwnd;
     }
 
+    public bool IsPinnedProcessElevated()
+    {
+        if (!IsPinned) return false;
+        try
+        {
+            using var proc = Process.GetProcessById((int)_gameProcessId);
+            return IsProcessElevated(proc.Handle);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     [DllImport("user32.dll")]
     private static extern nint GetForegroundWindow();
 
@@ -61,4 +83,49 @@ public bool IsGameForeground()
 
     [DllImport("user32.dll")]
     private static extern bool IsWindow(nint hWnd);
+
+    [DllImport("advapi32.dll", SetLastError = true)]
+    private static extern bool OpenProcessToken(IntPtr ProcessHandle, uint DesiredAccess, out IntPtr TokenHandle);
+
+    [DllImport("advapi32.dll", SetLastError = true)]
+    private static extern bool GetTokenInformation(
+        IntPtr TokenHandle,
+        int TokenInformationClass,
+        out TOKEN_ELEVATION TokenInformation,
+        int TokenInformationLength,
+        out int ReturnLength);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool CloseHandle(IntPtr hObject);
+
+    private const uint TOKEN_QUERY = 0x0008;
+    private const int TokenElevation = 20;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct TOKEN_ELEVATION
+    {
+        public int TokenIsElevated;
+    }
+
+    private static bool IsProcessElevated(IntPtr processHandle)
+    {
+        IntPtr tokenHandle = IntPtr.Zero;
+        try
+        {
+            if (!OpenProcessToken(processHandle, TOKEN_QUERY, out tokenHandle))
+                return false;
+
+            var elevation = new TOKEN_ELEVATION();
+            var returnedLength = 0;
+            if (!GetTokenInformation(tokenHandle, TokenElevation, out elevation, Marshal.SizeOf<TOKEN_ELEVATION>(), out returnedLength))
+                return false;
+
+            return elevation.TokenIsElevated != 0;
+        }
+        finally
+        {
+            if (tokenHandle != IntPtr.Zero)
+                CloseHandle(tokenHandle);
+        }
+    }
 }

src/PassTheStick.Host/HotkeyManager.cs

@@ -12,34 +12,82 @@ public sealed class HotkeyManager : IDisposable
     private const int MOD_CONTROL = 0x0002;
     private const int MOD_SHIFT = 0x0001;
     private const int VK_RIGHT = 0x27;
-    private static readonly int HotkeyId = 1;
+    private const int VK_LEFT = 0x25;
+    private const int HotkeyIdPass = 1;
+    private const int HotkeyIdTakeBack = 2;
 
     private nint _hwnd;
-    private bool _registered;
+    private bool _registeredPass;
+    private bool _registeredTakeBack;
 
-    [DllImport("user32.dll")]
+    [DllImport("user32.dll", SetLastError = true)]
     private static extern bool RegisterHotKey(nint hWnd, int id, uint fsModifiers, uint vk);
 
     [DllImport("user32.dll")]
     private static extern bool UnregisterHotKey(nint hWnd, int id);
 
+    public event Action<string>? HotkeyConflict;
+
     public void Register(nint windowHandle)
     {
         _hwnd = windowHandle;
-        _registered = RegisterHotKey(_hwnd, HotkeyId, (uint)(MOD_CONTROL | MOD_SHIFT), VK_RIGHT);
+        _registeredPass = false;
+        _registeredTakeBack = false;
+
+        if (RegisterHotKey(_hwnd, HotkeyIdPass, (uint)(MOD_CONTROL | MOD_SHIFT), VK_RIGHT))
+        {
+            _registeredPass = true;
+        }
+        else
+        {
+            var err = System.Runtime.InteropServices.Marshal.GetLastWin32Error();
+            HotkeyConflict?.Invoke($"Hotkey conflict detected — Ctrl+Shift+→ is in use (err={err}).");
+        }
+
+        if (RegisterHotKey(_hwnd, HotkeyIdTakeBack, (uint)(MOD_CONTROL | MOD_SHIFT), VK_LEFT))
+        {
+            _registeredTakeBack = true;
+        }
+        else
+        {
+            var err = System.Runtime.InteropServices.Marshal.GetLastWin32Error();
+            HotkeyConflict?.Invoke($"Hotkey conflict detected — Ctrl+Shift+← is in use (err={err}).");
+        }
     }
 
     public void Unregister()
     {
-        if (_registered && _hwnd != nint.Zero)
+        if (_hwnd == nint.Zero) return;
+        if (_registeredPass)
+        {
+            UnregisterHotKey(_hwnd, HotkeyIdPass);
+            _registeredPass = false;
+        }
+        if (_registeredTakeBack)
+        {
+            UnregisterHotKey(_hwnd, HotkeyIdTakeBack);
+            _registeredTakeBack = false;
+        }
+        if (!_registeredPass && !_registeredTakeBack)
         {
-            UnregisterHotKey(_hwnd, HotkeyId);
-            _registered = false;
+            // nothing
         }
     }
 
-    public static bool IsHotkeyMessage(int msg, nint wParam) =>
-        msg == WM_HOTKEY && wParam == (nint)HotkeyId;
+    public static bool TryGetHotkey(int msg, nint wParam, out HotkeyKind kind)
+    {
+        kind = HotkeyKind.Pass;
+        if (msg != WM_HOTKEY) return false;
+        if (wParam == (nint)HotkeyIdPass) { kind = HotkeyKind.Pass; return true; }
+        if (wParam == (nint)HotkeyIdTakeBack) { kind = HotkeyKind.TakeBack; return true; }
+        return false;
+    }
+
+    public enum HotkeyKind
+    {
+        Pass,
+        TakeBack
+    }
 
     public void Dispose() => Unregister();
 }

src/PassTheStick.Host/InputInjector.cs

@@ -39,9 +39,19 @@ public static void InjectKey(ushort scanCode, bool keyDown)
 
         var result = SendInput(1, inputs, Marshal.SizeOf<INPUT>());
         if (result > 0)
+        {
             InputDebugLog.Log($"SendInput result: {result} (success)");
+        }
         else
-            InputDebugLog.Log($"SendInput result: {result} ERROR: {Marshal.GetLastWin32Error()}");
+        {
+            var err = Marshal.GetLastWin32Error();
+            InputDebugLog.Log($"SendInput result: {result} ERROR: {err}");
+
+            if (err == 5)
+                InputDebugLog.Log("SendInput FAILED: Access denied/elevation mismatch (error 5). Run PassTheStick as administrator.");
+            else if (err == 6)
+                InputDebugLog.Log("SendInput FAILED: Invalid handle (error 6). Game window handle may be invalid.");
+        }
     }
 
     [StructLayout(LayoutKind.Sequential)]