微信跳一跳刷分java代码实现

朋友圈晒跳一跳成绩好久了，今天无意中看到以前一个同事小妞晒用代码刷分的视频，百度了一下果然看到了代码（代码在最后），几经波折，终于成功运行，刷了一点分数。

首先大概说一下步骤：

1.百度下载刷分代码

2.安装adb

3.找个手机使用usb调试模式连接电脑

4.启动跳一跳微信小程序

5.在eclipse中运行代码（此处要不断调试根据手机屏幕大小修改参数）

结果就是你的手机屏幕会自动按压然后让棋子跳。

再说下问题：

一、安装adb问题集：

下载adb工具

在此处的设备管理器中，如果没有安装在其他设备这里，adb就是一个感叹号，安装完毕后如图所示，会出现android device 这一行

安装的话在adb一栏里右击选择属性，弹出如下界面，点击更新驱动程序，选择浏览计算机选择程序（也就是第二个选项），此时会弹出一个浏览计算机上的驱动程序选项，选择安装包所在地，然后一切放行，就能安装。

问题来了：

安装完后，你在cmd命令窗口下能使用adb，但是在eclipse中运行代码完全没有效果（程序不报错，手机里也没有截图）,然后eclipse控制台就显示图片不存在，

此时需要把你安装好的一个exe程序，两个动态链接库dll拷贝到如下两个目录下：（找不到就在c盘全局搜一下）

adb.exe

adbwinapi.dll

adbwinusbapi.dll

c:\windows\system32

c:\windows\syswow64

此时一定要放在syswow64下，我是win7 64位，所以有这个目录（网上其他人说win32就不需要放这个了，我没试过），

如果没有放syswow64目录，此时eclipse运行依旧没有效果：但如果你在cmd中运行adb shell screencap -p /sdcard/tencent/customerpic/current.png这条命令，发现手机里面会有current.png图片，这说明eclipse没有找到对应的adb工具。

我找出这个问题是通过cd到system32和安装目录（c:\program files (x86)\thunder network\thunder\program）下，我在program中运行上述命令成功，在system32中运行报错：

---------------------------adb.exe - 系统错误---------------------------

无法启动此程序，因为计算机中丢失 adbwinapi.dll。尝试重新安装该程序以解决此问题。 

---------------------------

确定   

---------------------------

ok，这说明system32中的adb找不到adbwinapi.dll动态链接文件，但明明就有，机缘巧合之下，老夫看到了syswow64这个目录，然后百度这个目录是什么意思，什么作用，ok，将拷贝到system32目录下的三个文件再次拷贝一份到此syswow64目录下，搞定。

问题二：device offline

在cmd命令窗口运行adb shell结果报错device offline，我以为是我adb安装有问题，百度了一大堆，试过adb kill server，adb remount等命令都没用，后来换了发现代码里面是/sdcard/，一看这应该是外置sd卡吧，是不是路径不对，（我用的是vivo x9，这手机没有外置sd卡选项），换了旧一点的手机（vivo y27）后运行adb shell可以了，不过/sdcard不是外置sd卡路径，而是手机u盘路径。

那么就说明不应该是代码路径问题，又是百度了一番,被告知是adb工具太老，adb version得到版本 1.0.26，好吧，我也懒得去找新版adb，用老的vivo y27调试了下能刷就行。

列举一下我学到的：

1.知道有adb这东西，也知道使用adb shell可以得到手机的bash会话，可以截图，使用adb pull可以从手机里面得到文件，更多命令的话官网有，我看多了也记不住。

2.知道原来代码里面java使用runtime.getruntime().exec()可以在windows中调用系统命令：

process = runtime.getruntime().exec(command); 
 system.out.println("exec command start: " + command); 
 process.waitfor(); 
 process.getinputstream(); 
 bufferedreader bufferedreader = new bufferedreader(new inputstreamreader(process.geterrorstream())); 
 string line = bufferedreader.readline(); 

3.明白代码中通过计算截图的rgb颜色值等分析一张图片int pixel = bufferedimage.getrgb(x, y);

全部代码：

package com.lw.test; 
 
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 <a href="https://zhuanlan.zhihu.com/p/32452473" rel="external nofollow" target="_blank">https://zhuanlan.zhihu.com/p/32452473</a> 
 * 
 * 跳一跳辅助 
 * 
 * @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 path = "/sdcard/tencent/customerpic/"; 
 private final string[] adb_screen_capture_cmds = 
  {"adb shell screencap -p "+path + image_name, 
 "adb pull "+path+"current.png " + store_dir }; 
 
 //截屏中游戏分数显示区域最下方的y坐标，300是 1920x1080的值，根据实际情况修改 
 private final int gamescorebottomy = 300; 
 
 //按压的时间系数，可根据具体情况适当调节 
 private final double presstimecoefficient = 2.05; 
 
 //按压的起始点坐标，也是再来一局的起始点坐标 
 private final int swipex = 280; 
 
 private final int swipey = 600; 
 
 //二分之一的棋子底座高度 
 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(); 
 process.getinputstream(); 
 bufferedreader bufferedreader = new bufferedreader(new inputstreamreader(process.geterrorstream())); 
 string line = bufferedreader.readline(); 
 if (line != null) 
 { 
 system.out.println(line); 
 } 
 bufferedreader = new bufferedreader(new inputstreamreader(process.getinputstream())); 
 string line02 = bufferedreader.readline(); 
 if (line02 != null) 
 { 
 system.out.println(line02); 
 } 
 
 
 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) 
 { 
 
 
 jumpjumphelper jumpjumphelper = new jumpjumphelper(); 
// string command = "adb shell screencap -p "+jumpjumphelper.path + image_name; 
//// command = "adb devices"; 
// jumpjumphelper.executecommand(command); 
// 
// if(true){return ;} 
 
 
 
 try 
 { 
 file storedir = new file(store_dir); 
 if (!storedir.exists()) { 
 boolean flag = storedir.mkdir(); 
 if (!flag) { 
 system.err.println("创建图片存储目录失败"); 
 return; 
 } 
 } 
 
 //执行次数 
 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; 
 } 
 } 
} 

当然，现在刷了一会就被清空成绩，但作为一个程序员知道还是好的。从一开始的post提交漏洞，让电脑作为代理抓包修改数据，现在代码模拟点击（虽然不会生效。）

更多内容大家可以参考专题《微信跳一跳》进行学习。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。