C#实现跳一跳辅助

发表于 | |

微信跳一跳小程序原理比较简单，抛开声音要素，跳的距离与拇指按压时间成正比例，假设每次跳动距离都等于拇指按压时间*常数系数，这个游戏就变成了根据跳动距离求解按压时间，于是乎我在PC端用安卓模拟器和C#实现了一个跳一跳辅助程序

需求分析

思路

  1. 在模拟器确定起点和终点的位置坐标，勾股定理算出两点距离
  2. 一个可以实时调节大小的系数，乘以距离算出鼠标按压时间
  3. 根据算出的按压时间模拟鼠标按压动作

可行性

针对上述1：如果想实现完全自动跳跃，肯定要用到图像匹配，从跳一跳界面来看，起点旗子的图形是固定的紫色象棋，想确定位置比较容易

终点的图形是新落的方块，这个方块素材目前看来官方会不断更新，如果想通过维护一个图形素材库，用来匹配终点的话非常麻烦。那么通过分解图像算出来呢？新落下的方块总是出现在界面左上或右上方，可以先取界面角落的像素点确定背景色（因为背景色会变化，需要每次起跳前确认），然后从界面左上至右下遍历像素点，比较与背景色的色差，先出现色差的区域既是新落下方块的坐标区域，这样可以吗？很难实现，首先方块颜色不是单色的，简单的根据色差判断轮廓很可能不准确，其次知道了轮廓想要确定方块顶层区域也是很有难度的

所以我采用半自动方式，利用人确定终点位置，人为鼠标挪到终点右键一下，记录下终点坐标，简单粗暴就是累点

针对上述2：需要一个控件，每次起跳前读这里的数字

针对上述3：调用win32接口，鼠标移动至界面内，鼠标左键按下，线程休眠xx毫秒，鼠标左键松开

最终效果

具体实现

图像匹配

这里图像匹配指的是在一个大图A中找到小图B的位置，可能是多个或一个坐标，我之前并没有处理过图像相关，所以只能在网上看人家怎么实现的，在网上找了一个比较靠谱的例子，但他只找了单个匹配结果，我改成了找多个匹配结果，具体代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
/// <summary>  
/// 判断图形里是否存在另外一个图形 所在行的索引  
/// </summary>  
/// <param name="p_Source">原始图形数据</param>  
/// <param name="p_Part">小图形数据</param>  
/// <param name="p_SourceIndex">开始位置</param>  
/// <param name="p_SourceWidth">原始图形宽</param>  
/// <param name="p_PartWidth">小图宽</param>  
/// <param name="p_Float">溶差</param>  
/// <returns>所在行的索引 如果找不到返回-1</returns>  
private static int GetImageContains(byte[] p_Source, byte[] p_Part, int p_SourceIndex, int p_SourceWidth, int p_PartWidth, int p_Float)
{
    int _PartIndex = 0;
    int _SourceIndex = p_SourceIndex;
    for (int i = 0; i < p_SourceWidth; i++)
    {
        if (p_SourceWidth - i < p_PartWidth) return -1;
        //这里放弃构造Color类，因为太耗时了，为了效率连自建color结构都不搞了，直接比较RGB三色的字节
        //Color _CurrentlyColor = Color.FromArgb(p_Source[_SourceIndex + 3], p_Source[_SourceIndex + 2], p_Source[_SourceIndex + 1], p_Source[_SourceIndex]);
        //Color _CompareColoe = Color.FromArgb(p_Part[3], p_Part[2], p_Part[1], p_Part[0]);
        _SourceIndex += 4;

        bool _ScanColor = ScanColor(p_Source[_SourceIndex + 2], p_Source[_SourceIndex + 1], p_Source[_SourceIndex], p_Part[2], p_Part[1], p_Part[0], p_Float);

        if (_ScanColor)
        {
            _PartIndex += 4;
            int _SourceRVA = _SourceIndex;
            bool _Equals = true;
            for (int z = 0; z != p_PartWidth - 1; z++)
            {
                //_CurrentlyColor = Color.FromArgb(p_Source[_SourceRVA + 3], p_Source[_SourceRVA + 2], p_Source[_SourceRVA + 1], p_Source[_SourceRVA]);
                //_CompareColoe = Color.FromArgb(p_Part[_PartIndex + 3], p_Part[_PartIndex + 2], p_Part[_PartIndex + 1], p_Part[_PartIndex]);

                if (!ScanColor(p_Source[_SourceRVA + 2], p_Source[_SourceRVA + 1], p_Source[_SourceRVA], p_Part[_PartIndex + 2], p_Part[_PartIndex + 1], p_Part[_PartIndex], p_Float))
                {
                    _PartIndex = 0;
                    _Equals = false;
                    break;
                }
                _PartIndex += 4;
                _SourceRVA += 4;
            }
            if (_Equals) return i;
        }
        else
        {
            _PartIndex = 0;
        }
    }
    return -1;
}

/// <summary>  
/// 检查色彩(可以根据这个更改比较方式  
/// </summary>  
/// <param name="p_CurrentlyColor">当前色彩</param>  
/// <param name="p_CompareColor">比较色彩</param>  
/// <param name="p_Float">溶差</param>  
/// <returns></returns>  
private static bool ScanColor(byte source_R, byte source_G, byte source_B, byte part_R, byte part_G, byte part_B, int p_Float)
{
    //int _R = p_CurrentlyColor.R;
    //int _G = p_CurrentlyColor.G;
    //int _B = p_CurrentlyColor.B;

    return (source_R <= part_R + p_Float && source_R >= part_R - p_Float)
        && (source_G <= part_G + p_Float && source_G >= part_G - p_Float)
        && (source_B <= part_B + p_Float && source_B >= part_B - p_Float);

}

/// <summary>  
/// 判断图形里是否存在另外一个图形 并返回所在位置  
/// </summary>  
/// <param name="p_SourceBitmap">原始图形</param>  
/// <param name="p_PartBitmap">小图形</param>  
/// <param name="p_Float">溶差</param>  
/// <returns>坐标</returns>  
public static List<Point> GetAllPoints(Bitmap p_SourceBitmap, Bitmap p_PartBitmap, int p_Float)
{
    var pointList = new List<Point>();
    int _SourceWidth = p_SourceBitmap.Width;
    int _SourceHeight = p_SourceBitmap.Height;

    int _PartWidth = p_PartBitmap.Width;
    int _PartHeight = p_PartBitmap.Height;

    Bitmap _SourceBitmap = new Bitmap(_SourceWidth, _SourceHeight);
    Graphics _Graphics = Graphics.FromImage(_SourceBitmap);
    _Graphics.DrawImage(p_SourceBitmap, new System.Drawing.Rectangle(0, 0, _SourceWidth, _SourceHeight));
    _Graphics.Dispose();

    BitmapData _SourceData = _SourceBitmap.LockBits(new System.Drawing.Rectangle(0, 0, _SourceWidth, _SourceHeight), ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
    byte[] _SourceByte = new byte[_SourceData.Stride * _SourceHeight];
    Marshal.Copy(_SourceData.Scan0, _SourceByte, 0, _SourceByte.Length);  //复制出p_SourceBitmap的相素信息   
    _SourceBitmap.UnlockBits(_SourceData);

    Bitmap _PartBitmap = new Bitmap(_PartWidth, _PartHeight);
    _Graphics = Graphics.FromImage(_PartBitmap);
    _Graphics.DrawImage(p_PartBitmap, new System.Drawing.Rectangle(0, 0, _PartWidth, _PartHeight));
    _Graphics.Dispose();
    BitmapData _PartData = _PartBitmap.LockBits(new System.Drawing.Rectangle(0, 0, _PartWidth, _PartHeight), ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
    byte[] _PartByte = new byte[_PartData.Stride * _PartHeight];
    Marshal.Copy(_PartData.Scan0, _PartByte, 0, _PartByte.Length);   //复制出p_PartBitmap的相素信息   
    _PartBitmap.UnlockBits(_PartData);

    //匹配基本思路如下
    //1. 先遍历原图Y坐标
    //2.    遍历匹配图Y坐标AS目标坐标
    //3.        找出该行完全匹配的X坐标，如果没有，原图Y+1，重复步骤1
    //          如果成功找到X，目标坐标Y+1，再次匹配，但是X值必须一致，直至目标Y最大，匹配结束
    for (int _PointY = 0; _PointY != _SourceHeight; _PointY++)
    {
        if (_SourceHeight - _PointY < _PartHeight) break;  //如果 剩余的高 比需要比较的高 还要小 就直接返回               
        int _PointX = -1;    //临时存放坐标 需要保证找到的是在一个X点上  
        bool _SacnOver = true;   //是否都比配的上  
        for (int z = 0; z != _PartHeight - 1; z++)       //循环目标进行比较  
        {
            int _TrueX = GetImageContains(_SourceByte, _PartByte, _PointY * _SourceData.Stride, _SourceWidth, _PartWidth, p_Float);

            if (_TrueX == -1)   //如果没找到   
            {
                _PointX = -1;    //设置坐标为没找到  
                _SacnOver = false;   //设置不进行返回  
                //_SourceByte = _SourceByte.Skip(_SourceData.Stride).ToArray();
                //_SourceHeight = _SourceHeight - 1;
                break;
            }
            else
            {
                if (z == 0) _PointX = _TrueX;
                if (_PointX != _TrueX)   //如果找到了 也的保证坐标和上一行的坐标一样 否则也返回  
                {
                    _PointX = -1;//设置坐标为没找到  
                    _SacnOver = false;  //设置不进行返回  
                    //_SourceByte = _SourceByte.Skip(_SourceData.Stride).ToArray();
                    //_SourceHeight = _SourceHeight - 1;
                    break;
                }
            }
        }
        if (_SacnOver)
        {
            //加入集合
            pointList.Add(new Point(_PointX, _PointY));
            //矩形涂黑
            var tmpX = _PointX + _PartWidth;
            var tmpY = _PointY + _PartHeight;
            for (int y = 0; y < tmpY; y++)
            {
                for (int x = 0; x < tmpX; x++)
                {
                    var index = y * _SourceData.Stride + x * 4;
                    _SourceByte[index] = 255;
                    _SourceByte[index + 1] = 255;
                    _SourceByte[index + 2] = 255;
                    _SourceByte[index + 3] = 255;
                }
            }
            //重置Y坐标
            _PointY = 0;

            //Bitmap tmpBitmap = new Bitmap(_SourceWidth, _SourceHeight);
            //BitmapData tmBitmapData = tmpBitmap.LockBits(new System.Drawing.Rectangle(0, 0, _SourceWidth, _SourceHeight), ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
            //Marshal.Copy(_SourceByte, 0, tmBitmapData.Scan0, _SourceByte.Length);   //复制出p_PartBitmap的相素信息   
            ////byte[] source, int startIndex, IntPtr destination, int length
            //tmpBitmap.UnlockBits(_PartData);


            //Graphics tmpGraphics = Graphics.FromImage(tmpBitmap);
            //tmpGraphics.DrawImage(tmpBitmap, new System.Drawing.Rectangle(0, 0, _SourceWidth, _SourceHeight));
            //tmpGraphics.Dispose();

            //tmpBitmap.Save("test.bmp");
        }

    }
    return pointList;
}

我改成匹配多个结果的时候用的方法是把匹配到结果图形右下角到坐标0,0的区域涂黑，然后重新匹配，直到没有结果为止。但是这个跳一跳不用匹配多个结果，他只要这个方法确定象棋位置就可以

鼠标钩子

这部分其实比较简单，就是调用 user32.dll 外部方法，搞几个委托处理下回调函数，有一个需要注意点就是钩子的回调函数必须搞成静态变量，不然会被GC回收掉，导致回调报错，我自己整理的钩子类如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
/// <summary>
/// 全局钩子
/// </summary>
public class Hook
{
    private const int WM_MOUSEMOVE = 0x200;//鼠标移动
    private const int WM_LBUTTONDOWN = 0x201;//左键按下
    private const int WM_RBUTTONDOWN = 0x204;//右键按下
    private const int WM_MBUTTONDOWN = 0x207;//滚轮按下
    private const int WM_LBUTTONUP = 0x202;//左键松开
    private const int WM_RBUTTONUP = 0x205;//右键松开
    private const int WM_MBUTTONUP = 0x208;//滚轮松开
    private const int WM_LBUTTONDBLCLK = 0x203;//左键双击
    private const int WM_RBUTTONDBLCLK = 0x206;//右键双击
    private const int WM_MBUTTONDBLCLK = 0x209;//滚轮双击
    private const int WH_KEYBOARD_LL = 13; //键盘
    private const int WH_MOUSE_LL = 14; // mouse hook constant
    private const int WM_KEYDOWN = 0x0100; //按下一个键
    private const int WM_KEYUP = 0x0101; //释放一个键
    private const int WM_CHAR = 0x0102; //按下某键，并已发出WM_KEYDOWN，WM_KEYUP消息
    private const int WM_SYSKEYDOWN = 0x0104; //当用户按住ALT键同时按下其它键时提交此消息给拥有焦点的窗口
    private const int WM_SYSKEYUP = 0x0105; //当用户释放一个键同时ALT 键还按着时提交此消息给拥有焦点的窗口
    private const int WM_SYSCHAR = 0x0106; //当WM_SYSKEYDOWN消息被TRANSLATEMESSAGE函数翻译后提交此消息给拥有焦点的窗口

    /// <summary>
    /// 点
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public class POINT
    {
        public int x;
        public int y;
    }

    /// <summary>
    /// 鼠标钩子结构体
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public class MouseHookStruct
    {
        public POINT pt;
        public int hWnd;
        public int wHitTestCode;
        public int dwExtraInfo;
    }
    /// <summary>
    /// 键盘钩子结构体
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public class KeyBoardHookStruct
    {
        public int vkCode;
        public int scanCode;
        public int flags;
        public int time;
        public int dwExtraInfo;
    }


    // 装置钩子的函数
    [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
    public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);

    // 卸下钩子的函数
    [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
    public static extern bool UnhookWindowsHookEx(int idHook);

    // 下一个钩挂的函数
    [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
    public static extern int CallNextHookEx(int idHook, int nCode, Int32 wParam, IntPtr lParam);

    // 全局的鼠标事件
    public event MouseEventHandler OnMouseActivity;

    // 全局的键盘事件
    public event System.Windows.Forms.KeyEventHandler OnKeyBoardActivity;

    // 钩子回调函数
    public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);

    // 声明鼠标钩子事件类型
    //private HookProc _mouseHookProcedure;
    //private HookProc _keyBoacrdHookProcedure;
    private static int _hMouseHook = 0; // 鼠标钩子句柄 卸载钩子需要使用
    private static int _hKeyBoardHook = 0; // 键盘钩子句柄 卸载钩子需要使用

    /// <summary>
    /// 构造函数
    /// </summary>
    public Hook()
    {

    }

    /// <summary>
    /// 析构函数
    /// </summary>
    ~Hook()
    {
        StopMouseHook();
    }
    private static HookProc _mouseHookProcedure;
    /// <summary>
    /// 启动鼠标钩子
    /// </summary>
    public void StartMouseHook()
    {
        // 安装鼠标钩子
        if (_hMouseHook == 0)
        {
            // 生成一个HookProc的实例.

            _mouseHookProcedure = MouseHookProc;
            _hMouseHook = SetWindowsHookEx(WH_MOUSE_LL, _mouseHookProcedure, IntPtr.Zero, 0);

            //假设装置失败停止钩子
            if (_hMouseHook == 0)
            {
                StopMouseHook();
                throw new Exception("SetWindowsHookEx failed.");
            }
        }
    }

    /// <summary>
    /// 停止鼠标钩子
    /// </summary>
    public void StopMouseHook()
    {
        bool retMouse = true;

        if (_hMouseHook != 0)
        {
            retMouse = UnhookWindowsHookEx(_hMouseHook);
            _hMouseHook = 0;
        }

        // 假设卸下钩子失败
        if (!(retMouse))
            throw new Exception("UnhookWindowsHookEx failed.");
    }

    /// <summary>
    /// 鼠标钩子回调函数
    /// </summary>
    private int MouseHookProc(int nCode, Int32 wParam, IntPtr lParam)
    {
        // 假设正常执行而且用户要监听鼠标的消息
        if ((nCode >= 0) && (OnMouseActivity != null))
        {
            MouseButtons button = MouseButtons.None;
            int clickCount = 0;

            switch (wParam)
            {
                case WM_LBUTTONDOWN:
                    break;
                case WM_LBUTTONUP:
                    button = MouseButtons.Left;
                    clickCount = 1;
                    break;
                case WM_LBUTTONDBLCLK:
                    button = MouseButtons.Left;
                    clickCount = 2;
                    break;
                case WM_RBUTTONDOWN:
                    break;
                case WM_RBUTTONUP:
                    button = MouseButtons.Right;
                    clickCount = 1;
                    break;
                case WM_RBUTTONDBLCLK:
                    button = MouseButtons.Right;
                    clickCount = 2;
                    break;
            }

            // 从回调函数中得到鼠标的信息
            MouseHookStruct myMouseHookStruct = (MouseHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseHookStruct));
            MouseEventArgs e = new MouseEventArgs(button, clickCount, myMouseHookStruct.pt.x, myMouseHookStruct.pt.y, 0);

            // 假设想要限制鼠标在屏幕中的移动区域能够在此处设置
            // 后期须要考虑实际的x、y的容差
            //if (!Screen.PrimaryScreen.Bounds.Contains(e.X, e.Y))
            //{
            //    //return 1;
            //}

            OnMouseActivity(this, e);
        }

        // 启动下一次钩子
        return CallNextHookEx(_hMouseHook, nCode, wParam, lParam);
    }
    private static HookProc _keyBoacrdHookProcedure;
    /// <summary>
    /// 启动键盘钩子
    /// </summary>
    public void StartKeyBoardHook()
    {
        // 安装鼠标钩子
        if (_hKeyBoardHook == 0)
        {
            // 生成一个HookProc的实例.
            _keyBoacrdHookProcedure = KeyBoardHookProc;

            _hKeyBoardHook = SetWindowsHookEx(WH_KEYBOARD_LL, _keyBoacrdHookProcedure, IntPtr.Zero, 0);

            //假设装置失败停止钩子
            if (_hKeyBoardHook == 0)
            {
                StopKeyBoardHook();
                throw new Exception("SetWindowsHookEx failed.");
            }
        }
    }

    /// <summary>
    /// 停止键盘钩子
    /// </summary>
    public void StopKeyBoardHook()
    {
        bool retMouse = true;

        if (_hKeyBoardHook != 0)
        {
            retMouse = UnhookWindowsHookEx(_hKeyBoardHook);
            _hKeyBoardHook = 0;
        }

        // 假设卸下钩子失败
        if (!(retMouse))
            throw new Exception("UnhookWindowsHookEx failed.");
    }

    /// <summary>
    /// 键盘钩子回调函数
    /// </summary>
    private int KeyBoardHookProc(int nCode, Int32 wParam, IntPtr lParam)
    {
        // 假设正常执行而且用户要监听鼠标的消息
        if ((nCode >= 0) && (OnKeyBoardActivity != null))
        {
            KeyBoardHookStruct kbh = (KeyBoardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyBoardHookStruct));
            var k = (Keys)Enum.Parse(typeof(Keys), kbh.vkCode.ToString());

            switch (k)
            {
                case Keys.F10:
                    if (wParam == WM_KEYDOWN)
                    {
                        Keys keyData = (Keys)kbh.vkCode;
                        System.Windows.Forms.KeyEventArgs e = new System.Windows.Forms.KeyEventArgs(keyData);
                        OnKeyBoardActivity(this, e);
                        break;
                    }
                    else
                    {
                        break;
                    }
                default:
                    return -1;
            }

        }

        // 启动下一次钩子
        return CallNextHookEx(_hKeyBoardHook, nCode, wParam, lParam);
    }
}

界面以及主逻辑

因为每次跳动都要确定模拟器的区域，所以第一步我先获取句柄，然后根据窗体句柄获取模拟器界面边界，屏幕截图在截取出模拟器的界面，得到匹配用的原图

素材图片，就是旗子身体的一部分，因为根据模拟器窗体大小会变化，所以采用读取本件的方法，这意味着你要事先截取好素材图片，需要注意的是之前自己写的图片匹配方法比较死板，所以素材图片不能把背景搞进去，不然肯定匹配不出来

然后就是 user32一些外部方法，用来移动鼠标，模拟鼠标操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
#region 跳一跳相关

RECT _jumpRect = new RECT();//模拟器坐标
string _pieceImgPath = String.Empty;//棋子图片路径
/// <summary>
/// 鼠标取句柄按钮点击
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button3_Click_1(object sender, RoutedEventArgs e)
{
    //开启钩子监听鼠标点击事件
    hook.OnMouseActivity += Jump1HookActivity;
    hook.StartMouseHook();
}
/// <summary>
/// 鼠标钩子左键回调
/// </summary>
/// <param name="sender"></param>
/// <param name="mouseEventArgs"></param>
private void Jump1HookActivity(object sender, System.Windows.Forms.MouseEventArgs mouseEventArgs)
{
    if (mouseEventArgs.Button == MouseButtons.Left && mouseEventArgs.Clicks == 1)
    {
        //当前鼠标坐标
        var point = new POINT();
        GetCursorPos(out point);
        //句柄
        formHandle = WindowFromPoint(point);
        //标题
        var title = new StringBuilder(256);
        GetWindowText(formHandle, title, title.Capacity);
        //类名
        var className = new StringBuilder();
        GetClassName(formHandle, className, className.Capacity);
        //Size
        _jumpRect = new RECT();
        GetWindowRect(formHandle, ref _jumpRect);
        AddLog($"句柄采集成功！窗体坐标范围为 {_jumpRect.Left},{_jumpRect.Top}-{_jumpRect.Right},{_jumpRect.Bottom}");
        AddLog($"窗体大小 Width:{_jumpRect.Right - _jumpRect.Left},Height:{_jumpRect.Bottom - _jumpRect.Top}");
        hook.StopMouseHook();
        hook.OnMouseActivity -= Jump1HookActivity;
    }
}

private void AddLog(string str)
{
    if (!string.IsNullOrWhiteSpace(textBox3.Text))
    {
        textBox3.Text += Environment.NewLine;
    }
    textBox3.Text += $"{DateTime.Now:yyyy-MM-dd HH:mm:ss}：{str}";
    textBox3.ScrollToEnd();
}
/// <summary>
/// 取象棋图片素材
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button4_Click(object sender, RoutedEventArgs e)
{
    //初始化一个OpenFileDialog类
    OpenFileDialog fileDialog = new OpenFileDialog();
    fileDialog.Multiselect = false;
    fileDialog.Filter = "(*.bmp)|*.bmp";

    //判断用户是否正确的选择了文件
    if (fileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
    {
        //获取用户选择文件的后缀名
        string extension = Path.GetExtension(fileDialog.FileName);
        //声明允许的后缀名
        string[] str = new string[] { ".bmp", ".BMP" };
        if (!((IList)str).Contains(extension))
        {
            MessageBox.Show("只能处理BMP格式图片");
        }
        else
        {
            _pieceImgPath = fileDialog.FileName;
            AddLog($"棋子素材路径读取成功 {_pieceImgPath}");
        }
    }
}
/// <summary>
/// 开始
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button5_Click(object sender, RoutedEventArgs e)
{
    //开启钩子监听鼠标右键
    hook.OnMouseActivity += Jump2HookActivity;
    hook.StartMouseHook();
}
/// <summary>
/// 鼠标钩子右键回调
/// </summary>
/// <param name="sender"></param>
/// <param name="mouseEventArgs"></param>
private void Jump2HookActivity(object sender, System.Windows.Forms.MouseEventArgs mouseEventArgs)
{
    if (mouseEventArgs.Button == MouseButtons.Right && mouseEventArgs.Clicks == 1)
    {
        Bitmap image1 = new Bitmap(_jumpRect.Right - _jumpRect.Left, _jumpRect.Bottom - _jumpRect.Top);//截取屏幕
        Graphics imgGraphics = Graphics.FromImage(image1);
        imgGraphics.CopyFromScreen(new System.Drawing.Point(_jumpRect.Left, _jumpRect.Top), new System.Drawing.Point(0, 0),
            new System.Drawing.Size(_jumpRect.Right - _jumpRect.Left, _jumpRect.Bottom - _jumpRect.Top));
        //image1.Save("test.bmp");

        Bitmap image2 = (Bitmap)System.Drawing.Image.FromFile(_pieceImgPath);
        _points = ToFindPic.GetAllPoints(image1, image2, 10);
        if (_points == null || _points.Count == 0)
        {
            AddLog("没有匹配到棋子坐标");
            return;
        }

        var pointPeople = new System.Windows.Point(_jumpRect.Left + _points[0].X, _jumpRect.Top + _points[0].Y);
        //偏移坐标
        pointPeople.X += image2.Width / 2;
        pointPeople.Y += image2.Height / 2;

        //SetCursorPos(Convert.ToInt32(pointPeople.X), Convert.ToInt32(pointPeople.Y));//test

        var pointTarget = new Point(mouseEventArgs.X, mouseEventArgs.Y);
        var distance = Math.Sqrt(Math.Pow(pointTarget.X - pointPeople.X, 2) + Math.Pow(pointTarget.Y - pointPeople.Y, 2));
        var coefficient = 3.6;
        if (pointTarget.X < pointPeople.X)
        {
            coefficient = Convert.ToDouble(this.textBox_jumpX.Text);//系数
        }
        else
        {
            coefficient = Convert.ToDouble(this.textBox_jumpY.Text);//系数
        }

        var pressTime = new TimeSpan(0, 0, 0, 0, Convert.ToInt32(coefficient * distance));//毫秒


        var random = new Random();
        SetCursorPos(_jumpRect.Right - random.Next(150, 250), _jumpRect.Top + random.Next(150, 250));//移动鼠标位置
        mouse_event(MouseEventFlag.LeftDown, 0, 0, 0, UIntPtr.Zero);
        var now = DateTime.Now;
        Thread.Sleep(pressTime);
        var ts = DateTime.Now - now;
        AddLog($"预计耗时{pressTime.Milliseconds},实际耗时{ts.TotalMilliseconds}");
        mouse_event(MouseEventFlag.LeftUp, 0, 0, 0, UIntPtr.Zero);
    }
}
/// <summary>
/// stop
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button6_Click(object sender, RoutedEventArgs e)
{
    hook.StopMouseHook();
    hook = new Hook();
}

#endregion

user32部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#region user32
//句柄窗体相关
[DllImport("user32.dll")]
public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
[DllImport("user32.dll")]
public static extern int GetClassName(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
[DllImport("user32.dll")]
public static extern IntPtr WindowFromPoint(POINT point);
[DllImport("user32.dll", CharSet = CharSet.Auto)]
public static extern bool GetCursorPos(out POINT point);
[DllImport("user32.dll")]
public static extern int SetCursorPos(int x, int y);
[DllImport("user32.dll", EntryPoint = "GetParent", SetLastError = true)]
public static extern IntPtr GetParent(IntPtr hWnd);
[DllImport("user32.dll", EntryPoint = "GetWindowThreadProcessId")]
public static extern uint GetWindowThreadProcessId(IntPtr hWnd, ref uint lpdwProcessId);
//设置鼠标按键和动作
[Flags]
enum MouseEventFlag : uint //设置鼠标动作的键值
{
    Move = 0x0001,               //发生移动
    LeftDown = 0x0002,           //鼠标按下左键
    LeftUp = 0x0004,             //鼠标松开左键
    RightDown = 0x0008,          //鼠标按下右键
    RightUp = 0x0010,            //鼠标松开右键
    MiddleDown = 0x0020,         //鼠标按下中键
    MiddleUp = 0x0040,           //鼠标松开中键
    XDown = 0x0080,
    XUp = 0x0100,
    Wheel = 0x0800,              //鼠标轮被移动
    VirtualDesk = 0x4000,        //虚拟桌面
    Absolute = 0x8000
}
[DllImport("user32.dll")]
static extern void mouse_event(MouseEventFlag flags, int dx, int dy, uint data, UIntPtr extraInfo); //UIntPtr指针多句柄类型
[StructLayout(LayoutKind.Sequential)]
public struct POINT
{
    public int X;
    public int Y;

    public POINT(int x, int y)
    {
        this.X = x;
        this.Y = y;
    }

    public override string ToString()
    {
        return ("X:" + X + ", Y:" + Y);
    }
}
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool GetWindowRect(IntPtr hWnd, ref RECT lpRect);
[StructLayout(LayoutKind.Sequential)]
public struct RECT
{
    public int Left;                             //最左坐标
    public int Top;                             //最上坐标
    public int Right;                           //最右坐标
    public int Bottom;                        //最下坐标
}

[DllImport("User32.dll", EntryPoint = "FindWindow")]
private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
[DllImport("User32.dll", EntryPoint = "FindWindowEx")]
private static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpClassName, string lpWindowName);

//鼠标钩子相关
[StructLayout(LayoutKind.Sequential)]
public class MouseHookStruct
{
    public POINT pt;
    public int hwnd;
    public int wHitTestCode;
    public int dwExtraInfo;
}
public delegate int HookProc(int nCode, IntPtr wParam, IntPtr lParam);
//安装钩子
[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
//卸载钩子
[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern bool UnhookWindowsHookEx(int idHook);
//调用下一个钩子
[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern int CallNextHookEx(int idHook, int nCode, IntPtr wParam, IntPtr lParam);


#endregion

后记

  1. 效果图每次右键一次会记两次日志是因为我之前点了两次go按钮，导致每次右键回调了2次 这可真蠢
  2. 跳一跳后台估计会根据连续perfect次数判断是否用作弊，如果它判断你作弊就不记录成绩了，而且我怀疑只要你超过一定分数他都直接判你作弊，然后骗一波个人照去申诉，因为作不作弊没那么容易区分
  3. 图像匹配和识别简单的很容易实现，但是想实现复杂一些的，比如扭曲倾斜的图片，没有研究过理论光靠直觉是想不出解决方案的，还是很有深度