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