这篇文章主要介绍Java如何实现微信跳一跳辅助，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！

专注于为中小企业提供网站设计制作、成都网站设计服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业南华免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上千家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

环境配置及相关说明：

1）、Windows系统，本人win10
2）、AVA环境安装，JDK7以上即可
3）、安卓手机一部、数据线一条
4）、电脑安装ADB驱动，连接安卓手机，同时打开USB调试模式
5）、打开微信小程序的跳一跳游戏，JAVA程序跑起来，具体代码往下看
6）、本人所用为魅蓝note2安卓手机，屏幕 分辨率1920x1080，不同型号的手机，可能需要调整相关参数，具体看代码注释
7）、增加了刷分失败后游戏自动重新开局功能
8）、娱乐而已，不要较真，据说微信官方已经关注，分数太高可能会被清零，哈哈

上代码：

package com.yihusitian.gamehelper; 
 
import java.awt.image.BufferedImage; 
import java.io.BufferedReader; 
import java.io.File; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Arrays; 
import java.util.concurrent.TimeUnit; 
 
import javax.imageio.ImageIO; 
 
/** 
 * 参考知乎 
 * 
 * @link https://zhuanlan.zhihu.com/p/32452473 
 * 
 * 跳一跳辅助 
 * 
 * @author LeeHo 
 */ 
public class JumpJumpHelper 
{ 
 
 private static final String IMAGE_NAME    = "current.png"; 
 
 private static final String STORE_DIR    = "d:/jump_screencapture"; 
 
 //数量 
 private static final int imageLengthLength  = 5; 
 
 //存放图片的大小 
 private static final long[] imageLength    = new long[imageLengthLength]; 
 
 private final RGBInfo  rgbInfo     = new RGBInfo(); 
 
 private final String[]  ADB_SCREEN_CAPTURE_CMDS = 
              { "adb shell screencap -p /sdcard/" + IMAGE_NAME, 
   "adb pull /sdcard/current.png " + STORE_DIR }; 
 
 //截屏中游戏分数显示区域最下方的Y坐标，300是 1920x1080的值，根据实际情况修改 
 private final int   gameScoreBottomY  = 300; 
 
 //按压的时间系数，可根据具体情况适当调节 
 private final double  pressTimeCoefficient = 1.35; 
 
 //按压的起始点坐标，也是再来一局的起始点坐标 
 private final int   swipeX     = 550; 
 
 private final int   swipeY     = 1580; 
 
 //二分之一的棋子底座高度 
 private final int   halfBaseBoardHeight  = 20; 
 
 //棋子的宽度，从截屏中量取，自行调节 
 private final int   halmaBodyWidth   = 74; 
 
 //游戏截屏里的两个跳板的中点坐标，主要用来计算角度，可依据实际的截屏计算，计算XY的比例 
 private final int   boardX1     = 813; 
 
 private final int   boardY1     = 1122; 
 
 private final int   boardX2     = 310; 
 
 private final int   boardY2     = 813; 
 
 /** 
  * 获取跳棋以及下一块跳板的中心坐标 
  * 
  * @return 
  * @author LeeHo 
  * @throws IOException 
  * @update 2017年12月31日 下午12:18:22 
  */ 
 private int[] getHalmaAndBoardXYValue(File currentImage) throws IOException 
 { 
  BufferedImage bufferedImage = ImageIO.read(currentImage); 
  int width = bufferedImage.getWidth(); 
  int height = bufferedImage.getHeight(); 
  System.out.println("宽度：" + width + "，高度：" + height); 
  int halmaXSum = 0; 
  int halmaXCount = 0; 
  int halmaYMax = 0; 
  int boardX = 0; 
  int boardY = 0; 
  //从截屏从上往下逐行遍历像素点，以棋子颜色作为位置识别的依据，最终取出棋子颜色最低行所有像素点的平均值，即计算出棋子所在的坐标 
  for (int y = gameScoreBottomY; y < height; y++) 
  { 
   for (int x = 0; x < width; x++) 
   { 
    processRGBInfo(bufferedImage, x, y); 
    int rValue = this.rgbInfo.getRValue(); 
    int gValue = this.rgbInfo.getGValue(); 
    int bValue = this.rgbInfo.getBValue(); 
    //根据RGB的颜色来识别棋子的位置， 
    if (rValue > 50 && rValue < 60 && gValue > 53 && gValue < 63 && bValue > 95 && bValue < 110) 
    { 
     halmaXSum += x; 
     halmaXCount++; 
     //棋子底行的Y坐标值 
     halmaYMax = y > halmaYMax ? y : halmaYMax; 
    } 
   } 
  } 
 
  if (halmaXSum != 0 && halmaXCount != 0) 
  { 
   //棋子底行的X坐标值 
   int halmaX = halmaXSum / halmaXCount; 
   //上移棋子底盘高度的一半 
   int halmaY = halmaYMax - halfBaseBoardHeight; 
   //从gameScoreBottomY开始 
   for (int y = gameScoreBottomY; y < height; y++) 
   { 
    processRGBInfo(bufferedImage, 0, y); 
    int lastPixelR = this.rgbInfo.getRValue(); 
    int lastPixelG = this.rgbInfo.getGValue(); 
    int lastPixelB = this.rgbInfo.getBValue(); 
    //只要计算出来的boardX的值大于0，就表示下个跳板的中心坐标X值取到了。 
    if (boardX > 0) 
    { 
     break; 
    } 
    int boardXSum = 0; 
    int boardXCount = 0; 
    for (int x = 0; x < width; x++) 
    { 
     processRGBInfo(bufferedImage, x, y); 
     int pixelR = this.rgbInfo.getRValue(); 
     int pixelG = this.rgbInfo.getGValue(); 
     int pixelB = this.rgbInfo.getBValue(); 
     //处理棋子头部比下一个跳板还高的情况 
     if (Math.abs(x - halmaX) < halmaBodyWidth) 
     { 
      continue; 
     } 
 
     //从上往下逐行扫描至下一个跳板的顶点位置，下个跳板可能为圆形，也可能为方框，取多个点，求平均值 
     if ((Math.abs(pixelR - lastPixelR) + Math.abs(pixelG - lastPixelG) + Math.abs(pixelB - lastPixelB)) > 10) 
     { 
      boardXSum += x; 
      boardXCount++; 
     } 
    } 
 
    if (boardXSum > 0) 
    { 
     boardX = boardXSum / boardXCount; 
    } 
   } 
 
   //按实际的角度来算，找到接近下一个 board 中心的坐标 
   boardY = (int) (halmaY - Math.abs(boardX - halmaX) * Math.abs(boardY1 - boardY2) 
     / Math.abs(boardX1 - boardX2)); 
   if (boardX > 0 && boardY > 0) 
   { 
    int[] result = new int[4]; 
    //棋子的X坐标 
    result[0] = halmaX; 
    //棋子的Y坐标 
    result[1] = halmaY; 
    //下一块跳板的X坐标 
    result[2] = boardX; 
    //下一块跳板的Y坐标 
    result[3] = boardY; 
    return result; 
   } 
  } 
 
  return null; 
 } 
 
 /** 
  * 执行命令 
  * 
  * @param command 
  * @author LeeHo 
  * @update 2017年12月31日 下午12:13:39 
  */ 
 private void executeCommand(String command) 
 { 
  Process process = null; 
  try 
  { 
   process = Runtime.getRuntime().exec(command); 
   System.out.println("exec command start: " + command); 
   process.waitFor(); 
   BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getErrorStream())); 
   String line = bufferedReader.readLine(); 
   if (line != null) 
   { 
    System.out.println(line); 
   } 
   System.out.println("exec command end: " + command); 
  } 
  catch (Exception e) 
  { 
   e.printStackTrace(); 
  } 
  finally 
  { 
   if (process != null) 
   { 
    process.destroy(); 
   } 
  } 
 } 
 
 /** 
  * ADB获取安卓截屏 
  * 
  * @author LeeHo 
  * @update 2017年12月31日 下午12:11:42 
  */ 
 private void executeADBCaptureCommands() 
 { 
  for (String command : ADB_SCREEN_CAPTURE_CMDS) 
  { 
   executeCommand(command); 
  } 
 } 
 
 /** 
  * 跳一下 
  * 
  * @param distance 
  * @author LeeHo 
  * @update 2017年12月31日 下午12:23:19 
  */ 
 private void doJump(double distance) 
 { 
  System.out.println("distance: " + distance); 
  //计算按压时间，最小200毫秒 
  int pressTime = (int) Math.max(distance * pressTimeCoefficient, 200); 
  System.out.println("pressTime: " + pressTime); 
  //执行按压操作 
  String command = String.format("adb shell input swipe %s %s %s %s %s", swipeX, swipeY, swipeX, swipeY, 
    pressTime); 
  System.out.println(command); 
  executeCommand(command); 
 } 
 
 /** 
  * 再来一局 
  * 
  * @author LeeHo 
  * @update 2017年12月31日 下午12:47:06 
  */ 
 private void replayGame() 
 { 
  String command = String.format("adb shell input tap %s %s", swipeX, swipeY); 
  executeCommand(command); 
 } 
 
 /** 
  * 计算跳跃的距离，也即两个点之间的距离 
  * 
  * @param halmaX 
  * @param halmaY 
  * @param boardX 
  * @param boardY 
  * @return 
  * @author LeeHo 
  * @update 2017年12月31日 下午12:27:30 
  */ 
 private double computeJumpDistance(int halmaX, int halmaY, int boardX, int boardY) 
 { 
  return Math.sqrt(Math.pow(Math.abs(boardX - halmaX), 2) + Math.pow(Math.abs(boardY - halmaY), 2)); 
 } 
 
 public static void main(String[] args) 
 { 
  try 
  { 
   File storeDir = new File(STORE_DIR); 
   if (!storeDir.exists()) { 
    boolean flag = storeDir.mkdir(); 
    if (!flag) { 
     System.err.println("创建图片存储目录失败"); 
     return; 
    } 
   } 
    
   JumpJumpHelper jumpjumpHelper = new JumpJumpHelper(); 
   //执行次数 
   int executeCount = 0; 
   for (;;) 
   { 
    //执行ADB命令，获取安卓截屏 
    jumpjumpHelper.executeADBCaptureCommands(); 
    File currentImage = new File(STORE_DIR, IMAGE_NAME); 
    if (!currentImage.exists()) 
    { 
     System.out.println("图片不存在"); 
     continue; 
    } 
 
    long length = currentImage.length(); 
    imageLength[executeCount % imageLengthLength] = length; 
    //查看是否需要重新开局 
    jumpjumpHelper.checkDoReplay(); 
    executeCount++; 
    System.out.println("当前第" + executeCount + "次执行!"); 
    //获取跳棋和底板的中心坐标 
    int[] result = jumpjumpHelper.getHalmaAndBoardXYValue(currentImage); 
    if (result == null) 
    { 
     System.out.println("The result of method getHalmaAndBoardXYValue is null!"); 
     continue; 
    } 
    int halmaX = result[0]; 
    int halmaY = result[1]; 
    int boardX = result[2]; 
    int boardY = result[3]; 
    System.out.println("halmaX: " + halmaX + ", halmaY: " + halmaY + ", boardX: " + boardX + ", boardY: " 
      + boardY); 
    //计算跳跃的距离 
    double jumpDistance = jumpjumpHelper.computeJumpDistance(halmaX, halmaY, boardX, boardY); 
    jumpjumpHelper.doJump(jumpDistance); 
    //每次停留2.5秒 
    TimeUnit.MILLISECONDS.sleep(2500); 
   } 
  } 
  catch (Exception e) 
  { 
   e.printStackTrace(); 
  } 
 } 
 
 /** 
  * 检查是否需要重新开局 
  * 
  * @author LeeHo 
  * @update 2017年12月31日 下午1:39:18 
  */ 
 private void checkDoReplay() 
 { 
  if (imageLength[0] > 0 && imageLength[0] == imageLength[1] && imageLength[1] == imageLength[2] 
    && imageLength[2] == imageLength[3] && imageLength[3] == imageLength[4]) 
  { 
   //此时表示已经连续5次图片大小一样了，可知当前屏幕处于再来一局 
   Arrays.fill(imageLength, 0); 
   //模拟点击再来一局按钮重新开局 
   replayGame(); 
  } 
 } 
 
 /** 
  * 获取指定坐标的RGB值 
  * 
  * @param bufferedImage 
  * @param x 
  * @param y 
  * @author LeeHo 
  * @update 2017年12月31日 下午12:12:43 
  */ 
 private void processRGBInfo(BufferedImage bufferedImage, int x, int y) 
 { 
  this.rgbInfo.reset(); 
  int pixel = bufferedImage.getRGB(x, y); 
  //转换为RGB数字 
  this.rgbInfo.setRValue((pixel & 0xff0000) >> 16); 
  this.rgbInfo.setGValue((pixel & 0xff00) >> 8); 
  this.rgbInfo.setBValue((pixel & 0xff)); 
 } 
 
 class RGBInfo 
 { 
  private int RValue; 
 
  private int GValue; 
 
  private int BValue; 
 
  public int getRValue() 
  { 
   return RValue; 
  } 
 
  public void setRValue(int rValue) 
  { 
   RValue = rValue; 
  } 
 
  public int getGValue() 
  { 
   return GValue; 
  } 
 
  public void setGValue(int gValue) 
  { 
   GValue = gValue; 
  } 
 
  public int getBValue() 
  { 
   return BValue; 
  } 
 
  public void setBValue(int bValue) 
  { 
   BValue = bValue; 
  } 
 
  public void reset() 
  { 
   this.RValue = 0; 
   this.GValue = 0; 
   this.BValue = 0; 
  } 
 } 
}

以上是“Java如何实现微信跳一跳辅助”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注创新互联行业资讯频道！

分享题目：Java如何实现微信跳一跳辅助
当前地址：http://scgulin.cn/article/phocgd.html