在上一篇《我的Android進階之旅------>Android瘋狂連連看游戲的實現之加載界面圖片和實現游戲Activity(四)》中提到的兩個類：
GameConf:負責管理游戲的初始化設置信息。
GameService：負責游戲的邏輯實現。
其中GameConf的代碼如下：cn/oyp/link/utils/GameConf.java
package cn.oyp.link.utils; import android.content.Context; /** * 保存游戲配置的對象 <br/> * <br/> * 關于本代碼介紹可以參考一下博客: 歐陽鵬的CSDN博客</a> <br/> */ public class GameConf { /** * 連連看的每個方塊的圖片的寬 */ public static final int PIECE_WIDTH = 40; /** * 連連看的每個方塊的圖片的高s */ public static final int PIECE_HEIGHT = 40; /** * 記錄游戲的總事件（100秒）. */ public static int DEFAULT_TIME = 100; /** * Piece[][]數組第一維的長度 */ private int xSize; /** * Piece[][]數組第二維的長度 */ private int ySize; /** * Board中第一張圖片出現的x座標 */ private int beginImageX; /** * Board中第一張圖片出現的y座標 */ private int beginImageY; /** * 記錄游戲的總時間, 單位是秒 */ private long gameTime; /** * 應用上下文 */ private Context context; /** * 提供一個參數構造器 * * @param xSize * Piece[][]數組第一維長度 * @param ySize * Piece[][]數組第二維長度 * @param beginImageX * Board中第一張圖片出現的x座標 * @param beginImageY * Board中第一張圖片出現的y座標 * @param gameTime * 設置每局的時間, 單位是豪秒 * @param context * 應用上下文 */ public GameConf(int xSize, int ySize, int beginImageX, int beginImageY, long gameTime, Context context) { this.xSize = xSize; this.ySize = ySize; this.beginImageX = beginImageX; this.beginImageY = beginImageY; this.gameTime = gameTime; this.context = context; } /** * @return 游戲的總時間 */ public long getGameTime() { return gameTime; } /** * @return Piece[][]數組第一維的長度 */ public int getXSize() { return xSize; } /** * @return Piece[][]數組第二維的長度 */ public int getYSize() { return ySize; } /** * @return Board中第一張圖片出現的x座標 */ public int getBeginImageX() { return beginImageX; } /** * @return Board中第一張圖片出現的y座標 */ public int getBeginImageY() { return beginImageY; } /** * @return 應用上下文 */ public Context getContext() { return context; } } 而GameService則是整個游戲邏輯實現的核心，而且GameService是一個可以復用的業務邏輯類，它于游戲平臺無關，既可以在Java Swing中使用，也可以在Android游戲中使用，甚至只要稍作修改，GameService也可以移植到C#平臺的連連看游戲中。
考慮到程序的可擴展行，先給GameService組件定義一個接口，代碼如下：cn/oyp/link/board/GameService.java
package cn.oyp.link.board; import cn.oyp.link.utils.LinkInfo; import cn.oyp.link.view.Piece; /** * 游戲邏輯接口 <br/> * <br/> * 關于本代碼介紹可以參考一下博客: 歐陽鵬的CSDN博客</a> <br/> */ public interface GameService { /** * 控制游戲開始的方法 */ public void start(); /** * 定義一個接口方法, 用于返回一個二維數組 * * @return 存放方塊對象的二維數組 */ public Piece[][] getPieces(); /** * 判斷參數Piece[][]數組中是否還存在非空的Piece對象 * * @return 如果還剩Piece對象返回true, 沒有返回false */ public boolean hasPieces(); /** * 根據鼠標的x座標和y座標, 查找出一個Piece對象 * * @param touchX * 鼠標點擊的x座標 * @param touchY * 鼠標點擊的y座標 * @return 返回對應的Piece對象, 沒有返回null */ public Piece findPiece(float touchX, float touchY); /** * 判斷兩個Piece是否可以相連, 可以連接, 返回LinkInfo對象 * * @param p1 * 第一個Piece對象 * @param p2 * 第二個Piece對象 * @return 如果可以相連，返回LinkInfo對象, 如果兩個Piece不可以連接, 返回null */ public LinkInfo link(Piece p1, Piece p2); } 下面來具體實現GameService組件，首先的public void start()方法，public Piece[][] getPieces()方法和public boolean hasPieces()方法很容易實現，具體實現如下：cn/oyp/link/board/impl/GameServiceImpl.java
/** * 游戲邏輯的實現類 <br/> * <br/> * 關于本代碼介紹可以參考一下博客: 歐陽鵬的CSDN博客</a> <br/> */ public class GameServiceImpl implements GameService { /** * 定義一個Piece[][]數組 */ private Piece[][] pieces; /** * 游戲配置對象 */ private GameConf config; /** * 構造方法 * * @param config * 游戲配置對象 */ public GameServiceImpl(GameConf config) { // 將游戲的配置對象設置本類中 this.config = config; } @Override public void start() { // 定義一個AbstractBoard對象 AbstractBoard board = null; Random random = new Random(); // 獲取一個隨機數, 可取值0、1、2、3四值。 int index = random.nextInt(4); // 隨機生成AbstractBoard的子類實例 switch (index) { case 0: // 0返回VerticalBoard(豎向) board = new VerticalBoard(); break; case 1: // 1返回HorizontalBoard(橫向) board = new HorizontalBoard(); break; default: // 默認返回FullBoard board = new FullBoard(); break; } // 初始化Piece[][]數組 this.pieces = board.create(config); } @Override public Piece[][] getPieces() { return this.pieces; } @Override public boolean hasPieces() { // 遍歷Piece[][]數組的每個元素 for (int i = 0; i < pieces.length; i++) { for (int j = 0; j < pieces[i].length; j++) { // 只要任意一個數組元素不為null，也就是還剩有非空的Piece對象 if (pieces[i][j] != null) { return true; } } } return false; } ... } 1、獲取觸碰點的方塊
首先當用戶碰觸游戲界面時，事件監聽器獲取的是該觸碰到在游戲界面上的X、Y坐標，但是程序需要的是獲取用戶碰觸的到底是那個方塊，因此程序必須把界面上的X、Y坐標換算成在Piece[][]二維數組中的兩個索引值?？紤]到游戲界面上每個方塊的高度和寬度都是相同的，因此想要將界面上的X、Y坐標換算成Piece[][]二維數組中的索引也比較簡單，只要拿X、Y坐標值除以圖片的寬、高即可。下面是根據觸點X、Y坐標獲取對于方塊的代碼：
/** * 根據觸碰點的位置查找相應的方塊 */ @Override public Piece findPiece(float touchX, float touchY) { /* * 由于在創建Piece對象的時候, 將每個Piece的開始座標加了 * GameConf中設置的beginImageX、beginImageY值, 因此這里要減去這個值 */ int relativeX = (int) touchX - this.config.getBeginImageX(); int relativeY = (int) touchY - this.config.getBeginImageY(); /* * 如果鼠標點擊的地方比board中第一張圖片的開始x座標和開始y座標要小, 即沒有找到相應的方塊 */ if (relativeX < 0 || relativeY < 0) { return null; } /* * 獲取relativeX座標在Piece[][]數組中的第一維的索引值 ，第二個參數為每張圖片的寬 */ int indexX = getIndex(relativeX, GameConf.PIECE_WIDTH); /* * 獲取relativeY座標在Piece[][]數組中的第二維的索引值 ，第二個參數為每張圖片的高 */ int indexY = getIndex(relativeY, GameConf.PIECE_HEIGHT); // 這兩個索引比數組的最小索引還小, 返回null if (indexX < 0 || indexY < 0) { return null; } // 這兩個索引比數組的最大索引還大(或者等于), 返回null if (indexX >= this.config.getXSize() || indexY >= this.config.getYSize()) { return null; } // 返回Piece[][]數組的指定元素 return this.pieces[indexX][indexY]; } 上面的方法調用了getIndex(int relative,int size)方法，該方法的實現就是拿relative除以size,程序需要判斷可以整除和不能整除兩種情況：如果可以整除，說明還在前一個方塊內；如果不能整除，則對于于下一個方塊，下面是getIndex(int relative,int size)方法的代碼：
/** * 工具方法：計算相對于Piece[][]數組的第一維 或第二維的索引值 * * @param relative * 座標 * @param size * 每張圖片邊的長或者寬 * @return */ private int getIndex(int relative, int size) { // 表示座標relative不在該數組中，數組下標從0開始 int index = -1; /* * 讓座標除以邊長, 沒有余數, 索引減1， 例如點了x座標為20, 邊寬為10, 20 % 10 沒有余數, index為1, * 即在數組中的索引為1(第二個元素) */ if (relative % size == 0) { index = relative / size - 1; } else { /* * 有余數, 例如點了x座標為21, 邊寬為10, 21 % 10有余數, index為2， 即在數組中的索引為2(第三個元素) */ index = relative / size; } return index; } 2、判斷兩個方塊是否可以相連
兩個方塊可以相連的情況可以大致分為以下幾種：
下面的link(Piece p1, Piece p2)方法把這四種情況分開進行處理，代碼如下：
@Override public LinkInfo link(Piece p1, Piece p2) { // 兩個Piece是同一個, 即選中了同一個方塊, 返回null if (p1.equals(p2)) return null; // 如果p1的圖片與p2的圖片不相同, 則返回null if (!p1.isSameImage(p2)) return null; // 如果p2在p1的左邊, 則需要重新執行本方法, 兩個參數互換 if (p2.getIndexX() < p1.getIndexX()) return link(p2, p1); // 獲取p1的中心點 Point p1Point = p1.getCenter(); // 獲取p2的中心點 Point p2Point = p2.getCenter(); // 情況1：如果兩個Piece在同一行，并且可以直接相連 if (p1.getIndexY() == p2.getIndexY()) { // 它們在同一行并可以相連 if (!isXBlock(p1Point, p2Point, GameConf.PIECE_WIDTH)) { // 它們之間沒有真接障礙, 沒有轉折點 return new LinkInfo(p1Point, p2Point); } } // 情況2：如果兩個Piece在同一列，并且可以直接相連 if (p1.getIndexX() == p2.getIndexX()) { if (!isYBlock(p1Point, p2Point, GameConf.PIECE_HEIGHT)) { // 它們之間沒有真接障礙, 沒有轉折點 return new LinkInfo(p1Point, p2Point); } } /* * 情況3：兩個Piece以兩條線段相連，也就是有一個轉折點的情況。 獲取兩個點的直角相連的點, 即只有一個轉折點 */ Point cornerPoint = getCornerPoint(p1Point, p2Point, GameConf.PIECE_WIDTH, GameConf.PIECE_HEIGHT); // 它們之間有一個轉折點 if (cornerPoint != null) { return new LinkInfo(p1Point, cornerPoint, p2Point); } /* * 情況4：兩個Piece以三條線段相連，有兩個轉折點的情況。 該map的key存放第一個轉折點, * value存放第二個轉折點,map的size()說明有多少種可以連的方式 */ Map<Point, Point> turns = getLinkPoints(p1Point, p2Point, GameConf.PIECE_WIDTH, GameConf.PIECE_WIDTH); // 它們之間有轉折點 if (turns.size() != 0) { // 獲取p1和p2之間最短的連接信息 return getShortcut(p1Point, p2Point, turns, getDistance(p1Point, p2Point)); } return null; } 3、定義獲取通道的方法
所謂通道，指的是一個方塊上、下、左、右四個方向上的空白方塊，如下圖所示：
下面是獲取某個坐標點四周通道的四個方法：
/** * 給一個Point對象,返回它的左邊通道 * * @param p * @param pieceWidth * piece圖片的寬 * @param min * 向左遍歷時最小的界限 * @return 給定Point左邊的通道 */ private List<Point> getLeftChanel(Point p, int min, int pieceWidth) { List<Point> result = new ArrayList<Point>(); // 獲取向左通道, 由一個點向左遍歷, 步長為Piece圖片的寬 for (int i = p.x - pieceWidth; i >= min; i = i - pieceWidth) { // 遇到障礙, 表示通道已經到盡頭, 直接返回 if (hasPiece(i, p.y)) { return result; } result.add(new Point(i, p.y)); } return result; } /** * 給一個Point對象, 返回它的右邊通道 * * @param p * @param pieceWidth * @param max * 向右時的最右界限 * @return 給定Point右邊的通道 */ private List<Point> getRightChanel(Point p, int max, int pieceWidth) { List<Point> result = new ArrayList<Point>(); // 獲取向右通道, 由一個點向右遍歷, 步長為Piece圖片的寬 for (int i = p.x + pieceWidth; i <= max; i = i + pieceWidth) { // 遇到障礙, 表示通道已經到盡頭, 直接返回 if (hasPiece(i, p.y)) { return result; } result.add(new Point(i, p.y)); } return result; } /** * 給一個Point對象, 返回它的上面通道 * * @param p * @param min * 向上遍歷時最小的界限 * @param pieceHeight * @return 給定Point上面的通道 */ private List<Point> getUpChanel(Point p, int min, int pieceHeight) { List<Point> result = new ArrayList<Point>(); // 獲取向上通道, 由一個點向右遍歷, 步長為Piece圖片的高 for (int i = p.y - pieceHeight; i >= min; i = i - pieceHeight) { // 遇到障礙, 表示通道已經到盡頭, 直接返回 if (hasPiece(p.x, i)) { // 如果遇到障礙, 直接返回 return result; } result.add(new Point(p.x, i)); } return result; } /** * 給一個Point對象, 返回它的下面通道 * * @param p * @param max * 向上遍歷時的最大界限 * @return 給定Point下面的通道 */ private List<Point> getDownChanel(Point p, int max, int pieceHeight) { List<Point> result = new ArrayList<Point>(); // 獲取向下通道, 由一個點向右遍歷, 步長為Piece圖片的高 for (int i = p.y + pieceHeight; i <= max; i = i + pieceHeight) { // 遇到障礙, 表示通道已經到盡頭, 直接返回 if (hasPiece(p.x, i)) { // 如果遇到障礙, 直接返回 return result; } result.add(new Point(p.x, i)); } return result; } 上面調用到的hasPiece(int x, int y)方法是判斷GamePanel中的x, y座標中是否有Piece對象的，代碼如下：
/** * 判斷GamePanel中的x, y座標中是否有Piece對象 * * @param x * @param y * @return true 表示有該座標有piece對象 false 表示沒有 */ private boolean hasPiece(int x, int y) { if (findPiece(x, y) == null) return false; return true; } 4、沒有轉折點的橫向連接
如果兩個Piece對象在Piece[][]數組中的第二維索引值相等，那么這兩個Piece就在同一行，這時候需要判斷兩個Piece直接是否有障礙，調用isXBlock(Point p1,Point p2,int pieceWidth)方法，代碼如下：
/** * 判斷兩個y座標相同的點對象之間是否有障礙, 以p1為中心向右遍歷 * * @param p1 * @param p2 * @param pieceWidth * 連連看的每個方塊的圖片的寬 * @return 兩個Piece之間有障礙返回true，否則返回false */ private boolean isXBlock(Point p1, Point p2, int pieceWidth) { if (p2.x < p1.x) { // 如果p2在p1左邊, 調換參數位置調用本方法 return isXBlock(p2, p1, pieceWidth); } for (int i = p1.x + pieceWidth; i < p2.x; i = i + pieceWidth) { if (hasPiece(i, p1.y)) {// 有障礙 return true; } } return false; } 如果兩個方塊位于同一行，且它們之間沒有障礙，那么這兩個方塊就可以消除，兩個方塊的連接信息就是它們的中心。
5、沒有轉折點的縱向連接
如果兩個Piece對象在Piece[][]數組中的第一維索引值相等，那么這兩個Piece就在同一列，這時候需要判斷兩個Piece直接是否有障礙，調用isYBlock(Point p1,Point p2,int pieceWidth)方法，代碼如下：
/** * 判斷兩個x座標相同的點對象之間是否有障礙, 以p1為中心向下遍歷 * * @param p1 * @param p2 * @param pieceHeight * 連連看的每個方塊的圖片的高 * @return 兩個Piece之間有障礙返回true，否則返回false */ private boolean isYBlock(Point p1, Point p2, int pieceHeight) { if (p2.y < p1.y) { // 如果p2在p1的上面, 調換參數位置重新調用本方法 return isYBlock(p2, p1, pieceHeight); } for (int i = p1.y + pieceHeight; i < p2.y; i = i + pieceHeight) { if (hasPiece(p1.x, i)) { // 有障礙 return true; } } return false; } 如果兩個方塊位于同一列，且它們之間沒有障礙，那么這兩個方塊就可以消除，兩個方塊的連接信息就是它們的中心。
6、一個轉折點的連接
對于兩個方塊連接線上只有一個轉折點的情況，程序需要先找到這個轉折點。為了找到這個轉折點，程序定義了一個遍歷兩個通道并獲取它們交點的方法，getWrapPoint(List<Point> p1Chanel, List<Point> p2Chanel)，代碼如下：
/** * 遍歷兩個通道, 獲取它們的交點 * * @param p1Chanel * 第一個點的通道 * @param p2Chanel * 第二個點的通道 * @return 兩個通道有交點，返回交點，否則返回null */ private Point getWrapPoint(List<Point> p1Chanel, List<Point> p2Chanel) { for (int i = 0; i < p1Chanel.size(); i++) { Point temp1 = p1Chanel.get(i); for (int j = 0; j < p2Chanel.size(); j++) { Point temp2 = p2Chanel.get(j); if (temp1.equals(temp2)) { // 如果兩個List中有元素有同一個, 表明這兩個通道有交點 return temp1; } } } return null; } 為了找出兩個方塊連接線上的連接點，程序需要分析p1和p2的位置分布。所以我們可以分析p2要么在p1的右上角，要么在p1的右下角。至于p2位于p1的左上角和左下角的情況，只要將p1、p2交換即可，如下圖所示：
當p2位于p1右上角時候，應該計算p1的右通道和p2的下通道是否有交點，p1的上通道和p2的左通道是否有交點。
當p2位于p1右下角時候，應該計算p1的右通道和p2的上通道是否有交點，p1的下通道和p2的左通道是否有交點。
下面是具體是實現方法getCornerPoint(Point point1, Point point2, int pieceWidth,
int pieceHeight)的代碼：
/** * 獲取兩個不在同一行或者同一列的座標點的直角連接點, 即只有一個轉折點 * * @param point1 * 第一個點 * @param point2 * 第二個點 * @return 兩個不在同一行或者同一列的座標點的直角連接點 */ private Point getCornerPoint(Point point1, Point point2, int pieceWidth, int pieceHeight) { // 先判斷這兩個點的位置關系, 如果point2在point1的左上角或者 point2在point1的左下角 if (isLeftUp(point1, point2) || isLeftDown(point1, point2)) { // 參數換位, 重新調用本方法 return getCornerPoint(point2, point1, pieceWidth, pieceHeight); } // 獲取p1向右的通道 List<Point> point1RightChanel = getRightChanel(point1, point2.x, pieceWidth); // 獲取p1向上的通道 List<Point> point1UpChanel = getUpChanel(point1, point2.y, pieceHeight); // 獲取p1向下的通道 List<Point> point1DownChanel = getDownChanel(point1, point2.y, pieceHeight); // 獲取p2向下的通道 List<Point> point2DownChanel = getDownChanel(point2, point1.y, pieceHeight); // 獲取p2向左的通道 List<Point> point2LeftChanel = getLeftChanel(point2, point1.x, pieceWidth); // 獲取p2向上的通道 List<Point> point2UpChanel = getUpChanel(point2, point1.y, pieceHeight); // 如果point2在point1的右上角 if (isRightUp(point1, point2)) { // 獲取p1向右和p2向下的交點 Point linkPoint1 = getWrapPoint(point1RightChanel, point2DownChanel); // 獲取p1向上和p2向左的交點 Point linkPoint2 = getWrapPoint(point1UpChanel, point2LeftChanel); // 返回其中一個交點, 如果沒有交點, 則返回null return (linkPoint1 == null) ? linkPoint2 : linkPoint1; } /**********************************************************/ // 如果point2在point1的右下角 if (isRightDown(point1, point2)) { // point2在point1的右下角 // 獲取p1向下和p2向左的交點 Point linkPoint1 = getWrapPoint(point1DownChanel, point2LeftChanel); // 獲取p1向右和p2向下的交點 Point linkPoint2 = getWrapPoint(point1RightChanel, point2UpChanel); return (linkPoint1 == null) ? linkPoint2 : linkPoint1; } return null; } 上面方法調用了以下四個方法：
/** * 判斷point2是否在point1的左上角 * * @param point1 * @param point2 * @return p2位于p1的左上角時返回true，否則返回false */ private boolean isLeftUp(Point point1, Point point2) { return (point2.x < point1.x && point2.y < point1.y); } /** * 判斷point2是否在point1的左下角 * * @param point1 * @param point2 * @return p2位于p1的左下角時返回true，否則返回false */ private boolean isLeftDown(Point point1, Point point2) { return (point2.x < point1.x && point2.y > point1.y); } /** * 判斷point2是否在point1的右上角 * * @param point1 * @param point2 * @return p2位于p1的右上角時返回true，否則返回false */ private boolean isRightUp(Point point1, Point point2) { return (point2.x > point1.x && point2.y < point1.y); } /** * 判斷point2是否在point1的右下角 * * @param point1 * @param point2 * @return p2位于p1的右下角時返回true，否則返回false */ private boolean isRightDown(Point point1, Point point2) { return (point2.x > point1.x && point2.y > point1.y); } 7、兩個轉折點的連接
兩個轉折點可以分為以下幾種情況討論：
至于p2位于p1的左上角和左下角的情況，只要將p1、p2交換即可。
1）、p1、p2位于同一行，不能直接相連，就必須有兩個轉折點，如下圖所示
當p1與p2位于同一行不能直接相連，這兩個點既可以在上面相連，也可以在下面相連，這兩種情況都代表他們可以相連，先把這兩種情況加入到結果中，最后去計算最近的距離。
實現時先構建一個Map,Map的key為第一個轉折點，Map的value為第二個轉折點，如果Map的size()大于1，說明這兩個Point有多種連接途徑，那么程序還需要計算路徑最小的連接方式。
2）p1、p2位于同一行，不能直接相連，就必須有兩個轉折點，如上圖所示。
當p1與p2位于同一列不能直接相連，這兩個點既可以在左邊相連，也可以在右邊相連，這兩種情況都代表他們可以相連，先把這兩種情況加入到結果中，最后去計算最近的距離。
實現時先構建一個Map,Map的key為第一個轉折點，Map的value為第二個轉折點，如果Map的size()大于1，說明這兩個Point有多種連接途徑，那么程序還需要計算路徑最小的連接方式。
3)p2位于p1右下角的六種轉折情況，如下圖所示：
定義一個方法來處理上面具有兩個連接點的情況，getLinkPoints(Point point1, Point point2,
int pieceWidth, int pieceHeight)，代碼如下所示：
/** * 獲取兩個轉折點的情況 * * @param point1 * @param point2 * @return Map對象的每個key-value對代表一種連接方式， 其中key、value分別代表第1個、第2個連接點 */ private Map<Point, Point> getLinkPoints(Point point1, Point point2, int pieceWidth, int pieceHeight) { Map<Point, Point> result = new HashMap<Point, Point>(); // 獲取以point1為中心的向上的通道 List<Point> p1UpChanel = getUpChanel(point1, point2.y, pieceHeight); // 獲取以point1為中心的向右的通道 List<Point> p1RightChanel = getRightChanel(point1, point2.x, pieceWidth); // 獲取以point1為中心的向下的通道 List<Point> p1DownChanel = getDownChanel(point1, point2.y, pieceHeight); // 獲取以point2為中心的向下的通道 List<Point> p2DownChanel = getDownChanel(point2, point1.y, pieceHeight); // 獲取以point2為中心的向左的通道 List<Point> p2LeftChanel = getLeftChanel(point2, point1.x, pieceWidth); // 獲取以point2為中心的向上的通道 List<Point> p2UpChanel = getUpChanel(point2, point1.y, pieceHeight); // 獲取Board的最大高度 int heightMax = (this.config.getYSize() + 1) * pieceHeight + this.config.getBeginImageY(); // 獲取Board的最大寬度 int widthMax = (this.config.getXSize() + 1) * pieceWidth + this.config.getBeginImageX(); /* * 先確定兩個點的關系，如果 point2在point1的左上角或者左下角 */ if (isLeftUp(point1, point2) || isLeftDown(point1, point2)) { // 參數換位, 調用本方法 return getLinkPoints(point2, point1, pieceWidth, pieceHeight); } // 情況1：如果p1、p2位于同一行而不能直接相連，需要兩個轉折點，可以在上面相連也可以在下面相連 if (point1.y == point2.y) {// 在同一行 // 第1步: 向上遍歷 // 以p1的中心點向上遍歷獲取點集合 p1UpChanel = getUpChanel(point1, 0, pieceHeight); // 以p2的中心點向上遍歷獲取點集合 p2UpChanel = getUpChanel(point2, 0, pieceHeight); // 如果兩個集合向上中有Y坐標相同，即在同一行，且之間沒有障礙物 Map<Point, Point> upLinkPoints = getXLinkPoints(p1UpChanel, p2UpChanel, pieceHeight); // 第2步: 向下遍歷, 不超過Board(有方塊的地方)的邊框 // 以p1中心點向下遍歷獲取點集合 p1DownChanel = getDownChanel(point1, heightMax, pieceHeight); // 以p2中心點向下遍歷獲取點集合 p2DownChanel = getDownChanel(point2, heightMax, pieceHeight); // 如果兩個集合向上中有Y坐標相同，即在同一行，且之間沒有障礙物 Map<Point, Point> downLinkPoints = getXLinkPoints(p1DownChanel, p2DownChanel, pieceHeight); result.putAll(upLinkPoints); result.putAll(downLinkPoints); } // 情況2：p1、p2位于同一列不能直接相連，需要兩個轉折點，可以在左邊相連也可以在右邊相連 if (point1.x == point2.x) {// 在同一列 // 第1步:向左遍歷 // 以p1的中心點向左遍歷獲取點集合 List<Point> p1LeftChanel = getLeftChanel(point1, 0, pieceWidth); // 以p2的中心點向左遍歷獲取點集合 p2LeftChanel = getLeftChanel(point2, 0, pieceWidth); // 如果兩個集合向上中有X坐標相同，即在同一列，且之間沒有障礙物 Map<Point, Point> leftLinkPoints = getYLinkPoints(p1LeftChanel, p2LeftChanel, pieceWidth); // 第2步:向右遍歷, 不得超過Board的邊框（有方塊的地方） // 以p1的中心點向右遍歷獲取點集合 p1RightChanel = getRightChanel(point1, widthMax, pieceWidth); // 以p2的中心點向右遍歷獲取點集合 List<Point> p2RightChanel = getRightChanel(point2, widthMax, pieceWidth); // 如果兩個集合向上中有X坐標相同，即在同一列，且之間沒有障礙物 Map<Point, Point> rightLinkPoints = getYLinkPoints(p1RightChanel, p2RightChanel, pieceWidth); result.putAll(leftLinkPoints); result.putAll(rightLinkPoints); } // 情況3:point2位于point1的右上角,分六種情況討論 if (isRightUp(point1, point2)) { //第1步： 獲取point1向上遍歷, point2向下遍歷時橫向可以連接的點 Map<Point, Point> upDownLinkPoints = getXLinkPoints(p1UpChanel, p2DownChanel, pieceWidth); /**********************************************************/ //第2步：獲取point1向右遍歷, point2向左遍歷時縱向可以連接的點 Map<Point, Point> rightLeftLinkPoints = getYLinkPoints( p1RightChanel, p2LeftChanel, pieceHeight); /**********************************************************/ // 獲取以p1為中心的向上通道 p1UpChanel = getUpChanel(point1, 0, pieceHeight); // 獲取以p2為中心的向上通道 p2UpChanel = getUpChanel(point2, 0, pieceHeight); //第3步： 獲取point1向上遍歷, point2向上遍歷時橫向可以連接的點 Map<Point, Point> upUpLinkPoints = getXLinkPoints(p1UpChanel, p2UpChanel, pieceWidth); /**********************************************************/ // 獲取以p1為中心的向下通道 p1DownChanel = getDownChanel(point1, heightMax, pieceHeight); // 獲取以p2為中心的向下通道 p2DownChanel = getDownChanel(point2, heightMax, pieceHeight); //第4步： 獲取point1向下遍歷, point2向下遍歷時橫向可以連接的點 Map<Point, Point> downDownLinkPoints = getXLinkPoints(p1DownChanel, p2DownChanel, pieceWidth); /**********************************************************/ // 獲取以p1為中心的向右通道 p1RightChanel = getRightChanel(point1, widthMax, pieceWidth); // 獲取以p2為中心的向右通道 List<Point> p2RightChanel = getRightChanel(point2, widthMax, pieceWidth); //第5步：獲取point1向右遍歷, point2向右遍歷時縱向可以連接的點 Map<Point, Point> rightRightLinkPoints = getYLinkPoints( p1RightChanel, p2RightChanel, pieceHeight); /**********************************************************/ // 獲取以p1為中心的向左通道 List<Point> p1LeftChanel = getLeftChanel(point1, 0, pieceWidth); // 獲取以p2為中心的向左通道 p2LeftChanel = getLeftChanel(point2, 0, pieceWidth); //第6步： 獲取point1向左遍歷, point2向左遍歷時縱向可以連接的點 Map<Point, Point> leftLeftLinkPoints = getYLinkPoints(p1LeftChanel, p2LeftChanel, pieceHeight); /**********************************************************/ result.putAll(upDownLinkPoints); result.putAll(rightLeftLinkPoints); result.putAll(upUpLinkPoints); result.putAll(downDownLinkPoints); result.putAll(rightRightLinkPoints); result.putAll(leftLeftLinkPoints); } // 情況4：point2位于point1的右下角,分六種情況討論 if (isRightDown(point1, point2)) { //第1步： 獲取point1向下遍歷, point2向上遍歷時橫向可連接的點 Map<Point, Point> downUpLinkPoints = getXLinkPoints(p1DownChanel, p2UpChanel, pieceWidth); /**********************************************************/ //第2步： 獲取point1向右遍歷, point2向左遍歷時縱向可連接的點 Map<Point, Point> rightLeftLinkPoints = getYLinkPoints( p1RightChanel, p2LeftChanel, pieceHeight); /**********************************************************/ // 獲取以p1為中心的向上通道 p1UpChanel = getUpChanel(point1, 0, pieceHeight); // 獲取以p2為中心的向上通道 p2UpChanel = getUpChanel(point2, 0, pieceHeight); //第3步： 獲取point1向上遍歷, point2向上遍歷時橫向可連接的點 Map<Point, Point> upUpLinkPoints = getXLinkPoints(p1UpChanel, p2UpChanel, pieceWidth); /**********************************************************/ // 獲取以p1為中心的向下通道 p1DownChanel = getDownChanel(point1, heightMax, pieceHeight); // 獲取以p2為中心的向下通道 p2DownChanel = getDownChanel(point2, heightMax, pieceHeight); //第4步： 獲取point1向下遍歷, point2向下遍歷時橫向可連接的點 Map<Point, Point> downDownLinkPoints = getXLinkPoints(p1DownChanel, p2DownChanel, pieceWidth); /**********************************************************/ // 獲取以p1為中心的向左通道 List<Point> p1LeftChanel = getLeftChanel(point1, 0, pieceWidth); // 獲取以p2為中心的向左通道 p2LeftChanel = getLeftChanel(point2, 0, pieceWidth); //第5步： 獲取point1向左遍歷, point2向左遍歷時縱向可連接的點 Map<Point, Point> leftLeftLinkPoints = getYLinkPoints(p1LeftChanel, p2LeftChanel, pieceHeight); /**********************************************************/ // 獲取以p1為中心的向右通道 p1RightChanel = getRightChanel(point1, widthMax, pieceWidth); // 獲取以p2為中心的向右通道 List<Point> p2RightChanel = getRightChanel(point2, widthMax, pieceWidth); //第6步： 獲取point1向右遍歷, point2向右遍歷時縱向可以連接的點 Map<Point, Point> rightRightLinkPoints = getYLinkPoints( p1RightChanel, p2RightChanel, pieceHeight); /**********************************************************/ result.putAll(downUpLinkPoints); result.putAll(rightLeftLinkPoints); result.putAll(upUpLinkPoints); result.putAll(downDownLinkPoints); result.putAll(leftLeftLinkPoints); result.putAll(rightRightLinkPoints); } return result; } 上面調用的getXLinkPoints、getYLinkPoints方法代碼如下：
/** * 遍歷兩個集合, 先判斷第一個集合的元素的x座標與另一個集合中的元素x座標相同(縱向), 如果相同, 即在同一列, 再判斷是否有障礙, * 沒有則加到結果的Map中去 * * @param p1Chanel * @param p2Chanel * @param pieceHeight * @return */ private Map<Point, Point> getYLinkPoints(List<Point> p1Chanel, List<Point> p2Chanel, int pieceHeight) { Map<Point, Point> result = new HashMap<Point, Point>(); for (int i = 0; i < p1Chanel.size(); i++) { Point temp1 = p1Chanel.get(i); for (int j = 0; j < p2Chanel.size(); j++) { Point temp2 = p2Chanel.get(j); // 如果x座標相同(在同一列) if (temp1.x == temp2.x) { // 沒有障礙, 放到map中去 if (!isYBlock(temp1, temp2, pieceHeight)) { result.put(temp1, temp2); } } } } return result; } /** * 遍歷兩個集合, 先判斷第一個集合的元素的y座標與另一個集合中的元素y座標相同(橫向), 如果相同, 即在同一行, 再判斷是否有障礙, 沒有 * 則加到結果的map中去 * * @param p1Chanel * @param p2Chanel * @param pieceWidth * @return 存放可以橫向直線連接的連接點的鍵值對 */ private Map<Point, Point> getXLinkPoints(List<Point> p1Chanel, List<Point> p2Chanel, int pieceWidth) { Map<Point, Point> result = new HashMap<Point, Point>(); for (int i = 0; i < p1Chanel.size(); i++) { // 從第一通道中取一個點 Point temp1 = p1Chanel.get(i); // 再遍歷第二個通道, 看下第二通道中是否有點可以與temp1橫向相連 for (int j = 0; j < p2Chanel.size(); j++) { Point temp2 = p2Chanel.get(j); // 如果y座標相同(在同一行), 再判斷它們之間是否有直接障礙 if (temp1.y == temp2.y) { if (!isXBlock(temp1, temp2, pieceWidth)) { // 沒有障礙則直接加到結果的map中 result.put(temp1, temp2); } } } } return result; } 8、找出最短距離
為了找出所有連接情況中的最短路徑，程序可以分為以下2步驟來實現：
遍歷轉折點Map中的所有key-value對，與原來選擇的兩個點構成一個LinkInfo。每個LinkInfo代表一條完整的連接路徑，并將這些LinkInfo搜集成一個List集合。
遍歷第一步得到的List<LinkInfo>集合，計算每個LinkInfo中連接全部連接點的總距離，選與最短距離相差最小的LinkInfo返回。
/** * 獲取p1和p2之間最短的連接信息 * * @param p1 * @param p2 * @param turns * 放轉折點的map * @param shortDistance * 兩點之間的最短距離 * @return p1和p2之間最短的連接信息 */ private LinkInfo getShortcut(Point p1, Point p2, Map<Point, Point> turns, int shortDistance) { List<LinkInfo> infos = new ArrayList<LinkInfo>(); // 遍歷結果Map, for (Point point1 : turns.keySet()) { Point point2 = turns.get(point1); // 將轉折點與選擇點封裝成LinkInfo對象, 放到List集合中 infos.add(new LinkInfo(p1, point1, point2, p2)); } return getShortcut(infos, shortDistance); } /** * 從infos中獲取連接線最短的那個LinkInfo對象 * * @param infos * @return 連接線最短的那個LinkInfo對象 */ private LinkInfo getShortcut(List<LinkInfo> infos, int shortDistance) { int temp1 = 0; LinkInfo result = null; for (int i = 0; i < infos.size(); i++) { LinkInfo info = infos.get(i); // 計算出幾個點的總距離 int distance = countAll(info.getLinkPoints()); // 將循環第一個的差距用temp1保存 if (i == 0) { temp1 = distance - shortDistance; result = info; } // 如果下一次循環的值比temp1的還小, 則用當前的值作為temp1 if (distance - shortDistance < temp1) { temp1 = distance - shortDistance; result = info; } } return result; } /** * 計算List<Point>中所有點的距離總和 * * @param points * 需要計算的連接點 * @return 所有點的距離的總和 */ private int countAll(List<Point> points) { int result = 0; for (int i = 0; i < points.size() - 1; i++) { // 獲取第i個點 Point point1 = points.get(i); // 獲取第i + 1個點 Point point2 = points.get(i + 1); // 計算第i個點與第i + 1個點的距離，并添加到總距離中 result += getDistance(point1, point2); } return result; } /** * 獲取兩個LinkPoint之間的最短距離 * * @param p1 * 第一個點 * @param p2 * 第二個點 * @return 兩個點的距離距離總和 */ private int getDistance(Point p1, Point p2) { int xDistance = Math.abs(p1.x - p2.x); int yDistance = Math.abs(p1.y - p2.y); return xDistance + yDistance; } 關于具體的實現步驟，請參考下面的鏈接：
我的Android進階之旅------>Android瘋狂連連看游戲的實現之游戲效果預覽(一)
我的Android進階之旅------>Android瘋狂連連看游戲的實現之開發游戲界面(二)
我的Android進階之旅------>Android瘋狂連連看游戲的實現之狀態數據模型(三)
我的Android進階之旅------>Android瘋狂連連看游戲的實現之加載界面圖片和實現游戲Activity(四)
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持武林網。
新聞熱點
疑難解答
