一、前言

（Java程式碼的實現是基於另外一篇部落格，我精簡了計算方法而成，參考部落格地址http://blog.csdn.net/lihushiwoa/article/details/78942322）

先說一說我的感受，之前覺得能做出做出輔助工具的技術要求一定很高，然而當自己真正分析原理並且動手實現之後發現門檻沒有那麼高。

想做這個工具首先得知道adb是什麼，其次是會一門程式語言。我瞭解adb之後瞬間覺得思路豁然開朗。

adb是Android Debug Bridge。他的作用是可以通過在計算機cmd輸入命令控制Android手機，比如馬上要用到的效果----模擬實現觸控螢幕和觸控多長時間。所以你在java程式碼裡控制adb命令是可行的。

二、思路與原理

想象一下手動能讓棋子命中下一個platform的場景：

1：測量棋子到目標座標的距離S；

2：按壓時間T=S*時間係數；（時間係數：單位位移的用時，200ms的n倍，多次嘗試的大致確認）

 然後你按螢幕時間T就可以了。

在本程式碼中我發現每個跳板的連線與豎直方向大約呈60°夾角（跳板和跳板雖然是60°，但是棋子不一定與目標是60°角關係呀？沒關係，經過測試與棋子的角度沒太大關係），所以如果我們知道棋子和目標點的距離就可以算S了。

程式碼實現也一樣：

1：adb命令截圖，存放到指定資料夾。adb命令分別是：

adb shell screencap -p /sdcard/current.png

adb pull /sdcard/current.png

2：掃描棋子的X軸座標。

圖片是一個個畫素點組成，從上往下遍歷每一行畫素點，如果某畫素點的R、G、B值在棋子的RGB值區間（R∈（50,60），G∈（53,63），B∈（95,110）），那麼可以確定該畫素點在棋子內了，然後記下這是第幾個（halmaXCount），並且計算橫座標的和halmaSum+=halmaSum（原理：多次測量取平均值，精確棋子的X軸座標）。

3：掃描目標跳板的橫座標。原理與掃描棋子相似，但又不同。

原理：由於跳板是左右對稱的，也就是說假如目標跳板的上表面是標準的菱形，那麼一旦遍歷到菱形上方的頂點，那麼該頂點的X座標就是目標跳板上表面中心的X座標。

不同之處是：遍歷完目標調班的首行畫素點便停止，（缺點：樣本空間略小，可能導致目標座標不精確，留日後優化。）。記錄每行首個畫素點的RGB值之後，在接下來的遍歷中如果發現本行與首個畫素點RGB差異太大，則認為該畫素點已經在目標跳板之內。找到所有不同於第一個畫素點的X座標求平均數，然後結束。

4：計算棋子與目標點的距離，和按壓時間。

三、ADB配置

ADB主要是Path配置，配置完，在cmd中輸入adb，如下圖便是配置成功。需要的可以去http://download.csdn.net/download/thread_cooperation/10212920下載

四、程式碼實現

注意：不要在開發工具裡跑，可能無法呼叫ADB。在cmd中是可行的。

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;  
  
/** 
 * 參考CSDN
 *  @link <a target="_blank" href="http://blog.csdn.net/lihushiwoa/article/details/78942322">http://blog.csdn.net/lihushiwoa/article/details/78942322</a> 
 *  
 * 說明：本版本是在上述參考CSDN的基礎上，精簡計算而成，目前支援解析度1920x1080的安卓機（在下沒有其他解析度的手機用於測試）
 *  
 * 跳一跳輔助 
 * @author ykq 
 */  
public class Jump {  
  
    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();  
  
    //adb指令碼
    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        = 310;  
  
    //按壓的時間係數，可根據具體情況適當調節  
    private final double        pressTimeCoefficient    = 1.37;
    
    //按壓的起始點座標，也是再來一局的起始點座標  
    private final int           swipeX                  = 550;  
  
    private final int           swipeY                  = 1580;  
  
    //棋子的寬度，從截圖中量取，自行調節  
    private final int           halmaBodyWidth          = 74;

    //csc(pi/6)
    private final static double 		proportion 				= 2/Math.sqrt(3);
    
    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;  
               }  
            }  
              
            Jump jumpjumpHelper = new Jump();  
            //執行次數  
            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);   //Halma跳棋
                if (result == null){  
                    System.out.println("The result of method getHalmaAndBoardXYValue is null!");  
                    continue;  
                }  
                int halmaX = result[0];  
                int boardX = result[1];  
                System.out.println("halmaX: " + halmaX + "  ****  " + "boardX: " + boardX);  
                //計算跳躍的距離  
                double jumpDistance = Math.abs(boardX-halmaX)*proportion;
                jumpjumpHelper.doJump(jumpDistance);  
                //每次停留2.5秒  
                TimeUnit.MILLISECONDS.sleep(2500);  
            }  
        }  
        catch (Exception e){  
            e.printStackTrace();  
        }  
    } 
  
    /** 
     * 獲取跳棋以及下一塊跳板的中心座標 
     * 
     * @return 
     * @throws IOException 
     */  
    public 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 boardX = 0;  
        //從截圖從上往下逐行遍歷畫素點，以棋子顏色作為位置識別的依據，最終取出棋子顏色最低行所有畫素點的平均值，即計算出棋子所在的座標  
        for (int y = gameScoreBottomY; y < height; y++){  
            for (int x = 0; x < width; x++){  
                processRGBInfo(bufferedImage, x, y);  //獲取指定座標的RGB值 
                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++;  
                }  
            }  
        }  
  
        if (halmaXSum != 0 && halmaXCount != 0){  
            //棋子底行的X座標值  
            int halmaX = halmaXSum / halmaXCount;  
            
            //從gameScoreBottomY開始，獲取棋子的x座標
            for (int y = gameScoreBottomY; y < height; y++){  
                processRGBInfo(bufferedImage, 0, y);  //每行第一個畫素的RGB（獲取指定座標的RGB值 ）
                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();  
                    //處理棋子頭部比下一個跳板還高的情況      跳過棋子所在的x軸區域不遍歷（防止檢索到棋子的顏色）
                    if (Math.abs(x - halmaX) < halmaBodyWidth){    //abs絕對值
                        continue;  
                    }  
  
                    //從上往下逐行掃描至下一個跳板的頂點位置，下個跳板可能為圓形，也可能為方框，取多個點，求平均值  
                    if ((Math.abs(pixelR - lastPixelR) + Math.abs(pixelG - lastPixelG) + Math.abs(pixelB - lastPixelB)) > 8){   
                        boardXSum += x;  
                        boardXCount++;  
                    }  
                }  
  
                if (boardXSum > 0){  
                    boardX = boardXSum / boardXCount;  
                }  
            }  
  
            if (boardX > 0){  
                int[] result = new int[2];  
                //棋子的X座標  
                result[0] = halmaX;  
                //下一塊跳板的X座標    
                result[1] = boardX;  
                return result;  
            }  
        }  
  
        return null;  
    }  
  
    /** 
     * 執行命令 
     * 
     * @param command 
     */  
    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獲取安卓截圖 
     */  
    public void executeADBCaptureCommands(){  
        for (String command : ADB_SCREEN_CAPTURE_CMDS)  
        {  
            executeCommand(command);  
        }  
    }  
  
    /** 
     * 跳一下 
     * 
     * @param distance 
     */  
    public 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);  
        System.out.println();
        System.out.println();
    }  
  
    /** 
     * 再來一局 
     */  
    private void replayGame(){  
        String command = String.format("adb shell input tap %s %s", swipeX, swipeY);  //adb shell模擬點選事件 input
        executeCommand(command);  
    }  
  
    /** 
     * 檢查是否需要重新開局 
     */  
    public 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 
     */  
    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));  
    }  
  
    
    /**************************  RGBInfo  ****************************/
    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;  
        }  
    }  
}