13.2　魔幻矩阵——2048

13.2　魔幻矩阵——2048" level="2">13.2　魔幻矩阵——2048
- 13.2.1　2048概述" level="3">13.2.1　2048概述
- 13.2.2　2048游戏分析" level="3">13.2.2　2048游戏分析
  - 13.2.2.1　确定布局
  - 13.2.2.2　确定算法
- 13.2.3　2048初始化工作" level="3">13.2.3　2048初始化工作
  - 13.2.3.1　游戏主界面
  - 13.2.3.2　配置界面
- 13.2.4　小方块设计" level="3">13.2.4　小方块设计
- 13.2.5　全局设置" level="3">13.2.5　全局设置
- 13.2.6　游戏面板设计" level="3">13.2.6　游戏面板设计
- 13.2.7　主程序设计" level="3">13.2.7　主程序设计
  - 13.2.7.1　添加游戏面板和游戏信息
  - 13.2.7.2　动画效果
- 13.2.8　功能进阶" level="3">13.2.8　功能进阶

13.2　魔幻矩阵——2048" class="reference-link">13.2　魔幻矩阵——2048

本例要实现的是一个数字矩阵游戏——2048，相信这个游戏大家应该非常熟悉了，从Web版、PC版到手机版，各种各样的2048游戏着实火了一把。除了基础型的2048，后来各种衍生版的2048也层出不穷，例如六边形版、朝代版等。

13.2.1　2048概述" class="reference-link">13.2.1　2048概述

2048的游戏规则很简单，让人上手非常容易，但是游戏的过程却非常吸引人，让人很有游戏的动力。游戏界面也非常简单，一开始整体4×4一共16个小格子，随机在两个小格子中出现数字，数字随机为2或者4。玩家每次用手指进行上、下、左、右滑动，所有数字就会向滑动方向靠拢，遇到相同的数字则相加、合并。移动成功后，会在剩余的空格中随机出现一个数字，2或者4，直到数字合并到2048，则挑战成功。

在网上最多的版本就是基于Cocos2d开发的版本。的确，这款游戏引擎用来开发2D游戏是非常方便的。但作为Android开发者，我们希望能够使用原生Android来开发一款这样的游戏。正是这样一个念头，在2048火了之后，笔者就开始着手制作2048这款游戏。先来看一下这个游戏的游戏界面，对2048有一个大致的认识，如图13.10所示。

图13.10　2048游戏界面

游戏界面其实非常简单，整个游戏的核心便是中间的游戏面板，最下面的三个控制菜单和最上面的信息显示区域，则是辅助游戏的功能。那么这样一个界面，该如何去实现呢？

13.2.2　2048游戏分析" class="reference-link">13.2.2　2048游戏分析

13.2.2.1　确定布局

面板

游戏的面板，即4×4的格子面板。它是本实例实现的关键。要实现这个布局，方法有很多，例如自定义一个View，这个是万能方法，但是需要计算各个小方块的坐标，比较复杂。再比如用GridView，但是却不太好控制空格的小方块。因此，笔者最后选用了GridLayout布局，这个布局是Android 4.0新增的布局。该布局的引入，极大地方便了Grid类型的布局开发，不熟悉该布局的读者朋友可以在Android开发者网站上找到相关的开发资料。

小方块

游戏中移动的小方块是2048最小的游戏对象。通过面向对象的设计方法，可以将这些小方块抽象成一个个对象。小方块的颜色、显示数字等属性都在对象中进行设置。对方块的合并、产生等操作，也是基于对象的操作，这样非常有利于程序逻辑的控制。

13.2.2.2　确定算法

2048虽然游戏过程非常简单，但是对判断小方块的合并、产生的算法也是有一定要求的，如果算法太过复杂，那么就会造成画面的卡顿。这对于一个游戏来说，是最不能让用户接受的。这里笔者提供了一种效率比较高的算法。当然，2048的算法是非常多的，读者朋友们可以重新设计自己的算法，笔者的算法简单描述如下：

玩家在进行上、下、左、右地滑动时，先去判断每行（列），使用0来代表空格，如果某一行（列）的数字为2 2 0 4，那么首先将这一行（列）的非0数字存入一个list，即224。接下来，根据游戏规则，将2和2进行合并，即44。并将其作为该行（列）的返回值，从滑动的方向开始放置list中的数字。这样将每行（列）处理完毕后，就完成了一次滑动。

13.2.3　2048初始化工作" class="reference-link">13.2.3　2048初始化工作

13.2.3.1　游戏主界面

游戏界面如图13.10所示，由于游戏面板部分我们准备重写GridLayout来实现，因此在布局的时候，只需要预留出面板的位置来实现其他部分的布局即可。剩下的布局，都是一些最基本的布局方式，唯一需要注意的是，在布局中，我们使用了自定义的Shape来美化系统控件，如图13.11所示。

图13.11　Shape美化控件

这一方法在前面的实例中已经用的很多了，而且对于实现扁平化的UI风格，是非常重要的一个技巧。

13.2.3.2　配置界面

2048游戏的定制性非常强，如果仅仅实现一个4×4，目标为2048的游戏，那就显得太单调了。因此，可以设计一个配置界面，让用户来选择游戏的难度、增加趣味性，这里笔者给出了一个游戏配置界面供大家参考，如图13.12所示。

图13.12　2048配置界面

在这个配置界面中，可以设置游戏的难度，即不是简单的4×4共16个小方块，还可以是5×5、6×6等类型，相信大家在实现了4×4的2048后，实现其他难度的2048，应该是非常简单的了。同时，还可以设定需要完成的目标，即目标2048或者4096等，读者朋友们可以根据自身技术的高低，选择不同的模板，增加游戏的可玩性。

界面的设计同样是非常简单的，在按钮的美化上，与之前一样，借助了Shape和Selector来进行美化。

13.2.4　小方块设计" class="reference-link">13.2.4　小方块设计

2048游戏中滑动的小方块是游戏最终操作的最小单元。游戏的面板使用的是GridLayout，在设计好小方块之后，只要将不同属性的小方块加入到GridLayout中即可。那么该如何实现这样的小方块呢？不光是简单地实现，更需要最大限度地提高效率。

基于效率的考虑，让小方块——GameItem继承自FrameLayout，FrameLayout是几大布局中最轻量级的布局，并给在GameItem中给小方块设置了要显示的数字，并根据要显示的数字来设置相应的颜色。这些都通过小方块GameItem的构造方法来实现，代码如下所示。

    public GameItem(Context context, int cardShowNum) {
        super(context);
        this.mCardShowNum = cardShowNum;
        //初始化Item
        initCardItem();
    }

根据传入的cardShowNum，确定该小方块应该显示的数字和颜色。在初始化Item方法中，首先将背景颜色都设置为灰色，从而将整个面板展现成一个大的灰色布局，再将其中用于显示Item的TextView设置对应数字的背景颜色和边距，来展现一个游戏小方块，代码如下所示。

    /**
     *初始化Item
     */
    private void initCardItem() {
        //设置面板背景色，是由Frame拼起来的
        setBackgroundColor(Color.GRAY);
        mTvNum = new TextView(getContext());
        setNum(mCardShowNum);
        //修改5×5时字体太大
        int gameLines = Config.mSp.getInt(Config.KEY_GAME_LINES, 4);
        if (gameLines == 4) {
            mTvNum.setTextSize(35);
        } else if (gameLines == 5) {
            mTvNum.setTextSize(25);
        } else {
            mTvNum.setTextSize(20);
        }
        TextPaint tp = mTvNum.getPaint();
        tp.setFakeBoldText(true);
        mTvNum.setGravity(Gravity.CENTER);
 
        mParams = new LayoutParams(LayoutParams.MATCH_PARENT,
                LayoutParams.MATCH_PARENT);
        mParams.setMargins(5, 5, 5, 5);
        addView(mTvNum, mParams);
    }

其中setNum(mCardShowNum)方法如下所示。

    public void setNum(int num) {
        this.mCardShowNum = num;
        if (num == 0) {
            mTvNum.setText("");
        } else {
            mTvNum.setText("" + num);
        }
        //设置背景颜色
        switch (num) {
            case 0:
                mTvNum.setBackgroundColor(0x00000000);
                break;
            case 2:
                mTvNum.setBackgroundColor(0xffeee5db);
                break;
            case 4:
                mTvNum.setBackgroundColor(0xffeee0ca);
                break;
            case 8:
                mTvNum.setBackgroundColor(0xfff2c17a);
                break;
            case 16:
                mTvNum.setBackgroundColor(0xfff59667);
                break;
            case 32:
                mTvNum.setBackgroundColor(0xfff68c6f);
                break;
            case 64:
                mTvNum.setBackgroundColor(0xfff66e3c);
                break;
            case 128:
                mTvNum.setBackgroundColor(0xffedcf74);
                break;
            case 256:
                mTvNum.setBackgroundColor(0xffedcc64);
                break;
            case 512:
                mTvNum.setBackgroundColor(0xffedc854);
                break;
            case 1024:
                mTvNum.setBackgroundColor(0xffedc54f);
                break;
            case 2048:
                mTvNum.setBackgroundColor(0xffedc32e);
                break;
            default:
                mTvNum.setBackgroundColor(0xff3c4a34);
                break;
        }
    }

在setNum()方法中，给不同的数字设置不同的显示颜色，这里笔者提供了一套数字显示的颜色，读者可以根据自己的喜好来设置不同的颜色。而且，这里不仅仅可以设置颜色作为背景，同样可以设置图片作为背景，网上有很多2048的换肤版，用不同的图片来代替颜色，其实只要将这里的TextView换成ImageView，并将对应数字的图片设置给不同数字即可实现。

13.2.5　全局设置" class="reference-link">13.2.5　全局设置

由于游戏具有配置功能，所以需要使用一个数据持久化方法来保存这些配置，并在游戏开始时，Android提供了SharedPreferences数据持久化接口，它非常适合配置信息的保存，因此创建一个Application类——Config，并在Mainifest文件中设置程序的Application入口，代码如下所示。

    <application
        android:name=".config.Config"
        ……
    </application>

在Config类中，完成对游戏配置文件的读写，并给其增加默认的游戏配置值，代码如下所示。

    package com.imooc.game2048.config;
 
    import android.app.Application;
    import android.content.SharedPreferences;
 
    public class Config extends Application {
 
        /**
         * SP对象
         */
        public static SharedPreferences mSp;
 
        /**
         * Game Goal
         */
        public static int mGameGoal;
 
        /**
         * GameView行列数
         */
        public static int mGameLines;
 
        /**
         * Item宽高
 
         */
        public static int mItemSize;
 
        /**
         *记录分数
         */
        public static int SCROE = 0;
 
        public static String SP_HIGH_SCROE = "SP_HIGHSCROE";
 
        public static String KEY_HIGH_SCROE = "KEY_HighScore";
 
        public static String KEY_GAME_LINES = "KEY_GAMELINES";
 
        public static String KEY_GAME_GOAL = "KEY_GameGoal";
 
        @Override
        public void onCreate() {
            super.onCreate();
            mSp = getSharedPreferences(SP_HIGH_SCROE, 0);
            mGameLines = mSp.getInt(KEY_GAME_LINES, 4);
            mGameGoal = mSp.getInt(KEY_GAME_GOAL, 2048);
            mItemSize = 0;
        }
    }

13.2.6　游戏面板设计" class="reference-link">13.2.6　游戏面板设计

13.2.6.1　初始化游戏矩阵

在初始化游戏矩阵时，首先需要移除之前游戏的所有布局，并通过从配置文件中读取出来的配置值来生成游戏的布局，无论是4×4还是其他布局，并由此来计算出每个小方块的具体宽度，代码如下所示。

    /**
     *初始化View
     */
    private void initGameMatrix() {
        //初始化矩阵
        removeAllViews();
        mScoreHistory = 0;
        Config.SCROE = 0;
        Config.mGameLines = Config.mSp.getInt(Config.KEY_GAME_LINES, 4);
        mGameLines = Config.mGameLines;
        mGameMatrix = new GameItem[mGameLines][mGameLines];
        mGameMatrixHistory = new int[mGameLines][mGameLines];
        mCalList = new ArrayList<Integer>();
        mBlanks = new ArrayList<Point>();
        mHighScore = Config.mSp.getInt(Config.KEY_HIGH_SCROE, 0);
        setColumnCount(mGameLines);
        setRowCount(mGameLines);
        setOnTouchListener(this);
        //初始化View参数
        DisplayMetrics metrics = new DisplayMetrics();
        WindowManager wm = (WindowManager) getContext().getSystemService(
                Context.WINDOW_SERVICE);
        Display display = wm.getDefaultDisplay();
        display.getMetrics(metrics);
        Config.mItemSize = metrics.widthPixels / Config.mGameLines;
        initGameView(Config.mItemSize);
    }

在完成面板的初始化之后，就要根据具体的游戏难度，对游戏矩阵进行初始化，即在如上所示代码中的initGameView(Config.mItemSize)方法。在该方法中，首先将所有小方块都设置为0，然后根据游戏规则，随机添加两个数字到面板中，代码如下所示。

    private void initGameView(int cardSize) {
        removeAllViews();
        GameItem card;
 
        for (int i = 0; i < mGameLines; i++) {
            for (int j = 0; j < mGameLines; j++) {
                card = new GameItem(getContext(), 0);
                addView(card, cardSize, cardSize);
                //初始化GameMatrix全部为0空格List为所有
                mGameMatrix[i][j] = card;
                mBlanks.add(new Point(i, j));
            }
        }
        //添加随机数字
        addRandomNum();
        addRandomNum();
    }

对于添加随机数字，封装了addRandomNum()方法，并将所有的空格以Point(x, y)的形式保存在mBlankslist中，代码如下所示。

    /**
     *添加随机数字
     */
    private void addRandomNum() {
        getBlanks();
        if (mBlanks.size() > 0) {
            int randomNum = (int) (Math.random() * mBlanks.size());
            Point randomPoint = mBlanks.get(randomNum);
            mGameMatrix[randomPoint.x][randomPoint.y]
                    .setNum(Math.random() > 0.2d ? 2 : 4);
        }
    }

在如上所示的代码中，通过Math.random() > 0.2d ? 2 : 4方法来指定2和4出现的比例，例如比例为4:1，大家可以根据自己的喜好来进行设置。

13.2.6.2　增加滑动事件

初始化完毕后，我们来封装游戏面板的滑动事件。在2048游戏中，需要对上、左、右、四滑个动方向进行判断。判断的方法非常简单，只需要在onTouch()事件中捕获ACTION_DOWN事件CTION_UP事件，并判断最终的起始点坐标即可，代码如下所示。

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                saveHistoryMatrix();
                mStartX = (int) event.getX();
                mStartY = (int) event.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                break;
            case MotionEvent.ACTION_UP:
                mEndX = (int) event.getX();
                mEndY = (int) event.getY();
                judgeDirection(mEndX - mStartX, mEndY - mStartY);
                if (isMoved()) {
                    addRandomNum();
                    //修改显示分数
                    Game.getGameActivity().setScore(Config.SCROE, 0);
                }
                checkCompleted();
                break;
            default:
                break;
        }
        return true;
    }

在获取起始点坐标后，通过judgeDirection()方法，就可以判断具体的移动方向，代码如下所示。

    /**
     *根据偏移量判断移动方向
 
     *
     * @param offsetX offsetX
     * @param offsetY offsetY
     */
    private void judgeDirection(int offsetX, int offsetY) {
        int density = getDeviceDensity();
        int slideDis = 5 * density;
        int maxDis = 200 * density;
        boolean flagNormal =
                        (Math.abs(offsetX) > slideDis |
                        Math.abs(offsetY) > slideDis) &&
                        (Math.abs(offsetX) < maxDis) &&
                        (Math.abs(offsetY) < maxDis);
        boolean flagSuper = Math.abs(offsetX) > maxDis ||
                Math.abs(offsetY) > maxDis;
        if (flagNormal && !flagSuper) {
            if (Math.abs(offsetX) > Math.abs(offsetY)) {
                if (offsetX > slideDis) {
                    swipeRight();
                } else {
                    swipeLeft();             }
            } else {
                if (offsetY > slideDis) {
                    swipeDown();
                } else {
                    swipeUp();
                }
            }
        } else if (flagSuper) { //启动超级用户权限来添加自定义数字
            AlertDialog.Builder builder =
                    new AlertDialog.Builder(getContext());
            final EditText et = new EditText(getContext());
            builder.setTitle("Back Door")
                    .setView(et)
                    .setPositiveButton("OK",
                            new DialogInterface.OnClickListener() {
 
                                @Override
                                public void onClick(DialogInterface arg0,
                                                    int arg1) {
                                    if (!TextUtils.isEmpty(et.getText())) {
                                        addSuperNum(Integer.parseInt(et.getText().toString()));
                                        checkCompleted();
                                    }
                                }
                            })
                    .setNegativeButton("ByeBye",
                            new DialogInterface.OnClickListener() {
 
                                @Override
                            public void onClick(DialogInterface arg0, int arg1) {
                                    arg0.dismiss();
                                }
                            }).create().show();
        }
    }

大家可以发现，这里添加了一个超级用户权限的后门，我们规定当手指滑动的距离超过maxDis时，系统弹出一个对话框让用户输入想要生成的数字！如图13.13所示。

图13.13　超级用户权限</h4>

当然，这只是一个娱乐的功能。不过，这也体现了创造程序的乐趣，在自己的程序中，你自己就是创世者，你完全可以让程序按照你的意志来实现，这也算是一种开发程序的成就感吧。

在judgeDirection()方法中，当判断好具体滑动的方向之后，可以通过封装好的swipeRight()、swipeLeft()、swipeDown()、swipeUp()四个方法来执行小方块的合并操作。这就利用到了之前讲到的2048的游戏算法，这里以swipeLeft()方法为例，来看一下这个算法的实现，代码如下所示。

    /**
     *滑动事件：左
     */
    private void swipeLeft() {
        for (int i = 0; i < mGameLines; i++) {
            for (int j = 0; j < mGameLines; j++) {
                int currentNum = mGameMatrix[i][j].getNum();
                if (currentNum != 0) {
                    if (mKeyItemNum == -1) {
                        mKeyItemNum = currentNum;
                    } else {
                        if (mKeyItemNum == currentNum) {
                            mCalList.add(mKeyItemNum * 2);
                            Config.SCROE += mKeyItemNum * 2;
 
                            mKeyItemNum = -1;
                        } else {
                            mCalList.add(mKeyItemNum);
                            mKeyItemNum = currentNum;
                        }
                    }
                } else {
                    continue;
                }
            }
            if (mKeyItemNum != -1) {
                mCalList.add(mKeyItemNum);
            }
            //改变Item值
            for (int j = 0; j < mCalList.size(); j++) {
                mGameMatrix[i][j].setNum(mCalList.get(j));
            }
            for (int m = mCalList.size(); m < mGameLines; m++) {
                mGameMatrix[i][m].setNum(0);
            }
            //重置行参数
            mKeyItemNum = -1;
            mCalList.clear();
        }
    }

通过外层循环，遍历每一行，再通过内层循环遍历每一列，对相同的数字进行合并，并通过mKeyItemNum标识来区分是否已经进行过一次合并，例如2 2 0 4，2和2进行合并后，不会再和4进行合并。整个算法概括起来就是一句话——选取基准，挨个比较，重新排列。最后，将处理之后的数字矩阵重新设置给游戏面板的数字矩阵，从而实现滑动之后的数字矩阵变换。

13.2.6.3 记录历史矩阵

针对每次数字矩阵变换前的矩阵，我们可以使用一个二维数组保存起来。作为上一次变换的历史矩阵，这样做有两个好处。一个是可以通过对比两次数字矩阵的差异，判断是否发生了移动，另一个是可以实现“Revert”撤销功能。不过，由于“撤销”功能极大地降低了游戏的挑战性，因此笔者这里只记录了上次的历史数字矩阵，而没有记录所有的矩阵，如果读者需要实现所有步骤的“Revert”功能，可以将这些历史数字矩阵都保存到一个list中来实现。保存历史矩阵的代码如下所示。

    /**
     *保存历史记录
     */
    private void saveHistoryMatrix() {
        mScoreHistory = Config.SCROE;
        for (int i = 0; i < mGameLines; i++) {
            for (int j = 0; j < mGameLines; j++) {
                mGameMatrixHistory[i][j] = mGameMatrix[i][j].getNum();
            }
        }
    }

只需要在捕获到ACTION_DOWN事件时，进行矩阵的记录即可。有了移动前的历史矩阵，就可以通过它来实现判断是否移动过的功能和“Revert”功能，代码如下所示。

    /**
     *判断是否移动过(是否需要新增Item)
     *
     * @return是否移动
     */
    private boolean isMoved() {
        for (int i = 0; i < mGameLines; i++) {
            for (int j = 0; j < mGameLines; j++) {
                if (mGameMatrixHistory[i][j] != mGameMatrix[i][j].getNum()) {
                    return true;
                }
            }
        }
        return false;
    }
 
    /**
     *撤销上次移动
     */
    public void revertGame() {
        //第一次不能撤销
        int sum = 0;
        for (int[] element : mGameMatrixHistory) {
            for (int i : element) {
                sum += i;
            }
        }
        if (sum != 0) {
            Game.getGameActivity().setScore(mScoreHistory, 0);
            Config.SCROE = mScoreHistory;
            for (int i = 0; i < mGameLines; i++) {
                for (int j = 0; j < mGameLines; j++) {
                    mGameMatrix[i][j].setNum(mGameMatrixHistory[i][j]);
                }
            }
        }
    }

在判断发生了移动之后，就需要重新生成一个新的数字填充到剩余的空格中。添加随机数字的方法，前面已经写好了，这里只需要简单地调用即可。那么只需要一个方法来获取整个面板中剩余空格的位置。方法非常简单，直接遍历每个小方块，如果值为0，即代表空格小方块，代码如下所示。

    /**
     *获取空格Item数组
     */
    private void getBlanks() {
 
        mBlanks.clear();
        for (int i = 0; i < mGameLines; i++) {
            for (int j = 0; j < mGameLines; j++) {
                if (mGameMatrix[i][j].getNum() == 0) {
                    mBlanks.add(new Point(i, j));
                }
            }
        }
    }

13.2.6.4　判断游戏结束

游戏面板所提供的最后一个逻辑功能就是判断游戏是否已经结束，即checkCompleted()方法。游戏成功意味着完成目标值2048或其他设定值，游戏失败意味着所有的小方块都无法再移动。在每次捕获ACTION_UP事件后，都需要调用CheckComplete()方法来进行游戏是否状态的判断。判断游戏是否成功非常简单，只需要遍历，看是否具有目标值即可。而判断游戏失败，则需要判断每个小方块的数值在其上、下、左、右所对应的方块中是否存在相同的小方块。如果存在，就可以继续游戏。判断代码如下所示。

    /**
     *判断是否结束
     * <p/>
     * 0:结束1:正常2:成功
     */
    private void checkCompleted() {
        int result = checkNums();
    if (result == 0) {
    ……
        } else if (result == 2) {
            ……
        }
    }
 
    /**
 
     *检测所有数字看是否有满足条件的
     *
     * @return 0:结束1:正常2:成功
     */
    private int checkNums() {
        getBlanks();
        if (mBlanks.size() == 0) {
            for (int i = 0; i < mGameLines; i++) {
                for (int j = 0; j < mGameLines; j++) {
                    if (j < mGameLines - 1) {
                        if (mGameMatrix[i][j].getNum() == mGameMatrix[i][j + 1]
                                .getNum()) {
                            return 1;
                        }
                    }
                    if (i < mGameLines - 1) {
                        if (mGameMatrix[i][j].getNum() == mGameMatrix[i + 1][j]
                                .getNum()) {
                            return 1;
                        }
                    }
                }
            }
            return 0;
        }
        for (int i = 0; i < mGameLines; i++) {
            for (int j = 0; j < mGameLines; j++) {
                if (mGameMatrix[i][j].getNum() == mTarget) {
                    return 2;
                }
            }
        }
        return 1;
    }

当判断游戏结束后，可以弹出对话框，提示用户“Game Over”（游戏结束），重新开始游戏。游戏成功后，将用户目标值提升为下一个目标值，并提示用户继续游戏或者退出游戏，这些都是一些简单的对话框操作，这里就不再给出详细的代码了。到此为止，游戏面板的逻辑，就基本实现了。

13.2.7　主程序设计" class="reference-link">13.2.7　主程序设计

13.2.7.1　添加游戏面板和游戏信息

在程序的主Activity中，只需要将游戏面板添加到前面预留的布局中即可，整个游戏的逻辑，都封装在游戏面板这个类中，所以主程序Activity只需要负责一些信息的显示、辅助功能即可。例如最下方三个辅助按钮的点击事件、游戏目标、游戏记录和当前分数等显示。为了显示分数，在游戏面板的逻辑中，还需要加入统计分数的功能，相信看完前面游戏面板实现方法的读者应该对这个功能的添加信手拈来，只需要在合并数字的时候，对分数进行增加即可，这里不再详述。

13.2.7.2　动画效果

程序实现到这里，相信大家都已经能够完成基本的2048游戏功能了，不过，我们所开发的2048与网上流传的2048相比，好像总觉得少了点什么。由于每次都是根据重新生成的数字矩阵来对GridLayout进行重新布局，实现变换的效果，这就导致缺少了生成小方块的动画效果。下面我们就来给2048增加相应的动画效果，在addRandomNum()方法中，会生成一个新的小方块，在生成小方块的时候，只需要对新生成的小方块做一个简单的Scale变换即可，代码如下所示。

    /**
     *添加随机数字
     */
    private void addRandomNum() {
        getBlanks();
        if (mBlanks.size() > 0) {
            int randomNum = (int) (Math.random() * mBlanks.size());
            Point randomPoint = mBlanks.get(randomNum);
 
            mGameMatrix[randomPoint.x][randomPoint.y]
                    .setNum(Math.random() > 0.2d ? 2 : 4);
            animCreate(mGameMatrix[randomPoint.x][randomPoint.y]);
        }
    }  /**
     *生成动画
     * @param target GameItem
     */
    private void animCreate(GameItem target) {
        ScaleAnimation sa = new ScaleAnimation(0.1f, 1, 0.1f, 1,
    Animation.RELATIVE_TO_SELF, 0.5f,
    Animation.RELATIVE_TO_SELF, 0.5f);
        sa.setDuration(100);
        target.setAnimation(null);
        target.getItemView().startAnimation(sa);
    }

13.2.8　功能进阶" class="reference-link">13.2.8　功能进阶

到此为止，2048就基本开发完毕了。与之前的拼图游戏一样，2048还有很多地方是可以进行优化的，例如前面所提到的换肤功能，其实就是改变一下小方块的显示背景而已。相信看加这样一个功能，应该是不在话下。另外，还有我们所实现的一个简单的后门，通过大距离的滑动来开启超级用户权限的作弊功能，这也是增加游戏娱乐性的一个方法。“我的程序听我的”，如果要对2048进行进一步的优化，还可以给2048增加SNS功能，毕竟游戏就是要大家一起玩才好玩。

13.2 魔幻矩阵——2048