multiboxer/DD2Switcher/Program.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace DD2Switcher {
internal static class Program {
  private static int NumProc = 19;
  private static Process[] windows = new Process[NumProc];
  private static int ActiveIndex = -1;

  private static readonly IntPtr defaultAffinity = new(0xFF000000);
  private static readonly IntPtr fullAffinity = new(0xFFFFFFFF);

  [DllImport("user32.dll")]
  public static extern IntPtr GetForegroundWindow();

  [DllImport("user32.dll")]
  public static extern bool SetForegroundWindow(IntPtr hWnd);

  [DllImport("kernel32.dll", SetLastError = true)]
  [return:MarshalAs(UnmanagedType.Bool)]
  static extern bool AllocConsole();

  private static void CleanWindows() {
    for (int i = 0; i < NumProc; i++) {
      var window = windows[i];
      if (window == null)
        continue;
      if (window.MainWindowHandle == IntPtr.Zero) {
        Console.WriteLine(
            $"Window at index {i} has no main window, removing from tracked windows");
        windows[i] = null;
      }
    }
  }

  private static void AdjustAffinities() {
    CleanWindows();
    for (int i = 0; i < NumProc; i++) {
      var window = windows[i];
      if (window == null)
        continue;
      if (i != ActiveIndex) {
        try {
          window.ProcessorAffinity = defaultAffinity;
        } catch (Exception e) {
          windows[i] = null;
        }
      }
    }

    var active = windows[ActiveIndex];
    if (active != null) {
      try {
        active.ProcessorAffinity = fullAffinity;
      } catch (Exception e) {
        windows[ActiveIndex] = null;
      }
    }
  }

  private static void AdjustPriorities() {
    CleanWindows();
    for (int i = 0; i < NumProc; i++) {
      var window = windows[i];
      if (window == null)
        continue;

      if (i != ActiveIndex) {
        try {
          window.PriorityClass = ProcessPriorityClass.Idle;
        } catch (Exception e) {
          windows[i] = null;
        }
      }
    }

    var active = windows[ActiveIndex];
    if (active != null) {
      try {
        active.PriorityClass = ProcessPriorityClass.High;
      } catch (Exception e) {
        windows[ActiveIndex] = null;
      }
    }
  }

  private static Process GetForegroundProcess() {
    var foregroundWindow = GetForegroundWindow();
    var process = Process.GetProcesses();
    Process foregroundProcess = null;
    foreach (var p in process)
      if (foregroundWindow == p.MainWindowHandle) {
        foregroundProcess = p;
        break;
      }

    if (foregroundProcess == null)
      return null;
    return foregroundProcess;
  }

  private static Boolean ProcessTracked(int id) {
    for (int i = 0; i < NumProc; i++) {
      if (windows[i] != null && windows[i].Id == id) {
        return true;
      }
    }

    return false;
  }

  private static void Track(Process process) {
    for (int i = 0; i < NumProc; i++) {
      if (windows[i] == null) {
        windows[i] = process;
        Console.WriteLine(
            $"Added {process.ProcessName} to tracked windows at index {i}");
        return;
      }
    }
  }

  private static void TrackWows() {
    CleanWindows();
    var processes = Process.GetProcesses();
    foreach (var process in processes) {
      if (process.ProcessName == "UWow-64") {
        Console.WriteLine($"Found UWow-64 at pid {process.Id}");
        if (ProcessTracked(process.Id))
          continue;
        Track(process);
      }
    }
  }

  private static void Swap(int index) {
    index = (index - 1) % NumProc;
    if (index < 0)
      index = NumProc - 1;
    if (index >= NumProc)
      return;
    CleanWindows();
    Console.WriteLine($"Swapping window at index {index}");
    var process = GetForegroundProcess();
    if (process == null)
      return;
    Console.WriteLine($"Foreground process: {process}");
    bool found = false;

    for (int i = 0; i < NumProc; i++) {
      var window = windows[i];
      if (window != null && window.Id == process.Id) {
        found = true;
        break;
      }
    }

    if (!found) {
      for (int i = 0; i < NumProc; i++) {
        var window = windows[i];
        if (window == null) {
          Console.WriteLine(
              $"Adding foreground window to tracked at index {i}...");
          windows[i] = process;
        }
      }
    }

    for (int i = 0; i < NumProc; i++) {
      var window = windows[i];
      if (window != null && window.Id == process.Id) {
        windows[i] = windows[index];
        windows[index] = window;
        Console.WriteLine($"Swapped window at index {i} to {index}");
        return;
      }
    }
  }

  private static void TabTo(int index) {
    index = (index - 1) % NumProc;
    if (index < 0)
      index = NumProc - 1;
    if (index >= NumProc)
      return;
    CleanWindows();
    Console.WriteLine($"Tab to window at index {index}");

    var window = windows[index];
    if (window == null || window.MainWindowHandle == IntPtr.Zero) {
      Console.WriteLine(
          $"Window at index {index} does not exist, removing from tracked windows");
      windows[index] = null;
    } else {
      SetForegroundWindow(window.MainWindowHandle);
      ActiveIndex = index;
      AdjustAffinities();
      AdjustPriorities();
    }
  }

  [STAThread]
  private static void Main() {
    // AllocConsole();

    var processes = Process.GetProcesses();
    var currentProcess = Process.GetCurrentProcess();

    foreach (var process in processes)
      if (process.Id != currentProcess.Id &&
          process.ProcessName == currentProcess.ProcessName) {
        process.Kill();
        Process.GetCurrentProcess().Kill();
      }

    long delLast = 0;
    HotKeyManager.RegisterHotKey(Keys.End, KeyModifiers.NoRepeat);
    // Register main number keys (0-9)
    for (int i = 0; i < 10; i++)
      HotKeyManager.RegisterHotKey(Keys.D0 + i, KeyModifiers.Alt);

    // Register numpad keys (1-9)
    for (int i = 0; i < 9; i++)
      HotKeyManager.RegisterHotKey(Keys.NumPad1 + i, KeyModifiers.Alt);

    HotKeyManager.RegisterHotKey(Keys.Oemtilde, KeyModifiers.Alt);
    HotKeyManager.HotKeyPressed += HotKeyManager_HotKeyPressed;

    void HotKeyManager_HotKeyPressed(object sender, HotKeyEventArgs e) {
      if (e.Key == Keys.Oemtilde && e.Modifiers == KeyModifiers.Alt) {
        TrackWows();
        return;
      }

      long now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
      if (e.Key == Keys.End)
        delLast = now;

      int index;
      if (e.Key >= Keys.D0 && e.Key <= Keys.D9) {
        index = e.Key - Keys.D0;
      } else if (e.Key >= Keys.NumPad1 && e.Key <= Keys.NumPad9) {
        index = 10 + (e.Key - Keys.NumPad1);
      } else {
        return;
      }

      long cocksucker = DateTime.Now.Second;
      Console.WriteLine(cocksucker);
      if (e.Modifiers == KeyModifiers.Alt) {
        if (now - delLast <= 1) {
          Swap(index);
          delLast = 0;
        } else {
          TabTo(index);
        }
      }
    }

    Console.CancelKeyPress +=
        (sender, e) => { Process.GetCurrentProcess().Kill(); };
    while (true)
      System.Threading.Thread.Sleep(100000);
  }
}
}