前两天放假无聊，天气太冷不想出门，玩起了很多年前玩过的一款游戏：骑士。太久没玩，手指灵活度不够，玩的是一塌糊涂。于是想起了大名鼎鼎的按键精灵，下载，写脚本，再上游戏，解放了双手的感觉就是不一样，轻松+惬意。今天是新年上班第一天，比较有空，想起来这件事，秉承重复造轮子的指导方针，经过一下午的google，大概功能已经写好，能够满足骑士中战士这个职业最基本的需求.

　　有点标题党的感觉~~这东西充其量只能说是按键辅助工具，和大名鼎鼎的按键精灵比起来实在是小巫见大巫了。

　　前两天放假无聊，天气太冷不想出门，玩起了很多年前玩过的一款游戏：骑士。太久没玩，手指灵活度不够，玩的是一塌糊涂。于是想起了大名鼎鼎的按键精灵，下载，写脚本，再上游戏，解放了双手的感觉就是不一样，轻松+惬意。今天是新年上班第一天，比较有空，想起来这件事，秉承重复造轮子的指导方针，经过一下午的google，大概功能已经写好，能够满足骑士中战士这个职业最基本的需求。以下是代码：

  1.     public class hook
  2.     {
  3.         // Fields
  4.         private static int hHook;
  5.         private HookProc KeyBoardHookProcedure;
  6.  
  7.         static Dictionary<string, Thread> dict = new Dictionary<string, Thread>();
  8.  
  9.         // Methods
  10.         static hook() { }
  11.         public hook() { }
  12.         [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
  13.         public static extern IntPtr GetForegroundWindow();
  14.         [DllImport("user32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Auto)]
  15.         public static extern int CallNextHookEx(int idHook, int nCode, IntPtr wParam, IntPtr lParam);
  16.         [DllImport("USER32.DLL")]
  17.         public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
  18.         [DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Auto)]
  19.         private static extern IntPtr GetModuleHandle(string lpModuleName);
  20.         public void Hook_Clear()
  21.         {
  22.             bool flag = true;
  23.             if (hHook != 0)
  24.             {
  25.                 flag = UnhookWindowsHookEx(hHook);
  26.                 hHook = 0;
  27.             }
  28.             if (!flag)
  29.             {
  30.                 throw new Exception("取消hook失败!");
  31.             }
  32.         }
  33.         public void Hook_Start()
  34.         {
  35.             if (hHook == 0)
  36.             {
  37.                 this.KeyBoardHookProcedure = new HookProc(hook.KeyBoardHookProc);
  38.                 hHook = SetWindowsHookEx(13, this.KeyBoardHookProcedure, GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);
  39.                 if (hHook == 0)
  40.                 {
  41.                     MessageBox.Show("设置Hook失败!");
  42.                     this.Hook_Clear();
  43.                 }
  44.             }
  45.         }
  46.         [DllImport("User32.dll")]
  47.         public static extern void keybd_event(byte bVk, byte bScan, int dwFlags, int dwExtraInfo);
  48.  
  49.         public static void 战士抖杀()
  50.         {
  51.             while (true)
  52.             {
  53.                 byte num1 = (byte)Keys.E;
  54.                 keybd_event(num1, 0, 0, 0);
  55.                 Thread.Sleep(100);
  56.                 keybd_event(num1, 0, 2, 0);
  57.                 Thread.Sleep(100);
  58.                 keybd_event(num1, 0, 0, 0);
  59.                 Thread.Sleep(100);
  60.                 keybd_event(num1, 0, 2, 0);
  61.                 Thread.Sleep(100);
  62.                 byte num2 = (byte)Keys.D4;
  63.                 keybd_event(num2, 0, 0, 0);
  64.                 Thread.Sleep(100);
  65.                 keybd_event(num2, 0, 2, 0);
  66.                 Thread.Sleep(100);
  67.                 keybd_event(num1, 0, 0, 0);
  68.                 Thread.Sleep(100);
  69.                 keybd_event(num1, 0, 2, 0);
  70.                 Thread.Sleep(100);
  71.                 keybd_event(num1, 0, 0, 0);
  72.                 Thread.Sleep(100);
  73.                 keybd_event(num1, 0, 2, 0);
  74.                 Thread.Sleep(100);
  75.                 byte num4 = (byte)Keys.R;
  76.                 keybd_event(num4, 0, 0, 0);
  77.                 Thread.Sleep(100);
  78.                 keybd_event(num4, 0, 2, 0);
  79.                 Thread.Sleep(100);
  80.             }
  81.         }
  82.  
  83.         public static int KeyBoardHookProc(int nCode, IntPtr wParam, IntPtr lParam)
  84.         {
  85.             KeyBoardHookStruct input = (KeyBoardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyBoardHookStruct));
  86.  
  87.             if (input.vkCode == (int)Keys.F11)
  88.             {
  89.                 IntPtr ptr = GetForegroundWindow();
  90.                 if (ptr != IntPtr.Zero)
  91.                 {
  92.                     if (dict.Count < 1)
  93.                     {
  94.                         ThreadStart threadStart = new ThreadStart(战士抖杀);
  95.                         Thread thread = new Thread(threadStart);
  96.                         thread.Start();
  97.                         dict.Clear();
  98.                         dict.Add("战士抖杀", thread);
  99.                     }
  100.                 }
  101.                 return 1;
  102.             }
  103.             else if (input.vkCode == (int)Keys.F12)
  104.             {
  105.                 foreach (var th in dict)
  106.                 {
  107.                     Thread thread = th.Value;
  108.                     if (thread != null && thread.IsAlive)
  109.                     {
  110.                         if (!thread.Join(3))
  111.                         {
  112.                             thread.Abort();
  113.                         }
  114.                     }
  115.                 }
  116.                 dict.Clear();
  117.             }
  118.             return CallNextHookEx(hHook, nCode, wParam, lParam);
  119.         }
  120.         [DllImport("USER32.DLL")]
  121.         public static extern bool SetForegroundWindow(IntPtr hWnd);
  122.         [DllImport("user32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Auto)]
  123.         public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
  124.         [DllImport("user32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Auto)]
  125.         public static extern bool UnhookWindowsHookEx(int idHook);
  126.  
  127.         // Nested Types
  128.         public delegate int HookProc(int nCode, IntPtr wParam, IntPtr lParam);
  129.  
  130.         [StructLayout(LayoutKind.Sequential)]
  131.         public class KeyBoardHookStruct
  132.         {
  133.             public int vkCode;
  134.             public int scanCode;
  135.             public int flags;
  136.             public int time;
  137.             public int dwExtraInfo;
  138.             public KeyBoardHookStruct() { }
  139.         }
  140.     }

　　

版权声明：本文为JasonChou原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/JasonChou/archive/2013/01/04/2844408.html