android开发学习之路——连连看之游戏Activity（四）

    前面连连看之游戏界面（一）中已设计出游戏界面的布局文件，该布局文件需要使用一个Activity来负责显示，除此以外，Activity还需要为游戏界面的按钮、GameView组件的事件提供事件监听器。

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

    ·如果程序之前已经选中了某个方块，就判断当前触碰多的方块是否能与之前的方块“相连”，如果可以相连，则消除两个方块；如果两个方块不可以相连，则把当前方块设置为选中方块。

    ·如果程序之前没有选中方块，直接将当前方块设置为选中方块。

    Activity的代码如下：srcorgcrazyitlinkLink.java

public class Link 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 selected = null;
    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 , 100000, 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();
    }

    // 触碰游戏区域的处理方法
    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.selected == null)
        {
            // 将当前方块设为已选中的方块, 重新将GamePanel绘制, 并不再往下执行
            this.selected = currentPiece;
            this.gameView.postInvalidate();
            return;
        }
        // 表示之前已经选择了一个
        if (this.selected != null)
        {
            // 在这里就要对currentPiece和prePiece进行判断并进行连接
            LinkInfo linkInfo = this.gameService.link(this.selected,
                currentPiece);
            // 两个Piece不可连, linkInfo为null
            if (linkInfo == null)
            {
                // 如果连接不成功, 将当前方块设为选中方块
                this.selected = currentPiece;
                this.gameView.postInvalidate();
            }
            else
            {
                // 处理成功连接
                handleSuccessLink(linkInfo, this.selected
                    , currentPiece, pieces);
            }
        }
    }
    // 触碰游戏区域的处理方法
    private void gameViewTouchUp(MotionEvent e)
    {
        this.gameView.postInvalidate();
    }
    
    // 以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.selected = 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.selected = null;
        // 手机振动(100毫秒)
        this.vibrator.vibrate(100);
        // 判断是否还有剩下的方块, 如果没有, 游戏胜利
        if (!this.gameService.hasPieces())
        {
            // 游戏胜利
            this.successDialog.show();
            // 停止定时器
            stopTimer();
            // 更改游戏状态
            isPlaying = false;
        }
    }

    // 创建对话框的工具方法
    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;
    }
}

    上面代码中的gameViewTouchDown（）方法负责处理触碰事件。它会先根据触碰点计算出触碰的方法。接下来该方法会判断是否之前已有选中的方块，如果没有，直接将当前方块设为选中方块，如果有，判断两个方块是否可以相连。

    如果两个方块可以相连，程序将会从Piece[][]数组中删除这两个方块，该逻辑由handleSuccessLink()方法完成。

    除此之外，该程序为了控制时间流失，定义了一个计时器，该计时器每隔1秒发送一条消息，程序将会根据该消息减少游戏剩余的时间。

    该Link Activity用的两个类如下：

    ·GameConf：负责管理游戏的初始化设置信息。

    ·GameService：负责游戏的逻辑实现。

    上面两个工具类中GameConf只是一个简单的设置类，代码如下：

public class GameConf
{
    // 设置连连看的每个方块的图片的宽、高
    public static final int PIECE_WIDTH = 40;
    public static final int PIECE_HEIGHT = 40;
    // 记录游戏的总事件（100秒）.
    public static int DEFAULT_TIME = 100;    
    // Piece[][]数组第一维的长度
    private int xSize;
    // Piece[][]数组第二维的长度
    private int ySize;
    // Board中第一张图片出现的x座标
    private int beginImageX;
    // Board中第一张图片出现的y座标
    private int beginImageY;
    // 记录游戏的总时间, 单位是秒
    private long gameTime;
    private Context context;

    /**
     * 提供一个参数构造器
     * 
     * @param xSize Piece[][]数组第一维长度
     * @param ySize Piece[][]数组第二维长度
     * @param beginImageX Board中第一张图片出现的x座标
     * @param beginImageY Board中第一张图片出现的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;
    }

    public long getGameTime()
    {
        return gameTime;
    }

    public int getXSize()
    {
        return xSize;
    }

    public int getYSize()
    {
        return ySize;
    }

    public int getBeginImageX()
    {
        return beginImageX;
    }

    public int getBeginImageY()
    {
        return beginImageY;
    }

    public Context getContext()
    {
        return context;
    }
}

具体实现步骤连接：

android开发学习之路——连连看之游戏界面（一）

android开发学习之路——连连看之数据模型（二）

android开发学习之路——连连看之加载图片（三）

android开发学习之路——连连看之游戏Activity（四）

android开发学习之路——连连看之游戏逻辑（五）