世界快看点丨跳一跳j算法ava代码是什么？微信跳一跳辅助的Java实现代码

微信跳一跳辅助的Java具体实现代码，供大家参考，具体内容如下

1.参考知乎教你用Python来玩微信跳一跳，鉴于本人Python一直都是半吊子水平，之前打算用python刷分，可无奈安装python环境各种模块缺失，报错不停，于是乎，使用Java重新实现了一下。

2.环境配置及相关说明：

(资料图)

1)、Windows系统，本人win10

2)、AVA环境安装，JDK7以上即可

3)、安卓手机一部、数据线一条

4)、电脑安装ADB驱动，连接安卓手机，同时打开USB调试模式

5)、打开微信小程序的跳一跳游戏，JAVA程序跑起来，具体代码往下看

6)、本人所用为魅蓝note2安卓手机，屏幕 分辨率1920x1080，不同型号的手机，可能需要调整相关参数，具体看代码注释

7)、增加了刷分失败后游戏自动重新开局功能

8)、娱乐而已，不要较真，据说微信官方已经关注，分数太高可能会被清零，哈哈

3、废话不多说，上代码：

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;

}

}

}

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

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