android 贪吃蛇简易实现

最新推荐文章于 2023-12-25 20:20:58 发布
原创 最新推荐文章于 2023-12-25 20:20:58 发布 · 1.1k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

这篇博客分享了作者闲暇时编写的Android版贪吃蛇游戏的实现过程，虽然代码网上有很多，但作者还是提供了自己的实现。文中提到代码可能存在瑕疵，如数组集合转换的效率优化和蛇长度计算的冗余，以及未实现的碰撞检测功能，鼓励读者自行完善。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

其实关于贪吃蛇的代码在网上实在是一搜一大堆，我也是闲着无聊随便写写 有瑕疵  数组集合转换部分应该有更快的算法，蛇的长度计算其实设计时没考虑充分有多余代码 ，碰撞检测部分没写 大家自己发挥吧     直接上代码 


/**
 * Created by Administrator on 2017/8/10.
 */

public class SnakeView extends SurfaceView implements SurfaceHolder.Callback, Runnable {

    private Paint mPaint;
    private Thread mThread;
    private SurfaceHolder mHolder;
    private int screenWidth;
    private int screenHeight;
    private static MyLinkList list;
    private int sX1;
    private int sY1;
    private int sX2;
    private int sY2;
    private int foodX;
    private int foodY;
    private int headX;
    private int headY;
    private int foodRadiu;

    private void initView() {
        screenWidth = getResources().getDisplayMetrics().widthPixels;
        screenHeight = getResources().getDisplayMetrics().heightPixels;
        mPaint = new Paint();
        foodRadiu=10;
        mPaint.setColor(Color.BLACK);
        mPaint.setStrokeWidth(15);
        list = new MyLinkList();
        mHolder = this.getHolder();
        mHolder.addCallback(this);
        mThread = new Thread(this);
        list.add(new CustomStructure(0, 30, 500, 30, Direction.RIGHT, 500, true, true, new LenghtListener() {
            @Override
            public void lengehCheanger(int lenght, CustomStructure customStructure) {

                if (list.size() == 1) {
                    customStructure.setPositionX1(customStructure.getPositionX1() + 1);

                    customStructure.setPositionX2(customStructure.getPositionX2() + 1);
                } else {
                    customStructure.setPositionX1(customStructure.getPositionX1() + 1);
                }
            }
        }));
    }

    private void snakeRun() {
        list.get(0).setLenght(list.get(0).getLenght());


    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {

        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:

                sX1 = list.get(list.size() - 1).getPositionX1();
                sY1 = list.get(list.size() - 1).getPositionY1();

                sX2 = list.get(list.size() - 1).getPositionX2();
                sY2 = list.get(list.size() - 1).getPositionY2();
                list.get(list.size() - 1).setStart(false);
                if (event.getRawX() > sX1 && (list.get(list.size() - 1).getmDirection() == Direction.UP || list.get(list.size() - 1).getmDirection() == Direction.DOWN)) {
                    if (list.get(list.size() - 1).getmDirection() == Direction.UP) {
                        list.add(new CustomStructure(sX1, sY1, sX1, sY1, Direction.RIGHT, 0, true, false, new LenghtListener() {
                            @Override
                            public void lengehCheanger(int lenght, CustomStructure customStructure) {
                                if (list.size() == 1) {
                                    customStructure.setPositionX1(customStructure.getPositionX1() + 1);
                                    customStructure.setPositionX2(customStructure.getPositionX2() + 1);
                                } else if (customStructure.isEnd()) {
                                    customStructure.setPositionX1(customStructure.getPositionX1() + 1);
                                } else if (customStructure.isStart()) {
                                    customStructure.setPositionX2(customStructure.getPositionX2() + 1);
                                }
                            }
                        }));
                    } else {
                        list.add(new CustomStructure(sX2, sY2, sX2, sY2, Direction.RIGHT, 0, true, false, new LenghtListener() {
                            @Override
                            public void lengehCheanger(int lenght, CustomStructure customStructure) {
                                if (list.size() == 1) {
                                    customStructure.setPositionX1(customStructure.getPositionX1() + 1);
                                    customStructure.setPositionX2(customStructure.getPositionX2() + 1);
                                } else if (customStructure.isEnd()) {
                                    customStructure.setPositionX1(customStructure.getPositionX1() + 1);
                                } else if (customStructure.isStart()) {
                                    customStructure.setPositionX2(customStructure.getPositionX2() + 1);
                                }
                            }
                        }));
                    }
                } else if (event.getRawX() < sX1 && (list.get(list.size() - 1).getmDirection() == Direction.UP || list.get(list.size() - 1).getmDirection() == Direction.DOWN)) {
                    if (list.get(list.size() - 1).getmDirection() == Direction.UP) {
                        list.add(new CustomStructure(sX1, sY1, sX1, sY1, Direction.LEFT, 0, true, false, new LenghtListener() {
                            @Override
                            public void lengehCheanger(int lenght, CustomStructure customStructure) {
                                if (list.size() == 1) {
                                    customStructure.setPositionX1(customStructure.getPositionX1() - 1);
                                    customStructure.setPositionX2(customStructure.getPositionX2() - 1);
                                } else if (customStructure.isEnd()) {
                                    customStructure.setPositionX2(customStructure.getPositionX2() - 1);
                                } else if (customStructure.isStart()) {
                                    customStructure.setPositionX1(customStructure.getPositionX1() - 1);
                                }
                            }
                        }));
                    } else {
                        list.add(new CustomStructure(sX2, sY2, sX2, sY2, Direction.LEFT, 0, true, false, new LenghtListener() {
                            @Override
                            public void lengehCheanger(int lenght, CustomStructure customStructure) {
                                if (list.size() == 1) {
                                    customStructure.setPositionX1(customStructure.getPositionX1() - 1);
                                    customStructure.setPositionX2(customStructure.getPositionX2() - 1);
                                } else if (customStructure.isEnd()) {
                                    customStructure.setPositionX2(customStructure.getPositionX2() - 1);
                                } else if (customStructure.isStart()) {
                                    customStructure.setPositionX1(customStructure.getPositionX1() - 1);
                                }
                            }
                        }));
                    }
                } else if (event.getRawY() > sY1 && (list.get(list.size() - 1).getmDirection() == Direction.LEFT || list.get(list.size() - 1).getmDirection() == Direction.RIGHT)) {
                    if (list.get(list.size() - 1).getmDirection() == Direction.LEFT) {
                        list.add(new CustomStructure(sX1, sY1, sX1, sY1, Direction.DOWN, 0, true, false, new LenghtListener() {
                            @Override
                            public void lengehCheanger(int lenght, CustomStructure customStructure) {
                                if (list.size() == 1) {
                                    customStructure.setPositionY1(customStructure.getPositionY1() + 1);
                                    customStructure.setPositionY2(customStructure.getPositionY2() + 1);
                                } else if (customStructure.isEnd()) {
                                    customStructure.setPositionY1(customStructure.getPositionY1() + 1);
                                } else if (customStructure.isStart()) {
                                    customStructure.setPositionY2(customStructure.getPositionY2() + 1);
                                }
                            }
                        }));
                    } else {
                        list.add(new CustomStructure(sX2, sY2, sX2, sY2, Direction.DOWN, 0, true, false, new LenghtListener() {
                            @Override
                            public void lengehCheanger(int lenght, CustomStructure customStructure) {
                                if (list.size() == 1) {
                                    customStructure.setPositionY1(customStructure.getPositionY1() + 1);
                                    customStructure.setPositionY2(customStructure.getPositionY2() + 1);
                                } else if (customStructure.isEnd()) {
                                    customStructure.setPositionY1(customStructure.getPositionY1() + 1);
                                } else if (customStructure.isStart()) {
                                    customStructure.setPositionY2(customStructure.getPositionY2() + 1);
                                }
                            }
                        }));
                    }
                } else if (event.getRawY() < sY1 && (list.get(list.size() - 1).getmDirection() == Direction.LEFT || list.get(list.size() - 1).getmDirection() == Direction.RIGHT)) {
                    if (list.get(list.size() - 1).getmDirection() == Direction.LEFT) {
                        list.add(new CustomStructure(sX1, sY1, sX1, sY1, Direction.UP, 0, true, false, new LenghtListener() {
                            @Override
                            public void lengehCheanger(int lenght, CustomStructure customStructure) {
                                if (list.size() == 1) {
                                    customStructure.setPositionY1(customStructure.getPositionY1() - 1);
                                    customStructure.setPositionY2(customStructure.getPositionY2() - 1);
                                } else if (customStructure.isEnd()) {
                                    customStructure.setPositionY2(customStructure.getPositionY2() - 1);
                                } else if (customStructure.isStart()) {
                                    customStructure.setPositionY1(customStructure.getPositionY1() - 1);
                                }
                            }
                        }));
                    } else {
                        list.add(new CustomStructure(sX2, sY2, sX2, sY2, Direction.UP, 0, true, false, new LenghtListener() {
                            @Override
                            public void lengehCheanger(int lenght, CustomStructure customStructure) {
                                if (list.size() == 1) {
                                    customStructure.setPositionY1(customStructure.getPositionY1() - 1);
                                    customStructure.setPositionY2(customStructure.getPositionY2() - 1);
                                } else if (customStructure.isEnd()) {
                                    customStructure.setPositionY2(customStructure.getPositionY2() - 1);
                                } else if (customStructure.isStart()) {
                                    customStructure.setPositionY1(customStructure.getPositionY1() - 1);
                                }
                            }
                        }));
                    }
                }
                break;
        }
        return true;
    }

    public SnakeView(Context context) {
        super(context);
        initView();
    }

    public SnakeView(Context context, AttributeSet attrs) {
        super(context, attrs);
        initView();
    }
    private void initFoodPosition(){
        foodX = new Random().nextInt(screenWidth + 1);
        foodY = new Random().nextInt(screenHeight + 1);
    }

    public SnakeView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        initView();
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        initFoodPosition();

        mThread.start();
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        mThread.interrupt();
    }

    @Override
    public void run() {


        while (true) {
            Canvas mCanvas = null;

            try {
                synchronized (mHolder) {
                    mCanvas = mHolder.lockCanvas();
                    mCanvas.drawColor(Color.WHITE);

                    if (list.size() == 1) {
                        list.get(0).setLenght(list.get(0).getLenght());

                    } else {
                        list.get(list.size() - 1).setLenght(list.get(list.size() - 1).getLenght() + 1);
                        list.get(0).setLenght(list.get(0).getLenght() - 1);
                        if (list.get(0).getLenght() == 0) {
                            list.remove(0);
                            list.get(0).setEnd(true);
                        }
                    }

                    Log.e("snakasd", list.toString());

                    mCanvas.drawLines(list.toFloatArray(), 0, list.size() * 4, mPaint);
//                    mCanvas.drawCircle(foodX, foodY, foodRadiu, mPaint);

                    Thread.sleep(10);
                }

            } catch (Exception e) {

            } finally {
                if (mCanvas != null) {
                    mHolder.unlockCanvasAndPost(mCanvas);
                }
            }
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
        int width;
        int height;

        if (widthMode == MeasureSpec.EXACTLY) {
            width = widthSize;
        } else {
            int desired = getPaddingLeft() + screenWidth + getPaddingRight();
            width = desired;
        }

        if (heightMode == MeasureSpec.EXACTLY) {
            height = heightSize;
        } else {
            int desired = getPaddingTop() + screenHeight + getPaddingBottom();
            height = desired;
        }
        setMeasuredDimension(width, height);


    }

    interface LenghtListener {
        void lengehCheanger(int lenght, CustomStructure customStructure);
    }

    class CustomStructure {
        private LenghtListener lenghtListener;

        public int getPositionX1() {
            return positionX1;
        }

        public void setPositionX1(int positionX1) {
            this.positionX1 = positionX1;
        }

        public int getPositionY1() {
            return positionY1;
        }

        public void setPositionY1(int positionY1) {
            this.positionY1 = positionY1;
        }

        public int getPositionX2() {
            return positionX2;
        }

        public void setPositionX2(int positionX2) {
            this.positionX2 = positionX2;
        }

        public int getPositionY2() {
            return positionY2;
        }

        public void setPositionY2(int positionY2) {
            this.positionY2 = positionY2;
        }

        public Direction getmDirection() {
            return mDirection;
        }

        public void setmDirection(Direction mDirection) {
            this.mDirection = mDirection;
        }

        public int getLenght() {
            return lenght;
        }

        public void setLenght(int lenght) {
            this.lenght = lenght;
            lenghtListener.lengehCheanger(lenght, CustomStructure.this);
        }


        private int positionX1;
        private int positionY1;
        private int positionX2;
        private int positionY2;
        private Direction mDirection;
        private int lenght;
        private boolean isEnd;
        private boolean isStart;

        public CustomStructure(int positionX1, int positionY1, int positionX2, int positionY2, Direction mDirection, int lenght, boolean isStart, boolean isEnd, LenghtListener lenghtListener) {
            this.positionX1 = positionX1;
            this.positionY1 = positionY1;
            this.positionX2 = positionX2;
            this.positionY2 = positionY2;
            this.mDirection = mDirection;
            this.lenght = lenght;
            this.isEnd = isEnd;
            this.isStart = isStart;
            this.lenghtListener = lenghtListener;
        }


        public boolean isEnd() {
            return isEnd;
        }

        public void setEnd(boolean end) {
            isEnd = end;
        }

        public boolean isStart() {
            return isStart;
        }

        public void setStart(boolean start) {
            isStart = start;
        }

        @Override
        public String toString() {
            return "CustomStructure{" +
                    "lenghtListener=" + lenghtListener +
                    ", positionX1=" + positionX1 +
                    ", positionY1=" + positionY1 +
                    ", positionX2=" + positionX2 +
                    ", positionY2=" + positionY2 +
                    ", mDirection=" + mDirection +
                    ", lenght=" + lenght +
                    ", isEnd=" + isEnd +
                    ", isStart=" + isStart +
                    '}';
        }
    }

    enum Direction {
        UP, DOWN, LEFT, RIGHT
    }

    class MyLinkList extends LinkedList<CustomStructure> {
        float a[];

        public float[] toFloatArray() {
            a = new float[this.size() * 4];
            for (int i = 0; i < this.size(); i++) {
                a[4 * i] = this.get(i).getPositionX1();
                a[4 * i + 1] = this.get(i).getPositionY1();
                a[4 * i + 2] = this.get(i).getPositionX2();
                a[4 * i + 3] = this.get(i).getPositionY2();
            }
            return a;
        }
    }
}
 

安卓实现的简单贪吃蛇游戏
12-05
个人写的一个贪吃蛇的小游戏，突然想到还有点适合童鞋毕业设计的参考，呵 呵 不多说，简单的逻辑和功能呢已经实现，由于还有项目接手，所以暂时留给多才的你扩展吧，如果有什么不懂的可以发文给我。
Android开发的贪吃蛇（专门用于课程设计）
01-03
非常好用的课程设计，能直接运行，好东西，注释全，改改就能交，好东西 当然贵，自己在工作中研发的小项目
Android游戏_贪吃蛇源码（java实现）
07-28
文件是整个安卓工程包，包含源码和全部配置文件。该游戏以Google源码为基础，加入了暂停功能，另新增了5个界面，用以提升用户体验。源码的解释可参考本人的博客。http://blog.csdn.net/kuaiguixs/article/details/52035847
贪吃蛇游戏
wangyeqiang的专栏
05-10 1021
贪吃蛇是一款足够经典的游戏。它的经典，在于用户操作的简单，在于技术实现的简介，在于他的经久不衰。 这里的贪吃蛇的android实现，是SDK Samples中的开源例程。可能各位都有看过~界面如下图啦~ 作为一个刚入门或者还没入门的新手，着实花了我一些力气来理解这段代码。 对于各种不懂的地方，慢慢查询资料，对于新的方法，通过修改代码尝试效果。到现在终于能算个一知半解。 在代码中，对
Android Studio实现贪吃蛇小游戏
振华OPPO的博客世界
06-15 8383
贪吃蛇是一款经典的街机游戏，不仅在电子游戏史上占有一席之地，也在很多人的童年回忆中留下了深刻的印象。在游戏中，玩家需要操纵一条蛇通过吃食物来增加自己的长度，同时要避免撞到墙或自己的身体。随着蛇不断吃食物，它的身体会越来越长，游戏的难度也会随之增加。贪吃蛇的游戏机制很简单，但是它具有很高的可玩性和挑战性，深受玩家喜爱。在现代计算机上，贪吃蛇已经经过了许多改进和升级，增加了更多的游戏元素和特性，例如多种模式，不同的难度级别，多人游戏等等。
安卓贪吃蛇小游戏AndroidStudio实现
07-01
【标题】"安卓贪吃蛇小游戏Android Studio实现"是一个基于Android Studio开发的项目，它旨在教授用户如何使用这个强大的集成开发环境（IDE）来创建一个经典的休闲游戏——贪吃蛇。这个项目对于初学者来说是一个很好...
Android贪吃蛇游戏简易编程实现
贪吃蛇游戏作为一款经典的娱乐游戏，在Android平台上实现具有一定的挑战性，但同时也充满乐趣。通过本资源，下载者可以深入理解游戏编程的基本原理，并在此基础上进行扩展和创新，增加个人独特的游戏元素，制作出...
Android贪吃蛇游戏源码分享：简易实现
为了下载和研究提供的Android贪吃蛇源码，开发者需要准备一个配置好的Android开发环境。这通常意味着安装Android Studio，配置SDK和NDK，以及搭建模拟器或连接真实的Android设备。 7. Android游戏源码使用协议: 在...
简易贪吃蛇
04-20
【简易贪吃蛇】是一款基于Android平台开发的经典游戏，它以简单的编程逻辑和直观的游戏界面重现了经典的贪吃蛇玩法。在这个项目中，开发者通过Java语言实现了游戏的主要功能，包括蛇的移动、食物生成、碰撞检测以及...
Android开发实现简易贪吃蛇游戏教程
资源摘要信息:"Android自定义View贪吃蛇游戏开发" 在Android平台上进行贪吃蛇游戏开发是一个让许多开发者感兴趣的项目。这个项目不仅涵盖了基础的游戏逻辑，还需要对Android的自定义View有深入的理解。通过这个教程...
android贪吃蛇
11-16
android移动端，代码完整可运行可安装，课程设计可选使用
基于Android的贪吃蛇游戏app
11-28
有贪吃蛇游戏的所有基本功能，内含有可运行的apk。。。。
android实现贪吃蛇源码
11-30
android实现贪吃蛇源码…………初学android的同学，这个贪吃蛇小游戏，对于android学习有着很好的启发作用哦
Android（贪吃蛇源代码）
01-02
安卓（Android）应用，贪吃蛇的源代码。
安卓编写的贪吃蛇程序
10-15
安卓下编写的贪吃蛇程序,比较简单，完成基本的功能，仅仅给大家提供参考。
Android实现贪吃蛇游戏
abc054600的博客
06-18 362
【绥江一百】http://www.sj100.net 欢迎，进入绥江一百感谢点击[我的小网站，请大家多多指教相互共勉] 贪吃蛇是一个非常古老的游戏，他的算法不难但也算不上很简单，这里呢我做了一个不完整的贪吃蛇的游戏。设计的思路是这样的：由于蛇是由一块一块的小方块组成的，所以我们首...
Java课程设计、安卓开发（AndroidStudio）：JavaScript实现贪吃蛇小游戏（手机APK）
最新发布
AGATHA_66的博客
12-25 1260
本人一直想找时间系统整理一下之前做过的一些实验，便于后续用到的时候可以尽快的使用，po出来也便于大家交流学习，有问题欢迎交流指正，与诸君共勉！这次是Java的课程设计，现在看起来更像是一个安卓开发的课程设计。设计了一个贪吃蛇游戏，有友好的GUI界面和较为全面的功能。
Android编程实现贪吃蛇游戏,Android制作贪吃蛇游戏
weixin_31175771的博客
05-26 824
网络112 梁海亮打开eclipse新建项目TCS。项目结构：： 然后开始编写java代码：TCSActivity.java代码：package lianghailiang.f;import android.app.Activity;import android.os.Bundle;import android.view.KeyEvent;import android.view.View;impo...
简单的Android贪吃蛇
巴里阿阿的笔记
03-20 9618
初学Android，想做一个小游戏来练练手，于是选择了贪吃蛇这个既能练手，做完了自己又爱玩的游戏。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值