扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 移动开发 >Android 2d游戏开发之贪吃蛇基于surfaceview
  • 863

0
分享到

Android 2d游戏开发之贪吃蛇基于surfaceview

2024-04-02 19:04:59 863人浏览 薄情痞子
摘要

前两个游戏是基于View游戏框架的，View游戏框架只适合做静止的，异步触发的游戏，如果做一直在动的游戏，View的效率就不高了，我们需要一种同步触发的游戏框架，也就是surface

前两个游戏是基于View游戏框架的，View游戏框架只适合做静止的，异步触发的游戏，如果做一直在动的游戏，View的效率就不高了，我们需要一种同步触发的游戏框架，也就是surfaceview游戏框架，你可能会问，什么乱七八糟的，啥叫同步？啥叫异步？。。。我就不告诉你。。。我们先看一下这个同步框架，看看骚年你能不能自己领悟。

GameView.java(继承自SurfaceView)


package com.next.eatsnake;

import Android.content.Context;
import android.graphics.canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.View.OnTouchListener;

import java.util.Random;


public class GameView extends SurfaceView implements SurfaceHolder.Callback,OnTouchListener,Runnable {

    enum GameState{
        Menu,
        Playing,
        Over;
    }
    GameState gameState;//游戏状态
    Thread thread;//游戏线程
    Boolean flag;//游戏循环控制标志
    Canvas canvas;//画布
    Paint paint;//画笔
    SurfaceHolder holder;//SurfaceView控制句柄
    Random random;//随机数
    NextEvent nextEvent;//游戏输入事件
    int scrW,scrH;//屏幕的宽和高
    public GameView(Context context) {
        super(context);
        gameState = GameState.Menu;
        flag = true;
        paint = new Paint();
        paint.setAntiAlias(true);//笔迹平滑
        thread = new Thread(this);
        random = new Random();
        nextEvent = new NextEvent();
        holder = this.getHolder();
        holder.addCallback(this);
        this.setOnTouchListener(this);
        seTKEepScreenOn(true);
        scrW = ((MainActivity)context).getWindowManager().getDefaultDisplay().getWidth();
        scrH = ((MainActivity)context).getWindowManager().getDefaultDisplay().getHeight();
    }



    @Override
    public boolean onTouch(View v, MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            nextEvent.setDownX((int) event.getX());
            nextEvent.setDownY((int) event.getY());
        }else if (event.getAction() == MotionEvent.ACTION_UP) {
            nextEvent.setUpX((int) event.getX());
            nextEvent.setUpY((int) event.getY());
        }
        return true;
    }

    private void mLogic(){
        switch (gameState){
            case Menu:
                menuLogic();
                break;
            case Playing:
                playingLogic();
                break;
            case Over:
                overLogic();
                break;
        }
        nextEvent.init();//每次逻辑循环后，清空事件
    }

    private void menuLogic(){
        if(nextEvent.getUpX() > 0){
            gameState = GameState.Playing;
        }
    }

    private void playingLogic(){
        if(nextEvent.getDir() == NextEvent.DOWN){
            gameState = GameState.Over;
        }
    }

    private void overLogic(){
        if(nextEvent.getDir() == NextEvent.RIGHT){
            gameState = GameState.Menu;
        }
    }

    private void mDraw(){
        try {
            canvas = holder.lockCanvas();
            canvas.drawColor(Color.WHITE);
            switch (gameState){
                case Menu:
                    menuDraw(canvas);
                    break;
                case Playing:
                    playingDraw(canvas);
                    break;
                case Over:
                    overDraw(canvas);
                    break;
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            holder.unlockCanvasAndPost(canvas);
        }
    }

    private void menuDraw(Canvas canvas){
        paint.setColor(Color.RED);
        paint.setTextSize(50);
        canvas.drawText("I am in menu.Touch me to next scence",100,100,paint);
    }

    private void playingDraw(Canvas canvas){
        paint.setColor(Color.RED);
        paint.setTextSize(50);
        canvas.drawText("I am in playing,Slide down to next scence ",100,100,paint);
    }

    private void overDraw(Canvas canvas){
        paint.setColor(Color.RED);
        paint.setTextSize(50);
        canvas.drawText("I am in over,Slide right to next scence",100,100,paint);
    }

    //这里就是同步触发机制了
    //每一个时钟周期，执行一次逻辑方法和绘图方法
    @Override
    public void run() {
        while(flag){
            mLogic();
            mDraw();
            try {
                Thread.sleep(500);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    //SurfaceView创建时调用
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        thread.start();
    }

    //SurfaceView发生改变时调用
    @Override
    public void surfaceChanged(SurfaceHolder holder, int fORMat, int width, int height) {

    }

    //SurfaceView销毁时调用
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        flag = false;
    }

}

这只是一个游戏框架，还没有往里写任何内容，但根据我的经验（虽然我也没有很多经验），这里已经包括了所有游戏（这里特指小游戏-_-）的主体框架代码，有了这个框架，我们就只需要写游戏的逻辑和绘图方法了，不用纠结怎么搭建游戏框架了。
这里我还加了一个NextEvent的方法，在里面我封装了上个游戏用到的滑动手势，在这个挨踢圈里，人们最常说的一句话就是：不要重复造轮子。当我们看到写了很多重复代码时，就是我们需要精简的时候了。
上代码：

NextEvent.java


package com.next.eatsnake;


public class NextEvent {
    public static final int LEFT = 1;
    public static final int RIGHT = 2;
    public static final int UP = 3;
    public static final int DOWN = 4;
    public static final int QUIET = -1;//没有滑动
    private int dir;
    private int downX,downY,upX,upY;
    public NextEvent()
    {
        init();
    }
    public void init(){
        this.dir = QUIET;
        this.downX = -1;
        this.downY = -1;
        this.upX = -1;
        this.upY = -1;
    }
    public int getDir(){
        float offsetX,offsetY;
        offsetX = upX - downX;
        offsetY = upY - downY;
        if (Math.abs(offsetX) > Math.abs(offsetY)) {
            if (offsetX > 5 ) {
                dir = RIGHT;
            }else if (offsetX < -5) {
                dir = LEFT;
            }
        }else {
            if (offsetY > 5) {
                dir = DOWN;
            }else if (offsetY < -5) {
                dir = UP;
            }
        }
        return dir;
    }

    public int getDownX() {
        return downX;
    }

    public void setDownX(int downX) {
        this.downX = downX;
    }

    public int getDownY() {
        return downY;
    }

    public void setDownY(int downY) {
        this.downY = downY;
    }

    public int getUpX() {
        return upX;
    }

    public void setUpX(int upX) {
        this.upX = upX;
    }

    public int getUpY() {
        return upY;
    }

    public void setUpY(int upY) {
        this.upY = upY;
    }
}

这个NextEvent是用来存储用户输入事件的，我们只是存储，而没有直接触发游戏逻辑。那么什么时候用到读取这个NextEvent呢？如果你仔细看了第一段代码，应该已经知道了——在每一个时钟周期的逻辑方法里判断NextEvent，并由此改变游戏逻辑。这种就是同步机制，而用户输入事件游戏逻辑就随之改变的就是异步机制。

下面我们用这个框架做一个贪吃蛇游戏，效果图如下：

这里写图片描述

这里写图片描述

这里写图片描述

MainActivity.java


package com.next.eatsnake;

import android.app.Activity;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(new GameView(this));
    }
}

GameView.java


package com.next.eatsnake;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.View.OnTouchListener;

import java.util.ArrayList;
import java.util.Random;


public class GameView extends SurfaceView implements SurfaceHolder.Callback,OnTouchListener,Runnable {

    enum GameState{
        Menu,
        Playing,
        Over;
    }
    GameState gameState;//游戏状态
    Thread thread;//游戏线程
    Boolean flag;//游戏循环控制标志
    Canvas canvas;//画布
    Paint paint;//画笔
    SurfaceHolder holder;//SurfaceView控制句柄
    public static Random random;//随机数
    NextEvent nextEvent;//游戏输入事件
    int scrW,scrH;//屏幕的宽和高
    final int MAX_X = 15;
    int MAX_Y;//竖向tile数量根据MAX_X动态计算，保证tile是正方形
    public static Tile[][] tiles;
    Snake snake;
    public static boolean isEatFood;
    public GameView(Context context) {
        super(context);
        gameState = GameState.Menu;
        flag = true;
        paint = new Paint();
        paint.setAntiAlias(true);//笔迹平滑
        paint.setTextAlign(Paint.Align.CENTER);//文字中间对齐
        thread = new Thread(this);
        random = new Random();
        nextEvent = new NextEvent();
        holder = this.getHolder();
        holder.addCallback(this);
        this.setOnTouchListener(this);
        setKeepScreenOn(true);
        scrW = ((MainActivity)context).getWindowManager().getDefaultDisplay().getWidth();
        scrH = ((MainActivity)context).getWindowManager().getDefaultDisplay().getHeight();
        Tile.width = scrW/MAX_X;
        MAX_Y = scrH/Tile.width;
        tiles = new Tile[MAX_X][MAX_Y];
        isEatFood = false;
    }

    private void newGame(){
        for (int x = 0;x < MAX_X;x++){
            for (int y = 0;y < MAX_Y;y++){
                if (x == 0||y == 0||x == MAX_X-1||y == MAX_Y-1){
                    tiles[x][y] = new Tile(x,y,Tile.TYPE_WALL);
                }else {
                    tiles[x][y] = new Tile(x,y,Tile.TYPE_NULL);
                }
            }
        }
        snake = new Snake(tiles[4][4],tiles[5][4],tiles[6][4], NextEvent.DOWN);
        addFood();
        addFood();
        addFood();
    }

    public void addFood(){
        ArrayList<Tile> nullList = new ArrayList<Tile>();
        for (int x = 0;x < MAX_X;x++){
            for (int y = 0;y < MAX_Y;y++){
                if (tiles[x][y].getType() == Tile.TYPE_NULL){
                    nullList.add(tiles[x][y]);
                }
            }
        }
        if (nullList.size()!=0){
            nullList.get(random.nextInt(nullList.size())).setType(Tile.TYPE_FOOD);
        }
    }

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            nextEvent.setDownX((int) event.getX());
            nextEvent.setDownY((int) event.getY());
        }else if (event.getAction() == MotionEvent.ACTION_UP) {
            nextEvent.setUpX((int) event.getX());
            nextEvent.setUpY((int) event.getY());
        }
        return true;
    }

    private void mLogic(){
        switch (gameState){
            case Menu:
                menuLogic();
                break;
            case Playing:
                playingLogic();
                break;
            case Over:
                overLogic();
                break;
        }
        nextEvent.init();//每次逻辑循环后，清空事件
    }

    private void menuLogic(){
        if(nextEvent.getUpX() > 0){
            gameState = GameState.Playing;
            newGame();
        }
    }

    private void playingLogic(){
        if (nextEvent.getDir()!=NextEvent.QUIET){
            snake.setDir(nextEvent.getDir());
        }
        snake.move();
        if (isEatFood){
            addFood();
            isEatFood = false;
        }
        if(!snake.isAlive()){
            gameState = GameState.Over;
        }
    }

    private void overLogic(){
        if(nextEvent.getUpX() > 0){
            gameState = GameState.Playing;
            newGame();
        }
    }

    private void mDraw(){
        try {
            canvas = holder.lockCanvas();
            canvas.drawColor(Color.WHITE);
            switch (gameState){
                case Menu:
                    menuDraw(canvas);
                    break;
                case Playing:
                    playingDraw(canvas);
                    break;
                case Over:
                    overDraw(canvas);
                    break;
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            holder.unlockCanvasAndPost(canvas);
        }
    }

    private void menuDraw(Canvas canvas){
        paint.setColor(Color.BLACK);
        paint.setTextSize(50);
        canvas.drawText("Eat Snake,Touch me and start",scrW/2,scrH/2,paint);
    }

    private void playingDraw(Canvas canvas){
        for (int x = 0;x < MAX_X;x++){
            for (int y = 0;y < MAX_Y;y++){
                tiles[x][y].draw(canvas,paint);
            }
        }
    }

    private void overDraw(Canvas canvas){
        paint.setColor(Color.BLACK);
        paint.setTextSize(50);
        canvas.drawText("Your score is:"+snake.getLength(),scrW/2,scrH/4,paint);
        canvas.drawText("Touch me and try again",scrW/2,scrH/2,paint);
    }

    @Override
    public void run() {
        while(flag){
            mLogic();
            mDraw();
            try {
                Thread.sleep(500);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        thread.start();
    }

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

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        flag = false;
    }

}

Tile.java


package com.next.eatsnake;

import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;


public class Tile {
    public static final int TYPE_NULL = 0;//空
    public static final int TYPE_WALL = 1;//墙
    public static final int TYPE_HEAD = 2;//蛇头
    public static final int TYPE_BODY = 3;//蛇身
    public static final int TYPE_TAIL = 4;//蛇尾
    public static final int TYPE_FOOD = 5;//食物
    private int x,y;
    private int type;
    public static int width;

    public Tile(int x, int y, int type) {
        this.x = x;
        this.y = y;
        this.type = type;
    }

    public void draw(Canvas canvas,Paint paint){
        switch (type){
            case TYPE_NULL:
                break;
            case TYPE_WALL:
                paint.setColor(Color.BLACK);
                canvas.drawCircle(x*width+width/2,y*width+width/2,width/2,paint);
                break;
            case TYPE_HEAD:
                paint.setColor(Color.MAGENTA);
                canvas.drawCircle(x*width+width/2,y*width+width/2,width/2,paint);
                paint.setColor(Color.WHITE);
                canvas.drawCircle(x*width+width/2,y*width+width/2,width/8,paint);
                break;
            case TYPE_BODY:
                paint.setColor(Color.MAGENTA);
                canvas.drawCircle(x*width+width/2,y*width+width/2,width/2,paint);
                break;
            case TYPE_TAIL:
                paint.setColor(Color.MAGENTA);
                paint.setStrokeWidth(10);
                canvas.drawLine(x * width, y * width + width / 2, x * width + width / 2, y * width, paint);
                canvas.drawLine(x*width+ width / 2,y*width,x*width+width,y*width+width/2,paint);
                canvas.drawLine(x*width+width,y*width+width/2,x*width+width/2,y*width+width,paint);
                canvas.drawLine(x*width+width/2,y*width+width,x*width,y*width+ width / 2,paint);
                break;
            case TYPE_FOOD:
                switch (GameView.random.nextInt(3)){
                    case 0:
                        paint.setColor(Color.YELLOW);
                        break;
                    case 1:
                        paint.setColor(Color.GREEN);
                        break;
                    case 2:
                        paint.setColor(Color.CYAN);
                        break;
                }
                canvas.drawCircle(x*width+width/2,y*width+width/2,width/2,paint);
                break;

        }
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
}

Snake.java


package com.next.eatsnake;

import java.util.ArrayList;


public class Snake {
    private ArrayList<Tile> snake;
    private int dir;
    private boolean isAlive;


    public Snake(Tile head,Tile body,Tile tail,int dir){
        snake = new ArrayList<Tile>();
        head.setType(Tile.TYPE_HEAD);
        body.setType(Tile.TYPE_BODY);
        tail.setType(Tile.TYPE_TAIL);
        snake.add(head);
        snake.add(body);
        snake.add(tail);
        isAlive = true;
        this.dir = dir;
    }

    public void move(){
        if (!isAlive)
            return;
        switch (dir){
            case NextEvent.LEFT:
                switch (GameView.tiles[snake.get(0).getX()-1][snake.get(0).getY()].getType()){
                    case Tile.TYPE_WALL:
                    case Tile.TYPE_BODY:
                    case Tile.TYPE_TAIL:
                        isAlive = false;
                        break;
                    case Tile.TYPE_FOOD:
                        GameView.tiles[snake.get(0).getX()-1][snake.get(0).getY()].setType(Tile.TYPE_HEAD);
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()].setType(Tile.TYPE_BODY);
                        snake.add(0, GameView.tiles[snake.get(0).getX() - 1][snake.get(0).getY()]);
                        GameView.isEatFood = true;
                        break;
                    case Tile.TYPE_NULL:
                        GameView.tiles[snake.get(0).getX()-1][snake.get(0).getY()].setType(Tile.TYPE_HEAD);
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()].setType(Tile.TYPE_BODY);
                        snake.add(0, GameView.tiles[snake.get(0).getX() - 1][snake.get(0).getY()]);
                        snake.get(snake.size()-1).setType(Tile.TYPE_NULL);
                        snake.remove(snake.size()-1);
                        snake.get(snake.size()-1).setType(Tile.TYPE_TAIL);
                        break;
                }
                break;
            case NextEvent.RIGHT:
                switch (GameView.tiles[snake.get(0).getX()+1][snake.get(0).getY()].getType()){
                    case Tile.TYPE_WALL:
                    case Tile.TYPE_BODY:
                    case Tile.TYPE_TAIL:
                        isAlive = false;
                        break;
                    case Tile.TYPE_FOOD:
                        GameView.tiles[snake.get(0).getX()+1][snake.get(0).getY()].setType(Tile.TYPE_HEAD);
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()].setType(Tile.TYPE_BODY);
                        snake.add(0, GameView.tiles[snake.get(0).getX() + 1][snake.get(0).getY()]);
                        GameView.isEatFood = true;
                        break;
                    case Tile.TYPE_NULL:
                        GameView.tiles[snake.get(0).getX()+1][snake.get(0).getY()].setType(Tile.TYPE_HEAD);
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()].setType(Tile.TYPE_BODY);
                        snake.add(0, GameView.tiles[snake.get(0).getX() + 1][snake.get(0).getY()]);
                        snake.get(snake.size()-1).setType(Tile.TYPE_NULL);
                        snake.remove(snake.size() - 1);
                        snake.get(snake.size()-1).setType(Tile.TYPE_TAIL);
                        break;
                }
                break;
            case NextEvent.UP:
                switch (GameView.tiles[snake.get(0).getX()][snake.get(0).getY()-1].getType()){
                    case Tile.TYPE_WALL:
                    case Tile.TYPE_BODY:
                    case Tile.TYPE_TAIL:
                        isAlive = false;
                        break;
                    case Tile.TYPE_FOOD:
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()-1].setType(Tile.TYPE_HEAD);
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()].setType(Tile.TYPE_BODY);
                        snake.add(0, GameView.tiles[snake.get(0).getX()][snake.get(0).getY()-1]);
                        GameView.isEatFood = true;
                        break;
                    case Tile.TYPE_NULL:
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()-1].setType(Tile.TYPE_HEAD);
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()].setType(Tile.TYPE_BODY);
                        snake.add(0, GameView.tiles[snake.get(0).getX()][snake.get(0).getY()-1]);
                        snake.get(snake.size()-1).setType(Tile.TYPE_NULL);
                        snake.remove(snake.size()-1);
                        snake.get(snake.size()-1).setType(Tile.TYPE_TAIL);
                        break;
                }
                break;
            case NextEvent.DOWN:
                switch (GameView.tiles[snake.get(0).getX()][snake.get(0).getY()+1].getType()){
                    case Tile.TYPE_WALL:
                    case Tile.TYPE_BODY:
                    case Tile.TYPE_TAIL:
                        isAlive = false;
                        break;
                    case Tile.TYPE_FOOD:
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()+1].setType(Tile.TYPE_HEAD);
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()].setType(Tile.TYPE_BODY);
                        snake.add(0, GameView.tiles[snake.get(0).getX()][snake.get(0).getY() + 1]);
                        GameView.isEatFood = true;
                        break;
                    case Tile.TYPE_NULL:
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()+1].setType(Tile.TYPE_HEAD);
                        GameView.tiles[snake.get(0).getX()][snake.get(0).getY()].setType(Tile.TYPE_BODY);
                        snake.add(0, GameView.tiles[snake.get(0).getX()][snake.get(0).getY()+1]);
                        snake.get(snake.size()-1).setType(Tile.TYPE_NULL);
                        snake.remove(snake.size()-1);
                        snake.get(snake.size()-1).setType(Tile.TYPE_TAIL);
                        break;
                }
                break;
        }
    }

    public void setDir(int dir){
        if (this.dir == dir||this.dir == -dir||dir == NextEvent.QUIET)
            return;
        else
            this.dir = dir;
    }

    public boolean isAlive(){
        return isAlive;
    }

    public int getLength(){
        return snake.size();
    }
}

NextEvent.java

就是刚开始介绍的那个类，这里就不重复贴出了

到此这篇关于Android 2d游戏开发之贪吃蛇基于surfaceview的文章就介绍到这了,更多相关Android 贪吃蛇内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

--结束END--

本文标题: Android 2d游戏开发之贪吃蛇基于surfaceview

本文链接: https://lsjlt.com/news/135330.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Android 2d游戏开发之贪吃蛇基于surfaceview
    前两个游戏是基于View游戏框架的，View游戏框架只适合做静止的，异步触发的游戏，如果做一直在动的游戏，View的效率就不高了，我们需要一种同步触发的游戏框架，也就是surface...
    99+
    2024-04-02
  • Android开发之经典游戏贪吃蛇
    前言 这款游戏实现的思路和源码参考了Google自带的Snake的例子，其中修改了一些个人认为还不够完善的地方，加入了一些新的功能，比如屏幕上的方向操作盘，暂停按钮，开始按钮，...
    99+
    2022-06-06
    android开发 贪吃蛇 Android
  • C#游戏开发之实现贪吃蛇游戏
    目录实践过程效果代码实践过程 效果 代码 public partial class Form1 : Form { public Form1() { ...
    99+
    2023-01-04
    C#实现贪吃蛇游戏 C#贪吃蛇游戏 C#贪吃蛇
  • 基于AndroidFlutter编写贪吃蛇游戏
    目录前言开发步骤：1.定义蛇和豆子2.让蛇动起来3.使用陀螺仪来控制蛇4.让蛇吃掉豆子5.吃掉豆子随机生成一个豆子前言 放假期间，小T打算回顾一下经典，想用Flutter做一下小游戏...
    99+
    2024-04-02
  • 基于Vueuniapp实现贪吃蛇游戏
    目录游戏演示代码结构渲染蛇身控制蛇的方向游戏演示 代码结构 详细代码结构如果需要请到github查看 <template> <view ref="body" c...
    99+
    2024-04-02
  • 基于MFC实现贪吃蛇小游戏
    本文实例为大家分享了MFC实现贪吃蛇小游戏的具体代码，供大家参考，具体内容如下 一、功能描述 （1）通过“START”、“PAUSE”、“EXIT”三个控件,控制游戏的开始、暂停和终...
    99+
    2024-04-02
  • 基于Java实现简单贪吃蛇游戏
    本文实例为大家分享了Java实现简单贪吃蛇游戏的具体代码，供大家参考，具体内容如下 贪吃蛇小游戏制作方法 首先需要的准备有： 1、掌握Java基础知识，即Java SE 2、了解一定...
    99+
    2024-04-02
  • 如何用Silverlight开发贪吃蛇游戏
    今天就跟大家聊聊有关如何用Silverlight开发贪吃蛇游戏，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。介绍使用 Silverlight 3.0(c#) 开发一个贪吃蛇...
    99+
    2023-06-17
  • 基于C语言实现贪吃蛇小游戏
    本文实例为大家分享了C语言实现贪吃蛇小游戏的具体代码，供大家参考，具体内容如下 1.目标要求： 1.上下左右控制蛇头转向2.若蛇头碰到食物，长度加一3.若蛇头碰到边框、碰到自身或蛇回...
    99+
    2024-04-02
  • 基于Pygame实现简单的贪吃蛇游戏
    目录导入相关的包设置屏幕大小以及基本参数设置贪吃蛇的位置，以及移动的大小绘制蛇让蛇动起来实现贪吃蛇拐弯实现随机食物吃食物完整代码 导入相关的包 import pygame, sy...
    99+
    2024-04-02
  • 基于pygame实现贪吃蛇小游戏示例
    目录游戏截图引入库初始化模型获取键盘事件移动贪吃蛇吃食物逻辑碰撞到自身逻辑结束游戏显示文字函数完整代码游戏截图 引入库 import copy import random i...
    99+
    2024-04-02
  • 基于Vue uniapp怎么实现贪吃蛇游戏
    本篇内容介绍了“基于Vue uniapp怎么实现贪吃蛇游戏”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！游戏演示代码结构详细代码结...
    99+
    2023-06-30
  • Android Studio实现贪吃蛇小游戏
    项目目录 一、项目概述二、开发环境三、详细设计四、运行演示五、项目总结六、源码获取 一、项目概述 贪吃蛇是一款经典的街机游戏，不仅在电子游戏史上占有一席之地，也在很多人的童年回忆中留下了深...
    99+
    2023-10-01
    android studio android 安卓 安卓app android程序
  • C语言实现贪吃蛇小游戏开发
    本文实例为大家分享了C语言实现贪吃蛇小游戏的具体代码，供大家参考，具体内容如下 程序介绍 代码 #include<stdafx.h>            //vc自带...
    99+
    2022-11-13
    C语言 贪吃蛇
  • 基于Pygame如何实现简单的贪吃蛇游戏
    这篇文章主要为大家展示了“基于Pygame如何实现简单的贪吃蛇游戏”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“基于Pygame如何实现简单的贪吃蛇游戏”这篇文章吧。导入相关的包import&n...
    99+
    2023-06-21
  • C语言基于EasyX如何实现贪吃蛇游戏
    本篇内容主要讲解“C语言基于EasyX如何实现贪吃蛇游戏”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“C语言基于EasyX如何实现贪吃蛇游戏”吧!成品展示：实现思路：贪吃蛇的实现思路并不复杂，由...
    99+
    2023-07-02
  • Java实战之贪吃蛇小游戏（源码+注释）
    目录一、工程文件二、Main.java三、Mpanel.java四、效果一、工程文件 二、Main.java package com.company; import java...
    99+
    2024-04-02
  • C++入门指南之贪吃蛇游戏的实现
    目录参考贪吃蛇游戏程序框架绘制游戏地图和蛇小蛇向右移动控制小蛇4个方向移动时间控制的改进失败判断与显示添加食物完整代码总结参考 《C和C++游戏趣味编程》 贪...
    99+
    2024-04-02
  • python实战之利用pygame实现贪吃蛇游戏（一）
    目录一、前言二、搭建界面三、运行结果四、结语一、前言 之前尝试了自己用pygame写井字棋，这次玩的是贪吃蛇系列。 个人感觉模块可能会比较大，所以选择将函数和主要逻辑代码分在了两个文件中。 fuc为函数模块，存储了...
    99+
    2022-06-02
    pygame实现贪吃蛇游戏 python游戏 python pygame
  • python实战之利用pygame实现贪吃蛇游戏（二）
    目录一、前言二、创建蛇三、创建食物四、蛇的移动五、按键感应六、整合部分七、结语一、前言 在上一篇博客中，我们实现了基本的界面搭建，这次实现一下逻辑部分。 二、创建蛇 首先，先分析一下...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作