Android實現(xiàn)瘋狂連連看游戲之實現(xiàn)游戲邏輯(五)
更新時間：2017年03月31日 11:50:23 作者：歐陽鵬
這篇文章主要為大家詳細介紹了Android實現(xiàn)瘋狂連連看游戲之實現(xiàn)游戲邏輯，具有一定的參考價值，感興趣的小伙伴們可以參考一下
在上一篇《我的Android進階之旅------>Android瘋狂連連看游戲的實現(xiàn)之加載界面圖片和實現(xiàn)游戲Activity(四)》中提到的兩個類：
GameConf:負責管理游戲的初始化設置信息。
GameService：負責游戲的邏輯實現(xiàn)。
其中GameConf的代碼如下：cn\oyp\link\utils\GameConf.java
package cn.oyp.link.utils;
import android.content.Context;
/**
* 保存游戲配置的對象 <br/>
* <br/>
* 關(guān)于本代碼介紹可以參考一下博客: 歐陽鵬的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[][]數(shù)組第一維的長度
*/
private int xSize;
/**
* Piece[][]數(shù)組第二維的長度
*/
private int ySize;
/**
* Board中第一張圖片出現(xiàn)的x座標
*/
private int beginImageX;
/**
* Board中第一張圖片出現(xiàn)的y座標
*/
private int beginImageY;
/**
* 記錄游戲的總時間, 單位是秒
*/
private long gameTime;
/**
* 應用上下文
*/
private Context context;
/**
* 提供一個參數(shù)構(gòu)造器
*
* @param xSize
* Piece[][]數(shù)組第一維長度
* @param ySize
* Piece[][]數(shù)組第二維長度
* @param beginImageX
* Board中第一張圖片出現(xiàn)的x座標
* @param beginImageY
* Board中第一張圖片出現(xiàn)的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[][]數(shù)組第一維的長度
*/
public int getXSize() {
return xSize;
}
/**
* @return Piece[][]數(shù)組第二維的長度
*/
public int getYSize() {
return ySize;
}
/**
* @return Board中第一張圖片出現(xiàn)的x座標
*/
public int getBeginImageX() {
return beginImageX;
}
/**
* @return Board中第一張圖片出現(xiàn)的y座標
*/
public int getBeginImageY() {
return beginImageY;
}
/**
* @return 應用上下文
*/
public Context getContext() {
return context;
}
}
而GameService則是整個游戲邏輯實現(xiàn)的核心，而且GameService是一個可以復用的業(yè)務邏輯類，它于游戲平臺無關(guān)，既可以在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/>
* 關(guān)于本代碼介紹可以參考一下博客: 歐陽鵬的CSDN博客</a> <br/>
*/
public interface GameService {
/**
* 控制游戲開始的方法
*/
public void start();
/**
* 定義一個接口方法, 用于返回一個二維數(shù)組
*
* @return 存放方塊對象的二維數(shù)組
*/
public Piece[][] getPieces();
/**
* 判斷參數(shù)Piece[][]數(shù)組中是否還存在非空的Piece對象
*
* @return 如果還剩Piece對象返回true, 沒有返回false
*/
public boolean hasPieces();
/**
* 根據(jù)鼠標的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);
}
下面來具體實現(xiàn)GameService組件，首先的public void start()方法，public Piece[][] getPieces()方法和public boolean hasPieces()方法很容易實現(xiàn)，具體實現(xiàn)如下：cn\oyp\link\board\impl\GameServiceImpl.java
/**
* 游戲邏輯的實現(xiàn)類 <br/>
* <br/>
* 關(guān)于本代碼介紹可以參考一下博客: 歐陽鵬的CSDN博客</a> <br/>
*/
public class GameServiceImpl implements GameService {
/**
* 定義一個Piece[][]數(shù)組
*/
private Piece[][] pieces;
/**
* 游戲配置對象
*/
private GameConf config;
/**
* 構(gòu)造方法
*
* @param config
* 游戲配置對象
*/
public GameServiceImpl(GameConf config) {
// 將游戲的配置對象設置本類中
this.config = config;
}
@Override
public void start() {
// 定義一個AbstractBoard對象
AbstractBoard board = null;
Random random = new Random();
// 獲取一個隨機數(shù), 可取值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[][]數(shù)組
this.pieces = board.create(config);
}
@Override
public Piece[][] getPieces() {
return this.pieces;
}
@Override
public boolean hasPieces() {
// 遍歷Piece[][]數(shù)組的每個元素
for (int i = 0; i < pieces.length; i++) {
for (int j = 0; j < pieces[i].length; j++) {
// 只要任意一個數(shù)組元素不為null，也就是還剩有非空的Piece對象
if (pieces[i][j] != null) {
return true;
}
}
}
return false;
}
...
}
1、獲取觸碰點的方塊
首先當用戶碰觸游戲界面時，事件監(jiān)聽器獲取的是該觸碰到在游戲界面上的X、Y坐標，但是程序需要的是獲取用戶碰觸的到底是那個方塊，因此程序必須把界面上的X、Y坐標換算成在Piece[][]二維數(shù)組中的兩個索引值?？紤]到游戲界面上每個方塊的高度和寬度都是相同的，因此想要將界面上的X、Y坐標換算成Piece[][]二維數(shù)組中的索引也比較簡單，只要拿X、Y坐標值除以圖片的寬、高即可。下面是根據(jù)觸點X、Y坐標獲取對于方塊的代碼：
/**
* 根據(jù)觸碰點的位置查找相應的方塊
*/
@Override
public Piece findPiece(float touchX, float touchY) {
/*
* 由于在創(chuàng)建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[][]數(shù)組中的第一維的索引值 ，第二個參數(shù)為每張圖片的寬
*/
int indexX = getIndex(relativeX, GameConf.PIECE_WIDTH);
/*
* 獲取relativeY座標在Piece[][]數(shù)組中的第二維的索引值 ，第二個參數(shù)為每張圖片的高
*/
int indexY = getIndex(relativeY, GameConf.PIECE_HEIGHT);
// 這兩個索引比數(shù)組的最小索引還小, 返回null
if (indexX < 0 || indexY < 0) {
return null;
}
// 這兩個索引比數(shù)組的最大索引還大(或者等于), 返回null
if (indexX >= this.config.getXSize()
|| indexY >= this.config.getYSize()) {
return null;
}
// 返回Piece[][]數(shù)組的指定元素
return this.pieces[indexX][indexY];
}
上面的方法調(diào)用了getIndex(int relative,int size)方法，該方法的實現(xiàn)就是拿relative除以size,程序需要判斷可以整除和不能整除兩種情況：如果可以整除，說明還在前一個方塊內(nèi)；如果不能整除，則對于于下一個方塊，下面是getIndex(int relative,int size)方法的代碼：
/**
* 工具方法：計算相對于Piece[][]數(shù)組的第一維 或第二維的索引值
*
* @param relative
* 座標
* @param size
* 每張圖片邊的長或者寬
* @return
*/
private int getIndex(int relative, int size) {
// 表示座標relative不在該數(shù)組中，數(shù)組下標從0開始
int index = -1;
/*
* 讓座標除以邊長, 沒有余數(shù), 索引減1， 例如點了x座標為20, 邊寬為10, 20 % 10 沒有余數(shù), index為1,
* 即在數(shù)組中的索引為1(第二個元素)
*/
if (relative % size == 0) {
index = relative / size - 1;
} else {
/*
* 有余數(shù), 例如點了x座標為21, 邊寬為10, 21 % 10有余數(shù), index為2， 即在數(shù)組中的索引為2(第三個元素)
*/
index = relative / size;
}
return index;
}
2、判斷兩個方塊是否可以相連
兩個方塊可以相連的情況可以大致分為以下幾種：
- 兩個方塊位于同一條水平線，可以直接相連。
- 兩個方塊位于同一條豎直線，可以直接相連。
- 兩個方塊以兩條線段相連，也就是有1個拐角。
- 兩個方塊以三條線段相連，也就是有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的左邊, 則需要重新執(zhí)行本方法, 兩個參數(shù)互換
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)) {
// 它們之間沒有真接障礙, 沒有轉(zhuǎn)折點
return new LinkInfo(p1Point, p2Point);
}
}
// 情況2：如果兩個Piece在同一列，并且可以直接相連
if (p1.getIndexX() == p2.getIndexX()) {
if (!isYBlock(p1Point, p2Point, GameConf.PIECE_HEIGHT)) {
// 它們之間沒有真接障礙, 沒有轉(zhuǎn)折點
return new LinkInfo(p1Point, p2Point);
}
}
/*
* 情況3：兩個Piece以兩條線段相連，也就是有一個轉(zhuǎn)折點的情況。 獲取兩個點的直角相連的點, 即只有一個轉(zhuǎn)折點
*/
Point cornerPoint = getCornerPoint(p1Point, p2Point,
GameConf.PIECE_WIDTH, GameConf.PIECE_HEIGHT);
// 它們之間有一個轉(zhuǎn)折點
if (cornerPoint != null) {
return new LinkInfo(p1Point, cornerPoint, p2Point);
}
/*
* 情況4：兩個Piece以三條線段相連，有兩個轉(zhuǎn)折點的情況。 該map的key存放第一個轉(zhuǎn)折點,
* value存放第二個轉(zhuǎn)折點,map的size()說明有多少種可以連的方式
*/
Map<Point, Point> turns = getLinkPoints(p1Point, p2Point,
GameConf.PIECE_WIDTH, GameConf.PIECE_WIDTH);
// 它們之間有轉(zhuǎn)折點
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) {
// 遇到障礙, 表示通道已經(jīng)到盡頭, 直接返回
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) {
// 遇到障礙, 表示通道已經(jīng)到盡頭, 直接返回
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) {
// 遇到障礙, 表示通道已經(jīng)到盡頭, 直接返回
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) {
// 遇到障礙, 表示通道已經(jīng)到盡頭, 直接返回
if (hasPiece(p.x, i)) {
// 如果遇到障礙, 直接返回
return result;
}
result.add(new Point(p.x, i));
}
return result;
}
上面調(diào)用到的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、沒有轉(zhuǎn)折點的橫向連接
如果兩個Piece對象在Piece[][]數(shù)組中的第二維索引值相等，那么這兩個Piece就在同一行，這時候需要判斷兩個Piece直接是否有障礙，調(diào)用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左邊, 調(diào)換參數(shù)位置調(diào)用本方法
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、沒有轉(zhuǎn)折點的縱向連接
如果兩個Piece對象在Piece[][]數(shù)組中的第一維索引值相等，那么這兩個Piece就在同一列，這時候需要判斷兩個Piece直接是否有障礙，調(diào)用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的上面, 調(diào)換參數(shù)位置重新調(diào)用本方法
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、一個轉(zhuǎn)折點的連接
對于兩個方塊連接線上只有一個轉(zhuǎn)折點的情況，程序需要先找到這個轉(zhuǎn)折點。為了找到這個轉(zhuǎn)折點，程序定義了一個遍歷兩個通道并獲取它們交點的方法，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的左通道是否有交點。
下面是具體是實現(xiàn)方法getCornerPoint(Point point1, Point point2, int pieceWidth,
int pieceHeight)的代碼：
/**
* 獲取兩個不在同一行或者同一列的座標點的直角連接點, 即只有一個轉(zhuǎn)折點
*
* @param point1
* 第一個點
* @param point2
* 第二個點
* @return 兩個不在同一行或者同一列的座標點的直角連接點
*/
private Point getCornerPoint(Point point1, Point point2, int pieceWidth,
int pieceHeight) {
// 先判斷這兩個點的位置關(guān)系, 如果point2在point1的左上角或者 point2在point1的左下角
if (isLeftUp(point1, point2) || isLeftDown(point1, point2)) {
// 參數(shù)換位, 重新調(diào)用本方法
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;
}
上面方法調(diào)用了以下四個方法：
/**
* 判斷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、兩個轉(zhuǎn)折點的連接
兩個轉(zhuǎn)折點可以分為以下幾種情況討論：
- p1、p2位于同一行，不能直接相連，就必須有兩個轉(zhuǎn)折點，分向上和向下兩種連接情況。
- p1、p2位于同一行，不能直接相連，就必須有兩個轉(zhuǎn)折點，分向左和向右兩種連接情況。
- p2在p1的右下角，有6中轉(zhuǎn)折情況。
- p2在p1的右上角，也有6種轉(zhuǎn)折情況。
至于p2位于p1的左上角和左下角的情況，只要將p1、p2交換即可。
1）、p1、p2位于同一行，不能直接相連，就必須有兩個轉(zhuǎn)折點，如下圖所示
當p1與p2位于同一行不能直接相連，這兩個點既可以在上面相連，也可以在下面相連，這兩種情況都代表他們可以相連，先把這兩種情況加入到結(jié)果中，最后去計算最近的距離。
實現(xiàn)時先構(gòu)建一個Map,Map的key為第一個轉(zhuǎn)折點，Map的value為第二個轉(zhuǎn)折點，如果Map的size()大于1，說明這兩個Point有多種連接途徑，那么程序還需要計算路徑最小的連接方式。
2）p1、p2位于同一行，不能直接相連，就必須有兩個轉(zhuǎn)折點，如上圖所示。
當p1與p2位于同一列不能直接相連，這兩個點既可以在左邊相連，也可以在右邊相連，這兩種情況都代表他們可以相連，先把這兩種情況加入到結(jié)果中，最后去計算最近的距離。
實現(xiàn)時先構(gòu)建一個Map,Map的key為第一個轉(zhuǎn)折點，Map的value為第二個轉(zhuǎn)折點，如果Map的size()大于1，說明這兩個Point有多種連接途徑，那么程序還需要計算路徑最小的連接方式。
3)p2位于p1右下角的六種轉(zhuǎn)折情況，如下圖所示：
定義一個方法來處理上面具有兩個連接點的情況，getLinkPoints(Point point1, Point point2,
int pieceWidth, int pieceHeight)，代碼如下所示：
/**
* 獲取兩個轉(zhuǎn)折點的情況
*
* @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();
/*
* 先確定兩個點的關(guān)系，如果 point2在point1的左上角或者左下角
*/
if (isLeftUp(point1, point2) || isLeftDown(point1, point2)) {
// 參數(shù)換位, 調(diào)用本方法
return getLinkPoints(point2, point1, pieceWidth, pieceHeight);
}
// 情況1：如果p1、p2位于同一行而不能直接相連，需要兩個轉(zhuǎn)折點，可以在上面相連也可以在下面相連
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位于同一列不能直接相連，需要兩個轉(zhuǎn)折點，可以在左邊相連也可以在右邊相連
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;
}
上面調(diào)用的getXLinkPoints、getYLinkPoints方法代碼如下：
/**
* 遍歷兩個集合, 先判斷第一個集合的元素的x座標與另一個集合中的元素x座標相同(縱向), 如果相同, 即在同一列, 再判斷是否有障礙,
* 沒有則加到結(jié)果的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座標相同(橫向), 如果相同, 即在同一行, 再判斷是否有障礙, 沒有
* 則加到結(jié)果的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)) {
// 沒有障礙則直接加到結(jié)果的map中
result.put(temp1, temp2);
}
}
}
}
return result;
}
8、找出最短距離
為了找出所有連接情況中的最短路徑，程序可以分為以下2步驟來實現(xiàn)：
遍歷轉(zhuǎn)折點Map中的所有key-value對，與原來選擇的兩個點構(gòu)成一個LinkInfo。每個LinkInfo代表一條完整的連接路徑，并將這些LinkInfo搜集成一個List集合。
遍歷第一步得到的List<LinkInfo>集合，計算每個LinkInfo中連接全部連接點的總距離，選與最短距離相差最小的LinkInfo返回。
/**
* 獲取p1和p2之間最短的連接信息
*
* @param p1
* @param p2
* @param turns
* 放轉(zhuǎn)折點的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>();
// 遍歷結(jié)果Map,
for (Point point1 : turns.keySet()) {
Point point2 = turns.get(point1);
// 將轉(zhuǎn)折點與選擇點封裝成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());
// 將循環(huán)第一個的差距用temp1保存
if (i == 0) {
temp1 = distance - shortDistance;
result = info;
}
// 如果下一次循環(huán)的值比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;
}
關(guān)于具體的實現(xiàn)步驟，請參考下面的鏈接：
我的Android進階之旅------>Android瘋狂連連看游戲的實現(xiàn)之游戲效果預覽(一)
我的Android進階之旅------>Android瘋狂連連看游戲的實現(xiàn)之開發(fā)游戲界面(二)
我的Android進階之旅------>Android瘋狂連連看游戲的實現(xiàn)之狀態(tài)數(shù)據(jù)模型(三)
我的Android進階之旅------>Android瘋狂連連看游戲的實現(xiàn)之加載界面圖片和實現(xiàn)游戲Activity(四)
以上就是本文的全部內(nèi)容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。
相關(guān)文章
Android中Uri和Path之間的轉(zhuǎn)換的示例代碼
本篇文章主要介紹了Android中Uri和Path之間的轉(zhuǎn)換的示例代碼，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-04-04
Android編程實現(xiàn)橫豎屏切換時不銷毀當前activity和鎖定屏幕的方法
這篇文章主要介紹了Android編程實現(xiàn)橫豎屏切換時不銷毀當前activity和鎖定屏幕的方法,涉及Android屬性設置及activity操作的相關(guān)技巧,需要的朋友可以參考下2015-11-11
Android基于ListView實現(xiàn)類似Market分頁加載效果示例
這篇文章主要介紹了Android基于ListView實現(xiàn)類似Market分頁加載效果,結(jié)合完整實例形式分析了ListView的OnScroll方法來實現(xiàn)分頁與滾動加載的操作步驟與相關(guān)實現(xiàn)技巧,需要的朋友可以參考下2016-10-10
這篇文章主要為大家詳細介紹了Android實現(xiàn)滑動效果，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-09-09
淺析Android Service中實現(xiàn)彈出對話框的坑
這篇文章主要介紹了Android Service中實現(xiàn)彈出對話框的坑,本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-04-04
Android開發(fā)實現(xiàn)文件關(guān)聯(lián)方法介紹
這篇文章主要介紹了Android開發(fā)實現(xiàn)文件關(guān)聯(lián)方法介紹，具有一定參考價值，需要的朋友樂意了解下。2017-10-10
這篇文章主要介紹了android控件的縮放，移動功能，本文圖文并茂給大家介紹的非常詳細,需要的朋友可以參考下2018-01-01
這篇文章主要介紹了Android 動畫實現(xiàn)幾種方案的相關(guān)資料,需要的朋友可以參考下2017-06-06
Android開發(fā)中通過手機號+短信驗證碼登錄的實例代碼
最近在開發(fā)一個android的項目，需要通過獲取手機驗證碼來完成登錄功能，接下來通過實例代碼給大家分享手機號+短信驗證碼登錄的實現(xiàn)方法，需要的的朋友參考下吧2017-05-05
這篇文章主要為大家詳細介紹了android實現(xiàn)九宮格程序，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-06-06