Замена клика

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using Utilities;
 
namespace KaBoom
{
    public partial class KaBoom : Form
    {
        [DllImport("user32.dll")]
        static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint dwData, UIntPtr dwExtraInfo);
 
        [DllImport("user32.dll")]
        static extern bool ClientToScreen(IntPtr hWnd, ref Point lpPoint);
 
        private static bool run = true;
        private static bool shoot = false;
        private static Bitmap bmpScreenshot;
        private static Graphics gfxScreenshot;
        private static Color color;
        private static bool setHotkey = false;
        private static Keys hotkey = Keys.C;
 
        private class User32
        {
            [StructLayout(LayoutKind.Sequential)]
            public struct Rect
            {
                public int left;
                public int top;
                public int right;
                public int bottom;
            }
 
            [DllImport("user32.dll")]
            public static extern IntPtr GetWindowRect(IntPtr hWnd, ref Rect rect);
        }
 
        public KaBoom()
        {
            InitializeComponent();
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            globalKeyboardHook gkh = new globalKeyboardHook();
            gkh.KeyUp += new KeyEventHandler(keyUpEvent);
            gkh.KeyDown += new KeyEventHandler(keyDownEvent);
            CheckForIllegalCrossThreadCalls = false;
            Thread t = new Thread(new ThreadStart(screen));
            t.Start();
        }
        private void keyUpEvent(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == hotkey)
            {
                shoot = false;
            }
        }
        private void keyDownEvent(object sender, KeyEventArgs e)
        {
            if (setHotkey)
            {
                System.Diagnostics.Debug.WriteLine("New hotkey: " + e.KeyCode.ToString());
                hotkey = e.KeyCode;
                lbl_Hotkey.Text = hotkey.ToString();
                lbl_Hotkey.ForeColor = Color.Black;
                setHotkey = false;
                return;
            }
 
            if (shoot)
            {
                return;
            }
            if (e.KeyCode == hotkey)
            {                             
                try
                {
                    int x = (Screen.PrimaryScreen.Bounds.Size.Width / 2);
                    int y = (Screen.PrimaryScreen.Bounds.Size.Height / 2);
                    bmpScreenshot = new Bitmap(1, 1, PixelFormat.Format32bppArgb);
                    gfxScreenshot = Graphics.FromImage(bmpScreenshot);
                    gfxScreenshot.CopyFromScreen(x - 1, y + 1,0, 0, new Size(1, 1), CopyPixelOperation.SourceCopy);
                    Color c = bmpScreenshot.GetPixel(0, 0);
                    color = c;
                    System.Diagnostics.Debug.WriteLine("Start color: " + color.ToString());
                    bmpScreenshot.Dispose();
                    gfxScreenshot.Dispose();
                    shoot = true;
                }
                catch(Exception ee)
                {
                    System.Diagnostics.Debug.WriteLine("Keydown\r\n" + ee.Message);
                }
                
            }
        }
        private void click()
        {
            mouse_event(0x00000002, 0, 0, 0, UIntPtr.Zero);
            mouse_event(0x00000004, 0, 0, 0, UIntPtr.Zero);
        }
        private void screen()
        {
            while (run)
            {
                while (shoot)
                {
                    try
                    {
                        int x = (Screen.PrimaryScreen.Bounds.Size.Width / 2);
                        int y = (Screen.PrimaryScreen.Bounds.Size.Height / 2);
                        bmpScreenshot = new Bitmap(1, 1, PixelFormat.Format32bppArgb);
                        gfxScreenshot = Graphics.FromImage(bmpScreenshot);
                        gfxScreenshot.CopyFromScreen(x - 1, y + 1, 0, 0, new Size(1, 1), CopyPixelOperation.SourceCopy);
                         Color c = bmpScreenshot.GetPixel(0,0);
                        if (tolerrance(c))
                        {
                            System.Diagnostics.Debug.WriteLine("Boom old color: " + color.ToString() + " new color: " + c.ToString());
                            color = c;
                            Thread.Sleep(delayTrack.Value);
                            click();
                        }
                        bmpScreenshot.Dispose();
                        gfxScreenshot.Dispose();
                        Thread.Sleep(1);
                    }
                    catch(Exception ee)
                    {
                        System.Diagnostics.Debug.WriteLine("Screen catch\r\n" + ee.Message);
                    }
                }
             
            }
        
        }
        private bool between(int val, int min, int max)
        {
            if (val >= min && val <= max)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        private bool tolerrance(Color col)
        {
            int t = toleranceTrack.Value;
            if (col == color)
            {
                return false;
            }
            if (between(col.R,color.R-t,color.R+t))
            {
                return true;
            }
            if (between(col.G, color.G - t, color.G + t))
            {
                return true;
            }
            if (between(col.B, color.B - t, color.B + t))
            {
                return true;
            }
 
            if (between(col.A, color.A - t, color.A + t))
            {
                Text += " -" + color.A.ToString() + " - " + col.A.ToString();
                return true;
            }
            return false;
        }
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            run = false;
            shoot = false;
        }
        private void trackBar1_Scroll(object sender, EventArgs e)
        {
            lbl_track_val.Text = toleranceTrack.Value.ToString();
        }
 
        private void panel1_MouseClick(object sender, MouseEventArgs e)
        {
            if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                setHotkey = true;
                lbl_Hotkey.ForeColor = Color.Blue;
            }
        }
 
        private void notifyIcon1_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            this.Visible = true;
            this.WindowState = FormWindowState.Normal;
            trayIcon.Visible = false;
        }
 
        private void button1_Click_1(object sender, EventArgs e)
        {
            trayIcon.Visible = true;
            this.Visible = false;
        }
 
        private void delayTrack_Scroll(object sender, EventArgs e)
        {
            lbl_delayVal.Text = delayTrack.Value.ToString();
        }
 
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.ComponentModel;
namespace Utilities
{
    /// <summary>
    /// A class that manages a global low level keyboard hook
    /// </summary>
    class globalKeyboardHook
    {
        #region Constant, Structure and Delegate Definitions
        /// <summary>
        /// defines the callback type for the hook
        /// </summary>
        public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);
 
        public struct keyboardHookStruct
        {
            public int vkCode;
            public int scanCode;
            public int flags;
            public int time;
            public int dwExtraInfo;
        }
 
        const int WH_KEYBOARD_LL = 13;
        const int WM_KEYDOWN = 0x100;
        const int WM_KEYUP = 0x101;
        const int WM_SYSKEYDOWN = 0x104;
        const int WM_SYSKEYUP = 0x105;
        #endregion
 
        #region Instance Variables
        /// <summary>
        /// The collections of keys to watch for
        /// </summary>
        public List<Keys> HookedKeys = new List<Keys>();
        /// <summary>
        /// Handle to the hook, need this to unhook and call the next hook
        /// </summary>
        IntPtr hhook = IntPtr.Zero;
        #endregion
 
        #region Events
        /// <summary>
        /// Occurs when one of the hooked keys is pressed
        /// </summary>
        public event KeyEventHandler KeyDown;
        /// <summary>
        /// Occurs when one of the hooked keys is released
        /// </summary>
        public event KeyEventHandler KeyUp;
        #endregion
 
        #region Constructors and Destructors
        /// <summary>
        /// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
        /// </summary>
        public globalKeyboardHook()
        {
            hook();
        }
 
        /// <summary>
        /// Releases unmanaged resources and performs other cleanup operations before the
        /// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
        /// </summary>
        ~globalKeyboardHook()
        {
            unhook();
        }
        #endregion
 
        #region Public Methods
        /// <summary>
        /// Installs the global hook
        /// </summary>
        /// 
        private static keyboardHookProc callbackDelegate;
        public void hook()
        {
            if (callbackDelegate != null) throw new InvalidOperationException("Can't hook more than once");
            IntPtr hInstance = LoadLibrary("User32");
            callbackDelegate = new keyboardHookProc(hookProc);
            hhook = SetWindowsHookEx(WH_KEYBOARD_LL, callbackDelegate, hInstance, 0);
            if (hhook == IntPtr.Zero) throw new Win32Exception();
        }
 
        /// <summary>
        /// Uninstalls the global hook
        /// </summary>
        public void unhook()
        {
            if (callbackDelegate == null) return;
            bool ok = UnhookWindowsHookEx(hhook);
            callbackDelegate = null;
        }
 
        /// <summary>
        /// The callback for the keyboard hook
        /// </summary>
        /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
        /// <param name="wParam">The event type</param>
        /// <param name="lParam">The keyhook event information</param>
        /// <returns></returns>
        public int hookProc(int code, int wParam, ref keyboardHookStruct lParam)
        {
            if (code >= 0)
            {
                Keys key = (Keys)lParam.vkCode;
                KeyEventArgs kea = new KeyEventArgs(key);
                if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null))
                {
                    KeyDown(this, kea);
                }
                else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null))
                {
                    KeyUp(this, kea);
                }
                if (kea.Handled)
                    return 1;
            }
            return CallNextHookEx(hhook, code, wParam, ref lParam);
        }
        #endregion
 
        #region DLL imports
        /// <summary>
        /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
        /// </summary>
        /// <param name="idHook">The id of the event you want to hook</param>
        /// <param name="callback">The callback.</param>
        /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
        /// <param name="threadId">The thread you want to attach the event to, can be null</param>
        /// <returns>a handle to the desired hook</returns>
        [DllImport("user32.dll")]
        static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
 
        /// <summary>
        /// Unhooks the windows hook.
        /// </summary>
        /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
        /// <returns>True if successful, false otherwise</returns>
        [DllImport("user32.dll")]
        static extern bool UnhookWindowsHookEx(IntPtr hInstance);
 
        /// <summary>
        /// Calls the next hook.
        /// </summary>
        /// <param name="idHook">The hook id</param>
        /// <param name="nCode">The hook code</param>
        /// <param name="wParam">The wparam.</param>
        /// <param name="lParam">The lparam.</param>
        /// <returns></returns>
        [DllImport("user32.dll")]
        static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);
 
        /// <summary>
        /// Loads the library.
        /// </summary>
        /// <param name="lpFileName">Name of the library</param>
        /// <returns>A handle to the library</returns>
        [DllImport("kernel32.dll")]
        static extern IntPtr LoadLibrary(string lpFileName);
        #endregion
    }
}