Android五子棋游戏程序完整实例分析

public class MainActivity extends AppCompatActivity {
 private ChessBoardView chessBoardView;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
 chessBoardView = (ChessBoardView) findViewById(R.id.boardView);
 }

 @Override
 public boolean onOptionsItemSelected(MenuItem item) {
 int id = item.getItemId();
 // 再来一局
 if (id == R.id.action_setting) {
 chessBoardView.start();
 return true;
 }
 return super.onOptionsItemSelected(item);
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
 getMenuInflater().inflate(R.menu.menu_main, menu);
 return true;
 }
}

public class Constants {
 // 五子连珠
 public final static int MAX_COUNT_IN_LINE = 5;
 // 棋盘的行数
 final static int MAX_LINE = 15;

 // 检查的方向
 final static int HORIZOnTAL= 0;
 final static int VERTICAL = 1;
 final static int LEFT_DIAGOnAL= 2;
 final static int RIGHT_DIAGOnAL= 4;
}

<&＃63;xml version="1.0" encoding="utf-8"&＃63;>


 

<&＃63;xml version="1.0" encoding="utf-8"&＃63;>


 

// 棋盘的宽度，也是长度
private int mViewWidth;
// 棋盘每格的长度
private float maxLineHeight;
private Paint paint = new Paint();
// 定义黑白棋子的Bitmap
private Bitmap mwhitePiece, mblackPiece;
private float ratioPieceOfLineHeight = 3 * 1.0f / 4;

// 判断当前落下的棋子是否是白色的
private boolean mIsWhite = true;
// 记录黑白棋子位置的列表
private ArrayList mwhiteArray = new ArrayList<>();
private ArrayList mblackArray = new ArrayList<>();

// 游戏是否结束
private boolean mIsGameOver;
// 游戏结束，是否是白色方胜利
private boolean mIsWhiteWinner;

public ChessBoardView(Context context, AttributeSet attrs) {
 super(context, attrs);
 init();
}
private void init() {
 paint.setColor(0x88000000);
 paint.setAntiAlias(true);
 paint.setDither(true);
 paint.setStyle(Paint.Style.STROKE);

 mwhitePiece = BitmapFactory.decodeResource(getResources(), R.mipmap.stone_w2);
 mblackPiece = BitmapFactory.decodeResource(getResources(), R.mipmap.stone_b1);
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 int widthSize = MeasureSpec.getSize(widthMeasureSpec);
 int widthModel = MeasureSpec.getMode(widthMeasureSpec);

 int heightSize = MeasureSpec.getSize(heightMeasureSpec);
 int heightModel = MeasureSpec.getMode(heightMeasureSpec);

 int width = Math.min(widthSize, heightSize);
 if (widthModel == MeasureSpec.UNSPECIFIED) {
 width = heightSize;
 } else if (heightModel == MeasureSpec.UNSPECIFIED) {
 width = widthSize;
 }
 setMeasuredDimension(width, width);
} 

@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
 super.onSizeChanged(w, h, oldw, oldh);
 mViewWidth = w;
 maxLineHeight = mViewWidth * 1.0f / Constants.MAX_LINE;

 int pieceWidth = (int) (maxLineHeight * ratioPieceOfLineHeight);
 mwhitePiece = Bitmap.createScaledBitmap(mwhitePiece, pieceWidth, pieceWidth, false);
 mblackPiece = Bitmap.createScaledBitmap(mblackPiece, pieceWidth, pieceWidth, false);
} 

@Override
public boolean onTouchEvent(MotionEvent event) {
 if (mIsGameOver) {
 return false;
 }
 int action = event.getAction();
 if (action == MotionEvent.ACTION_UP) {
 int x = (int) event.getX();
 int y = (int) event.getY();

 Point point = getValidPoint(x, y);
 if (mwhiteArray.contains(point) || mblackArray.contains(point)) {
 return false;
 }
 if (mIsWhite) {
 mwhiteArray.add(point);
 } else {
 mblackArray.add(point);
 }
 invalidate();
 mIsWhite = !mIsWhite;
 }
 return true;
} 

@Override
protected void onDraw(Canvas canvas) {
 super.onDraw(canvas);
 // 绘制棋盘的网格
 drawBoard(canvas);
 // 绘制棋盘的黑白棋子
 drawPieces(canvas);
 // 检查游戏是否结束
 checkGameOver();
}

// 绘制棋盘的网线
private void drawBoard(Canvas canvas) {
 int w = mViewWidth;
 float lineHeight = maxLineHeight;

 for (int i = 0; i 

// 根据黑白棋子的数组绘制棋子
private void drawPieces(Canvas canvas) {
 for (int i = 0, n = mwhiteArray.size(); i 

// 检查游戏是否结束
private void checkGameOver() {
 CheckWinner checkWinner = new CheckWinner();
 boolean whiteWin = checkWinner.checkFiveInLineWinner(mwhiteArray);
 boolean blackWin = checkWinner.checkFiveInLineWinner(mblackArray);

 if (whiteWin || blackWin) {
 mIsGameOver = true;
 mIsWhiteWinner = whiteWin;
 String text = mIsWhiteWinner &＃63; "白棋胜利" : "黑棋胜利";
 Toast.makeText(getContext(), text, Toast.LENGTH_SHORT).show();
 }
}

private static final String INSTANCE = "instance";
private static final String INSTANCE_GAME_OVER = "instance_game_over";
private static final String INSTANCE_WHITE_ARRAY = "instance_white_array";
private static final String INSTANCE_BLACK_ARRAY = "instance_black_array";

@Override
protected Parcelable onSaveInstanceState() {
 Bundle bundle = new Bundle();
 bundle.putParcelable(INSTANCE, super.onSaveInstanceState());
 bundle.putBoolean(INSTANCE_GAME_OVER, mIsGameOver);

 bundle.putParcelableArrayList(INSTANCE_BLACK_ARRAY, mblackArray);
 bundle.putParcelableArrayList(INSTANCE_WHITE_ARRAY, mwhiteArray);
 return bundle;
}

@Override
protected void onRestoreInstanceState(Parcelable state) {
 if (state instanceof Bundle) {
 Bundle bundle = (Bundle) state;
 mIsGameOver = bundle.getBoolean(INSTANCE_GAME_OVER);
 mwhiteArray = bundle.getParcelableArrayList(INSTANCE_WHITE_ARRAY);
 mblackArray = bundle.getParcelableArrayList(INSTANCE_BLACK_ARRAY);
 super.onRestoreInstanceState(bundle.getParcelable(INSTANCE));
 return;
 }
 super.onRestoreInstanceState(state);
} 

// 再来一局
public void start() {
 mwhiteArray.clear();
 mblackArray.clear();
 mIsGameOver = false;
 mIsWhiteWinner = false;
 invalidate();
}

private boolean check(int x, int y, List points, int checkOri) {
 int count = 1;
 for (int i = 1; i 

// 横向判断
private boolean checkHorizontal(int x, int y, List points) {
 checkModel = Constants.HORIZONTAL;
 return check(x, y, points, checkModel);
}

// 竖向判断
private boolean checkVertical(int x, int y, List points) {
 checkModel = Constants.VERTICAL;
 return check(x, y, points, checkModel);
}

// 左斜判断
private boolean checkLeftDiagonal(int x, int y, List points) {
 checkModel = Constants.LEFT_DIAGONAL;
 return check(x, y, points, checkModel);
}

// 右斜判断
private boolean checkRighttDiagonal(int x, int y, List points) {
 checkModel = Constants.RIGHT_DIAGONAL;
 return check(x, y, points, checkModel);
} 

private Point point1, point2;
private int checkModel = -1;

public boolean checkFiveInLineWinner(List points) {
 for (Point point : points) {
 int x = point.x;
 int y = point.y;

 if (checkHorizontal(x, y, points)) {
 return true;
 } else if (checkVertical(x, y, points)) {
 return true;
 } else if (checkLeftDiagonal(x, y, points)) {
 return true;
 } else if (checkRighttDiagonal(x, y, points)) {
 return true;
 }
 }
 return false;
}