2048游戏实现——GridLayout应用

最新推荐文章于 2024-04-03 11:30:25 发布
最新推荐文章于 2024-04-03 11:30:25 发布
阅读量2k 收藏 3
点赞数 1
文章标签： 游戏

学习自http://blog.csdn.net/lmj623565791/article/details/40020137

原博主用继承自RelativeLayout的布局实现，我用专门实现网格布局的GridLayout重新实现。另外用二维数组来存储每一个子View，逻辑上更清晰。

先上效果图




其中的每一个格子是一个自定义的View


public class Game2048Item extends View {

    private Paint paint;
    private int number;
    private Rect textRect;
    private String numberValue;

    public Game2048Item(Context context) {
        this(context, null);
    }

    public Game2048Item(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public Game2048Item(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        paint = new Paint();
    }

    public void setNumber(int number) {
        this.number = number;
        numberValue = "" + number;
        paint.setTextSize(50);
        textRect = new Rect();
        paint.getTextBounds(numberValue, 0, numberValue.length(), textRect);
        invalidate();
    }

    public int getNumber() {
        return number;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        String backColor;
        switch (number) {
            case 0:
                backColor = "#CCC0B3";
                break;
            case 2:
                backColor = "#EEE4DA";
                break;
            case 4:
                backColor = "#EDE0C8";
                break;
            case 8:
                backColor = "#F2B179";
                break;
            case 16:
                backColor = "#F49563";
                break;
            case 32:
                backColor = "#F5794D";
                break;
            case 64:
                backColor = "#F55D37";
                break;
            case 128:
                backColor = "#EEE863";
                break;
            case 256:
                backColor = "#EDB04D";
                break;
            case 512:
                backColor = "#ECB04D";
                break;
            case 1024:
                backColor = "#EB9437";
                break;
            case 2048:
                backColor = "#EA7821";
                break;
            default:
                backColor = "#EA7821";
                break;
        }

        /*每个方块的背景*/
        paint.setColor(Color.parseColor(backColor));
        paint.setStyle(Paint.Style.FILL);
        canvas.drawRect(0,0,getMeasuredWidth(),getMeasuredHeight(),paint);

        /*每个方块上的数字*/
        if (number != 0) {
            paint.setColor(Color.BLACK);
            float x = (getMeasuredWidth()-textRect.width())/2;
            float y = getMeasuredHeight()/2 + textRect.width()/2;
            canvas.drawText(numberValue, x, y, paint);
        }
    }
}


把他们用一个继承自GridLayout的自定义ViewGroup放置 


public class Game2048GridLayout extends GridLayout {

    private int childWidth;
    private int padding;
    private int childRow = 4;
    private int margin = 10;
    private boolean isLayout = false;
    private Game2048Item[][] game2048Items = null;
    private GestureDetector gestureDetector;
    private boolean isMoveHappen = false;
    private boolean isMergeHappen = false;
    private boolean isFirst = true;
    private int score;
    private OnGame2048Listener onGame2048Listener;

    /*枚举手势操作类型*/
    private enum Action {
        UP, DOWN, LEFT, RIGHT
    }

    public Game2048GridLayout(Context context) {
        this(context, null);
    }

    public Game2048GridLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public Game2048GridLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        padding = Math.min(getPaddingBottom(), getPaddingTop());
        gestureDetector = new GestureDetector(context, new MyGestureListener());
        score = 0;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        /*布局的实际长宽一致，为两者中的最小值*/
        int length = Math.min(MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.getSize(heightMeasureSpec));
        childWidth = (length - 2 * padding - (childRow - 1) * margin) / childRow;
        setMeasuredDimension(length, length);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        /*避免多次加载*/
        if (!isLayout) {
            if (game2048Items == null) {
                game2048Items = new Game2048Item[childRow][childRow];
            }

            for (int i = 0; i < childRow; i++) {
                for (int j = 0; j < childRow; j++) {
                    Game2048Item child = new Game2048Item(getContext());
                    game2048Items[i][j] = child;

                    Spec row = GridLayout.spec(i);
                    Spec column = GridLayout.spec(j);
                    GridLayout.LayoutParams lp = new LayoutParams(row, column);
                    /*每个子View的宽高*/
                    lp.width = childWidth;
                    lp.height = childWidth;
                    if ((j + 1) != childRow) {
                        lp.rightMargin = margin;
                    }
                    if (i > 0) {
                        lp.topMargin = margin;
                    }
                    lp.setGravity(Gravity.FILL);
                    addView(child, lp);
                }
            }

            /*生成、显示数字*/
            generateNum();
        }
        isLayout = true;
    }

    private void generateNum() {
        if (isGameOver()) {
            onGame2048Listener.onGameOver();
            return;
        }

        /*初始化，随机产生四个非零子View*/
        if (isFirst) {
            for (int i = 0; i < 4; i++) {
                int randomRow = new Random().nextInt(childRow);
                int randomCol = new Random().nextInt(childRow);
                Game2048Item item = game2048Items[randomRow][randomCol];
                while (item.getNumber() != 0) {
                    randomRow = new Random().nextInt(childRow);
                    randomCol = new Random().nextInt(childRow);
                    item = game2048Items[randomRow][randomCol];
                }
                item.setNumber(Math.random() > 0.75 ? 4 : 2);
                Animation scaleAnimation = new ScaleAnimation(0, 1, 0, 1,
                        Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
                scaleAnimation.setDuration(200);
                item.startAnimation(scaleAnimation);
                isMoveHappen = isMergeHappen = false;
            }
            isFirst = false;
        }

        if (!isFull()) {
            if (isMoveHappen || isMergeHappen) {
                int randomRow = new Random().nextInt(childRow);
                int randomCol = new Random().nextInt(childRow);
                Game2048Item item = game2048Items[randomRow][randomCol];
                while (item.getNumber() != 0) {
                    randomRow = new Random().nextInt(childRow);
                    randomCol = new Random().nextInt(childRow);
                    item = game2048Items[randomRow][randomCol];
                }
                item.setNumber(Math.random() > 0.75 ? 4 : 2);
                Animation scaleAnimation = new ScaleAnimation(0, 1, 0, 1,
                        Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
                scaleAnimation.setDuration(200);
                item.startAnimation(scaleAnimation);
                isMoveHappen = isMergeHappen = false;
            }
        }
    }

    /*触摸事件交由手势监听器处理*/
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        gestureDetector.onTouchEvent(event);
        return true;
    }

    private class MyGestureListener extends GestureDetector.SimpleOnGestureListener {

        final int MIN_DISTANCE = 50;

        @Override
        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
            float x = e2.getX() - e1.getX();
            float y = e2.getY() - e1.getY();
            float absX = Math.abs(x);
            float absY = Math.abs(y);

            if (x > MIN_DISTANCE && absX > absY) {
                action(Action.RIGHT);
            }
            if (x < -MIN_DISTANCE && absX > absY) {
                action(Action.LEFT);
            }
            if (y > MIN_DISTANCE && absY > absX) {
                action(Action.DOWN);
            }
            if (y < -MIN_DISTANCE && absY > absX) {
                action(Action.UP);
            }
            return true;
        }
    }

    private void action(Action action) {
        for (int i = 0; i < childRow; i++) {
            /*用来存储行或列的临时列表*/
            List<Game2048Item> rowList = new ArrayList<>();
            for (int j = 0; j < childRow; j++) {
                int rowIndex = getRowIndexByAction(action, i, j);
                int colIndex = getColIndexByAction(action, i, j);
                Game2048Item item = game2048Items[rowIndex][colIndex];
                /*将非零的子项存入临时列表*/
                if (item.getNumber() != 0) {
                    rowList.add(item);
                }
            }
            for (int j = 0; j < rowList.size(); j++) {
                int rowIndex = getRowIndexByAction(action, i, j);
                int colIndex = getColIndexByAction(action, i, j);
                Game2048Item item = game2048Items[rowIndex][colIndex];
                /*如果临时列表（除去数值为0的项）里的子项与移动前的此列或者行出现不同，说明移动发生*/
                if (item.getNumber() != rowList.get(j).getNumber()) {
                    isMoveHappen = true;
                }
            }

            /*在临时列表里合并相同数字*/
            mergeItem(rowList);

            for (int j = 0; j < childRow; j++) {
                /*依次将临时列表里的数字填入本列/行，剩余直接填0*/
                if (rowList.size() > j) {
                    switch (action) {
                        case LEFT :
                            game2048Items[i][j].setNumber(rowList.get(j).getNumber());
                            break;
                        case RIGHT:
                            game2048Items[i][childRow - 1 - j].setNumber(rowList.get(j).getNumber());
                            break;
                        case UP:
                            game2048Items[j][i].setNumber(rowList.get(j).getNumber());
                            break;
                        case DOWN:
                            game2048Items[childRow - 1 - j][i].setNumber(rowList.get(j).getNumber());
                            break;
                    }
                } else {
                    switch (action) {
                        case LEFT :
                            game2048Items[i][j].setNumber(0);
                            break;
                        case RIGHT:
                            game2048Items[i][childRow - 1 - j].setNumber(0);
                            break;
                        case UP:
                            game2048Items[j][i].setNumber(0);
                            break;
                        case DOWN:
                            game2048Items[childRow - 1 - j][i].setNumber(0);
                            break;
                    }
                }
            }
        }
        generateNum();
    }

    /*根据手势方向确定如何取得子项。例如向上滑动，则从列方向从上到下取得每一个子项在game2048Item里的对应坐标*/
    private int getRowIndexByAction(Action action, int i, int j) {
        int rowIndex = -1;

        switch (action) {
            case LEFT:
            case RIGHT:
                rowIndex = i;
                break;
            case UP:
                rowIndex = j;
                break;
            case DOWN:
                rowIndex = childRow - 1 - j;
                break;
        }
        return rowIndex;

    }

    private int getColIndexByAction(Action action, int i, int j) {
        int colIndex = -1;
        switch (action) {
            case LEFT:
                colIndex = j;
                break;
            case RIGHT:
                colIndex = childRow - 1 - j;
                break;
            case UP:
            case DOWN:
                colIndex = i;
                break;
        }
        return colIndex;
    }

    private void mergeItem(List<Game2048Item> rowList) {
        if (rowList.size() < 2) {
            return;
        }
        for (int i = 0; i < rowList.size() - 1; i++) {
            Game2048Item item1 = rowList.get(i);
            Game2048Item item2 = rowList.get(i + 1);
            if (item1.getNumber() == item2.getNumber()) {
                isMergeHappen = true;
                score += item1.getNumber() * 2;
                item1.setNumber(item1.getNumber() * 2);
                onGame2048Listener.onScoreChange(score);
                for (int j = i + 1; j < rowList.size() - 1; j++) {
                    /*将后一项的数字依次向前移*/
                    rowList.get(j).setNumber(rowList.get(j + 1).getNumber());
                }
                /*最后一项一定设置为0*/
                rowList.get(rowList.size() - 1).setNumber(0);
                return;
            }
        }
    }


    private boolean isGameOver() {
        //*如果格子没有被非零数字填满*//*
        if (!isFull()) {
            return false;
        }
        //*如果填满了，检验是否有相邻子项具有相同数字*//*
        for (int i = 0; i < childRow; i++) {
            for (int j = 0; j < childRow; j++) {
                Game2048Item item = game2048Items[i][j];
                // 如果不是最后一列，则与右边项相比
                if ((j + 1) != childRow) {
                    Game2048Item itemRight = game2048Items[i][j + 1];
                    if (item.getNumber() == itemRight.getNumber())
                        return false;
                }
                // 如果不是最后一行，则与下边项相比
                if ((i + 1)  != childRow) {
                    Log.e("TAG", "DOWN");
                    Game2048Item itemBottom = game2048Items[i + 1][j];
                    if (item.getNumber() == itemBottom.getNumber())
                        return false;
                }
                // 如果不是第一列，则与左边项相比
                if (j != 0) {
                    Log.e("TAG", "LEFT");
                    Game2048Item itemLeft = game2048Items[i][j - 1];
                    if (itemLeft.getNumber() == item.getNumber())
                        return false;
                }
                // 如果不是第一行，则与上边项相比
                if (i != 0) {
                    Log.e("TAG", "UP");
                    Game2048Item itemTop = game2048Items[i - 1][j];
                    if (item.getNumber() == itemTop.getNumber())
                        return false;
                }
            }
        }
        return true;
    }

    public boolean isFull() {
        for (int i = 0; i < childRow; i++) {
            for (int j = 0; j < childRow; j++) {
                Game2048Item game2048Item = game2048Items[i][j];
                if (game2048Item.getNumber() == 0)
                    return false;
            }
        }
        return true;
    }

    /*对外接口，由调用方决定具体逻辑*/
    public interface OnGame2048Listener {
        void onScoreChange(int score);

        void onGameOver();
    }

    public void setOnGame2048Listener(OnGame2048Listener onGame2048Listener) {
        this.onGame2048Listener = onGame2048Listener;
    }

    public void reStart() {
        for (int i = 0; i < childRow; i++) {
            for (int j = 0; j < childRow; j++) {
                Game2048Item item = game2048Items[i][j];
                item.setNumber(0);
            }
        }
        score = 0;
        onGame2048Listener.onScoreChange(0);
        isFirst = true;
        generateNum();
    }
}


其中提供了一个借口用于在activity中调用，让主程序决定要实现的操作 


public class MainActivity extends AppCompatActivity implements Game2048Layout.OnGame2048Listener{

    private TextView scoreView;
    Game2048Layout game2048Layout;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        game2048Layout = (Game2048Layout) findViewById(R.id.game);
        game2048Layout.setOnGame2048Listener(this);
        scoreView = (TextView) findViewById(R.id.score);
    }

    @Override
    public void onScoreChange(int score) {
        scoreView.setText("Score : "+score);
    }

    @Override
    public void onGameOver() {
        new AlertDialog.Builder(this).setTitle("game Over")
                .setMessage("you have got "+ scoreView.getText()).setCancelable(false)
                .setPositiveButton("Restart", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        game2048Layout.reStart();
                    }
                }).setNegativeButton("Exit", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                finish();
            }
        }).show();
    }
}






倒霉催的笑脸猫
关注
(C语言)2048游戏实现
qq_24830869的博客
06-25 1745
C语言完美实现游戏2048，源代码详解，界面美化。
web小游戏 2048制作（一）:网页布局
z6719201102的博客
02-24 3710
这是html结构 2048 2048 New Game score: 0 这是它的css样式 #header { width: 500px; margin: 0 auto; text-align: center;
2048游戏核心实现
weixin_40947140的博客
08-26 1408
核心功能实现： 代码1（https://blog.csdn.net/hebtu666/article/details/81663648） def left():#向左 for i in range(4):#遍历每一行 for j in range(3):#遍历每一行的每个元素 for k in range(j+1,4):#遍历j右边的元素 ...
【JavaScript学习笔记】用js实现2048小游戏
orangecsy的博客
04-25 1313
360前端星技术笔试中的一道题目，现把解决过程记录如下：1、首先是界面&lt;!DOCTYPE html&gt; &lt;html lang="zh-CN"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;2048&lt;/title&gt; &lt;link rel="st
2048小游戏 - 原生JavaScript实现
04-18
经典2048小游戏，原生JavaScript实现，可改变格子数，漂亮好玩易操作
Android游戏——2048源码
10-24
《Android游戏——2048源码》 2048是一款广受欢迎的数字合并游戏，它的源码对于安卓开发初学者来说，是一份非常有价值的参考资料。在这个项目中，开发者用简洁的代码实现了2048的核心功能，使得游戏逻辑清晰易懂，...
Android应用开发-GridLayout的使用.pptx
12-10
在本教程中，我们将深入探讨如何有效地使用GridLayout来创建复杂的用户界面，尤其是通过一个实例——计算器界面的开发，来加深理解。 ### GridLayout的特点 GridLayout与TableLayout相似，但比TableLayout更为灵活...
Android小游戏——四棋
03-23
【Android小游戏——四棋】 四棋，又称为“井字游戏”或“圈圈叉叉”，是一种简单但富有策略性的双人对弈游戏。在这个Android版本的四棋游戏中，玩家可以选择“X”或“O”作为自己的棋子，并在3x3的棋盘上尝试连成...
Java Swing实现仿Chrome浏览器跳跳龙小游戏.zip
12-16
在这个特定的项目"Java Swing实现仿Chrome浏览器跳跳龙小游戏"中，开发者利用Java Swing来创建了一个类似Chrome浏览器上的经典小游戏——跳跳龙。这个游戏通常是一个简单的平台跳跃游戏，玩家需要控制一个小角色在...
基于Java Swing实现的飞机大战游戏.zip
09-10
在这个项目中，开发者利用Java Swing来设计和实现了一款经典的游戏——飞机大战。这个游戏的实现充分展示了Java Swing在游戏开发中的应用。 1. Java Swing基础 Java Swing是Java AWT（Abstract Window Toolkit）的...
Pyglet图形界面版2048游戏——详尽实现教程（上）
汉阳Hann's Home
03-03 2394
使用pyglet.text.Label()+pyglet.shapes.Rectangle()绘制标题图片，为美化效果把数字0转过一定角度，属性.rotaion为旋转角度，属性.anchor_position为旋转中心坐标，属性.x和.y为控件坐标，可以对个别控件的位置作出调整。方阵色块和数字设置成一个类class Game2048，从2阶到9阶，数字色块的背景随数字的变化而变化，色块和数字也使用 Rectangle 和 Label 绘制。运行效果：可以用键盘操作，数字2~9分别对应方阵的2~9阶。
2048游戏编程具体思路和实现（更新1）
君兮故人辞的博客
10-30 1158
2048游戏编程具体思路和实现 (更新中……) 一、游戏背景 思路很简单的游戏 试玩截图： 二、 游戏流程图 游戏的本质是根据玩家键盘（或其他）输入的值对一个 4 * 4 的二维矩阵进行移动、合并、检查等操作。 三、具体的功能实现 编译环境：Dev C++ 和 EGE图形库（网上自己搜索一下，有详细的安装流程的） 编程语言：C++ 丰富的图形只是数据的映射，编程语言只是思想实例化的工具，关键还是在于数据处理 环境准备：
2048 java代码_Java 实现2048游戏之详细教程
weixin_33940733的博客
02-12 2120
packagecom.baidu.czy;importjava.awt.event.ActionEvent;importjava.awt.event.ActionListener;importjava.awt.event.KeyAdapter;importjava.awt.event.KeyEvent;importjava.util.Arrays;importjava.util.Random;im...
【Android】基于GridLayout的Game2048开发
cungudafa的博客
12-29 943
目录一、2048游戏的玩法二、 游戏的开发（一）游戏的布局（二）实现游戏的主类（三）游戏触控的交互设计（四）实现卡片类Card.java（五）在GameView中添加游戏卡片（六）在GameView中添加随机数（七）在MainActivity中实现重启游戏的按钮功能（八）实现2048的游戏逻辑（九）游戏的计分（十）检查游戏结束三、Github源码 一、2048游戏的玩法 二、 游戏的开发 （一）游...
【C语言】2048小游戏【附源码】
最新发布
m0_73367097的博客
04-03 6836
C语言2048小游戏
2048
qq_25209459的博客
02-19 192
/*********************************************************************** 项    目：2048 编译坏境：VS2015 作  者：零起点 时  间：2017年2月18日 版  本：1.0 ***************************************************************
Android开发：使用RecyclerView+GridLayout实现滑动网格布局效果
shuaibiaoshishen的博客
07-21 3190
在实际开发中，我们很可能会遇到将许多功能已小图标的形式来展示给用户，因此需要将功能罗列出来。但是，如果只是单纯的网格布局的话，可能会导致占领过多的屏幕，影响到其他数据的展示。因此，我们应该做成滑动网格的效果。这里我们以美团为例，如下图。 美团的的中间多个小功能区可以横向滑动，所以我们考虑RecyclerView来实现这个效果。同时，内部数据已网格展现，因此我们可以考虑是不是能把GridLayout放入RecyclerView中实现效果。接下来我们就开始尝试一下。 ...
JAVA 实现《2048游戏》游戏
热门推荐
毅慎的博客
03-06 1万+
JAVA 实现《2048游戏》游戏
基于jQuery的2048游戏实战视频教程
10-17
基于jQuery的2048游戏实战视频培训课程（适配PC与移动端）：本课程基于JavaScript jQuery技术，使用Sublime开发工具。手把手带大家实现一个基于jQuery的2048游戏，并且能够自动适配PC端和移动端。主要锻炼JavaScript、jQuery的运用，通过项目实战，加强对JavaScript技术的理解和灵活运用，如果你是Web前端的初学者，这套视频课程最适合你！！本课程以通俗易懂的方式，手把手的一行一行带你敲代码，只讲干货，相信你看完后一定会收获很多！
Java毕业设计：连连看游戏与Swing应用
这篇文档是关于使用Java语言进行毕业课程设计的一个项目——连连看游戏的详细指南。这个项目旨在帮助学生深入理解Java编程，特别是涉及到图形用户界面（GUI）的设计和实现。以下是该课程设计的主要知识点： 1. **...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值