我的Android进阶之旅------>Android疯狂连连看游戏的实现之加载界面图片和实现游戏Activity(四)

正如在《我的Android进阶之旅------>Android疯狂连连看游戏的实现之状态数据模型(三)》一文中看到的，在AbstractBoard的代码中，当程序需要创建N个Piece对象时，程序会直接调用ImageUtil的getPlayImages()方法去获取图片，该方法会随机从res/drawable目录中取得N张图片。

下面是res/drawable目录视图：

为了让getPlayImages()方法能随机从res/drawable目录中取得N张图片，具体实现分为以下几步：

1. 通过反射来获取R.drawable的所有Field(Android的每张图片资源都会自动转换为R.drawable的静态Field),并将这些Field值添加到一个List集合中。
2. 从第一步得到的List集合中随机“抽取”N/2个图片ID。
3. 将第二步得到的N/2个图片ID全部复制一份，这样就得到了N个图片ID,而且每个图片ID都可以找到与之配对的。
4. 将第三步得到的N个图片ID再次“随机打乱”，并根据图片ID加载相应的Bitmap对象，最后把图片ID及对应的Bitmap封装成PieceImage对象后返回。

下面是ImageUtil类的代码：cn\oyp\link\utils\ImageUtil.java

package cn.oyp.link.utils;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import cn.oyp.link.R;
import cn.oyp.link.view.PieceImage;

/**
 * 图片资源工具类, 主要用于读取游戏图片资源值<br/>
 * <br/>
 * 关于本代码介绍可以参考一下博客: <a href="http://blog.csdn.net/ouyang_peng">欧阳鹏的CSDN博客</a> <br/>
 */
public class ImageUtil {
	/**
	 *  保存所有连连看图片资源值(int类型)
	 */
	private static List<Integer> imageValues = getImageValues();

	/**
	 *  获取连连看所有图片的ID（约定所有图片ID以p_开头）
	 */
	public static List<Integer> getImageValues() {
		try {
			// 得到R.drawable所有的属性, 即获取drawable目录下的所有图片
			Field[] drawableFields = R.drawable.class.getFields();
			List<Integer> resourceValues = new ArrayList<Integer>();
			for (Field field : drawableFields) {
				// 如果该Field的名称以p_开头
				if (field.getName().indexOf("p_") != -1) {
					resourceValues.add(field.getInt(R.drawable.class));
				}
			}
			return resourceValues;
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 随机从sourceValues的集合中获取size个图片ID, 返回结果为图片ID的集合
	 *
	 * @param sourceValues
	 *            从中获取的集合
	 * @param size
	 *            需要获取的个数
	 * @return size个图片ID的集合
	 */
	public static List<Integer> getRandomValues(List<Integer> sourceValues,
			int size) {
		// 创建一个随机数生成器
		Random random = new Random();
		// 创建结果集合
		List<Integer> result = new ArrayList<Integer>();
		for (int i = 0; i < size; i++) {
			try {
				// 随机获取一个数字，大于、小于sourceValues.size()的数值
				int index = random.nextInt(sourceValues.size());
				// 从图片ID集合中获取该图片对象
				Integer image = sourceValues.get(index);
				// 添加到结果集中
				result.add(image);
			} catch (IndexOutOfBoundsException e) {
				return result;
			}
		}
		return result;
	}

	/**
	 * 从drawable目录中中获取size个图片资源ID(以p_为前缀的资源名称), 其中size为游戏数量
	 *
	 * @param size
	 *            需要获取的图片ID的数量
	 * @return size个图片ID的集合
	 */
	public static List<Integer> getPlayValues(int size) {
		if (size % 2 != 0) {
			// 如果该数除2有余数，将size加1
			size += 1;
		}
		// 再从所有的图片值中随机获取size的一半数量,即N/2张图片
		List<Integer> playImageValues = getRandomValues(imageValues, size / 2);
		// 将playImageValues集合的元素增加一倍（保证所有图片都有与之配对的图片），即N张图片
		playImageValues.addAll(playImageValues);
		// 将所有图片ID随机“洗牌”
		Collections.shuffle(playImageValues);
		return playImageValues;
	}

	/**
	 * 将图片ID集合转换PieceImage对象集合，PieceImage封装了图片ID与图片本身
	 *
	 * @param context
	 * @param resourceValues
	 * @return size个PieceImage对象的集合
	 */
	public static List<PieceImage> getPlayImages(Context context, int size) {
		// 获取图片ID组成的集合
		List<Integer> resourceValues = getPlayValues(size);
		List<PieceImage> result = new ArrayList<PieceImage>();
		// 遍历每个图片ID
		for (Integer value : resourceValues) {
			// 加载图片
			Bitmap bm = BitmapFactory.decodeResource(context.getResources(),
					value);
			// 封装图片ID与图片本身
			PieceImage pieceImage = new PieceImage(bm, value);
			result.add(pieceImage);
		}
		return result;
	}

	/**
	 *  获取选中标识的图片
	 * @param context
	 * @return 选中标识的图片
	 */
	public static Bitmap getSelectImage(Context context) {
		Bitmap bm = BitmapFactory.decodeResource(context.getResources(),
				R.drawable.selected);
		return bm;
	}
}

前面已经给出了游戏界面的布局文件，该布局文件需要一个Activity来负责显示，除此之外，Activity还需要为游戏界面的按钮、GameView组件的事件提供事件监听器。

尤其是对于GameView组件，程序需要监听用户的触摸动作，当用户触摸屏幕时，程序需要获取用户触摸的是哪个方块，并判断是否需要“消除”该方块。为了判断是否消除该方块，程序需要进行如下判断：

• 如果程序之前已经选择了某个方块，就判断当前触碰的方块是否能和之前的方块“相连”，如果可以相连，则消除两个方块；如果不能相连，则把当前方块设置为选中方块。
• 如果程序之前没有选中方块，直接将当前方块设置为选中方块。

下面是Activity的代码：cn\oyp\link\LinkActivity.java

package cn.oyp.link;

import java.util.Timer;
import java.util.TimerTask;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Vibrator;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import cn.oyp.link.board.GameService;
import cn.oyp.link.board.impl.GameServiceImpl;
import cn.oyp.link.utils.GameConf;
import cn.oyp.link.utils.LinkInfo;
import cn.oyp.link.view.GameView;
import cn.oyp.link.view.Piece;

/**
 * 游戏Activity <br/>
 * <br/>
 * 关于本代码介绍可以参考一下博客: <a href="http://blog.csdn.net/ouyang_peng">欧阳鹏的CSDN博客</a> <br/>
 */
public class LinkActivity extends Activity {
	/**
	 * 游戏配置对象
	 */
	private GameConf config;
	/**
	 * 游戏业务逻辑接口
	 */
	private GameService gameService;
	/**
	 * 游戏界面
	 */
	private GameView gameView;
	/**
	 * 开始按钮
	 */
	private Button startButton;
	/**
	 * 记录剩余时间的TextView
	 */
	private TextView timeTextView;
	/**
	 * 失败后弹出的对话框
	 */
	private AlertDialog.Builder lostDialog;
	/**
	 * 游戏胜利后的对话框
	 */
	private AlertDialog.Builder successDialog;
	/**
	 * 定时器
	 */
	private Timer timer = new Timer();
	/**
	 * 记录游戏的剩余时间
	 */
	private int gameTime;
	/**
	 * 记录是否处于游戏状态
	 */
	private boolean isPlaying;
	/**
	 * 振动处理类
	 */
	private Vibrator vibrator;
	/**
	 * 记录已经选中的方块
	 */
	private Piece selectedPiece = null;
	/**
	 * Handler类，异步处理
	 */
	private Handler handler = new Handler() {
		public void handleMessage(Message msg) {
			switch (msg.what) {
			case 0x123:
				timeTextView.setText("剩余时间： " + gameTime);
				gameTime--; // 游戏剩余时间减少
				// 时间小于0, 游戏失败
				if (gameTime < 0) {
					// 停止计时
					stopTimer();
					// 更改游戏的状态
					isPlaying = false;
					// 失败后弹出对话框
					lostDialog.show();
					return;
				}
				break;
			}
		}
	};

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		// 初始化界面
		init();
	}

	/**
	 * 初始化游戏的方法
	 */
	private void init() {
		config = new GameConf(8, 9, 2, 10, GameConf.DEFAULT_TIME, this);
		// 得到游戏区域对象
		gameView = (GameView) findViewById(R.id.gameView);
		// 获取显示剩余时间的文本框
		timeTextView = (TextView) findViewById(R.id.timeText);
		// 获取开始按钮
		startButton = (Button) this.findViewById(R.id.startButton);
		// 获取振动器
		vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);
		// 初始化游戏业务逻辑接口
		gameService = new GameServiceImpl(this.config);
		// 设置游戏逻辑的实现类
		gameView.setGameService(gameService);
		// 为开始按钮的单击事件绑定事件监听器
		startButton.setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View source) {
				startGame(GameConf.DEFAULT_TIME);
			}
		});
		// 为游戏区域的触碰事件绑定监听器
		this.gameView.setOnTouchListener(new View.OnTouchListener() {
			public boolean onTouch(View view, MotionEvent e) {
				if (e.getAction() == MotionEvent.ACTION_DOWN) {
					gameViewTouchDown(e);
				}
				if (e.getAction() == MotionEvent.ACTION_UP) {
					gameViewTouchUp(e);
				}
				return true;
			}
		});
		// 初始化游戏失败的对话框
		lostDialog = createDialog("Lost", "游戏失败！ 重新开始", R.drawable.lost)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {
					public void onClick(DialogInterface dialog, int which) {
						startGame(GameConf.DEFAULT_TIME);
					}
				});
		// 初始化游戏胜利的对话框
		successDialog = createDialog("Success", "游戏胜利！ 重新开始",
				R.drawable.success).setPositiveButton("确定",
				new DialogInterface.OnClickListener() {
					public void onClick(DialogInterface dialog, int which) {
						startGame(GameConf.DEFAULT_TIME);
					}
				});
	}

	@Override
	protected void onPause() {
		// 暂停游戏
		stopTimer();
		super.onPause();
	}

	@Override
	protected void onResume() {
		// 如果处于游戏状态中
		if (isPlaying) {
			// 以剩余时间重新开始游戏
			startGame(gameTime);
		}
		super.onResume();
	}

	/**
	 * 触碰游戏区域的处理方法
	 *
	 * @param event
	 */
	private void gameViewTouchDown(MotionEvent event) {
		// 获取GameServiceImpl中的Piece[][]数组
		Piece[][] pieces = gameService.getPieces();
		// 获取用户点击的x座标
		float touchX = event.getX();
		// 获取用户点击的y座标
		float touchY = event.getY();
		// 根据用户触碰的座标得到对应的Piece对象
		Piece currentPiece = gameService.findPiece(touchX, touchY);
		// 如果没有选中任何Piece对象(即鼠标点击的地方没有图片), 不再往下执行
		if (currentPiece == null)
			return;
		// 将gameView中的选中方块设为当前方块
		this.gameView.setSelectedPiece(currentPiece);
		// 表示之前没有选中任何一个Piece
		if (this.selectedPiece == null) {
			// 将当前方块设为已选中的方块, 重新将GamePanel绘制, 并不再往下执行
			this.selectedPiece = currentPiece;
			this.gameView.postInvalidate();
			return;
		}
		// 表示之前已经选择了一个
		if (this.selectedPiece != null) {
			// 在这里就要对currentPiece和prePiece进行判断并进行连接
			LinkInfo linkInfo = this.gameService.link(this.selectedPiece,
					currentPiece);
			// 两个Piece不可连, linkInfo为null
			if (linkInfo == null) {
				// 如果连接不成功, 将当前方块设为选中方块
				this.selectedPiece = currentPiece;
				this.gameView.postInvalidate();
			} else {
				// 处理成功连接
				handleSuccessLink(linkInfo, this.selectedPiece, currentPiece,
						pieces);
			}
		}
	}

	/**
	 * 触碰游戏区域的处理方法
	 *
	 * @param e
	 */
	private void gameViewTouchUp(MotionEvent e) {
		this.gameView.postInvalidate();
	}

	/**
	 * 以gameTime作为剩余时间开始或恢复游戏
	 *
	 * @param gameTime
	 *            剩余时间
	 */
	private void startGame(int gameTime) {
		// 如果之前的timer还未取消，取消timer
		if (this.timer != null) {
			stopTimer();
		}
		// 重新设置游戏时间
		this.gameTime = gameTime;
		// 如果游戏剩余时间与总游戏时间相等，即为重新开始新游戏
		if (gameTime == GameConf.DEFAULT_TIME) {
			// 开始新的游戏游戏
			gameView.startGame();
		}
		isPlaying = true;
		this.timer = new Timer();
		// 启动计时器 ， 每隔1秒发送一次消息
		this.timer.schedule(new TimerTask() {
			public void run() {
				handler.sendEmptyMessage(0x123);
			}
		}, 0, 1000);
		// 将选中方块设为null。
		this.selectedPiece = null;
	}

	/**
	 * 成功连接后处理
	 *
	 * @param linkInfo
	 *            连接信息
	 * @param prePiece
	 *            前一个选中方块
	 * @param currentPiece
	 *            当前选择方块
	 * @param pieces
	 *            系统中还剩的全部方块
	 */
	private void handleSuccessLink(LinkInfo linkInfo, Piece prePiece,
			Piece currentPiece, Piece[][] pieces) {
		// 它们可以相连, 让GamePanel处理LinkInfo
		this.gameView.setLinkInfo(linkInfo);
		// 将gameView中的选中方块设为null
		this.gameView.setSelectedPiece(null);
		this.gameView.postInvalidate();
		// 将两个Piece对象从数组中删除
		pieces[prePiece.getIndexX()][prePiece.getIndexY()] = null;
		pieces[currentPiece.getIndexX()][currentPiece.getIndexY()] = null;
		// 将选中的方块设置null。
		this.selectedPiece = null;
		// 手机振动(100毫秒)
		this.vibrator.vibrate(100);
		// 判断是否还有剩下的方块, 如果没有, 游戏胜利
		if (!this.gameService.hasPieces()) {
			// 游戏胜利
			this.successDialog.show();
			// 停止定时器
			stopTimer();
			// 更改游戏状态
			isPlaying = false;
		}
	}

	/**
	 * 创建对话框的工具方法
	 *
	 * @param title
	 *            标题
	 * @param message
	 *            内容
	 * @param imageResource
	 *            图片
	 * @return
	 */
	private AlertDialog.Builder createDialog(String title, String message,
			int imageResource) {
		return new AlertDialog.Builder(this).setTitle(title)
				.setMessage(message).setIcon(imageResource);
	}

	/**
	 * 停止计时
	 */
	private void stopTimer() {
		// 停止定时器
		this.timer.cancel();
		this.timer = null;
	}
}

该Activity用了两个类,这两个类在下一篇博客中再进行相关描述。

1. GameConf:负责管理游戏的初始化设置信息。
2. GameService：负责游戏的逻辑实现。

关于具体的实现步骤，请参考下面的链接：

• 我的Android进阶之旅------>Android疯狂连连看游戏的实现之游戏效果预览(一)
  
• 我的Android进阶之旅------>Android疯狂连连看游戏的实现之开发游戏界面(二)
  
• 我的Android进阶之旅------>Android疯狂连连看游戏的实现之状态数据模型(三)
• 我的Android进阶之旅------>Android疯狂连连看游戏的实现之加载界面图片和实现游戏Activity(四)
• 我的Android进阶之旅------>Android疯狂连连看游戏的实现之实现游戏逻辑(五)

==================================================================================================

  作者：欧阳鹏  欢迎转载，与人分享是进步的源泉！

  转载请保留原文地址：http://blog.csdn.net/ouyang_peng

==================================================================================================