diff --git a/DD2Switcher/DD2Switcher.csproj b/DD2Switcher/DD2Switcher.csproj
index 03cf883..a4a34ac 100644
--- a/DD2Switcher/DD2Switcher.csproj
+++ b/DD2Switcher/DD2Switcher.csproj
@@ -54,6 +54,7 @@
             <DependentUpon>Form1.cs</DependentUpon>
         </Compile>
         <Compile Include="HotKeyManager.cs" />
+        <Compile Include="Pixel.cs" />
         <Compile Include="Program.cs" />
         <Compile Include="Properties\AssemblyInfo.cs" />
         <EmbeddedResource Include="Properties\Resources.resx">
diff --git a/DD2Switcher/Pixel.cs b/DD2Switcher/Pixel.cs
new file mode 100644
index 0000000..ea6c3c6
--- /dev/null
+++ b/DD2Switcher/Pixel.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Drawing;
+
+namespace DD2Switcher; 
+
+public class Pixel {
+    private int x { get; set; }
+    private int y { get; set; }
+    private int R { get; set; }
+    private int G { get; set; }
+    private int B { get; set; }
+
+    public Pixel(int x, int y, int R, int G, int B) {
+        this.x = x;
+        this.y = y;
+        this.R = R;
+        this.G = G;
+        this.B = B;
+    }
+
+    public Boolean ProcessBitmap(Bitmap bmp) {
+        Color tempPixel = bmp.GetPixel(x, y);
+        return tempPixel.R >= R && tempPixel.B >= B && tempPixel.G >= G;
+    }
+}
\ No newline at end of file
diff --git a/DD2Switcher/Program.cs b/DD2Switcher/Program.cs
index 1bb0265..c5ce764 100644
--- a/DD2Switcher/Program.cs
+++ b/DD2Switcher/Program.cs
@@ -1,130 +1,165 @@
 using System;
-using System.Windows.Forms;
-using System.Runtime.InteropServices;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Drawing;
+using System.Runtime.InteropServices;
 using System.Threading;
+using System.Windows.Forms;
 
-namespace DD2Switcher {
-    internal static class Program {
-        [DllImport("user32.dll")]
-        static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint dwData, UIntPtr dwExtraInfo);
+namespace DD2Switcher; 
 
-        [DllImport("user32.dll")]
-        public static extern IntPtr GetForegroundWindow();
+internal static class Program {
+    private static Rectangle rect = new(0, 0, 1920, 1080);
+    private static readonly Process[] games = Process.GetProcessesByName("Dundefgame");
+    private static Process activeGame = games[0];
+    private static Bitmap screenshot;
+    private static Graphics graphics;
+    private static readonly int defaultAffinity = 0b100000000000;
+    private static bool paused = true;
 
-        [DllImport("user32.dll")]
-        public static extern bool SetForegroundWindow(IntPtr hWnd);
+    [DllImport("user32.dll")]
+    private static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint dwData, UIntPtr dwExtraInfo);
 
-        [DllImport("User32.dll", SetLastError = true)]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        static extern bool PrintWindow(IntPtr hwnd, IntPtr hDC, uint nFlags);
+    [DllImport("user32.dll")]
+    public static extern IntPtr GetForegroundWindow();
 
-        [DllImport("user32.dll")]
-        static extern bool GetWindowRect(IntPtr handle, ref Rectangle rect);
+    [DllImport("user32.dll")]
+    public static extern bool SetForegroundWindow(IntPtr hWnd);
 
-        [DllImport("user32.dll", SetLastError = true)]
-        static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
+    [DllImport("User32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool PrintWindow(IntPtr hwnd, IntPtr hDC, uint nFlags);
 
-        static Process[] games = Process.GetProcessesByName("Dundefgame");
-        static Process activeGame = games[0];
-        static int defaultAffinity = 0b100000000000;
+    [DllImport("user32.dll")]
+    private static extern bool GetWindowRect(IntPtr handle, ref Rectangle rect);
 
-        private static void AdjustAffinities() {
-            int fullAffinity = 0b111111111111;
-            int i = 0;
-            foreach (Process game in games) {
-                if (game != activeGame) {
-                    var processAffinty = defaultAffinity >> i;
-                    fullAffinity = fullAffinity & ~processAffinty;
-                    game.ProcessorAffinity = new IntPtr(processAffinty);
-                    i++;                    
-                }
-            }
-            activeGame.ProcessorAffinity = new IntPtr(fullAffinity);
-        }
+    [DllImport("user32.dll", SetLastError = true)]
+    private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
 
-        private static void AdjustPriorities() {
-            foreach (Process game in games) {
-                game.PriorityClass = ProcessPriorityClass.Idle;
-            }
-            activeGame.PriorityClass = ProcessPriorityClass.High;
-        }
+    public static Bitmap CaptureWindow(IntPtr handle) {
+        if (screenshot == null)
+            screenshot = new Bitmap(rect.Width, rect.Height);
+        graphics = Graphics.FromImage(screenshot);
+        var hdc = graphics.GetHdc();
+        PrintWindow(handle, hdc, 0);
+        graphics.ReleaseHdc(hdc);
+        return screenshot;
+    }
 
-        private static void NerfAll() {
-            int i = 0;
-            foreach (Process game in games) {
-                game.ProcessorAffinity = new IntPtr(defaultAffinity >> i);
-                game.PriorityClass = ProcessPriorityClass.Idle;
+    private static void AdjustAffinities() {
+        var fullAffinity = 0b111111111111;
+        var i = 0;
+        foreach (var game in games)
+            if (game != activeGame) {
+                var processAffinty = defaultAffinity >> i;
+                fullAffinity = fullAffinity & ~processAffinty;
+                game.ProcessorAffinity = new IntPtr(processAffinty);
                 i++;
             }
-        }
 
-        private static void SwitchToGame(int index) {
-            SetForegroundWindow(games[index].MainWindowHandle);
-            activeGame = games[index];
-            AdjustAffinities();
-            AdjustPriorities();
-        }
+        activeGame.ProcessorAffinity = new IntPtr(fullAffinity);
+    }
 
-        private static void SwitchMainGame() {
-            IntPtr foregroundWindow = GetForegroundWindow();
-            Process foregroundGame = null;
-            int foregroundGameIndex = -1;
-            bool exists = false;
-            
-            foreach (Process game in games) {
-                if (foregroundWindow == game.MainWindowHandle) {
-                    exists = true;
-                    foregroundGame = game;
-                    foregroundGameIndex = Array.IndexOf(games, game);
+    private static void AdjustPriorities() {
+        foreach (var game in games) game.PriorityClass = ProcessPriorityClass.Idle;
+        activeGame.PriorityClass = ProcessPriorityClass.High;
+    }
+
+    private static void NerfAll() {
+        var i = 0;
+        foreach (var game in games) {
+            game.ProcessorAffinity = new IntPtr(defaultAffinity >> i);
+            game.PriorityClass = ProcessPriorityClass.Idle;
+            i++;
+        }
+    }
+
+    private static void SwitchToGame(int index) {
+        SetForegroundWindow(games[index].MainWindowHandle);
+        activeGame = games[index];
+        AdjustAffinities();
+        AdjustPriorities();
+    }
+
+    private static void SwitchMainGame() {
+        var foregroundWindow = GetForegroundWindow();
+        Process foregroundGame = null;
+        var foregroundGameIndex = -1;
+        var exists = false;
+
+        foreach (var game in games)
+            if (foregroundWindow == game.MainWindowHandle) {
+                exists = true;
+                foregroundGame = game;
+                foregroundGameIndex = Array.IndexOf(games, game);
+                break;
+            }
+
+        if (exists) {
+            var tempGame = games[0];
+            games[0] = foregroundGame;
+            games[foregroundGameIndex] = tempGame;
+        }
+    }
+
+    [STAThread]
+    private static void Main() {
+        HotKeyManager.RegisterHotKey(Keys.D1, KeyModifiers.Alt);
+        HotKeyManager.RegisterHotKey(Keys.D2, KeyModifiers.Alt);
+        HotKeyManager.RegisterHotKey(Keys.D3, KeyModifiers.Alt);
+        HotKeyManager.RegisterHotKey(Keys.D4, KeyModifiers.Alt);
+        HotKeyManager.RegisterHotKey(Keys.D5, KeyModifiers.Alt);
+        HotKeyManager.RegisterHotKey(Keys.Q, KeyModifiers.Alt);
+        HotKeyManager.RegisterHotKey(Keys.W, KeyModifiers.Alt);
+        HotKeyManager.HotKeyPressed += HotKeyManager_HotKeyPressed;
+        
+        List<Pixel> pixelList = new List<Pixel>();
+        pixelList.Add(new Pixel(1062, 885, 240, 240, 240));
+
+        static void HotKeyManager_HotKeyPressed(object sender, HotKeyEventArgs e) {
+            switch (e.Key) {
+                case Keys.D1:
+                    SwitchToGame(0);
                     break;
-                }
-            }
+                case Keys.D2:
+                    SwitchToGame(1);
+                    break;
+                case Keys.D3:
+                    SwitchToGame(2);
+                    break;
+                case Keys.D4:
+                    SwitchToGame(3);
+                    break;
+                case Keys.D5:
+                    SwitchMainGame();
+                    break;
+                case Keys.Q:
+                    NerfAll();
+                    break;
+                case Keys.W:
+                    if (paused) {
+                        Console.Beep(1500, 500);
+                        paused = false;
+                    } else {
+                        Console.Beep(500, 500);
+                        paused = true;
+                    }
 
-            if (exists) {
-                Process tempGame = games[0];
-                games[0] = foregroundGame;
-                games[foregroundGameIndex] = tempGame;
+                    break;
             }
         }
 
-        [STAThread]
-        private static void Main() {
-            HotKeyManager.RegisterHotKey(Keys.D1, KeyModifiers.Alt);
-            HotKeyManager.RegisterHotKey(Keys.D2, KeyModifiers.Alt);
-            HotKeyManager.RegisterHotKey(Keys.D3, KeyModifiers.Alt);
-            HotKeyManager.RegisterHotKey(Keys.D4, KeyModifiers.Alt);
-            HotKeyManager.RegisterHotKey(Keys.D5, KeyModifiers.Alt);
-            HotKeyManager.RegisterHotKey(Keys.Q, KeyModifiers.Alt);
-            HotKeyManager.HotKeyPressed += HotKeyManager_HotKeyPressed;
-
-            static void HotKeyManager_HotKeyPressed(object sender, HotKeyEventArgs e) {
-                switch (e.Key) {
-                    case Keys.D1:
-                        SwitchToGame(0);
-                        break;
-                    case Keys.D2:
-                        SwitchToGame(1);
-                        break;
-                    case Keys.D3:
-                        SwitchToGame(2);
-                        break;
-                    case Keys.D4:
-                        SwitchToGame(3);
-                        break;
-                    case Keys.D5:
-                        SwitchMainGame();
-                        break;
-                    case Keys.Q:
-                        NerfAll();
-                        break;
+        while (true) {
+            while (!paused) {
+                screenshot = CaptureWindow(games[0].MainWindowHandle);
+                foreach (Pixel p in pixelList) {
+                    if (p.ProcessBitmap(screenshot)) {
+                        Console.Beep(1500, 850);
+                    }
                 }
+                Thread.Sleep(1000);
             }
-            
-            while (true) {
-                Thread.Sleep(2000);
-            }
+            Thread.Sleep(1000);
         }
     }
 }
\ No newline at end of file