Android
Sviluppo di giochi Android

introduzione

Osservazioni

Gioco con Canvas e SurfaceView

Questo spiega come è possibile creare un gioco 2D di base usando SurfaceView.

Innanzitutto, abbiamo bisogno di un'attività:

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.
    }

}

L'attività deve essere dichiarata anche nel Manifest Android.

Ora per il gioco stesso. Innanzitutto, iniziamo implementando un thread di gioco:

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

Questa è la parte fondamentale. Ora hai la possibilità di disegnare sullo schermo.

Ora, iniziamo aggiungendo ai numeri interi:

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;

Per questa parte successiva, avrai bisogno di un'immagine. Dovrebbe essere di circa 100x100 ma può essere più grande o più piccolo. Per l'apprendimento, può anche essere usato un Rect (ma ciò richiede un cambiamento nel codice un po 'più in basso)

Ora dichiariamo una bitmap:

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

Nel rendering, dobbiamo disegnare questa bitmap.

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

PRIMA DI LANCIO ci sono ancora alcune cose da fare

Abbiamo bisogno di un primo booleano:

boolean up = false;

in onTouchEvent, aggiungiamo:

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

E in tick abbiamo bisogno di questo per spostare il giocatore:

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

e ora abbiamo bisogno di questo in 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();

E abbiamo bisogno di questi per variabili:

public static int WIDTH, HEIGHT;

A questo punto, il gioco è eseguibile. Significa che puoi lanciarlo e testarlo.

Ora dovresti avere un'immagine del giocatore o un rect che va su e giù per lo schermo. Il giocatore può essere creato come una classe personalizzata, se necessario. Quindi tutte le cose relative ai giocatori possono essere spostate in quella classe e usare un'istanza di quella classe per spostare, eseguire il rendering e fare altra logica.

Ora, come probabilmente hai visto sotto test, vola fuori dallo schermo. Quindi dobbiamo limitarlo.

Innanzitutto, dobbiamo dichiarare il Rect:

private Rect screen;

In init, dopo aver inizializzato la larghezza e l'altezza, creiamo un nuovo rect che è lo schermo.

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

Ora abbiamo bisogno di un altro rect sotto forma di un metodo:

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

e in tick:

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

L'implementazione di gameover può anche essere utilizzata per mostrare l'inizio di un gioco.

Altri aspetti di un gioco degno di nota:

Salvataggio (attualmente mancante nella documentazione)