微信跳一跳辅助JAVA 自动模拟点击

工具：ADB

原理：

1. 开始游戏后，使用ADB工具让手机截屏发送到电脑
2. 分析图像中小人与目标中心点间的距离，根据一定比例计算出需要触屏的时间
3. 使用ADB进行模拟点击（触屏）相应的时间，完成精准跳跃

程序代码：

 import java.awt.EventQueue;
 import java.awt.Graphics;

 import javax.swing.JFrame;
 import javax.swing.JLabel;
 import java.awt.BorderLayout;
 import java.awt.Color;

 import javax.imageio.ImageIO;
 import javax.swing.ImageIcon;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
 import java.math.BigDecimal;

 public class Skip {
     /*
      * 以下参数根据手机配置自行调整：
      */
     private final int time = 2800;        //执行跳跃间隔时间(单位：ms)
     private final double scale = 2.04;    //用于计算按下屏幕时间的比例，触屏时间=距离*scale

     private JFrame frame;                //窗体
     private JLabel lblNewLabel;            //用于显示图片的Label
     private BufferedImage image;        //手机截屏
     private int skipTime = 0;            //跳跃次数
     /**
      * Launch the application.
      */
     public static void main(String[] args) {
         EventQueue.invokeLater(new Runnable() {
             public void run() {
                 try {
                     Skip window = new Skip();        //跳一跳类实例
                     window.frame.setVisible(true);    //设置窗体可见
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
         });
     }

     /**
      * Create the application.
      */
     public Skip() {
         initialize();        //初始化
     }

     /**
      * Initialize the contents of the frame.
      */
     private void initialize() {
         image = Control.getScreen();            //截取第一个图片
         Control.getFoot(image);                    //寻找计算小人位置
         Control.getTarget(image);                //寻找目标中心
         ImageIcon imageIcon = new ImageIcon(image);        //以截图创建一个ImageIcon对象，供标签使用

         frame = new JFrame();                    //创建一个窗体
         frame.setBounds(100, 0, imageIcon.getIconWidth(), imageIcon.getIconHeight());    //设置窗体大小位置
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);        //关闭窗体时结束进程

         lblNewLabel = new JLabel("手机屏幕");        //创建标签
         //给标签添加单机时间：单机后开始自动跳跃
         lblNewLabel.addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 Thread skip = new Thread(new SkipRun());
                 skip.start();
             }
         });
         lblNewLabel.setIcon(imageIcon);            //设置标签图片
         frame.getContentPane().add(lblNewLabel, BorderLayout.CENTER);        //添加标签到窗体中
     }

     //单步跳跃
     protected void skip() {
         double distance = Control.getDistance(image);        //计算距离
         Control.mouseon(Integer.parseInt(new BigDecimal(String.valueOf(distance * scale)).setScale(0, BigDecimal.ROUND_HALF_UP).toString()));            //模拟触屏
         try {
             //记录本次图片
             ImageIO.write(image, "png", new File("debug" + skipTime++ + ".png"));
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     //自动跳跃主线程
     class SkipRun implements Runnable{

         @Override
         public void run() {
             //循环跳跃
             while(true) {
                 skip();
                 try {
                     //小人跳跃需要花一定时间，在此等待3秒
                     Thread.sleep(time);
                 } catch (InterruptedException e1) {
                     e1.printStackTrace();
                 }
                 //将当前手机屏幕显示在窗体中
                 image = Control.getScreen();
                 lblNewLabel.setIcon(new ImageIcon(image));
             }
         }

     }

 }

 /**
  * 工具类，负责发送ADB命令、计算小人与目标距离
  */
 class Control {
     private static int footX = 0, footY = 0;        //小人底部坐标
     private static int targetX = 0,targetY = 0;        //目标方块中心坐标
     //获取截屏
     public static BufferedImage getScreen(){
         //截屏
         try {
             //手机截屏，存储到SD卡
             Process process = Runtime.getRuntime().exec("adb shell screencap /sdcard/screen.png");
             process.waitFor();
             //将截图传到电脑，以便接下来的分析
             process = Runtime.getRuntime().exec("adb pull /sdcard/screen.png screen.png");
             process.waitFor();
         } catch (IOException | InterruptedException e) {
             //异常处理
             e.printStackTrace();
         }
         //加载文件
         File file = new File("screen.png");
         if (file == null || !file.exists()) {
             System.out.println("获取截屏失败");
             return null;
         }

         //加载图片
         BufferedImage image = null;
         try {
             image = ImageIO.read(file);
         } catch (IOException e) {
             e.printStackTrace();
         }
         return image;
     }

     //长按屏幕
     public static void mouseon(int time) {
         try {
             Runtime.getRuntime().exec("adb shell input swipe 200 200 200 200 " + time);
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

     //计算距离
     public static double getDistance (BufferedImage image) {
         getFoot(image);            //获取小人坐标
         getTarget(image);        //获取目标坐标
         return Math.sqrt((footX - targetX) * (footX - targetX) + (footY - targetY) * (footY - targetY));
     }

     public static void getFoot(BufferedImage image){

         Color footColor = new Color(54,60,102);        //小人底部颜色
         int top = (int)(image.getHeight() * 0.5);        //扫描范围顶部（X）
         int bottom = (int) (image.getHeight() * 0.7);    //扫描范围底部（X）
         /*
          * 自底向上扫描小人脚下位置
          */
         for(int i = bottom;i > top;i--)
         {
             for(int j = 0;j < image.getWidth();j++)
             {
                 //如果当前颜色与小人脚部颜色相近
                 if(Math.abs(image.getRGB(j, i) - footColor.getRGB()) < 200) {
                     footX = j;
                     footY = i - 10;        //自左向右扫描，原始结果会偏左，在此稍向右移
                     i = top;        //结束外层循环
                     break;
                 }
             }
         }
         /*
          * 用蓝色方块标记找到的小人位置
          */
         Graphics g = image.getGraphics();
         g.setColor(Color.BLUE);
         g.fillRect(footX - 5, footY - 5, 10, 10);
     }

     public static void getTarget(BufferedImage image) {

         /*
          * 第一步，找到目标方块上端顶点，该顶点的X坐标即中心的X坐标
          */

         int top = (int)(image.getHeight() * 0.35);            //扫描范围顶部
         int bottom = (int)(image.getHeight() * 0.49);        //扫描范围底部
         Color headColor = new Color(56, 54, 71);
         /*
          * 自顶向下扫描目标方块顶端位置
          */
         for(int i = top;i < bottom;i++)
         {
             Color bgColor = new Color(image.getRGB(10, i));        //取背景色
             for(int j = 0;j < image.getWidth();j++)
             {
                 /*
                  * 小人可能高于目标方块，为排除干扰，略过小人所在的纵坐标（列）
                  */
                 if (j >= footX - 30 && j <= footX + 30) {
                     continue;
                 }
                 Color color = new Color(image.getRGB(j, i));    //取当前颜色
                 int t = 0;
                 t = Math.abs(bgColor.getRGB() - color.getRGB());    //计算色差

                 if (t > 200000){    //如果与背景色不同
                     targetX = j;    //记录行坐标
                     targetY = i;    //记录纵坐标
                     i = bottom;        //结束外层循环
                     break;            //结束内层循环
                 }
             }
         }

         /*
          * 第二步，从顶点开始，向下扫描，找到方块占据最多列的那一行，即为目标的Y坐标
          */

         int maxLength;            //方块的直径
         int x = targetX;        //行扫描起始坐标
         int y = targetY;        //直径所在行（y坐标）

         /*
          * 如果在下面多行，该方块占据的列都相同，说明本行是中心所在行，
          * 即Y坐标就是本行。使用flag记录连续相同的行数
          */

         int flag = 0;            //不满足条件标志
         for(int i = y + 1;i < y + 101 && flag < 8;i++)        //当连续8行直径相同后，结束循环
         {
             for(int j = x;j < image.getWidth();j++)
             {
                 Color bgColor = new Color(image.getRGB(image.getWidth() - 10, i));        //取背景色
                 Color color = new Color(image.getRGB(j, i));        //取当前颜色
                 if (( Math.abs(bgColor.getRGB() - color.getRGB())) <= 703400) {        //如果与背景色颜色相近
                     if (j > x) {        //当前x坐标大于之前的x，（说明方块在本行占据的列更多）
                         x = j;            //当前x坐标赋值给x
                         targetY = i;    //直径所在行替换为当前y
                         flag = 0;
                     }else {                //当前x坐标不大于之前的x，（说明方块在本行占据的列不是最多）
                         flag++;            //此标志+1
                     }
                     break;
                 }
             }
         }
         targetY = targetY - flag;        //减去多加的flag

         /*至此，targetX与targetY寻找完毕*/
         /*
          * 用红色方块记录目标点
          */
         Graphics g = image.getGraphics();
         g.setColor(Color.RED);
         g.fillRect(targetX - 5, targetY - 5, 10, 10);
     }
 }

---恢复内容结束---