基于OpenCV的微信跳一跳外挂

摘要：微信跳一跳是时下热门的微信小游戏，基本原理是根据按压屏幕的时间控制棋子跳过的距离，使其跳到下一个方块上；现利用Android adb工具，PC端获取实时截图，使用OpenCV库分析图片计算距离，从而计算按压时间传回手机。

环境：Ubuntu18.04、OpenCV3.4.0

步骤：

1、获取Android截图，并传到PC端

adb shell /system/bin/screencap -p /sdcard/screenshot.png

adb pull /sdcard/screenshot.png .

2、程序读入图片并获取ROI

cvLoadImage("screenshot.png", 1);

cvSetImageROI(src, cvRect(0, 600, 1080, 900));

2、对ROI进行模板匹配，找到chess坐标

cvMatchTemplate(src, mode, result, CV_TM_CCOEFF);

3、对ROI灰度处理并边缘检测

cvCvtColor(src,srcGray, CV_BGR2GRAY);

cvCanny( srcGray, dst, 50, 100, 3);

4、对边缘检测结果进行遍历像素点，获取最上与最右（左）的像素 点坐标，从而得出下一方块中心点。

5、计算两个点坐标距离乘相应系数得到时间。

adb shell input swipe  400 400 400 400  time

效果图：

具体代码如下：

 #include "cv.h"
 #include "highgui.h"
 #include <iostream>
 #include <unistd.h>
 #include <stdio.h>
 using namespace std;
 using namespace cv;
 CvPoint find_chess_point(IplImage* src, IplImage* mode)
 {
     //模式匹配
     IplImage* result;
     CvPoint MinLocation, MaxLocation;
     double MinValue, MaxValue;
     int iwidth = src->width - mode->width + ;
     int iheight = src->height - mode->height + ;
     result = cvCreateImage(cvSize(iwidth, iheight), , );
     cvMatchTemplate(src, mode, result, CV_TM_CCOEFF);
     cvMinMaxLoc(result, &MinValue, &MaxValue, &MinLocation, &MaxLocation, NULL);
     return cvPoint(MaxLocation.x + (int)mode->width/, MaxLocation.y + mode->height);
 }
 CvPoint find_next_point(IplImage* src, CvPoint chess_point, int mode = )
 {
     IplImage* tmp = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, );
     cvCvtColor(src, tmp, CV_BGR2GRAY);
     cvEqualizeHist(tmp, tmp);
     IplImage* dst = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, );
     cvCanny(src, dst, , , );
     //cvNamedWindow("doCany");
     //cvShowImage("doCany", dst);
     CvPoint next_point;
     if(chess_point.x < )//分左右，如果棋子在左侧，目标方块则在右侧
     {
         /*遍历轮廓上顶点*/
         unsigned char *pixel = (unsigned char *)dst->imageData;//指向首地址
         for(int row = ; row <  ; ++row)//行扫描
         {
             for(int col = ; col < ; ++col)//列扫描
             {
                 if(pixel[row*dst->width + col] == )//灰度图Canny边缘处理后轮廓为白色255
                 {
                     next_point.x = col;
                     if(mode == )
                     {
                         /*这是根据chess与target的连线与水平夹角总是30度，只知道横坐标和角度即可算出纵坐标*/
                         next_point.y = (int) (chess_point.y - (chess_point.x - next_point.x)/1.732); //根号3
                         return next_point;
                     }
                     /*找到上顶点后，开始遍历右顶点*/
                     for(int col_=; col_ > ; --col_)//最右列向左遍历
                     {
                         for(int row_=; row_ < ; ++row_)//从上向下遍历
                         {
                             if(pixel[row_*dst->width + col_] == )
                             {
                                 /*找到右顶点*/
                                 next_point.y = row_;
                                 cvLine(dst, chess_point, next_point, Scalar(, , ));
                                 cvShowImage("line", dst);
                                 cvWaitKey();
                                 return next_point;
                             }
                         }
                     }
                 }
             }
         }
     }
     else
     {
         /*遍历轮廓上顶点*/
         unsigned char *pixel = (unsigned char* )dst->imageData;//指向首地址
         for(int row = ; row <  ; ++row)//行扫描
         {
             for(int col = ; col < ; ++col)//列扫描
             {
                 if(pixel[row*dst->width + col] == )
                 {
                     next_point.x = col;
                     if(mode == )
                     {
                         /*这是根据chess与target的连线与水平夹角总是30度，只知道横坐标和角度即可算出纵坐标, 这个方法效果好*/
                         next_point.y = (int) (chess_point.y - (chess_point.x - next_point.x)/1.732); //根号3
                         return next_point;
                     }
                     /*找到上顶点后，开始遍历右顶点*/
                     for(int col_=; col_ > ; --col_)//最正中间列向左遍历
                     {
                         for(int row_=; row_ < ; ++row_)//从上向下遍历
                         {
                             if(pixel[row_*dst->width + col_] == )
                             {
                                 /*找到右顶点*/
                                 next_point.y = row_;
                                 cvLine(dst, chess_point, next_point, Scalar(, , ));
                                 cvShowImage("line", dst);
                                 cvWaitKey();
                                 return next_point;
                             }
                         }
                     }
                 }
             }
         }
     }
     return next_point;
 }

 IplImage* cut_src_img(IplImage* src)
 {
     //SetImageROI
     cvSetImageROI(src, cvRect(, , , ));//取决于手机分辨率，可以在上一行resize后，其他地方不需要修改
     cvSaveImage("roi.jpg",src);
     return cvLoadImage("roi.jpg", );
 }

 float calculate_distance(CvPoint chess_point, CvPoint next_point)
 {
     float distance;
     distance = sqrt(pow(abs(chess_point.x - next_point.x), ) + pow(abs(chess_point.y - next_point.y), ));
     return distance;
 }
 void jump_one_jump(float distance, float parameter)
 {
     char jump[];
     RNG rng;
     sprintf(jump, "adb shell input swipe %d %d %d %d %d", rng.uniform(, ), rng.uniform(, ), rng.uniform(, ), rng.uniform(, ), (int)(distance * parameter));
     system(jump);
 }
 int main(int argc, char** argv)
 {
     IplImage* roi_image = NULL;
     IplImage* chess_mode = cvLoadImage("jump.png", );
     float distance;
     CvPoint chess_point, next_point;
     cvNamedWindow("line",);
     for(;;)
     {
         system("rm -rf screenshot.png && rm -rf roi.jpg");
         system("adb shell /system/bin/screencap -p /sdcard/screenshot.png");
         sleep(0.2);
         system("adb pull /sdcard/screenshot.png . >/dev/null");//把adb pull命令的shell提示重定向
         sleep(0.2);
         IplImage* src = cvLoadImage("screenshot.png", );
         roi_image = cut_src_img(src);//取截图中间部分
         chess_point = find_chess_point(roi_image, chess_mode);//match找到chess坐标
         next_point = find_next_point(roi_image, chess_point, );//像素点遍历找到target坐标，mode=1效果好
         //cvLine(roi_image, chess_point, next_point, Scalar(0, 255, 255));
         //cvShowImage("line",roi_image);
         //cvWaitKey(100);
         distance = calculate_distance(chess_point, next_point);//计算距离
         jump_one_jump(distance, 1.4);
         sleep();
     }
     return ;
 }

代码链接：https://files.cnblogs.com/files/luoyijie/jump2.0.tar.gz