扫雷4Android(附源码)

　　最近由于项目需要学习了一下Android ,感觉汗不错。做了一个Android版的扫雷游戏。

游戏简介

　在此游戏中，我们使用一个块的网格，其中有一些随机的地雷

下面是效果图

一、应用程序布局

使用TableLayout布局控件。设置3行。

<?xml version="1.0" encoding="utf-8"?>
<TableLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:background="@drawable/back">

<TableRow>
<TextView android:id="@+id/timer" android:layout_column="0"
android:layout_width="fill_parent" android:layout_height="48px"
android:gravity="center_horizontal" android:padding="5dip"
android:textColor="#FFFFFF" android:textSize="35sp"
android:text=" 0" />
<ImageButton android:id="@+id/smiley"
android:layout_column="1" android:scaleType="center" android:padding="5dip"
android:layout_width="48px" android:background="@drawable/smiley_button_states"
android:layout_height="48px" />
<TextView android:id="@+id/minecount" android:layout_column="2"
android:layout_width="fill_parent" android:layout_height="48px"
android:gravity="center_horizontal" android:padding="5dip"
android:textColor="#FFFFFF" android:textSize="35sp" android:text="000" />
</TableRow>

<TableRow>
<TextView android:layout_column="0" android:layout_height="50px"
android:layout_width="fill_parent" android:layout_span="3"
android:padding="10dip" />
</TableRow>

<TableRow>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/minefield" android:layout_width="260px"
android:layout_height="260px" android:gravity="bottom"
android:stretchColumns="*" android:layout_span="3" android:padding="5dip">
</TableLayout>
</TableRow>
</TableLayout>

二、地雷块

Block.java

/**
* 地雷的块，继承自Button
* @author 记忆的永恒
*
*/
public class Block extends Button {
private boolean isCovered; // 块是否覆盖
private boolean isMined; // 下个块
private boolean isFlagged; // 是否将该块标记为一个潜在的地雷
private boolean isQuestionMarked; // 是否是块的问题标记
private boolean isClickable; // 是否可以单击
private int numberOfMinesInSurrounding; // 在附近的地雷数量块

public Block(Context context) {
super(context);
// TODO Auto-generated constructor stub
}

public Block(Context context, AttributeSet attrs) {
super(context, attrs);
// TODO Auto-generated constructor stub
}

public Block(Context context, AttributeSet attrs, int defStyle)
{
super(context, attrs, defStyle);
}

/**
* 设置默认参数
*/
public void setDefaults() {
isCovered = true;
isMined = false;
isFlagged = false;
isQuestionMarked = false;
isClickable = true;
numberOfMinesInSurrounding = 0;

this.setBackgroundResource(R.drawable.square_blue);
setBoldFont();
}

public void setNumberOfSurroundingMines(int number) {
this.setBackgroundResource(R.drawable.square_grey);
updateNumber(number);
}

public void setMineIcon(boolean enabled) {
this.setText("M");
if (!enabled) {
this.setBackgroundResource(R.drawable.square_grey);
this.setTextColor(Color.RED);
}

else {
this.setTextColor(Color.BLACK);
}
}

public void setFlagIcon(boolean enabled) {
this.setText("F");
if (!enabled) {
this.setBackgroundResource(R.drawable.square_grey);
this.setTextColor(Color.RED);
}

else {
this.setTextColor(Color.BLACK);
}
}

public void setQuestionMarkIcon(boolean enabled) {
this.setText("?");
if (!enabled) {
this.setBackgroundResource(R.drawable.square_grey);
this.setTextColor(Color.RED);
}

else {
this.setTextColor(Color.BLACK);
}
}

public void setBlockAsDisabled(boolean enabled) {
if (!enabled) {
this.setBackgroundResource(R.drawable.square_grey);
}

else {
this.setTextColor(R.drawable.square_blue);
}
}

public void clearAllIcons() {
this.setText("");
}

private void setBoldFont() {
this.setTypeface(null, Typeface.BOLD);
}

public void OpenBlock() {
if (!isCovered) {
return;
}

setBlockAsDisabled(false);
isCovered = false;

if (hasMine()) {
setMineIcon(false);
}

else {
setNumberOfSurroundingMines(numberOfMinesInSurrounding);
}
}

public void updateNumber(int text) {
if (text != 0) {
this.setText(Integer.toString(text));
switch (text) {
case 1:
this.setTextColor(Color.BLUE);
break;
case 2:
this.setTextColor(Color.rgb(0, 100, 0));
break;
case 3:
this.setTextColor(Color.RED);
break;
case 4:
this.setTextColor(Color.rgb(85, 26, 139));
break;
case 5:
this.setTextColor(Color.rgb(139, 28, 98));
break;
case 6:
this.setTextColor(Color.rgb(238, 173, 14));
break;
case 7:
this.setTextColor(Color.rgb(47, 79, 79));
break;
case 8:
this.setTextColor(Color.rgb(71, 71, 71));
break;
case 9:
this.setTextColor(Color.rgb(205, 205, 0));
break;

}
}
}

public void plantMine() {
isMined = true;
}

public void triggerMine() {
setMineIcon(true);
this.setTextColor(Color.RED);
}

public boolean isCovered() {
return isCovered;
}

public boolean hasMine() {
return isMined;
}

public void setNumberOfMinesInSurrounding(int number) {
numberOfMinesInSurrounding = number;
}

public int getNumberOfMinesInSorrounding() {
return numberOfMinesInSurrounding;
}

public boolean isFlagged() {
return isFlagged;
}

public void setFlagged(boolean flagged) {
isFlagged = flagged;
}

public boolean isQuestionMarked() {
return isQuestionMarked;
}

public void setQuestionMarked(boolean questionMarked) {
isQuestionMarked = questionMarked;
}

public boolean isClickable() {
return isClickable;
}

public void setClickable(boolean clickable) {
isClickable = clickable;
}

}

三、主界面

1.TableLayout动态添加行

mineField = (TableLayout)findViewById(R.id.MineField);

private void showMineField()
{
for (int row = 1; row < numberOfRowsInMineField + 1; row++)
{
TableRow tableRow = new TableRow(this);
tableRow.setLayoutParams(new LayoutParams((blockDimension + 2 * blockPadding) *
numberOfColumnsInMineField, blockDimension + 2 * blockPadding));

for (int column = 1; column < numberOfColumnsInMineField + 1; column++)
{
blocks[row][column].setLayoutParams(new LayoutParams(
blockDimension + 2 * blockPadding,
blockDimension + 2 * blockPadding));
blocks[row][column].setPadding(blockPadding, blockPadding, blockPadding, blockPadding);
tableRow.addView(blocks[row][column]);
}
mineField.addView(tableRow,new TableLayout.LayoutParams(
(blockDimension + 2 * blockPadding) * numberOfColumnsInMineField, blockDimension + 2 * blockPadding));
}
}

2.定时器Handler

private Handler timer = new Handler();
private int secondsPassed = 0;

public void startTimer(){ if (secondsPassed == 0)
{
timer.removeCallbacks(updateTimeElasped);
// tell timer to run call back after 1 second
timer.postDelayed(updateTimeElasped, 1000);
}
}

public void stopTimer()
{
// disable call backs
timer.removeCallbacks(updateTimeElasped);
}

// timer call back when timer is ticked
private Runnable updateTimeElasped = new Runnable()
{
public void run()
{
long currentMilliseconds = System.currentTimeMillis();
++secondsPassed;
txtTimer.setText(Integer.toString(secondsPassed));

// add notification
timer.postAtTime(this, currentMilliseconds);
// notify to call back after 1 seconds
// basically to remain in the timer loop
timer.postDelayed(updateTimeElasped, 1000);
}
};

3.第一次点击

private boolean isTimerStarted; // check if timer already started or not
blocks[row][column].setOnClickListener(new OnClickListener()
{
@Override
public void onClick(View view)
{
// start timer on first click
if (!isTimerStarted)
{
startTimer();
isTimerStarted = true;
}
...
}
});

4.第一次点击无雷

private boolean areMinesSet; // check if mines are planted in blocks

blocks[row][column].setOnClickListener(new OnClickListener()
{
@Override
public void onClick(View view)
{
...
// set mines on first click
if (!areMinesSet)
{
areMinesSet = true;
setMines(currentRow, currentColumn);
}
}
});

private void setMines(int currentRow, int currentColumn)
{
// set mines excluding the location where user clicked
Random rand = new Random();
int mineRow, mineColumn;

for (int row = 0; row < totalNumberOfMines; row++)
{
mineRow = rand.nextInt(numberOfColumnsInMineField);
mineColumn = rand.nextInt(numberOfRowsInMineField);
if ((mineRow + 1 != currentColumn) || (mineColumn + 1 != currentRow))
{
if (blocks[mineColumn + 1][mineRow + 1].hasMine())
{
row--; // mine is already there, don't repeat for same block
}
// plant mine at this location
blocks[mineColumn + 1][mineRow + 1].plantMine();
}
// exclude the user clicked location
else
{
row--;
}
}

int nearByMineCount;

// count number of mines in surrounding blocks
...
}

5.点击雷块的效果

private void rippleUncover(int rowClicked, int columnClicked)
{
// don't open flagged or mined rows
if (blocks[rowClicked][columnClicked].hasMine() || blocks[rowClicked][columnClicked].isFlagged())
{
return;
}

// open clicked block
blocks[rowClicked][columnClicked].OpenBlock();

// if clicked block have nearby mines then don't open further
if (blocks[rowClicked][columnClicked].getNumberOfMinesInSorrounding() != 0 )
{
return;
}

// open next 3 rows and 3 columns recursively
for (int row = 0; row < 3; row++)
{
for (int column = 0; column < 3; column++)
{
// check all the above checked conditions
// if met then open subsequent blocks
if (blocks[rowClicked + row - 1][columnClicked + column - 1].isCovered()
&& (rowClicked + row - 1 > 0) && (columnClicked + column - 1 > 0)
&& (rowClicked + row - 1 < numberOfRowsInMineField + 1)
&& (columnClicked + column - 1 < numberOfColumnsInMineField + 1))
{
rippleUncover(rowClicked + row - 1, columnClicked + column - 1 );
}
}
}
return;
}

6.以问好标记空白

blocks[row][column].setOnLongClickListener(new OnLongClickListener()
{
public boolean onLongClick(View view)
{
// simulate a left-right (middle) click
// if it is a long click on an opened mine then
// open all surrounding blocks
...

// if clicked block is enabled, clickable or flagged
if (blocks[currentRow][currentColumn].isClickable() &&
(blocks[currentRow][currentColumn].isEnabled() || blocks[currentRow][currentColumn].isFlagged()))
{

// for long clicks set:
// 1. empty blocks to flagged
// 2. flagged to question mark
// 3. question mark to blank

// case 1. set blank block to flagged
if (!blocks[currentRow][currentColumn].isFlagged() && !blocks[currentRow][currentColumn].isQuestionMarked())
{
blocks[currentRow][currentColumn].setBlockAsDisabled(false);
blocks[currentRow][currentColumn].setFlagIcon(true);
blocks[currentRow][currentColumn].setFlagged(true);
minesToFind--; //reduce mine count
updateMineCountDisplay();
}
// case 2. set flagged to question mark
else if (!blocks[currentRow][currentColumn].isQuestionMarked())
{
blocks[currentRow][currentColumn].setBlockAsDisabled(true);
blocks[currentRow][currentColumn].setQuestionMarkIcon(true);
blocks[currentRow][currentColumn].setFlagged(false);
blocks[currentRow][currentColumn].setQuestionMarked(true);
minesToFind++; // increase mine count
updateMineCountDisplay();
}
// case 3. change to blank square
else
{
blocks[currentRow][currentColumn].setBlockAsDisabled(true);
blocks[currentRow][currentColumn].clearAllIcons();
blocks[currentRow][currentColumn].setQuestionMarked(false);
// if it is flagged then increment mine count
if (blocks[currentRow][currentColumn].isFlagged())
{
minesToFind++; // increase mine count
updateMineCountDisplay();
}
// remove flagged status
blocks[currentRow][currentColumn].setFlagged(false);
}

updateMineCountDisplay(); // update mine display
}

return true;
}
});

7.记录胜负

// check status of the game at each step
if (blocks[currentRow + previousRow][currentColumn + previousColumn].hasMine())
{
// oops game over
finishGame(currentRow + previousRow, currentColumn + previousColumn);
}

// did we win the game
if (checkGameWin())
{
// mark game as win
winGame();
}

private boolean checkGameWin()
{
for (int row = 1; row < numberOfRowsInMineField + 1; row++)
{
for (int column = 1; column < numberOfColumnsInMineField + 1; column++)
{
if (!blocks[row][column].hasMine() && blocks[row][column].isCovered())
{
return false;
}
}
}
return true;
}

8.完整代码

MinesweeperGame.java

package com.VertexVerveInc.Games;

import java.util.Random;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnLongClickListener;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TableLayout;
import android.widget.TableRow;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.TableRow.LayoutParams;

public class MinesweeperGame extends Activity {
private TextView txtMineCount;
private TextView txtTimer;
private ImageButton btnSmile;
private TableLayout mineField;

private Block blocks[][]; // blocks for mine field
private int blockDimension = 24; // width of each block
private int blockPadding = 2; // padding between blocks

private int numberOfRowsInMineField = 9;
private int numberOfColumnsInMineField = 9;
private int totalNumberOfMines = 10;

// timer to keep track of time elapsed
private Handler timer = new Handler();
private int secondsPassed = 0;

private boolean isTimerStarted; // check if timer already started or not
private boolean areMinesSet; // check if mines are planted in blocks
private boolean isGameOver;
private int minesToFind; // number of mines yet to be discovered

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.test);

txtMineCount = (TextView) findViewById(R.id.minecount);
txtTimer = (TextView) findViewById(R.id.timer);

btnSmile = (ImageButton) findViewById(R.id.smiley);
btnSmile.setOnClickListener(new OnClickListener()
{
@Override
public void onClick(View view)
{
endExistingGame();
startNewGame();
}
});

mineField = (TableLayout)findViewById(R.id.minefield);

showDialog("Click smiley to start New Game", 2000, true, false);

}

private void startNewGame() {
createMineField();
// display all blocks in UI
showMineField();

minesToFind = totalNumberOfMines;
isGameOver = false;
secondsPassed = 0;

}

private void createMineField() {
// we take one row extra row for each side
// overall two extra rows and two extra columns
// first and last row/column are used for calculations purposes only
// x|xxxxxxxxxxxxxx|x
// ------------------
// x| |x
// x| |x
// ------------------
// x|xxxxxxxxxxxxxx|x
// the row and columns marked as x are just used to keep counts of near
// by mines

blocks = new Block[numberOfRowsInMineField + 2][numberOfColumnsInMineField + 2];

for (int row = 0; row < numberOfColumnsInMineField + 2; row++) {
for (int column = 0; column < numberOfColumnsInMineField + 2; column++) {
blocks[row][column] = new Block(this);
blocks[row][column].setDefaults();

// pass current row and column number as final int's to event
// listeners
// this way we can ensure that each event listener is associated
// to
// particular instance of block only
final int currentRow = row;
final int currentColumn = column;

blocks[row][column].setOnClickListener(new OnClickListener() {

@Override
public void onClick(View v) {
// start timer on first click
if (!isTimerStarted) {
startTimer();
isTimerStarted = true;
}

// set mines on first click
if (!areMinesSet) {
areMinesSet = true;
setMines(currentRow, currentColumn);
}

// this is not first click
// check if current block is flagged
// if flagged the don't do anything
// as that operation is handled by LongClick
// if block is not flagged then uncover nearby blocks
// till we get numbered mines
if (!blocks[currentRow][currentColumn].isFlagged()) {
// open nearby blocks till we get numbered blocks
rippleUncover(currentRow, currentColumn);

// did we clicked a mine
if (blocks[currentRow][currentColumn].hasMine()) {
// Oops, game over
finishGame(currentRow, currentColumn);
}

// check if we win the game
if (checkGameWin()) {
// mark game as win
winGame();
}
}
}

});

// add Long Click listener
// this is treated as right mouse click listener
blocks[row][column]
.setOnLongClickListener(new OnLongClickListener() {
public boolean onLongClick(View view) {
// simulate a left-right (middle) click
// if it is a long click on an opened mine then
// open all surrounding blocks
if (!blocks[currentRow][currentColumn]
.isCovered()
&& (blocks[currentRow][currentColumn]
.getNumberOfMinesInSorrounding() > 0)
&& !isGameOver) {
int nearbyFlaggedBlocks = 0;
for (int previousRow = -1; previousRow < 2; previousRow++) {
for (int previousColumn = -1; previousColumn < 2; previousColumn++) {
if (blocks[currentRow + previousRow][currentColumn
+ previousColumn]
.isFlagged()) {
nearbyFlaggedBlocks++;
}
}
}

// if flagged block count is equal to nearby
// mine count
// then open nearby blocks
if (nearbyFlaggedBlocks == blocks[currentRow][currentColumn]
.getNumberOfMinesInSorrounding()) {
for (int previousRow = -1; previousRow < 2; previousRow++) {
for (int previousColumn = -1; previousColumn < 2; previousColumn++) {
// don't open flagged blocks
if (!blocks[currentRow
+ previousRow][currentColumn
+ previousColumn]
.isFlagged()) {
// open blocks till we get
// numbered block
rippleUncover(
currentRow
+ previousRow,
currentColumn
+ previousColumn);

// did we clicked a mine
if (blocks[currentRow
+ previousRow][currentColumn
+ previousColumn]
.hasMine()) {
// oops game over
finishGame(
currentRow
+ previousRow,
currentColumn
+ previousColumn);
}

// did we win the game
if (checkGameWin()) {
// mark game as win
winGame();
}
}
}
}
}

// as we no longer want to judge this
// gesture so return
// not returning from here will actually
// trigger other action
// which can be marking as a flag or
// question mark or blank
return true;
}

// if clicked block is enabled, clickable or
// flagged
if (blocks[currentRow][currentColumn]
.isClickable()
&& (blocks[currentRow][currentColumn]
.isEnabled() || blocks[currentRow][currentColumn]
.isFlagged())) {

// for long clicks set:
// 1. empty blocks to flagged
// 2. flagged to question mark
// 3. question mark to blank

// case 1. set blank block to flagged
if (!blocks[currentRow][currentColumn]
.isFlagged()
&& !blocks[currentRow][currentColumn]
.isQuestionMarked()) {
blocks[currentRow][currentColumn]
.setBlockAsDisabled(false);
blocks[currentRow][currentColumn]
.setFlagIcon(true);
blocks[currentRow][currentColumn]
.setFlagged(true);
minesToFind--; // reduce mine count
updateMineCountDisplay();
}
// case 2. set flagged to question mark
else if (!blocks[currentRow][currentColumn]
.isQuestionMarked()) {
blocks[currentRow][currentColumn]
.setBlockAsDisabled(true);
blocks[currentRow][currentColumn]
.setQuestionMarkIcon(true);
blocks[currentRow][currentColumn]
.setFlagged(false);
blocks[currentRow][currentColumn]
.setQuestionMarked(true);
minesToFind++; // increase mine count
updateMineCountDisplay();
}
// case 3. change to blank square
else {
blocks[currentRow][currentColumn]
.setBlockAsDisabled(true);
blocks[currentRow][currentColumn]
.clearAllIcons();
blocks[currentRow][currentColumn]
.setQuestionMarked(false);
// if it is flagged then increment mine
// count
if (blocks[currentRow][currentColumn]
.isFlagged()) {
minesToFind++; // increase mine
// count
updateMineCountDisplay();
}
// remove flagged status
blocks[currentRow][currentColumn]
.setFlagged(false);
}

updateMineCountDisplay();
// update mine
// display
}

return true;
}
});
}
}
}

private void showMineField() {
for (int row = 1; row < numberOfRowsInMineField + 1; row++) {
TableRow tableRow = new TableRow(this);
tableRow.setLayoutParams(new LayoutParams(
(blockDimension + 2 * blockPadding)
* numberOfColumnsInMineField, blockDimension + 2
* blockPadding));
for (int column = 1; column < numberOfColumnsInMineField + 1; column++) {
blocks[row][column].setLayoutParams(new LayoutParams(
blockDimension + 2 * blockPadding, blockDimension + 2
* blockPadding));
blocks[row][column].setPadding(blockPadding, blockPadding,
blockPadding, blockPadding);
tableRow.addView(blocks[row][column]);
}
mineField.addView(tableRow, new TableLayout.LayoutParams(
(blockDimension + 2 * blockPadding)
* numberOfColumnsInMineField, blockDimension + 2
* blockPadding));
}
}

private void endExistingGame() {
stopTimer(); // stop if timer is running
txtTimer.setText("000"); // revert all text
txtMineCount.setText("000"); // revert mines count
btnSmile.setBackgroundResource(R.drawable.smile);

// remove all rows from mineField TableLayout
mineField.removeAllViews();

// set all variables to support end of game
isTimerStarted = false;
areMinesSet = false;
isGameOver = false;
minesToFind = 0;

}

private boolean checkGameWin() {
for (int row = 1; row < numberOfRowsInMineField + 1; row++) {
for (int column = 1; column < numberOfColumnsInMineField + 1; column++) {
if (!blocks[row][column].hasMine()
&& blocks[row][column].isCovered()) {
return false;
}
}
}
return true;
}

private void updateMineCountDisplay() {
if (minesToFind < 0) {
txtMineCount.setText(Integer.toString(minesToFind));
} else if (minesToFind < 10) {
txtMineCount.setText("00" + Integer.toString(minesToFind));
} else if (minesToFind < 100) {
txtMineCount.setText("0" + Integer.toString(minesToFind));
} else {
txtMineCount.setText(Integer.toString(minesToFind));
}
}

private void winGame() {
stopTimer();
isTimerStarted = false;
isGameOver = true;
minesToFind = 0; // set mine count to 0

// set icon to cool dude
btnSmile.setBackgroundResource(R.drawable.cool);

updateMineCountDisplay(); // update mine count

// disable all buttons
// set flagged all un-flagged blocks
for (int row = 1; row < numberOfRowsInMineField + 1; row++) {
for (int column = 1; column < numberOfColumnsInMineField + 1; column++) {
blocks[row][column].setClickable(false);
if (blocks[row][column].hasMine()) {
blocks[row][column].setBlockAsDisabled(false);
blocks[row][column].setFlagIcon(true);
}
}
}

// show message
showDialog("You won in " + Integer.toString(secondsPassed)
+ " seconds!", 1000, false, true);
}

private void finishGame(int currentRow, int currentColumn) {
isGameOver = true; // mark game as over
stopTimer(); // stop timer
isTimerStarted = false;
btnSmile.setBackgroundResource(R.drawable.sad);

// show all mines
// disable all blocks
for (int row = 1; row < numberOfRowsInMineField + 1; row++) {
for (int column = 1; column < numberOfColumnsInMineField + 1; column++) {
// disable block
blocks[row][column].setBlockAsDisabled(false);

// block has mine and is not flagged
if (blocks[row][column].hasMine()
&& !blocks[row][column].isFlagged()) {
// set mine icon
blocks[row][column].setMineIcon(false);
}

// block is flagged and doesn't not have mine
if (!blocks[row][column].hasMine()
&& blocks[row][column].isFlagged()) {
// set flag icon
blocks[row][column].setFlagIcon(false);
}

// block is flagged
if (blocks[row][column].isFlagged()) {
// disable the block
blocks[row][column].setClickable(false);
}
}
}

// trigger mine
blocks[currentRow][currentColumn].triggerMine();

// show message
showDialog("You tried for " + Integer.toString(secondsPassed)
+ " seconds!", 1000, false, false);
}

private void setMines(int currentRow, int currentColumn) {
// set mines excluding the location where user clicked
Random rand = new Random();
int mineRow, mineColumn;

for (int row = 0; row < totalNumberOfMines; row++) {
mineRow = rand.nextInt(numberOfColumnsInMineField);
mineColumn = rand.nextInt(numberOfRowsInMineField);
if ((mineRow + 1 != currentColumn)
|| (mineColumn + 1 != currentRow)) {
if (blocks[mineColumn + 1][mineRow + 1].hasMine()) {
row--; // mine is already there, don't repeat for same block
}
// plant mine at this location
blocks[mineColumn + 1][mineRow + 1].plantMine();
}
// exclude the user clicked location
else {
row--;
}
}

int nearByMineCount;

for (int row = 0; row < numberOfRowsInMineField + 2; row++) {
for (int column = 0; column < numberOfColumnsInMineField + 2; column++) {
// for each block find nearby mine count
nearByMineCount = 0;
if ((row != 0) && (row != (numberOfRowsInMineField + 1))
&& (column != 0)
&& (column != (numberOfColumnsInMineField + 1))) {
// check in all nearby blocks
for (int previousRow = -1; previousRow < 2; previousRow++) {
for (int previousColumn = -1; previousColumn < 2; previousColumn++) {
if (blocks[row + previousRow][column
+ previousColumn].hasMine()) {
// a mine was found so increment the counter
nearByMineCount++;
}
}
}

blocks[row][column]
.setNumberOfMinesInSurrounding(nearByMineCount);
}
// for side rows (0th and last row/column)
// set count as 9 and mark it as opened
else {
blocks[row][column].setNumberOfMinesInSurrounding(9);
blocks[row][column].OpenBlock();
}
}
}
}

// open clicked block
blocks[rowClicked][columnClicked].OpenBlock();

// if clicked block have nearby mines then don't open further
if (blocks[rowClicked][columnClicked].getNumberOfMinesInSorrounding() != 0) {
return;
}

// open next 3 rows and 3 columns recursively
for (int row = 0; row < 3; row++) {
for (int column = 0; column < 3; column++) {
// check all the above checked conditions
// if met then open subsequent blocks
if (blocks[rowClicked + row - 1][columnClicked + column - 1]
.isCovered()
&& (rowClicked + row - 1 > 0)
&& (columnClicked + column - 1 > 0)
&& (rowClicked + row - 1 < numberOfRowsInMineField + 1)
&& (columnClicked + column - 1 < numberOfColumnsInMineField + 1)) {
rippleUncover(rowClicked + row - 1, columnClicked + column
- 1);
}
}
}
return;
}

public void startTimer() {
if (secondsPassed == 0) {
timer.removeCallbacks(updateTimeElasped);
// tell timer to run call back after 1 second
timer.postDelayed(updateTimeElasped, 1000);
Log.i("tag",String.valueOf((timer.postDelayed(updateTimeElasped, 1000))) );
}
}

public void stopTimer() {
// disable call backs
timer.removeCallbacks(updateTimeElasped);
}

// timer call back when timer is ticked
private Runnable updateTimeElasped = new Runnable() {
public void run() {
long currentMilliseconds = System.currentTimeMillis();
++secondsPassed;
txtTimer.setText(Integer.toString(secondsPassed));

// add notification
timer.postAtTime(this, currentMilliseconds);
// notify to call back after 1 seconds
// basically to remain in the timer loop
timer.postDelayed(updateTimeElasped, 1000);
}
};

private void showDialog(String message, int milliseconds,
boolean useSmileImage, boolean useCoolImage) {
// show message
Toast dialog = Toast.makeText(getApplicationContext(), message,
Toast.LENGTH_LONG);

dialog.setGravity(Gravity.CENTER, 0, 0);
LinearLayout dialogView = (LinearLayout) dialog.getView();
ImageView coolImage = new ImageView(getApplicationContext());
if (useSmileImage) {
coolImage.setImageResource(R.drawable.smile);
} else if (useCoolImage) {
coolImage.setImageResource(R.drawable.cool);
} else {
coolImage.setImageResource(R.drawable.sad);
}
dialogView.addView(coolImage, 0);
dialog.setDuration(milliseconds);
dialog.show();
Log.i("tag", "showDialog()");
}

}

源码下载

更多相关文章

随机推荐