【Android 2d 游戏开发(2)】——2048

最新推荐文章于 2019-11-16 18:12:53 发布
最新推荐文章于 2019-11-16 18:12:53 发布
阅读量1.6k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Android 2d 游戏开发日记 文章标签： android 游戏开发 2d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/potato47/article/details/50938580

实现效果 ：

开始界面
游戏界面
结束界面

代码结构：

这里写图片描述

完整代码：

MainActivity:

package com.next.next2048;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;

public class MainActivity extends AppCompatActivity {

    @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));
    }
}

Tile:
package com.next.next2048;

/**
* Created by Next on 2016/3/17 0017.
*/
public class Tile {
private int number;
private int x,y;
public Tile(int x,int y,int number){
this.x = x;
this.y = y;
this.number = number;
}

public int getY() {
    return y;
}

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

public int getX() {
    return x;
}

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

public int getNumber() {
    return number;
}

public void setNumber(int number) {
    this.number = number;
}

}
GameView:

package com.next.next2048;

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

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

/**
 * Created by Next on 2016/3/17 0017.
 */
public class GameView extends View {
    enum GameState {
        Menu,
        Playing,
        Over
    }

    GameState gameState = GameState.Menu;
    public static final int MAX_X = 4;
    public static final int MAX_Y = 4;
    int tWidth;//tile宽度
    int scrW;//屏幕宽
    int scrH;//屏幕高
    int offsetX;//偏移x
    int offsetY;//偏移y，用于调整游戏区域在屏幕中的位置
    Paint paint;
    Tile[][] tiles;//Tile集合
    Random random;
    ArrayList<Tile> zeroList;
    float downX, downY, upX, upY;

    public GameView(Context context) {
        super(context);
        scrW = ((MainActivity) context).getWindowManager().getDefaultDisplay().getWidth();
        scrH = ((MainActivity) context).getWindowManager().getDefaultDisplay().getHeight();
        offsetX = 30;
        offsetY = (scrH - scrW) / 2;//使棋盘位于屏幕中央
        tWidth = (scrW - offsetX * 2) / MAX_X;
        paint = new Paint();
        tiles = new Tile[MAX_X][MAX_Y];
        setKeepScreenOn(true);//保持屏幕常亮
        random = new Random();
        zeroList = new ArrayList<Tile>();
    }

    private void newGame() {
        for (int x = 0; x < MAX_X; x++) {
            for (int y = 0; y < MAX_Y; y++) {
                tiles[x][y] = new Tile(x, y, 0);
            }
        }
        newTile();
        newTile();


    }

    private void newTile() {
        zeroList.removeAll(zeroList);
        for (int x = 0; x < MAX_X; x++) {
            for (int y = 0; y < MAX_Y; y++) {
                if (tiles[x][y].getNumber() == 0) {
                    zeroList.add(tiles[x][y]);
                }
            }
        }
        int size = zeroList.size();
        if (size > 0) {
            //出现4的概率是20%，出现2的概率是80%
            if (random.nextInt(5) == 0) {
                zeroList.get(random.nextInt(size)).setNumber(4);
            } else {
                zeroList.get(random.nextInt(size)).setNumber(2);
            }
        } else {
            return;
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        switch (gameState) {
            case Menu:
                menuDraw(canvas);
                break;
            case Playing:
                playingDraw(canvas);
                break;
            case Over:
                overDraw(canvas);
                break;
            default:
                break;
        }
    }

    private void menuDraw(Canvas canvas) {
        canvas.drawColor(Color.WHITE);
        paint.setColor(Color.BLACK);
        paint.setTextAlign(Paint.Align.CENTER);
        paint.setTextSize(tWidth / 2);
        canvas.drawText("2048", scrW / 2, scrH / 4, paint);
        canvas.drawText("Touch me", scrW / 2, scrH / 2, paint);
    }

    private void playingDraw(Canvas canvas) {
        canvas.drawColor(Color.WHITE);
        //画主游戏区域
        paint.setColor(Color.BLACK);
        paint.setStrokeWidth(10);
        for (int x = 0; x < MAX_X + 1; x++) {
            canvas.drawLine(offsetX + x * tWidth, offsetY, offsetX + x * tWidth, offsetY + tWidth * MAX_Y, paint);
        }
        for (int y = 0; y < MAX_Y + 1; y++) {
            canvas.drawLine(offsetX, offsetY + y * tWidth, offsetX + MAX_X * tWidth, offsetY + y * tWidth, paint);
        }
        for (int x = 0; x < MAX_X; x++) {
            for (int y = 0; y < MAX_Y; y++) {
                if (tiles[x][y].getNumber() != 0) {
                    switch (tiles[x][y].getNumber()){
                        case 2:
                            paint.setColor(0xffff6666);
                            break;
                        case 4:
                            paint.setColor(0xffff9900);
                            break;
                        case 8:
                            paint.setColor(0xff99CC33);
                            break;
                        case 16:
                            paint.setColor(0xff33CC99);
                            break;
                        case 32:
                            paint.setColor(0xff666699);
                            break;
                        case 64:
                            paint.setColor(0xff339933);
                            break;
                        case 128:
                            paint.setColor(0xff0099CC);
                            break;
                        case 256:
                            paint.setColor(0xff660033);
                            break;
                        case 512:
                            paint.setColor(0xff006633);
                            break;
                        case 1024:
                            paint.setColor(0xff660099);
                            break;
                        case 2048:
                            paint.setColor(0xffff0033);
                            break;
                        case 4096:
                            paint.setColor(0xff333333);
                            break;
                        case 8192:
                            paint.setColor(0xff000000);
                            break;
                        default:
                            paint.setColor(0xff000000);
                            break;
                    }
                    canvas.drawText(tiles[x][y].getNumber() + "", offsetX + x * tWidth + tWidth / 2, offsetY + y * tWidth + tWidth * 3 / 4, paint);
                }
            }
        }
    }

    private void overDraw(Canvas canvas) {
        int max = 0;
        for (int x = 0; x < MAX_X; x++) {
            for (int y = 0; y < MAX_Y; y++) {
                if (tiles[x][y].getNumber() > max) {
                    max = tiles[x][y].getNumber();
                }
            }
        }
        canvas.drawColor(Color.WHITE);
        paint.setColor(Color.BLACK);
        paint.setTextAlign(Paint.Align.CENTER);
        paint.setTextSize(tWidth / 2);
        canvas.drawText("Top:" + max, scrW / 2, scrH / 4, paint);
        canvas.drawText("Try again", scrW / 2, scrH / 2, paint);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (gameState) {
            case Menu:
                menuLogic(event);
                break;
            case Playing:
                playingLoic(event);
                break;
            case Over:
                overLogic(event);
                break;
        }
        return true;
    }

    private void menuLogic(MotionEvent event) {
        if (event.getX() > 0) {
            gameState = GameState.Playing;
            newGame();
            invalidate();
        }
    }

    private void playingLoic(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            downX = event.getX();
            downY = event.getY();
        } else if (event.getAction() == MotionEvent.ACTION_UP) {
            upX = event.getX();
            upY = event.getY();
            float moveX = upX - downX;
            float moveY = upY - downY;
            if (Math.abs(moveX) > Math.abs(moveY)) {
                if (moveX > 50) {
                    //右滑
                    //合并
                    boolean isMove = false;//判断是否有tile移动
                    for (int y = 0; y < MAX_Y; y++) {
                        for (int x = MAX_X - 1; x >= 0; x--) {
                            if (tiles[x][y].getNumber() == 0) {
                                continue;
                            }
                            for (int x0 = x - 1; x0 >= 0; x0--) {
                                if (tiles[x0][y].getNumber() == 0) {
                                    continue;
                                } else if (tiles[x][y].getNumber() == tiles[x0][y].getNumber()) {
                                    tiles[x][y].setNumber(tiles[x][y].getNumber() * 2);
                                    tiles[x0][y].setNumber(0);
                                    isMove = true;
                                    break;
                                } else {
                                    break;
                                }
                            }
                        }
                    }
                    //移动
                    for (int y = 0; y < MAX_Y; y++) {
                        for (int x = MAX_X - 1; x >= 0; x--) {
                            if (tiles[x][y].getNumber() != 0) {
                                continue;
                            }
                            for (int x0 = x - 1; x0 >= 0; x0--) {
                                if (tiles[x0][y].getNumber() == 0) {
                                    continue;
                                } else {
                                    tiles[x][y].setNumber(tiles[x0][y].getNumber());
                                    tiles[x0][y].setNumber(0);
                                    isMove = true;
                                    break;
                                }
                            }
                        }
                    }
                    //有tile移动才添加新的tile
                    if (isMove) {
                        newTile();
                        invalidate();
                        judgeOver();
                    }
                } else if (moveX < -50) {
                    //左滑
                    //合并
                    boolean isMove = false;
                    for (int y = 0; y < MAX_Y; y++) {
                        for (int x = 0; x < MAX_X; x++) {
                            if (tiles[x][y].getNumber() == 0) {
                                continue;
                            }
                            for (int x0 = x + 1; x0 < MAX_X; x0++) {
                                if (tiles[x0][y].getNumber() == 0) {
                                    continue;
                                } else if (tiles[x][y].getNumber() == tiles[x0][y].getNumber()) {
                                    tiles[x][y].setNumber(tiles[x][y].getNumber() * 2);
                                    tiles[x0][y].setNumber(0);
                                    isMove = true;
                                    break;
                                } else {
                                    break;
                                }
                            }
                        }
                    }
                    //移动
                    for (int y = 0; y < MAX_Y; y++) {
                        for (int x = 0; x < MAX_X; x++) {
                            if (tiles[x][y].getNumber() != 0) {
                                continue;
                            }
                            for (int x0 = x + 1; x0 < MAX_X; x0++) {
                                if (tiles[x0][y].getNumber() == 0) {
                                    continue;
                                } else {
                                    tiles[x][y].setNumber(tiles[x0][y].getNumber());
                                    tiles[x0][y].setNumber(0);
                                    isMove = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (isMove) {
                        newTile();
                        invalidate();
                        judgeOver();
                    }
                }
            } else {
                if (moveY > 50) {
                    //下滑
                    //合并
                    boolean isMove = false;
                    for (int x = 0; x < MAX_X; x++) {
                        for (int y = MAX_Y - 1; y >= 0; y--) {
                            if (tiles[x][y].getNumber() == 0) {
                                continue;
                            }
                            for (int y0 = y - 1; y0 >= 0; y0--) {
                                if (tiles[x][y0].getNumber() == 0) {
                                    continue;
                                } else if (tiles[x][y].getNumber() == tiles[x][y0].getNumber()) {
                                    tiles[x][y].setNumber(tiles[x][y].getNumber() * 2);
                                    tiles[x][y0].setNumber(0);
                                    isMove = true;
                                    break;
                                } else {
                                    break;
                                }
                            }
                        }
                    }
                    //移动
                    for (int x = 0; x < MAX_X; x++) {
                        for (int y = MAX_Y - 1; y >= 0; y--) {
                            if (tiles[x][y].getNumber() != 0) {
                                continue;
                            }
                            for (int y0 = y - 1; y0 >= 0; y0--) {
                                if (tiles[x][y0].getNumber() == 0) {
                                    continue;
                                } else {
                                    tiles[x][y].setNumber(tiles[x][y0].getNumber());
                                    tiles[x][y0].setNumber(0);
                                    isMove = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (isMove) {
                        newTile();
                        invalidate();
                        judgeOver();
                    }
                } else if (moveY < -50) {
                    //上滑
                    //合并
                    boolean isMove = false;
                    for (int x = 0; x < MAX_X; x++) {
                        for (int y = 0; y < MAX_Y; y++) {
                            if (tiles[x][y].getNumber() == 0) {
                                continue;
                            }
                            for (int y0 = y + 1; y0 < MAX_Y; y0++) {
                                if (tiles[x][y0].getNumber() == 0) {
                                    continue;
                                } else if (tiles[x][y].getNumber() == tiles[x][y0].getNumber()) {
                                    tiles[x][y].setNumber(tiles[x][y].getNumber() * 2);
                                    tiles[x][y0].setNumber(0);
                                    isMove = true;
                                    break;
                                } else {
                                    break;
                                }
                            }
                        }
                    }
                    //移动
                    for (int x = 0; x < MAX_X; x++) {
                        for (int y = 0; y < MAX_Y; y++) {
                            if (tiles[x][y].getNumber() != 0) {
                                continue;
                            }
                            for (int y0 = y + 1; y0 < MAX_Y; y0++) {
                                if (tiles[x][y0].getNumber() == 0) {
                                    continue;
                                } else {
                                    tiles[x][y].setNumber(tiles[x][y0].getNumber());
                                    tiles[x][y0].setNumber(0);
                                    isMove = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (isMove) {
                        newTile();
                        invalidate();
                        judgeOver();
                    }
                }
            }
        }
    }

    private void overLogic(MotionEvent event) {
        if (event.getX() > 0) {
            newGame();
            gameState = GameState.Playing;
        }
    }

    private void judgeOver() {
        //右滑
        //合并
        for (int y = 0; y < MAX_Y; y++) {
            for (int x = MAX_X - 1; x >= 0; x--) {
                if (tiles[x][y].getNumber() == 0) {
                    continue;
                }
                for (int x0 = x - 1; x0 >= 0; x0--) {
                    if (tiles[x0][y].getNumber() == 0) {
                        continue;
                    } else if (tiles[x][y].getNumber() == tiles[x0][y].getNumber()) {
                        return;
                    } else {
                        break;
                    }
                }
            }
        }
        //移动
        for (int y = 0; y < MAX_Y; y++) {
            for (int x = MAX_X - 1; x >= 0; x--) {
                if (tiles[x][y].getNumber() != 0) {
                    continue;
                }
                for (int x0 = x - 1; x0 >= 0; x0--) {
                    if (tiles[x0][y].getNumber() == 0) {
                        continue;
                    } else {
                        return;
                    }
                }
            }
        }
        //左滑
        //合并
        for (int y = 0; y < MAX_Y; y++) {
            for (int x = 0; x < MAX_X; x++) {
                if (tiles[x][y].getNumber() == 0) {
                    continue;
                }
                for (int x0 = x + 1; x0 < MAX_X; x0++) {
                    if (tiles[x0][y].getNumber() == 0) {
                        continue;
                    } else if (tiles[x][y].getNumber() == tiles[x0][y].getNumber()) {
                        return;
                    } else {
                        break;
                    }
                }
            }
        }
        //移动
        for (int y = 0; y < MAX_Y; y++) {
            for (int x = 0; x < MAX_X; x++) {
                if (tiles[x][y].getNumber() != 0) {
                    continue;
                }
                for (int x0 = x + 1; x0 < MAX_X; x0++) {
                    if (tiles[x0][y].getNumber() == 0) {
                        continue;
                    } else {
                        return;
                    }
                }
            }
        }
        //下滑
        //合并
        for (int x = 0; x < MAX_X; x++) {
            for (int y = MAX_Y - 1; y >= 0; y--) {
                if (tiles[x][y].getNumber() == 0) {
                    continue;
                }
                for (int y0 = y - 1; y0 >= 0; y0--) {
                    if (tiles[x][y0].getNumber() == 0) {
                        continue;
                    } else if (tiles[x][y].getNumber() == tiles[x][y0].getNumber()) {
                        return;
                    } else {
                        break;
                    }
                }
            }
        }
        //移动
        for (int x = 0; x < MAX_X; x++) {
            for (int y = MAX_Y - 1; y >= 0; y--) {
                if (tiles[x][y].getNumber() != 0) {
                    continue;
                }
                for (int y0 = y - 1; y0 >= 0; y0--) {
                    if (tiles[x][y0].getNumber() == 0) {
                        continue;
                    } else {
                        return;
                    }
                }
            }
        }
        //上滑
        //合并
        for (int x = 0; x < MAX_X; x++) {
            for (int y = 0; y < MAX_Y; y++) {
                if (tiles[x][y].getNumber() == 0) {
                    continue;
                }
                for (int y0 = y + 1; y0 < MAX_Y; y0++) {
                    if (tiles[x][y0].getNumber() == 0) {
                        continue;
                    } else if (tiles[x][y].getNumber() == tiles[x][y0].getNumber()) {
                        return;
                    } else {
                        break;
                    }
                }
            }
        }
        //移动
        for (int x = 0; x < MAX_X; x++) {
            for (int y = 0; y < MAX_Y; y++) {
                if (tiles[x][y].getNumber() != 0) {
                    continue;
                }
                for (int y0 = y + 1; y0 < MAX_Y; y0++) {
                    if (tiles[x][y0].getNumber() == 0) {
                        continue;
                    } else {
                        return;
                    }
                }
            }
        }
        gameState = GameState.Over;
        invalidate();
    }
}

说两句：

这次跟上次的五子棋用的一样的游戏框架，应该很容易理解游戏的主题逻辑，当然最重要的是游戏算法，我实现的算法可能有些麻烦，但还算达到了效果，欢迎提意见。

关于主体算法：

我分了两个步骤：1.合并。2.移动
哎呀，不写了，有兴趣的人自己看代码吧，好像也没多少人看我写这个东西。。。囧

下次写个能动的游戏，就贪吃蛇吧，感觉自己帅的人请加我的公众微信号：xinshouit 更新会在里面通知

2D小游戏开发模板-Android
12-27
可用于2D小游戏的快速开发的程序模板，用到了 SurfaceView ，实现主循环、事件响应接口、绘图接口和声音接口，用户只需的重写相应的接口即可收到相应的响应。 带有横竖屏切换，屏幕自适应功能。 精灵动画编辑器使用的是 SPX 2011。 内附说明。 导入谷歌官方提供的 ADT 即可正常使用。
Android 3D游戏开发技术宝典——OpenGL ES 2.0 (吴亚峰)
04-14
《Android 3D游戏开发技术宝典——OpenGL ES 2.0》是吴亚峰编著的一本关于Android平台3D游戏开发的专业书籍，主要聚焦于利用OpenGL ES 2.0进行图形渲染和游戏设计。OpenGL ES是OpenGL的一个精简版本，专为嵌入式系统...
android 2D游戏开发
yuxiaohui78的专栏
12-16 949
http://dev.10086.cn/cmdn/wiki/index.php?doc-view-5146.html
Android中的2D游戏开发
书山有路勤为径
03-27 228
开发思路： 第一个Activity中，设置游戏全屏，设置初始化ContentView, 在CcontentView中，继承SurfaceView,实现Callback和Runnable接口 重写方法，在surfaceCreated方法中启动线程，在线程中给画布画画。   第一个类：SurfaceViewTestActivity     package cn.edu.su...
android 2D 游戏的开发的方法
程序员Android
03-15 2389
最近学习了android 2D 应用的开发，拿来和大家分享一下，学习2D 开发前我们先了解一下SurfaceView的使用以及贴图技术的使用，最后呢，是一个简单的2的游戏的实现。  1.SurfaceView的一些用法                      提供了一个专门的绘图渲染的图形嵌入在一个视图层次;SurfaceView负责将图形正确的显示在屏幕上，访问底层图形是通过Sur
【Android2D游戏开发之四】Android 游戏框架（一个游戏角色在屏幕行走的demo）
小苏博客--关注软件开发
01-17 266
Himi 原创， 转载请注明！ 谢谢。 原文地址： http://blog.youkuaiyun.com/xiaominghimi/archive/2010/12/21/6090631.aspx 各位童鞋请你们注意：surfaceview中确实有 onDraw这个方法，但是surfaceview不会自己去调用！！！ 而我代码中的ondraw 也好 dra...
基于Android的3D游戏开发——国际象棋.zip
02-28
【标题】"基于Android的3D游戏开发——国际象棋.zip"揭示了这个项目的核心内容是使用Android平台进行3D游戏的开发，具体是国际象棋这款游戏。这涉及到多个技术领域，包括移动游戏开发、3D图形编程以及网络通信。 在...
安卓Android源码——基于JBox2D的安卓Android游戏开发全源码.zip
10-10
本资源是关于使用JBox2D库进行安卓Android游戏开发的完整源码，这为我们提供了一个深入理解安卓游戏编程的实践案例。JBox2D是一个基于Java的物理引擎，它是Box2D的Java版本，Box2D是广泛应用于2D物理模拟的开源库，...
安卓Android源码——基于JBox2D的安卓Android游戏开发全源码.rar
10-10
本资源提供的"安卓Android源码——基于JBox2D的安卓Android游戏开发全源码.rar"是专门为学习Android游戏开发的开发者准备的，其中的核心技术点是利用JBox2D库来实现物理模拟。 JBox2D是一个开源的2D物理引擎，它是...
安卓Android源码——基于JBox2D的游戏开发全源码.zip
10-11
《安卓Android源码——基于JBox2D的游戏开发全源码》 在移动游戏开发领域，Android平台以其开源、开放的特性吸引了众多开发者。本资料是关于如何在Android上使用JBox2D库进行游戏开发的全源码教程，旨在帮助开发者...
android2D游戏框架源码
10-25
android游戏开发根据游戏的种类以及需求，可以考虑使用不同的方式去开发并搭建框架，这个是简单的2D休闲游戏的框架，采用SurfaceView起一个独立的线程来控制画板Canvas的刷新。
轻量级Android 2D/3D游戏引擎
04-16
LTLite Engine 是一个基于OpenGL ES的轻量级2D/3D游戏引擎，用C/C++实现， Android游戏开发者可以在windows下用cygwin+NDK+SDK环境，采用C++/C代码编写出的游戏运行效率高，引擎包含2D/3D的库，既可以单独使用2D库也可以2D/3D都使用。开发出来的游戏生成单独的so文件，java层的东西基本不用动，只需要拿例子里提供的代码即可使用，开发者不需要懂java，只要c/c++基础便可，如果想把开发的游戏移植到比的平台如iOs或者HP的WebOS只需要下载LTLite的对应平台SDK，把原先写好的游戏代码重新编译即可。
Android游戏源码纯java编写2d坦克小游戏
06-13
安卓开发游戏，坦克游戏，纯java编写
android 2D游戏
04-24
此款游戏源码的注释写的很完整，对于学习android 2D游戏开发的朋友应该会有算帮助。
Angle源码，android版的2D游戏引擎
03-16
摘要:Java源码,Android源码,2D游戏引擎　　一个适用于Android系统开发游戏所用的2D游戏引擎——Angle v1.0版本源码，代码文件较齐全，android 2d游戏开发相当不错的参考资料，很多朋友想要哦，Android源码的游戏开发引擎源码分享给大家。
android2D游戏编程总结
酒徒词客
12-28 1204
在android2D游戏编程中所要用到的主要类为 SurfaceView  Canvas  Paint     SurfaceView其实为两个View类组成，进行交替画图。要操作SurfaceView则需要实现接口Callback接口。      SurfaceHolder接口控制SurefaceView中的画布，即如果需要使用画布Canvas，则需要由SurefaceHolder来得到。
android 2D 游戏的开发的方法
闲云野鹤专栏
11-30 804
最近学习了android 2D 应用的开发，拿来和大家分享一下，学习2D 开发前我们先了解一下SurfaceView的使用以及贴图技术的使用，最后呢，是一个简单的2的游戏的实现。    1.SurfaceView的一些用法                        提供了一个专门的绘图渲染的图形嵌入在一个视图层次;SurfaceView负责将图形正确的显示在屏幕上，访问
Android之2D游戏开发子弹炸
wqewq19的博客
09-20 400
public class SimpleActivity extends Activity { private static final String TAG = SimpleActivity.class.getSimpleName(); //1.游戏界面引入 MySurfaceView mySurfaceView; @Override protected vo
Android零游戏引擎基础开发2d游戏
a2323247730的博客
11-16 924
使用Textview等进行 2d 游戏开发思路。 1.先实例化textview。 //假设 Textview 的 id 为 text1 Textview textview = (Textview)findViewById(R.id.text1); 2.发送信号。 public void run(){ for(int i=0;i<60;i++) { ...
Android游戏项目源码下载——忍者快跑开发参考
资源摘要信息: "Android游戏源码——忍者快跑.zip是一个适用于Android平台的游戏项目，提供了完整的游戏开发源码。项目基于流行的游戏引擎Cocos2d，是一个名为“忍者快跑”的游戏应用源码的下载资源。该资源不仅可以...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值