美服疯狂坦克辅助瞄准外挂C#版开发（二）全局鼠标键盘HOOK

最新推荐文章于 2024-11-04 13:11:17 发布
原创 最新推荐文章于 2024-11-04 13:11:17 发布 · 4.9k 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#hook #c# #button #null #byte
#keyboard
本文介绍如何使用C#开发全局鼠标键盘HOOK库，通过HOOK技术捕获和处理系统中的所有键盘鼠标事件。文章详细展示了鼠标键盘HOOK类的实现，包括键盘HOOK类、鼠标HOOK类以及HOOK抽象类，可用于游戏辅助或其他需要全局监听输入的场景。

大家都知道，Windows操作系统内部通讯是基于消息机制的。为了实现我们的功能，必须要能够截和处理获游戏中鼠标键盘事件的消息，常规做法是获取游戏窗体的句柄，然后加入HOOK，这样的好处是不会影响到其它正在运行的程序对鼠标键盘操作的响应。但是一般人在玩疯狂坦克的时候，应该不会同时运行Word之类的吧，也就是说，为了简单起见，我们在程序中加入的HOOK均为全局HOOK，注册到系统后会截获所有的键盘鼠标时间消息，而不管这个消息时由哪个程序激发，送往那个目标。

下面我们就用C#先写一个全局鼠标键盘HOOK库（部分代码及资料来源于CodeProject，具体URL找不到了，所以暂不列出）：

HOOK抽象类 GlobalHook.cs

  1. using System;
  2. using System.Text;
  3. using System.Runtime.InteropServices;
  4. using System.Reflection;
  5. using System.Windows.Forms;
  7. namespace GlobalMouseKeyBoardHook
  8. {
  10.     /// <summary>
  11.     /// Abstract base class for Mouse and Keyboard hooks
  12.     /// </summary>
  13.     public abstract class GlobalHook
  14.     {
  16.         #region Windows API Code
  18.         [StructLayout(LayoutKind.Sequential)]
  19.         protected class POINT
  20.         {
  21.             public int x;
  22.             public int y;
  23.         }
  25.         [StructLayout(LayoutKind.Sequential)]
  26.         protected class MouseHookStruct
  27.         {
  28.             public POINT pt;
  29.             public int hwnd;
  30.             public int wHitTestCode;
  31.             public int dwExtraInfo;
  32.         }
  34.         [StructLayout(LayoutKind.Sequential)]
  35.         protected class MouseLLHookStruct
  36.         {
  37.             public POINT pt;
  38.             public int mouseData;
  39.             public int flags;
  40.             public int time;
  41.             public int dwExtraInfo;
  42.         }
  44.         [StructLayout(LayoutKind.Sequential)]
  45.         protected class KeyboardHookStruct
  46.         {
  47.             public int vkCode;
  48.             public int scanCode;
  49.             public int flags;
  50.             public int time;
  51.             public int dwExtraInfo;
  52.         }
  54.         /// <summary>
  55.         /// Extern Method:define Hook to Windows.
  56.         /// </summary>
  57.         /// <param name="idHook">Hook type,decide what message want to Hook</param>
  58.         /// <param name="lpfn">Function Pointer</param>
  59.         /// <param name="hMod">The dll or model include the Hook function</param>
  60.         /// <param name="dwThreadId">Correlative thread,if 0 means the global</param>
  61.         /// <returns>Hook id</returns>
  62.         [DllImport("user32.dll",CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall,SetLastError = true)]
  63.         protected static extern int SetWindowsHookEx(int idHook,HookProc lpfn,IntPtr hMod,int dwThreadId);
  65.         /// <summary>
  66.         /// Extern Method:dispose the Hook.
  67.         /// </summary>
  68.         /// <param name="idHook">Hook id</param>
  69.         /// <returns>ture/false</returns>
  70.         [DllImport("user32.dll",CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall,SetLastError = true)]
  71.         protected static extern bool UnhookWindowsHookEx(int idHook);
  73.         /// <summary>
  74.         /// Extern Method:call the next hook in the hook linked list
  75.         /// </summary>
  76.         /// <param name="idHook">this hook id</param>
  77.         /// <param name="nCode">the code contain the next hook need to do </param>
  78.         /// <param name="wParam">the parameters</param>
  79.         /// <param name="lParam">the parameters</param>
  80.         /// <returns>The value after the next hook finished.</returns>
  81.         [DllImport("user32.dll",CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall)]
  82.         protected static extern int CallNextHookEx(int idHook,int nCode,int wParam,IntPtr lParam);
  84.         /// <summary>
  85.         /// Extern Method:transfer the virtual keycode and keyboard state to ascii string.
  86.         /// </summary>
  87.         /// <param name="uVirtKey">the virtual keycode need to transfer</param>
  88.         /// <param name="uScanCode">set the uVirtKey's transfer code</param>
  89.         /// <param name="lpbKeyState">256 length array to show all key's state in the keyboard</param>
  90.         /// <param name="lpwTransKey">the buffer of the transfer result</param>
  91.         /// <param name="fuState">define a menu is actived</param>
  92.         /// <returns>int</returns>
  93.         [DllImport("user32")]
  94.         protected static extern int ToAscii(int uVirtKey,int uScanCode,byte[] lpbKeyState,byte[] lpwTransKey,int fuState);
  96.         /// <summary>
  97.         /// Copy the 256 virtual key to he buffer
  98.         /// </summary>
  99.         /// <param name="pbKeyState">256 length array to show all key's state in the keyboard</param>
  100.         /// <returns>0</returns>
  101.         [DllImport("user32")]
  102.         protected static extern int GetKeyboardState(byte[] pbKeyState);
  104.         /// <summary>
  105.         /// get a virtual key's state
  106.         /// </summary>
  107.         /// <param name="vKey">a virtual key</param>
  108.         /// <returns>state</returns>
  109.         [DllImport("user32.dll",CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall)]
  110.         protected static extern short GetKeyState(int vKey);
  112.         protected delegate int HookProc(int nCode,int wParam,IntPtr lParam);
  114.         protected const int WH_MOUSE_LL = 14;
  115.         protected const int WH_KEYBOARD_LL = 13;
  117.         protected const int WH_MOUSE = 7;
  118.         protected const int WH_KEYBOARD = 2;
  119.         protected const int WM_MOUSEMOVE = 0x200;
  120.         protected const int WM_LBUTTONDOWN = 0x201;
  121.         protected const int WM_RBUTTONDOWN = 0x204;
  122.         protected const int WM_MBUTTONDOWN = 0x207;
  123.         protected const int WM_LBUTTONUP = 0x202;
  124.         protected const int WM_RBUTTONUP = 0x205;
  125.         protected const int WM_MBUTTONUP = 0x208;
  126.         protected const int WM_LBUTTONDBLCLK = 0x203;
  127.         protected const int WM_RBUTTONDBLCLK = 0x206;
  128.         protected const int WM_MBUTTONDBLCLK = 0x209;
  129.         protected const int WM_MOUSEWHEEL = 0x020A;
  130.         protected const int WM_KEYDOWN = 0x100;
  131.         protected const int WM_KEYUP = 0x101;
  132.         protected const int WM_SYSKEYDOWN = 0x104;
  133.         protected const int WM_SYSKEYUP = 0x105;
  135.         protected const byte VK_SHIFT = 0x10;
  136.         protected const byte VK_CAPITAL = 0x14;
  137.         protected const byte VK_NUMLOCK = 0x90;
  139.         protected const byte VK_LSHIFT = 0xA0;
  140.         protected const byte VK_RSHIFT = 0xA1;
  141.         protected const byte VK_LCONTROL = 0xA2;
  142.         protected const byte VK_RCONTROL = 0x3;
  143.         protected const byte VK_LALT = 0xA4;
  144.         protected const byte VK_RALT = 0xA5;
  146.         protected const byte LLKHF_ALTDOWN = 0x20;
  148.         #endregion
  150.         #region Private Variables
  152.         protected int _hookType;
  153.         protected int _handleToHook;
  154.         protected bool _isStarted;
  155.         protected HookProc _hookCallback;
  157.         #endregion
  159.         #region Properties
  161.         public bool IsStarted
  162.         {
  163.             get
  164.             {
  165.                 return _isStarted;
  166.             }
  167.         }
  169.         #endregion
  171.         #region Constructor
  173.         public GlobalHook()
  174.         {
  176.             Application.ApplicationExit += new EventHandler(Application_ApplicationExit);
  178.         }
  180.         #endregion
  182.         #region Methods
  184.         /// <summary>
  185.         /// start a hook
  186.         /// </summary>
  187.         public void Start()
  188.         {
  190.             if(!_isStarted && _hookType != 0)
  191.             {
  193.                 _hookCallback = new HookProc(HookCallbackProcedure);
  195.                 _handleToHook = SetWindowsHookEx(_hookType,_hookCallback,Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),0);
  197.                 if(_handleToHook != 0)
  198.                 {
  199.                     _isStarted = true;
  200.                 }
  202.             }
  204.         }
  206.         /// <summary>
  207.         /// stop the hook
  208.         /// </summary>
  209.         public void Stop()
  210.         {
  211.             if(_isStarted)
  212.             {
  213.                 UnhookWindowsHookEx(_handleToHook);
  214.                 _isStarted = false;
  215.             }
  216.         }
  218.         /// <summary>
  219.         /// virtual method:must be overriden by each extending hook
  220.         /// </summary>
  221.         /// <param name="nCode"></param>
  222.         /// <param name="wParam"></param>
  223.         /// <param name="lParam"></param>
  224.         /// <returns></returns>
  225.         protected virtual int HookCallbackProcedure(int nCode,Int32 wParam,IntPtr lParam)
  226.         {
  227.             return 0;
  228.         }
  230.         /// <summary>
  231.         /// stop the hook when the applaction is exiting.
  232.         /// </summary>
  233.         /// <param name="sender"></param>
  234.         /// <param name="e"></param>
  235.         protected void Application_ApplicationExit(object sender,EventArgs e)
  236.         {
  238.             if(_isStarted)
  239.             {
  240.                 Stop();
  241.             }
  243.         }
  245.         #endregion
  247.     }
  249. }

键盘HOOK类：KeyboardHook.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Windows.Forms;
  5. using System.Runtime.InteropServices;
  7. namespace GlobalMouseKeyBoardHook
  8. {
  10.     /// <summary>
  11.     /// Captures global keyboard events
  12.     /// </summary>
  13.     public class KeyboardHook : GlobalHook
  14.     {
  16.         public bool GoOnToCallNext = true;
  18.         #region Events
  20.         public event KeyEventHandler KeyDown;
  21.         public event KeyEventHandler KeyUp;
  22.         public event KeyPressEventHandler KeyPress;
  24.         #endregion
  26.         #region Constructor
  28.         public KeyboardHook()
  29.         {
  31.             _hookType = WH_KEYBOARD_LL;
  33.         }
  35.         #endregion
  37.         #region Methods
  39.         protected override int HookCallbackProcedure(int nCode, int wParam, IntPtr lParam)
  40.         {
  42.             bool handled = false;
  44.             if (nCode > -1 && (KeyDown != null || KeyUp != null || KeyPress != null))
  45.             {
  47.                 KeyboardHookStruct keyboardHookStruct =
  48.                     (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
  50.                 // Is Control being held down?
  51.                 bool control = ((GetKeyState(VK_LCONTROL) & 0x80) != 0) ||
  52.                                ((GetKeyState(VK_RCONTROL) & 0x80) != 0);
  54.                 // Is Shift being held down?
  55.                 bool shift = ((GetKeyState(VK_LSHIFT) & 0x80) != 0) ||
  56.                              ((GetKeyState(VK_RSHIFT) & 0x80) != 0);
  58.                 // Is Alt being held down?
  59.                 bool alt = ((GetKeyState(VK_LALT) & 0x80) != 0) ||
  60.                            ((GetKeyState(VK_RALT) & 0x80) != 0);
  62.                 // Is CapsLock on?
  63.                 bool capslock = (GetKeyState(VK_CAPITAL) != 0);
  65.                 // Create event using keycode and control/shift/alt values found above
  66.                 KeyEventArgs e = new KeyEventArgs(
  67.                     (Keys)(
  68.                         keyboardHookStruct.vkCode |
  69.                         (control ? (int)Keys.Control : 0) |
  70.                         (shift ? (int)Keys.Shift : 0) |
  71.                         (alt ? (int)Keys.Alt : 0)
  72.                         ));
  74.                 // Handle KeyDown and KeyUp events
  75.                 switch (wParam)
  76.                 {
  78.                     case WM_KEYDOWN:
  79.                     case WM_SYSKEYDOWN:
  80.                         if (KeyDown != null)
  81.                         {
  82.                             KeyDown(this, e);
  83.                             handled = handled || e.Handled;
  84.                         }
  85.                         break;
  86.                     case WM_KEYUP:
  87.                     case WM_SYSKEYUP:
  88.                         if (KeyUp != null)
  89.                         {
  90.                             KeyUp(this, e);
  91.                             handled = handled || e.Handled;
  92.                         }
  93.                         break;
  95.                 }
  97.                 // Handle KeyPress event
  98.                 if (wParam == WM_KEYDOWN &
  99.                    !handled &
  100.                    !e.SuppressKeyPress &
  101.                     KeyPress != null)
  102.                 {
  104.                     byte[] keyState = new byte[256];
  105.                     byte[] inBuffer = new byte[2];
  106.                     GetKeyboardState(keyState);
  108.                     if (ToAscii(keyboardHookStruct.vkCode,
  109.                               keyboardHookStruct.scanCode,
  110.                               keyState,
  111.                               inBuffer,
  112.                               keyboardHookStruct.flags) == 1)
  113.                     {
  115.                         char key = (char)inBuffer[0];
  116.                         if ((capslock ^ shift) && Char.IsLetter(key))
  117.                             key = Char.ToUpper(key);
  118.                         KeyPressEventArgs e2 = new KeyPressEventArgs(key);
  119.                         KeyPress(this, e2);
  120.                         handled = handled || e.Handled;
  122.                     }
  124.                 }
  126.             }
  128.             if(handled)
  129.             {
  130.                 return 1;
  131.             }
  132.             else
  133.             {
  134.                 if(GoOnToCallNext)
  135.                 {
  136.                     return CallNextHookEx(_handleToHook,nCode,wParam,lParam); 
  137.                 }
  138.                 else
  139.                 {
  140.                     return 1;
  141.                 }
  142.             }
  144.         }
  146.         #endregion
  148.     }
  150. }

鼠标HOOK类：MouseHook.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Windows.Forms;
  5. using System.Runtime.InteropServices;
  7. namespace GlobalMouseKeyBoardHook
  8. {
  10.     /// <summary>
  11.     /// Captures global mouse events
  12.     /// </summary>
  13.     public class MouseHook : GlobalHook
  14.     {
  16.         #region MouseEventType Enum
  18.         private enum MouseEventType
  19.         {
  20.             None,
  21.             MouseDown,
  22.             MouseUp,
  23.             DoubleClick,
  24.             MouseWheel,
  25.             MouseMove
  26.         }
  28.         #endregion
  30.         #region Events
  32.         public event MouseEventHandler MouseDown;
  33.         public event MouseEventHandler MouseUp;
  34.         public event MouseEventHandler MouseMove;
  35.         public event MouseEventHandler MouseWheel;
  37.         public event EventHandler Click;
  38.         public event EventHandler DoubleClick;
  40.         #endregion
  42.         #region Constructor
  44.         public MouseHook()
  45.         {
  47.             _hookType = WH_MOUSE_LL;
  49.         }
  51.         #endregion
  53.         #region Methods
  55.         protected override int HookCallbackProcedure(int nCode, int wParam, IntPtr lParam)
  56.         {
  57.             
  58.             if (nCode > -1 && (MouseDown != null || MouseUp != null || MouseMove != null))
  59.             {
  61.                 MouseLLHookStruct mouseHookStruct =
  62.                     (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));
  64.                 MouseButtons button = GetButton(wParam);
  65.                 MouseEventType eventType = GetEventType(wParam);
  67.                 MouseEventArgs e = new MouseEventArgs(
  68.                     button,
  69.                     (eventType == MouseEventType.DoubleClick ? 2 : 1),
  70.                     mouseHookStruct.pt.x,
  71.                     mouseHookStruct.pt.y,
  72.                     (eventType == MouseEventType.MouseWheel ? (int)((mouseHookStruct.mouseData >> 16) & 0xffff) : 0));
  74.                 // Prevent multiple Right Click events (this probably happens for popup menus)
  75.                 if (button == MouseButtons.Right && mouseHookStruct.flags != 0)
  76.                 {
  77.                     eventType = MouseEventType.None;
  78.                 }
  80.                 switch (eventType)
  81.                 {
  82.                     case MouseEventType.MouseDown:
  83.                         if (MouseDown != null)
  84.                         {
  85.                             MouseDown(this, e);
  86.                         }
  87.                         break;
  88.                     case MouseEventType.MouseUp:
  89.                         if (Click != null)
  90.                         {
  91.                             Click(this, new EventArgs());
  92.                         }
  93.                         if (MouseUp != null)
  94.                         {
  95.                             MouseUp(this, e);
  96.                         }
  97.                         break;
  98.                     case MouseEventType.DoubleClick:
  99.                         if (DoubleClick != null)
  100.                         {
  101.                             DoubleClick(this, new EventArgs());
  102.                         }
  103.                         break;
  104.                     case MouseEventType.MouseWheel:
  105.                         if (MouseWheel != null)
  106.                         {
  107.                             MouseWheel(this, e);
  108.                         }
  109.                         break;
  110.                     case MouseEventType.MouseMove:
  111.                         if (MouseMove != null)
  112.                         {
  113.                             MouseMove(this, e);
  114.                         }
  115.                         break;
  116.                     default:
  117.                         break;
  118.                 }
  120.             }
  122.             return CallNextHookEx(_handleToHook,nCode,wParam,lParam); 
  124.         }
  126.         private MouseButtons GetButton(Int32 wParam)
  127.         {
  129.             switch (wParam)
  130.             {
  132.                 case WM_LBUTTONDOWN:
  133.                 case WM_LBUTTONUP:
  134.                 case WM_LBUTTONDBLCLK:
  135.                     return MouseButtons.Left;
  136.                 case WM_RBUTTONDOWN:
  137.                 case WM_RBUTTONUP:
  138.                 case WM_RBUTTONDBLCLK:
  139.                     return MouseButtons.Right;
  140.                 case WM_MBUTTONDOWN:
  141.                 case WM_MBUTTONUP:
  142.                 case WM_MBUTTONDBLCLK:
  143.                     return MouseButtons.Middle;
  144.                 default:
  145.                     return MouseButtons.None;
  147.             }
  149.         }
  151.         private MouseEventType GetEventType(Int32 wParam)
  152.         {
  154.             switch (wParam)
  155.             {
  157.                 case WM_LBUTTONDOWN:
  158.                 case WM_RBUTTONDOWN:
  159.                 case WM_MBUTTONDOWN:
  160.                     return MouseEventType.MouseDown;
  161.                 case WM_LBUTTONUP:
  162.                 case WM_RBUTTONUP:
  163.                 case WM_MBUTTONUP:
  164.                     return MouseEventType.MouseUp;
  165.                 case WM_LBUTTONDBLCLK:
  166.                 case WM_RBUTTONDBLCLK:
  167.                 case WM_MBUTTONDBLCLK:
  168.                     return MouseEventType.DoubleClick;
  169.                 case WM_MOUSEWHEEL:
  170.                     return MouseEventType.MouseWheel;
  171.                 case WM_MOUSEMOVE:
  172.                     return MouseEventType.MouseMove;
  173.                 default:
  174.                     return MouseEventType.None;
  176.             }
  177.         }
  179.         #endregion
  180.         
  181.     }
  183. }

键盘模拟器：KeyboardSimulator.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Runtime.InteropServices;
  5. using System.Windows.Forms;
  7. namespace GlobalMouseKeyBoardHook
  8. {
  10.     /// <summary>
  11.     /// Standard Keyboard Shortcuts used by most applications
  12.     /// </summary>
  13.     public enum StandardShortcut
  14.     {
  15.         Copy,
  16.         Cut,
  17.         Paste,
  18.         SelectAll,
  19.         Save,
  20.         Open,
  21.         New,
  22.         Close,
  23.         Print
  24.     }
  26.     /// <summary>
  27.     /// Simulate keyboard key presses
  28.     /// </summary>
  29.     public static class KeyboardSimulator
  30.     {
  32.         #region Windows API Code
  34.         const int KEYEVENTF_EXTENDEDKEY = 0x1;
  35.         const int KEYEVENTF_KEYUP = 0x2;
  37.         [DllImport("user32.dll")]
  38.         static extern void keybd_event(byte key, byte scan, int flags, int extraInfo);
  40.         //[DllImport("user32.dll")]
  41.         //static extern int SetKeyboardState(byte[] lpKeyState);
  43.         //[DllImport("user32.dll")]
  44.         //static extern int GetKeyboardState(byte[] lpKeyState);
  46.         #endregion
  48.         #region Methods
  50.         public static void KeyDown(Keys key)
  51.         {
  52.             keybd_event(ParseKey(key), 0, 0, 0);
  53.         }
  55.         public static void KeyUp(Keys key)
  56.         {
  57.             keybd_event(ParseKey(key), 0, KEYEVENTF_KEYUP, 0);
  58.         }
  60.         public static void KeyPress(Keys key)
  61.         {
  62.             KeyDown(key);
  63.             KeyUp(key);
  64.         }
  66.         //public static void KeyHold(Keys key)
  67.         //{
  68.         //    byte[] KeyBoardState = new byte[256];
  69.         //    GetKeyboardState(KeyBoardState);
  70.         //    KeyBoardState[ParseKey(key)] =1;
  71.         //    SetKeyboardState(KeyBoardState);
  72.         //}
  74.         public static void SimulateStandardShortcut(StandardShortcut shortcut)
  75.         {
  76.             switch (shortcut)
  77.             {
  78.                 case StandardShortcut.Copy:
  79.                     KeyDown(Keys.Control);
  80.                     KeyPress(Keys.C);
  81.                     KeyUp(Keys.Control);
  82.                     break;
  83.                 case StandardShortcut.Cut:
  84.                     KeyDown(Keys.Control);
  85.                     KeyPress(Keys.X);
  86.                     KeyUp(Keys.Control);
  87.                     break;
  88.                 case StandardShortcut.Paste:
  89.                     KeyDown(Keys.Control);
  90.                     KeyPress(Keys.V);
  91.                     KeyUp(Keys.Control);
  92.                     break;
  93.                 case StandardShortcut.SelectAll:
  94.                     KeyDown(Keys.Control);
  95.                     KeyPress(Keys.A);
  96.                     KeyUp(Keys.Control);
  97.                     break;
  98.                 case StandardShortcut.Save:
  99.                     KeyDown(Keys.Control);
  100.                     KeyPress(Keys.S);
  101.                     KeyUp(Keys.Control);
  102.                     break;
  103.                 case StandardShortcut.Open:
  104.                     KeyDown(Keys.Control);
  105.                     KeyPress(Keys.O);
  106.                     KeyUp(Keys.Control);
  107.                     break;
  108.                 case StandardShortcut.New:
  109.                     KeyDown(Keys.Control);
  110.                     KeyPress(Keys.N);
  111.                     KeyUp(Keys.Control);
  112.                     break;
  113.                 case StandardShortcut.Close:
  114.                     KeyDown(Keys.Alt);
  115.                     KeyPress(Keys.F4);
  116.                     KeyUp(Keys.Alt);
  117.                     break;
  118.                 case StandardShortcut.Print:
  119.                     KeyDown(Keys.Control);
  120.                     KeyPress(Keys.P);
  121.                     KeyUp(Keys.Control);
  122.                     break;
  123.             }
  124.         }
  126.         static byte ParseKey(Keys key)
  127.         {
  129.             // Alt, Shift, and Control need to be changed for API function to work with them
  130.             switch (key)
  131.             {
  132.                 case Keys.Alt:
  133.                     return (byte)18;
  134.                 case Keys.Control:
  135.                     return (byte)17;
  136.                 case Keys.Shift:
  137.                     return (byte)16;
  138.                 default:
  139.                     return (byte)key;
  140.             }
  142.         } 
  144.         #endregion
  146.     }
  148. }

鼠标模拟器：MouseSimulator.cs

  1. using System;
  2. using System.Text;
  3. using System.Runtime.InteropServices;
  4. using System.Drawing;
  5. using System.Windows.Forms;
  7. namespace GlobalMouseKeyBoardHook
  8. {
  10.     /// <summary>
  11.     /// Mouse buttons that can be pressed
  12.     /// </summary>
  13.     public enum MouseButton
  14.     {
  15.         Left = 0x2,
  16.         Right = 0x8,
  17.         Middle = 0x20
  18.     }
  20.     /// <summary>
  21.     /// Operations that simulate mouse events
  22.     /// </summary>
  23.     public static class MouseSimulator
  24.     {
  26.         #region Windows API Code
  28.         [DllImport("user32.dll")]
  29.         static extern int ShowCursor(bool show);
  31.         [DllImport("user32.dll")]
  32.         static extern void mouse_event(int flags, int dX, int dY, int buttons, int extraInfo);
  34.         const int MOUSEEVENTF_MOVE = 0x1;
  35.         const int MOUSEEVENTF_LEFTDOWN = 0x2;
  36.         const int MOUSEEVENTF_LEFTUP = 0x4;
  37.         const int MOUSEEVENTF_RIGHTDOWN = 0x8;
  38.         const int MOUSEEVENTF_RIGHTUP = 0x10;
  39.         const int MOUSEEVENTF_MIDDLEDOWN = 0x20;
  40.         const int MOUSEEVENTF_MIDDLEUP = 0x40;
  41.         const int MOUSEEVENTF_WHEEL = 0x800;
  42.         const int MOUSEEVENTF_ABSOLUTE = 0x8000; 
  44.         #endregion
  46.         #region Properties
  48.         /// <summary>
  49.         /// Gets or sets a structure that represents both X and Y mouse coordinates
  50.         /// </summary>
  51.         public static Point Position
  52.         {
  53.             get
  54.             {
  55.                 return new Point(Cursor.Position.X, Cursor.Position.Y);
  56.             }
  57.             set
  58.             {
  59.                 Cursor.Position = value;
  60.             }
  61.         }
  63.         /// <summary>
  64.         /// Gets or sets only the mouse's x coordinate
  65.         /// </summary>
  66.         public static int X
  67.         {
  68.             get
  69.             {
  70.                 return Cursor.Position.X;
  71.             }
  72.             set
  73.             {
  74.                 Cursor.Position = new Point(value, Y);
  75.             }
  76.         }
  78.         /// <summary>
  79.         /// Gets or sets only the mouse's y coordinate
  80.         /// </summary>
  81.         public static int Y
  82.         {
  83.             get
  84.             {
  85.                 return Cursor.Position.Y;
  86.             }
  87.             set
  88.             {
  89.                 Cursor.Position = new Point(X, value);
  90.             }
  91.         } 
  93.         #endregion
  95.         #region Methods
  97.         /// <summary>
  98.         /// Press a mouse button down
  99.         /// </summary>
  100.         /// <param name="button"></param>
  101.         public static void MouseDown(MouseButton button)
  102.         {
  103.             mouse_event(((int)button), 0, 0, 0, 0);
  104.         }
  106.         /// <summary>
  107.         /// Press a mouse button down
  108.         /// </summary>
  109.         /// <param name="button"></param>
  110.         public static void MouseDown(MouseButtons button)
  111.         {
  112.             switch (button)
  113.             {
  114.                 case MouseButtons.Left:
  115.                     MouseDown(MouseButton.Left);
  116.                     break;
  117.                 case MouseButtons.Middle:
  118.                     MouseDown(MouseButton.Middle);
  119.                     break;
  120.                 case MouseButtons.Right:
  121.                     MouseDown(MouseButton.Right);
  122.                     break;
  123.             }
  124.         }
  126.         /// <summary>
  127.         /// Let a mouse button up
  128.         /// </summary>
  129.         /// <param name="button"></param>
  130.         public static void MouseUp(MouseButton button)
  131.         {
  132.             mouse_event(((int)button) * 2, 0, 0, 0, 0);
  133.         }
  135.         /// <summary>
  136.         /// Let a mouse button up
  137.         /// </summary>
  138.         /// <param name="button"></param>
  139.         public static void MouseUp(MouseButtons button)
  140.         {
  141.             switch (button)
  142.             {
  143.                 case MouseButtons.Left:
  144.                     MouseUp(MouseButton.Left);
  145.                     break;
  146.                 case MouseButtons.Middle:
  147.                     MouseUp(MouseButton.Middle);
  148.                     break;
  149.                 case MouseButtons.Right:
  150.                     MouseUp(MouseButton.Right);
  151.                     break;
  152.             }
  153.         }
  155.         /// <summary>
  156.         /// Click a mouse button (down then up)
  157.         /// </summary>
  158.         /// <param name="button"></param>
  159.         public static void Click(MouseButton button)
  160.         {
  161.             MouseDown(button);
  162.             MouseUp(button);
  163.         }
  165.         /// <summary>
  166.         /// Click a mouse button (down then up)
  167.         /// </summary>
  168.         /// <param name="button"></param>
  169.         public static void Click(MouseButtons button)
  170.         {
  171.             switch (button)
  172.             {
  173.                 case MouseButtons.Left:
  174.                     Click(MouseButton.Left);
  175.                     break;
  176.                 case MouseButtons.Middle:
  177.                     Click(MouseButton.Middle);
  178.                     break;
  179.                 case MouseButtons.Right:
  180.                     Click(MouseButton.Right);
  181.                     break;
  182.             }
  183.         }
  185.         /// <summary>
  186.         /// Double click a mouse button (down then up twice)
  187.         /// </summary>
  188.         /// <param name="button"></param>
  189.         public static void DoubleClick(MouseButton button)
  190.         {
  191.             Click(button);
  192.             Click(button);
  193.         }
  195.         /// <summary>
  196.         /// Double click a mouse button (down then up twice)
  197.         /// </summary>
  198.         /// <param name="button"></param>
  199.         public static void DoubleClick(MouseButtons button)
  200.         {
  201.             switch (button)
  202.             {
  203.                 case MouseButtons.Left:
  204.                     DoubleClick(MouseButton.Left);
  205.                     break;
  206.                 case MouseButtons.Middle:
  207.                     DoubleClick(MouseButton.Middle);
  208.                     break;
  209.                 case MouseButtons.Right:
  210.                     DoubleClick(MouseButton.Right);
  211.                     break;
  212.             }
  213.         }
  215.         /// <summary>
  216.         /// Roll the mouse wheel. Delta of 120 wheels up once normally, -120 wheels down once normally
  217.         /// </summary>
  218.         /// <param name="delta"></param>
  219.         public static void MouseWheel(int delta)
  220.         {
  222.             mouse_event(MOUSEEVENTF_WHEEL, 0, 0, delta, 0);
  224.         }
  226.         /// <summary>
  227.         /// Show a hidden current on currently application
  228.         /// </summary>
  229.         public static void Show()
  230.         {
  231.             ShowCursor(true);
  232.         }
  234.         /// <summary>
  235.         /// Hide mouse cursor only on current application's forms
  236.         /// </summary>
  237.         public static void Hide()
  238.         {
  239.             ShowCursor(false);
  240.         } 
  242.         #endregion
  244.     }
  246. }

至此，我们的全局鼠标键盘HOOK库所有源代码已经完成，直接编译输出为GlobalMouseKeyBoardHook.dll即可在其它任何需要全局HOOK的程序中直接引用。

 

调用DEMO：

1、在新建的WinFrom项目中引用GlobalMouseKeyBoardHook.dll。

2、Form1.cs中替换以下代码，直接编译运行。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Text;
  7. using System.Windows.Forms;
  8. using GlobalMouseKeyBoardHook;
  10. namespace WindowsApplication2
  11. {
  12.     public partial class Form1:Form
  13.     {
  14.         public Form1()
  15.         {
  16.             InitializeComponent();
  17.         }
  19.         private void Form1_Load(object sender,EventArgs e)
  20.         {
  21.             MouseHook MH = new MouseHook();
  22.             KeyboardHook KH = new KeyboardHook();
  24.             MH.MouseDown += new MouseEventHandler(MouseHook_MouseDown);
  25.             MH.MouseUp += new MouseEventHandler(MouseHook_MouseUp);
  26.             KH.KeyDown += new KeyEventHandler(KeyBoardHook_KeyDown);
  27.             KH.KeyUp += new KeyEventHandler(KeyBoardHook_KeyUp);
  28.             KH.KeyPress += new KeyPressEventHandler(KeyBoardHook_KeyPress);
  30.             MH.Start();
  31.             KH.Start();
  32.         }
  34.         private void MouseHook_MouseDown(object sender,MouseEventArgs e)
  35.         {
  36.             MessageBox.Show("当前鼠标鼠标：" + e.X.ToString() + "," + e.Y.ToString());
  37.         }
  39.         private void MouseHook_MouseUp(object sender,MouseEventArgs e)
  40.         {
  41.             MessageBox.Show("当前鼠标鼠标：" + e.X.ToString() + "," + e.Y.ToString());
  42.         }
  44.         private void KeyBoardHook_KeyDown(object sender,KeyEventArgs e)
  45.         {
  46.             MessageBox.Show(e.KeyCode.ToString());
  47.         }
  49.         private void KeyBoardHook_KeyUp(object sender,KeyEventArgs e)
  50.         {
  51.             MessageBox.Show(e.KeyCode.ToString());
  52.         }
  54.         private void KeyBoardHook_KeyPress(object sender,KeyPressEventArgs e)
  55.         {
  56.             MessageBox.Show(e.KeyChar.ToString());
  57.         }
  58.     }
  59. }
疯狂坦克网络版(附源代码)+疯狂坦克游戏设计方案
05-22
[记忆中的Fortress2] 疯狂坦克网络版源代码: 包括2个部分:CrazyTankServer,CrazyTankClient 3D渲染2D图形 服务器IOCP模型，MySql数据库 +疯狂坦克游戏设计方案.doc
美服疯狂坦克辅助瞄准外挂C#版开发（四）程序使用说明和完成源代码及其下载
ZXSDN
09-09 7788
到现在为止，我们已经将疯狂坦克外挂所需相关的功能点及解决方案完成。先说说常规的使用方法：1、编译发布程序后，先运行程序（默认不可见），然后进入美服疯狂坦克。2、在游戏中按（Pause）键启动各种辅助线。3、在游戏中按（Scroll Lock）键切换你当前所用的坦克。4、在游戏中鼠标放到你坦克所在的位置（小地图上圆点中心），按下（PrScrn SysRq）键确定曲线起点。5、
美服疯狂坦克辅助瞄准外挂C#版开发（三）在全屏游戏屏幕上绘制弹道曲线
ZXSDN
09-08 3558
要在游戏全屏模式下屏幕绘制弹道曲线，需要用到以下三个API：        //获取DC          [DllImport("User32.dll")]        public extern static System.IntPtr GetDC(System.IntPtr hWnd);                 //释放DC          [Sy
美服疯狂坦克辅助瞄准外挂C#版开发（一）物理模型及弹道曲线方程
ZXSDN
09-02 5076
疯狂坦克弹道曲线方程式： 由上面的图表，根据初中物理知识，我们可以推导以下弹道曲线方程式：以上物理模型和公式就已经完成了，当然这只是一个近似的公式，由于疯狂坦克游戏算法中存在同角和力点不均匀分布，所以以上模型绘制出来的曲线会有一定程度上的误差，但是作为一个辅助瞄准工具，这个误差是属于在可接受范围内的。如果大家有更精确或者分析过疯狂坦克源代码提供的算法，请多多指点和修正。 
【游戏】疯狂坦克2街机版（不需模拟器）
weixin_34375251的博客
07-30 880
下载地址：http://nyam.pe.kr/dev/program/Fortress2%20Blue%20Arcade.zip
编写外挂完全攻略
热门推荐
Yong的博客
07-03 7万+
一、先说一下写一个外挂需要什么条件  1、熟练的C语言知识  目前的外挂大部分都是用BC或者是vc写的，拥有熟练的C语言知识是写外挂的基本条件  2、具有很强的汇编基础 一般游戏都不可能有原代码的，必须*反汇编或者跟踪的办 法来探索其中的机理 ，所以有强的汇编基础也是必不可少的条件
分布式ID解决方案比较（雪花算法-Snowflake）
大壮
10-02 1607
分布式ID 1 方案选择 UUID UUID是通用唯一识别码（Universally Unique Identifier)的缩写，开放软件基金会(OSF)规范定义了包括网卡MAC地址、时间戳、名字空间（Namespace）、随机或伪随机数、时序等元素。利用这些元素来生成UUID。 UUID是由128位二进制组成，一般转换成十六进制，然后用String表示。 550e8400-e29b-41d4-a716-446655440000 UUID的优点: 通过本地生成，没有经过网络I/O，性能较快 无序，
疯狂坦克 初级教材
KEN Bolg
01-20 4005
很长一段时间以来，很多人都认为坦克无非就是 上，下，左，右键 变角度，移动，然后按空格键出炮，其实这个只是相关的最基本的操作方法。上，下，左，右的熟练程度直接影响等待值的大小，这个是需要预判的，多练习练习就可以。空格键的使用方法，想必大家都会，但是用的好的，却很少，为什么因为对力点的所在位置不是有个清晰的概念，第一期里面 TIPS 力点 这个包里，详细给出了各个坦克的力点分布示意图，希望对大家的坦
疯狂坦克 高级教程(二)
KEN Bolg
01-20 7705
第四章 半力高炮 §4.1 半力高炮原理 根据我们打全力高炮时经验，射程越大的坦克，如果使用满力的话，一度角产生的距离偏移就越大。 相反，如果射程比较小的话，一度误差产生的距离误差必然也越小。如果用极限情况作为例子， 很容易就可以理解，如果用力为0，那么无论用什么角度，都是打自己身上的。此时误差也为0。 这样一来，我们是不是可以人为的控制射程，使高炮的误差更小？当然是可以的，我们比较
疯狂坦克图17
KEN Bolg
01-20 925
 
游戏外挂内存数据读取
xqqing79的专栏
09-18 3992
源地址：http://hi.baidu.com/probill/blog/item/1d07d11efbd641f01ad576f3.html网络游戏.每一个数据比如你的血值.MP 值.怪的血值..在内存中是以16进制的形式存放的.而显示给我们看的是10进制的形式显示的,,[16进制转就是123456789ABCDEF,好比 十进制的0123456789,逢16进1,十进制是逢十进1,不想算可以用...
HMTT——SQLAlchemy映射构建
极地星辰
07-02 470
SQLAlchemy映射构建前言1 简介2 安装3 数据库连接设置4 模型类字段与选项5 构建模型类映射 前言 1 简介 SQLAlchemy是Python编程语言下的一款开源软件。提供了SQL工具包及对象关系映射（ORM）工具，使用MIT许可证发行。 SQLAlchemy“采用简单的Python语言，为高效和高性能的数据库访问设计，实现了完整的企业级持久模型”。 SQLAlchemy首次发行于2006年2月，并迅速地在Python社区中最广泛使用的ORM工具之一，不亚于Django的ORM框架。 Fla
深入理解HTTP请求辅助工具及应用
最新发布
weixin_28888459的博客
11-04 1203
本文还有配套的精品资源，点击获取 简介：HTTP作为网络上应用最广泛的协议，其请求的管理和调试成为互联网发展的重要部分。HTTP请求辅助工具提供了发送请求、查看响应、调试、参数化、编辑和保存请求、性能测试等多种功能，以支持API开发测试、网络爬虫、系统集成测试和安全审计等应用场景。本文将详细解析这些工具的功能，包括Postman、Fiddler、Curl、Chrome De...
疯狂坦克图14
KEN Bolg
01-20 1235
 
从游戏中得到动态内存数据（汇编+VC 例子：疯狂坦克的X坐标）
4111Y80Y的专栏
11-15 2272
各位朋友大家好，嗷嗷，我第一次在这里发文章，好高兴本人技术有限，不要笑话，如有错误请您告诉我一声。刚才我玩了几把疯狂坦克，输了好几盘，觉得无聊就搞搞这个，下面开始说说如何得到游戏中的动态数据（地址改变），以得到疯狂坦克中坦克X坐标为例------------------------------------------------------------------------------工具：
疯狂坦克高抛,半抛,小抛算法
KEN Bolg
01-20 1万+
所有车的高抛半抛及小抛算法17:等待和数字中间18:百位数字前端19:百位数字20:十位和个位数字中间21:数字框最后22:喇叭框开头23:喇叭把手前一点(23.5这个位置即为老土半抛和飞火老土抛的点)24:喇叭口25:喇叭后第二波纹26:喇叭后第四波纹27:第一个手机28:第一手机后第二波纹29:第一手机后第四波纹30:第二个手机31:小山32:满力老土抛 半抛(20算) 小抛(30算)
联网疯狂坦克简陋版
LeeStorm的移动游戏探秘
03-02 518
      去年在某软件公司工作时利用闲暇时间写的一个小demo，有点类似以前的网络游戏《疯狂坦克》。客户端Android实现，服务端用的J2SE的socket，有简单的连接框架和线程池，不过通信模式有点类似Http（做J2ME习惯了-_-b）。当时每天花个一两小时，总计做了一周左右吧，没啥时间去设计构架，所有很简陋，技术也不扎实，部分代码不规范，高手就不要看了，以免班门弄斧，给不熟悉Androi...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值