Android
Android 게임 개발

소개

비고

Canvas와 SurfaceView를 사용하는 게임

여기서는 SurfaceView를 사용하여 기본적인 2D 게임을 만드는 방법을 다룹니다.

첫째, 우리는 활동이 필요합니다 :

public class GameLauncher extends AppCompatActivity {

    private Game game;
    @Override
    public void onCreate(Bundle sis){
        super.onCreate(sis);
        game = new Game(GameLauncher.this);//Initialize the game instance
        setContentView(game);//setContentView to the game surfaceview
        //Custom XML files can also be used, and then retrieve the game instance using findViewById.
    }

}

활동은 Android Manifest에서도 선언되어야합니다.

이제 게임 그 자체. 먼저 게임 스레드를 구현합니다.

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

    /**
     * Holds the surface frame
     */
    private SurfaceHolder holder;

    /**
     * Draw thread
     */
    private Thread drawThread;

    /**
     * True when the surface is ready to draw
     */
    private boolean surfaceReady = false;


    /**
     * Drawing thread flag
     */

    private boolean drawingActive = false;

    /**
     * Time per frame for 60 FPS
     */
    private static final int MAX_FRAME_TIME = (int) (1000.0 / 60.0);

    private static final String LOGTAG = "surface";    

    /*
     * All the constructors are overridden to ensure functionality if one of the different constructors are used through an XML file or programmatically
     */
    public Game(Context context) {
        super(context);
        init();
    }
    public Game(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }
    public Game(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }
    @TargetApi(21)
    public Game(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init();
    }

    public void init(Context c) {
        this.c = c;
        
        SurfaceHolder holder = getHolder();
        holder.addCallback(this);
        setFocusable(true);
        //Initialize other stuff here later
    }

    public void render(Canvas c){
        //Game rendering here
    }

    public void tick(){
        //Game logic here
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height)
    {
        if (width == 0 || height == 0){
            return;
        }

        // resize your UI
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder){
        this.holder = holder;

        if (drawThread != null){
            Log.d(LOGTAG, "draw thread still active..");
            drawingActive = false;
            try{
                drawThread.join();
            } catch (InterruptedException e){}
        }

        surfaceReady = true;
        startDrawThread();
        Log.d(LOGTAG, "Created");
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder){
        // Surface is not used anymore - stop the drawing thread
        stopDrawThread();
        // and release the surface
        holder.getSurface().release();

        this.holder = null;
        surfaceReady = false;
        Log.d(LOGTAG, "Destroyed");
    }

    @Override
    public boolean onTouchEvent(MotionEvent event){
        // Handle touch events
        return true;
    }

    /**
     * Stops the drawing thread
     */
    public void stopDrawThread(){
        if (drawThread == null){
            Log.d(LOGTAG, "DrawThread is null");
            return;
        }
        drawingActive = false;
        while (true){
            try{
                Log.d(LOGTAG, "Request last frame");
                drawThread.join(5000);
                break;
            } catch (Exception e) {
                Log.e(LOGTAG, "Could not join with draw thread");
            }
        }
        drawThread = null;
    }

    /**
     * Creates a new draw thread and starts it.
     */
    public void startDrawThread(){
        if (surfaceReady && drawThread == null){
            drawThread = new Thread(this, "Draw thread");
            drawingActive = true;
            drawThread.start();
        }
    }

    @Override
    public void run() {
        Log.d(LOGTAG, "Draw thread started");
        long frameStartTime;
        long frameTime;

        /*
         * In order to work reliable on Nexus 7, we place ~500ms delay at the start of drawing thread
         * (AOSP - Issue 58385)
         */
        if (android.os.Build.BRAND.equalsIgnoreCase("google") && android.os.Build.MANUFACTURER.equalsIgnoreCase("asus") && android.os.Build.MODEL.equalsIgnoreCase("Nexus 7")) {
            Log.w(LOGTAG, "Sleep 500ms (Device: Asus Nexus 7)");
            try {
                Thread.sleep(500);
            } catch (InterruptedException ignored) {}
        }

        while (drawing) {
            if (sf == null) {
                return;
            }

            frameStartTime = System.nanoTime();
            Canvas canvas = sf.lockCanvas();
            if (canvas != null) {
                try {
                    synchronized (sf) {
                        tick();
                        render(canvas);
                    }
                } finally {

                    sf.unlockCanvasAndPost(canvas);
                }
            }

            // calculate the time required to draw the frame in ms
            frameTime = (System.nanoTime() - frameStartTime) / 1000000;

            if (frameTime < MAX_FRAME_TIME){
                try {
                    Thread.sleep(MAX_FRAME_TIME - frameTime);
                } catch (InterruptedException e) {
                    // ignore
                }
            }

        }
        Log.d(LOGTAG, "Draw thread finished");
    }
}

이것이 기본 부분입니다. 이제 화면에 그릴 수 있습니다.

이제 정수에 더해 보겠습니다.

public final int x = 100;//The reason for this being static will be shown when the game is runnable
public int y;
public int velY;

이 다음 부분에서는 이미지가 필요합니다. 약 100x100이어야하지만 더 크거나 작을 수 있습니다. 학습을 위해 Rect를 사용할 수도 있습니다 (하지만 코드를 약간 변경해야합니다).

이제 비트 맵을 선언합니다.

private Bitmap PLAYER_BMP = BitmapFactory.decodeResource(getResources(), R.drawable.my_player_drawable);

render에서 우리는이 비트 맵을 그릴 필요가있다.

...
c.drawBitmap(PLAYER_BMP, x, y, null);
...

시작하기 전에 아직해야 할 일이 있습니다.

먼저 boolean이 필요합니다.

boolean up = false;

onTouchEvent에서 다음을 추가합니다.

if(ev.getAction() == MotionEvent.ACTION_DOWN){
    up = true;
}else if(ev.getAction() == MotionEvent.ACTION_UP){
    up = false;
}

그리고 진드기로 플레이어를 이동하려면 다음이 필요합니다.

if(up){
    velY -=1;
}
else{
    velY +=1;
}
if(velY >14)velY = 14;
if(velY <-14)velY = -14;
y += velY *2;

이제 우리는 init에서 이것을 필요로합니다 :

WindowManager wm = (WindowManager) c.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();
Point size = new Point();
display.getSize(size);
WIDTH = size.x;
HEIGHT = size.y;
y = HEIGHT/ 2 - PLAYER_BMP.getHeight();

그리고 우리는 변수에 다음을 필요로합니다.

public static int WIDTH, HEIGHT;

이 시점에서 게임은 실행 가능합니다. 의미는 시작하고 테스트 할 수 있습니다.

이제 플레이어 이미지 나 직사각형이 화면 위아래로 이동해야합니다. 필요한 경우 플레이어를 사용자 정의 클래스로 만들 수 있습니다. 그런 다음 모든 플레이어 관련 항목을 해당 클래스로 옮기고 해당 클래스의 인스턴스를 사용하여 다른 로직을 이동하고 렌더링 및 수행 할 수 있습니다.

이제 테스트를 한 것처럼 보였으므로 화면에서 빠져 나옵니다. 그래서 우리는 그것을 제한 할 필요가 있습니다.

먼저 Rect를 선언해야합니다.

private Rect screen;

init에서 너비와 높이를 초기화 한 후에 화면 인 새로운 rect를 만듭니다.

screen = new Rect(0,0,WIDTH,HEIGHT);

이제 메소드의 형태로 또 다른 rect가 필요합니다 :

private Rect getPlayerBound(){
    return new Rect(x, y, x + PLAYER_BMP.getWidth(), y + PLAYER_BMP.getHeight();
}

그리고 틱 :

if(!getPlayerBound().intersects(screen){
    gameOver = true;
}

gameOVer의 구현은 또한 게임의 시작을 보여주기 위해 사용될 수 있습니다.

주목할 가치가있는 게임의 다른 측면 :

저장 중 (문서에 현재 누락 됨)