آموزش برنامه نویسی بازی اندروید – از صفر تا صد

1package org.o7planning.android2dgame;
2 
3import android.app.Activity;
4import android.os.Bundle;
5import android.view.Window;
6import android.view.WindowManager;
7
8public class MainActivity extends Activity {
9
10    @Override
11    protected void onCreate(Bundle savedInstanceState) {
12        super.onCreate(savedInstanceState);
13
14        // Set fullscreen
15        this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
16                WindowManager.LayoutParams.FLAG_FULLSCREEN);
17
18        // Set No Title
19        this.requestWindowFeature(Window.FEATURE_NO_TITLE);
20
21    }
22
23}

1<?xml version="1.0" encoding="utf-8"?>
2<manifest xmlns:android="http://schemas.android.com/apk/res/android"
3    package="org.o7planning.android2dgame">
4
5    <application
6        android:screenOrientation="landscape"
7        ... >
8
9       ...
10
11    </application>
12
13</manifest>

1package org.o7planning.android2dgame;
2
3import android.graphics.Bitmap;
4
5public abstract class GameObject {
6
7    protected Bitmap image;
8
9    protected final int rowCount;
10    protected final int colCount;
11
12    protected final int WIDTH;
13    protected final int HEIGHT;
14
15    protected final int width;
16
17
18    protected final int height;
19    protected int x;
20    protected int y;
21
22    public GameObject(Bitmap image, int rowCount, int colCount, int x, int y)  {
23
24        this.image = image;
25        this.rowCount= rowCount;
26        this.colCount= colCount;
27
28        this.x= x;
29        this.y= y;
30
31        this.WIDTH = image.getWidth();
32        this.HEIGHT = image.getHeight();
33
34        this.width = this.WIDTH/ colCount;
35        this.height= this.HEIGHT/ rowCount;
36    }
37
38    protected Bitmap createSubImageAt(int row, int col)  {
39        // createBitmap(bitmap, x, y, width, height).
40        Bitmap subImage = Bitmap.createBitmap(image, col* width, row* height ,width,height);
41        return subImage;
42    }
43
44    public int getX()  {
45        return this.x;
46    }
47
48    public int getY()  {
49        return this.y;
50    }
51
52
53    public int getHeight() {
54        return height;
55    }
56
57    public int getWidth() {
58        return width;
59    }
60
61}

1package org.o7planning.android2dgame;
2
3import android.graphics.Bitmap;
4import android.graphics.Canvas;
5
6public class ChibiCharacter extends GameObject {
7
8    private static final int ROW_TOP_TO_BOTTOM = 0;
9    private static final int ROW_RIGHT_TO_LEFT = 1;
10    private static final int ROW_LEFT_TO_RIGHT = 2;
11    private static final int ROW_BOTTOM_TO_TOP = 3;
12
13    // Row index of Image are being used.
14    private int rowUsing = ROW_LEFT_TO_RIGHT;
15
16    private int colUsing;
17
18    private Bitmap[] leftToRights;
19    private Bitmap[] rightToLefts;
20    private Bitmap[] topToBottoms;
21    private Bitmap[] bottomToTops;
22
23    // Velocity of game character (pixel/millisecond)
24    public static final float VELOCITY = 0.1f;
25
26    private int movingVectorX = 10;
27    private int movingVectorY = 5;
28
29    private long lastDrawNanoTime =-1;
30
31    private GameSurface gameSurface;
32
33    public ChibiCharacter(GameSurface gameSurface, Bitmap image, int x, int y) {
34        super(image, 4, 3, x, y);
35
36        this.gameSurface= gameSurface;
37
38        this.topToBottoms = new Bitmap[colCount]; // 3
39        this.rightToLefts = new Bitmap[colCount]; // 3
40        this.leftToRights = new Bitmap[colCount]; // 3
41        this.bottomToTops = new Bitmap[colCount]; // 3
42
43        for(int col = 0; col< this.colCount; col++ ) {
44            this.topToBottoms[col] = this.createSubImageAt(ROW_TOP_TO_BOTTOM, col);
45            this.rightToLefts[col]  = this.createSubImageAt(ROW_RIGHT_TO_LEFT, col);
46            this.leftToRights[col] = this.createSubImageAt(ROW_LEFT_TO_RIGHT, col);
47            this.bottomToTops[col]  = this.createSubImageAt(ROW_BOTTOM_TO_TOP, col);
48        }
49    }
50
51    public Bitmap[] getMoveBitmaps()  {
52        switch (rowUsing)  {
53            case ROW_BOTTOM_TO_TOP:
54                return  this.bottomToTops;
55            case ROW_LEFT_TO_RIGHT:
56                return this.leftToRights;
57            case ROW_RIGHT_TO_LEFT:
58                return this.rightToLefts;
59            case ROW_TOP_TO_BOTTOM:
60                return this.topToBottoms;
61            default:
62                return null;
63        }
64    }
65
66    public Bitmap getCurrentMoveBitmap()  {
67        Bitmap[] bitmaps = this.getMoveBitmaps();
68        return bitmaps[this.colUsing];
69    }
70
71
72    public void update()  {
73        this.colUsing++;
74        if(colUsing >= this.colCount)  {
75            this.colUsing =0;
76        }
77        // Current time in nanoseconds
78        long now = System.nanoTime();
79
80        // Never once did draw.
81        if(lastDrawNanoTime==-1) {
82            lastDrawNanoTime= now;
83        }
84        // Change nanoseconds to milliseconds (1 nanosecond = 1000000 milliseconds).
85        int deltaTime = (int) ((now - lastDrawNanoTime)/ 1000000 );
86
87        // Distance moves
88        float distance = VELOCITY * deltaTime;
89
90        double movingVectorLength = Math.sqrt(movingVectorX* movingVectorX + movingVectorY*movingVectorY);
91
92        // Calculate the new position of the game character.
93        this.x = x +  (int)(distance* movingVectorX / movingVectorLength);
94        this.y = y +  (int)(distance* movingVectorY / movingVectorLength);
95
96        // When the game's character touches the edge of the screen, then change direction
97
98        if(this.x < 0 )  {
99            this.x = 0;
100            this.movingVectorX = - this.movingVectorX;
101        } else if(this.x > this.gameSurface.getWidth() -width)  {
102            this.x= this.gameSurface.getWidth()-width;
103            this.movingVectorX = - this.movingVectorX;
104        }
105
106        if(this.y < 0 )  {
107            this.y = 0;
108            this.movingVectorY = - this.movingVectorY;
109        } else if(this.y > this.gameSurface.getHeight()- height)  {
110            this.y= this.gameSurface.getHeight()- height;
111            this.movingVectorY = - this.movingVectorY ;
112        }
113
114        // rowUsing
115        if( movingVectorX > 0 )  {
116            if(movingVectorY > 0 && Math.abs(movingVectorX) < Math.abs(movingVectorY)) {
117                this.rowUsing = ROW_TOP_TO_BOTTOM;
118            }else if(movingVectorY < 0 && Math.abs(movingVectorX) < Math.abs(movingVectorY)) {
119                this.rowUsing = ROW_BOTTOM_TO_TOP;
120            }else  {
121                this.rowUsing = ROW_LEFT_TO_RIGHT;
122            }
123        } else {
124            if(movingVectorY > 0 && Math.abs(movingVectorX) < Math.abs(movingVectorY)) {
125                this.rowUsing = ROW_TOP_TO_BOTTOM;
126            }else if(movingVectorY < 0 && Math.abs(movingVectorX) < Math.abs(movingVectorY)) {
127                this.rowUsing = ROW_BOTTOM_TO_TOP;
128            }else  {
129                this.rowUsing = ROW_RIGHT_TO_LEFT;
130            }
131        }
132    }
133
134    public void draw(Canvas canvas)  {
135        Bitmap bitmap = this.getCurrentMoveBitmap();
136        canvas.drawBitmap(bitmap,x, y, null);
137        // Last draw time.
138        this.lastDrawNanoTime= System.nanoTime();
139    }
140
141    public void setMovingVector(int movingVectorX, int movingVectorY)  {
142        this.movingVectorX= movingVectorX;
143        this.movingVectorY = movingVectorY;
144    }
145}

1package org.o7planning.android2dgame;
2
3import android.graphics.Canvas;
4import android.view.SurfaceHolder;
5
6public class GameThread extends Thread {
7
8    private boolean running;
9    private GameSurface gameSurface;
10    private SurfaceHolder surfaceHolder;
11
12    public GameThread(GameSurface gameSurface, SurfaceHolder surfaceHolder)  {
13        this.gameSurface= gameSurface;
14        this.surfaceHolder= surfaceHolder;
15    }
16
17    @Override
18    public void run()  {
19        long startTime = System.nanoTime();
20
21        while(running)  {
22            Canvas canvas= null;
23            try {
24                // Get Canvas from Holder and lock it.
25                canvas = this.surfaceHolder.lockCanvas();
26
27                // Synchronized
28                synchronized (canvas)  {
29                    this.gameSurface.update();
30                    this.gameSurface.draw(canvas);
31                }
32            }catch(Exception e)  {
33                // Do nothing.
34            } finally {
35                if(canvas!= null)  {
36                    // Unlock Canvas.
37                    this.surfaceHolder.unlockCanvasAndPost(canvas);
38                }
39            }
40            long now = System.nanoTime() ;
41            // Interval to redraw game
42            // (Change nanoseconds to milliseconds)
43            long waitTime = (now - startTime)/1000000;
44            if(waitTime < 10)  {
45                waitTime= 10; // Millisecond.
46            }
47            System.out.print(" Wait Time="+ waitTime);
48
49            try {
50                // Sleep.
51                this.sleep(waitTime);
52            } catch(InterruptedException e)  {
53
54            }
55            startTime = System.nanoTime();
56            System.out.print(".");
57        }
58    }
59
60    public void setRunning(boolean running)  {
61        this.running= running;
62    }
63}

1package org.o7planning.android2dgame;
2
3import android.content.Context;
4import android.graphics.Bitmap;
5import android.graphics.BitmapFactory;
6import android.graphics.Canvas;
7import android.view.SurfaceHolder;
8import android.view.SurfaceView;
9
10public class GameSurface extends SurfaceView implements SurfaceHolder.Callback {
11
12    private GameThread gameThread;
13    private ChibiCharacter chibi1;
14
15    public GameSurface(Context context)  {
16        super(context);
17
18        // Make Game Surface focusable so it can handle events. .
19        this.setFocusable(true);
20
21        // Sét callback.
22        this.getHolder().addCallback(this);
23    }
24
25    public void update()  {
26        this.chibi1.update();
27    }
28
29    @Override
30    public void draw(Canvas canvas)  {
31        super.draw(canvas);
32
33        this.chibi1.draw(canvas);
34    }
35
36    // Implements method of SurfaceHolder.Callback
37    @Override
38    public void surfaceCreated(SurfaceHolder holder) {
39        Bitmap chibiBitmap1 = BitmapFactory.decodeResource(this.getResources(),R.drawable.chibi1);
40        this.chibi1 = new ChibiCharacter(this,chibiBitmap1,100,50);
41
42        this.gameThread = new GameThread(this,holder);
43        this.gameThread.setRunning(true);
44        this.gameThread.start();
45    }
46
47    // Implements method of SurfaceHolder.Callback
48    @Override
49    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
50
51    }
52
53    // Implements method of SurfaceHolder.Callback
54    @Override
55    public void surfaceDestroyed(SurfaceHolder holder) {
56        boolean retry= true;
57        while(retry) {
58            try {
59                this.gameThread.setRunning(false);
60
61                // Parent thread must wait until the end of GameThread.
62                this.gameThread.join();
63            }catch(InterruptedException e)  {
64                e.printStackTrace();
65            }
66            retry= true;
67        }
68    }
69
70}

1package org.o7planning.android2dgame;
2
3import android.app.Activity;
4import android.os.Bundle;
5import android.view.Window;
6import android.view.WindowManager;
7
8public class MainActivity extends Activity {
9
10    @Override
11    protected void onCreate(Bundle savedInstanceState) {
12        super.onCreate(savedInstanceState);
13
14        // Set fullscreen
15        this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
16                WindowManager.LayoutParams.FLAG_FULLSCREEN);
17
18        // Set No Title
19        this.requestWindowFeature(Window.FEATURE_NO_TITLE);
20
21        this.setContentView(new GameSurface(this));
22    }
23
24}

1@Override
2public boolean onTouchEvent(MotionEvent event) {
3    if (event.getAction() == MotionEvent.ACTION_DOWN) {
4        int x=  (int)event.getX();
5        int y = (int)event.getY();
6
7        int movingVectorX =x-  this.chibi1.getX() ;
8        int movingVectorY =y-  this.chibi1.getY() ;
9
10        this.chibi1.setMovingVector(movingVectorX,movingVectorY);
11        return true;
12    }
13    return false;
14}

1package org.o7planning.android2dgame;
2
3import android.content.Context;
4import android.graphics.Bitmap;
5import android.graphics.BitmapFactory;
6import android.graphics.Canvas;
7import android.view.MotionEvent;
8import android.view.SurfaceHolder;
9import android.view.SurfaceView;
10
11public class GameSurface extends SurfaceView implements SurfaceHolder.Callback {
12
13    private GameThread gameThread;
14
15    private ChibiCharacter chibi1;
16
17    public GameSurface(Context context)  {
18        super(context);
19
20        // Make Game Surface focusable so it can handle events.
21        this.setFocusable(true);
22
23        // Set callback.
24        this.getHolder().addCallback(this);
25    }
26
27    public void update()  {
28        this.chibi1.update();
29    }
30
31    @Override
32    public boolean onTouchEvent(MotionEvent event) {
33        if (event.getAction() == MotionEvent.ACTION_DOWN) {
34            int x=  (int)event.getX();
35            int y = (int)event.getY();
36
37            int movingVectorX =x-  this.chibi1.getX() ;
38            int movingVectorY =y-  this.chibi1.getY() ;
39
40            this.chibi1.setMovingVector(movingVectorX,movingVectorY);
41            return true;
42        }
43        return false;
44    }
45
46    @Override
47    public void draw(Canvas canvas)  {
48        super.draw(canvas);
49
50        this.chibi1.draw(canvas);
51    }
52
53    // Implements method of SurfaceHolder.Callback
54    @Override
55    public void surfaceCreated(SurfaceHolder holder) {
56        Bitmap chibiBitmap1 = BitmapFactory.decodeResource(this.getResources(),R.drawable.chibi1);
57        this.chibi1 = new ChibiCharacter(this,chibiBitmap1,100,50);
58
59        this.gameThread = new GameThread(this,holder);
60        this.gameThread.setRunning(true);
61        this.gameThread.start();
62    }
63
64    // Implements method of SurfaceHolder.Callback
65    @Override
66    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
67
68    }
69
70    // Implements method of SurfaceHolder.Callback
71    @Override
72    public void surfaceDestroyed(SurfaceHolder holder) {
73        boolean retry= true;
74        while(retry) {
75            try {
76                this.gameThread.setRunning(false);
77
78                // Parent thread must wait until the end of GameThread.
79                this.gameThread.join();
80            }catch(InterruptedException e)  {
81                e.printStackTrace();
82            }
83            retry= true;
84        }
85    }
86
87}

1package org.o7planning.android2dgame;
2
3import android.content.Context;
4import android.graphics.Bitmap;
5import android.graphics.BitmapFactory;
6import android.graphics.Canvas;
7import android.view.MotionEvent;
8import android.view.SurfaceHolder;
9import android.view.SurfaceView;
10
11import java.util.ArrayList;
12import java.util.List;
13
14public class GameSurface extends SurfaceView implements SurfaceHolder.Callback {
15
16    private GameThread gameThread;
17
18    private final List<ChibiCharacter> chibiList = new ArrayList<ChibiCharacter>();
19
20    public GameSurface(Context context)  {
21        super(context);
22
23        // Make Game Surface focusable so it can handle events.
24        this.setFocusable(true);
25
26        // Set callback.
27        this.getHolder().addCallback(this);
28    }
29
30    public void update()  {
31        for(ChibiCharacter chibi: chibiList) {
32            chibi.update();
33        }
34    }
35
36    @Override
37    public boolean onTouchEvent(MotionEvent event) {
38        if (event.getAction() == MotionEvent.ACTION_DOWN) {
39            int x=  (int)event.getX();
40            int y = (int)event.getY();
41
42            for(ChibiCharacter chibi: chibiList) {
43                int movingVectorX =x-  chibi.getX() ;
44                int movingVectorY =y-  chibi.getY() ;
45                chibi.setMovingVector(movingVectorX, movingVectorY);
46            }
47            return true;
48        }
49        return false;
50    }
51
52    @Override
53    public void draw(Canvas canvas)  {
54        super.draw(canvas);
55
56        for(ChibiCharacter chibi: chibiList)  {
57            chibi.draw(canvas);
58        }
59
60    }
61
62    // Implements method of SurfaceHolder.Callback
63    @Override
64    public void surfaceCreated(SurfaceHolder holder) {
65        Bitmap chibiBitmap1 = BitmapFactory.decodeResource(this.getResources(),R.drawable.chibi1);
66        ChibiCharacter chibi1 = new ChibiCharacter(this,chibiBitmap1,100,50);
67
68        Bitmap chibiBitmap2 = BitmapFactory.decodeResource(this.getResources(),R.drawable.chibi2);
69        ChibiCharacter chibi2 = new ChibiCharacter(this,chibiBitmap2,300,150);
70
71        this.chibiList.add(chibi1);
72        this.chibiList.add(chibi2);
73
74        this.gameThread = new GameThread(this,holder);
75        this.gameThread.setRunning(true);
76        this.gameThread.start();
77    }
78
79    // Implements method of SurfaceHolder.Callback
80    @Override
81    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
82
83    }
84
85    // Implements method of SurfaceHolder.Callback
86    @Override
87    public void surfaceDestroyed(SurfaceHolder holder) {
88        boolean retry= true;
89        while(retry) {
90            try {
91                this.gameThread.setRunning(false);
92
93                // Parent thread must wait until the end of GameThread.
94                this.gameThread.join();
95            }catch(InterruptedException e)  {
96                e.printStackTrace();
97            }
98            retry= true;
99        }
100    }
101
102}

1package org.o7planning.android2dgame;  
2
3import android.graphics.Bitmap;
4import android.graphics.Canvas;
5
6public class Explosion extends GameObject {
7
8    private int rowIndex = 0 ;
9    private int colIndex = -1 ;
10
11    private boolean finish= false;
12    private GameSurface gameSurface;
13
14    public Explosion(GameSurface GameSurface, Bitmap image, int x, int y) {
15        super(image, 5, 5, x, y);
16
17        this.gameSurface= GameSurface;
18    }
19
20    public void update()  {
21        this.colIndex++;
22
23        if(this.colIndex >= this.colCount)  {
24            this.colIndex =0;
25            this.rowIndex++;
26
27            if(this.rowIndex>= this.rowCount)  {
28                this.finish= true;
29            }
30        }
31    }
32
33    public void draw(Canvas canvas)  {
34        if(!finish)  {
35            Bitmap bitmap= this.createSubImageAt(rowIndex,colIndex);
36            canvas.drawBitmap(bitmap, this.x, this.y,null);
37        }
38    }
39
40    public boolean isFinish() {
41        return finish;
42    }
43
44}

1package org.o7planning.android2dgame;
2
3import android.content.Context;
4import android.graphics.Bitmap;
5import android.graphics.BitmapFactory;
6import android.graphics.Canvas;
7import android.view.MotionEvent;
8import android.view.SurfaceHolder;
9import android.view.SurfaceView;
10
11import java.util.ArrayList;
12import java.util.Iterator;
13import java.util.List;
14
15public class GameSurface extends SurfaceView implements SurfaceHolder.Callback {
16
17    private GameThread gameThread;
18
19    private final List<ChibiCharacter> chibiList = new ArrayList<ChibiCharacter>();
20    private final List<Explosion> explosionList = new ArrayList<Explosion>();
21
22    public GameSurface(Context context)  {
23        super(context);
24
25        // Make Game Surface focusable so it can handle events.
26        this.setFocusable(true);
27
28        // Sét callback.
29        this.getHolder().addCallback(this);
30    }
31
32
33    @Override
34    public boolean onTouchEvent(MotionEvent event) {
35        if (event.getAction() == MotionEvent.ACTION_DOWN) {
36
37            int x=  (int)event.getX();
38            int y = (int)event.getY();
39
40            Iterator<ChibiCharacter> iterator= this.chibiList.iterator();
41
42            while(iterator.hasNext()) {
43                ChibiCharacter chibi = iterator.next();
44                if( chibi.getX() < x && x < chibi.getX() + chibi.getWidth()
45                        && chibi.getY() < y && y < chibi.getY()+ chibi.getHeight())  {
46                    // Remove the current element from the iterator and the list.
47                    iterator.remove();
48
49                    // Create Explosion object.
50                    Bitmap bitmap = BitmapFactory.decodeResource(this.getResources(),R.drawable.explosion);
51                    Explosion explosion = new Explosion(this, bitmap,chibi.getX(),chibi.getY());
52
53                    this.explosionList.add(explosion);
54                }
55            }
56
57
58            for(ChibiCharacter chibi: chibiList) {
59                int movingVectorX =x-  chibi.getX() ;
60                int movingVectorY =y-  chibi.getY() ;
61                chibi.setMovingVector(movingVectorX, movingVectorY);
62            }
63            return true;
64        }
65        return false;
66    }
67
68    public void update()  {
69        for(ChibiCharacter chibi: chibiList) {
70            chibi.update();
71        }
72        for(Explosion explosion: this.explosionList)  {
73            explosion.update();
74        }
75
76        Iterator<Explosion> iterator= this.explosionList.iterator();
77        while(iterator.hasNext())  {
78            Explosion explosion = iterator.next();
79
80            if(explosion.isFinish()) {
81                // If explosion finish, Remove the current element from the iterator & list.
82                iterator.remove();
83                continue;
84            }
85        }
86    }
87
88    @Override
89    public void draw(Canvas canvas)  {
90        super.draw(canvas);
91
92        for(ChibiCharacter chibi: chibiList)  {
93            chibi.draw(canvas);
94        }
95
96        for(Explosion explosion: this.explosionList)  {
97            explosion.draw(canvas);
98        }
99
100    }
101
102    // Implements method of SurfaceHolder.Callback
103    @Override
104    public void surfaceCreated(SurfaceHolder holder) {
105        Bitmap chibiBitmap1 = BitmapFactory.decodeResource(this.getResources(),R.drawable.chibi1);
106        ChibiCharacter chibi1 = new ChibiCharacter(this,chibiBitmap1,100,50);
107
108        Bitmap chibiBitmap2 = BitmapFactory.decodeResource(this.getResources(),R.drawable.chibi2);
109        ChibiCharacter chibi2 = new ChibiCharacter(this,chibiBitmap2,300,150);
110
111        this.chibiList.add(chibi1);
112        this.chibiList.add(chibi2);
113
114        this.gameThread = new GameThread(this,holder);
115        this.gameThread.setRunning(true);
116        this.gameThread.start();
117    }
118
119    // Implements method of SurfaceHolder.Callback
120    @Override
121    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
122
123    }
124
125    // Implements method of SurfaceHolder.Callback
126    @Override
127    public void surfaceDestroyed(SurfaceHolder holder) {
128        boolean retry= true;
129        while(retry) {
130            try {
131                this.gameThread.setRunning(false);
132
133                // Parent thread must wait until the end of GameThread.
134                this.gameThread.join();
135            }catch(InterruptedException e)  {
136                e.printStackTrace();
137            }
138            retry= true;
139        }
140    }
141
142}

1package org.o7planning.android2dgame;
2
3import android.graphics.Bitmap;
4import android.graphics.Canvas;
5
6public class Explosion extends GameObject {
7
8    private int rowIndex = 0 ;
9    private int colIndex = -1 ;
10
11    private boolean finish= false;
12    private GameSurface gameSurface;
13
14    public Explosion(GameSurface GameSurface, Bitmap image, int x, int y) {
15        super(image, 5, 5, x, y);
16
17        this.gameSurface= GameSurface;
18    }
19
20    public void update()  {
21        this.colIndex++;
22
23        // Play sound explosion.wav.
24        if(this.colIndex==0 && this.rowIndex==0) {
25            this.gameSurface.playSoundExplosion();
26        }
27
28        if(this.colIndex >= this.colCount)  {
29            this.colIndex =0;
30            this.rowIndex++;
31
32            if(this.rowIndex>= this.rowCount)  {
33                this.finish= true;
34            }
35        }
36    }
37
38    public void draw(Canvas canvas)  {
39        if(!finish)  {
40            Bitmap bitmap= this.createSubImageAt(rowIndex,colIndex);
41            canvas.drawBitmap(bitmap, this.x, this.y,null);
42        }
43    }
44
45    public boolean isFinish() {
46        return finish;
47    }
48
49}

1package org.o7planning.android2dgame;
2
3import android.content.Context;
4import android.graphics.Bitmap;
5import android.graphics.BitmapFactory;
6import android.graphics.Canvas;
7import android.media.AudioAttributes;
8import android.media.AudioManager;
9import android.media.SoundPool;
10import android.os.Build;
11import android.view.MotionEvent;
12import android.view.SurfaceHolder;
13import android.view.SurfaceView;
14
15import java.util.ArrayList;
16import java.util.Iterator;
17import java.util.List;
18
19public class GameSurface extends SurfaceView implements SurfaceHolder.Callback {
20
21    private GameThread gameThread;
22
23    private final List<ChibiCharacter> chibiList = new ArrayList<ChibiCharacter>();
24    private final List<Explosion> explosionList = new ArrayList<Explosion>();
25
26    private static final int MAX_STREAMS=100;
27    private int soundIdExplosion;
28    private int soundIdBackground;
29
30    private boolean soundPoolLoaded;
31    private SoundPool soundPool;
32
33
34
35    public GameSurface(Context context)  {
36        super(context);
37
38        // Make Game Surface focusable so it can handle events.
39        this.setFocusable(true);
40
41        // Sét callback.
42        this.getHolder().addCallback(this);
43
44        this.initSoundPool();
45    }
46
47    private void initSoundPool()  {
48        // With Android API >= 21.
49        if (Build.VERSION.SDK_INT >= 21 ) {
50
51            AudioAttributes audioAttrib = new AudioAttributes.Builder()
52                    .setUsage(AudioAttributes.USAGE_GAME)
53                    .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
54                    .build();
55
56            SoundPool.Builder builder= new SoundPool.Builder();
57            builder.setAudioAttributes(audioAttrib).setMaxStreams(MAX_STREAMS);
58
59            this.soundPool = builder.build();
60        }
61        // With Android API < 21
62        else {
63            // SoundPool(int maxStreams, int streamType, int srcQuality)
64            this.soundPool = new SoundPool(MAX_STREAMS, AudioManager.STREAM_MUSIC, 0);
65        }
66
67        // When SoundPool load complete.
68        this.soundPool.setOnLoadCompleteListener(new SoundPool.OnLoadCompleteListener() {
69            @Override
70            public void onLoadComplete(SoundPool soundPool, int sampleId, int status) {
71                soundPoolLoaded = true;
72
73                // Playing background sound.
74                playSoundBackground();
75            }
76        });
77
78        // Load the sound background.mp3 into SoundPool
79        this.soundIdBackground= this.soundPool.load(this.getContext(), R.raw.background,1);
80
81        // Load the sound explosion.wav into SoundPool
82        this.soundIdExplosion = this.soundPool.load(this.getContext(), R.raw.explosion,1);
83
84
85    }
86
87    public void playSoundExplosion()  {
88        if(this.soundPoolLoaded) {
89            float leftVolumn = 0.8f;
90            float rightVolumn =  0.8f;
91            // Play sound explosion.wav
92            int streamId = this.soundPool.play(this.soundIdExplosion,leftVolumn, rightVolumn, 1, 0, 1f);
93        }
94    }
95
96    public void playSoundBackground()  {
97        if(this.soundPoolLoaded) {
98            float leftVolumn = 0.8f;
99            float rightVolumn =  0.8f;
100            // Play sound background.mp3
101            int streamId = this.soundPool.play(this.soundIdBackground,leftVolumn, rightVolumn, 1, -1, 1f);
102        }
103    }
104
105    @Override
106    public boolean onTouchEvent(MotionEvent event) {
107        if (event.getAction() == MotionEvent.ACTION_DOWN) {
108
109            int x=  (int)event.getX();
110            int y = (int)event.getY();
111
112            Iterator<ChibiCharacter> iterator= this.chibiList.iterator();
113
114
115            while(iterator.hasNext()) {
116                ChibiCharacter chibi = iterator.next();
117                if( chibi.getX() < x && x < chibi.getX() + chibi.getWidth()
118                        && chibi.getY() < y && y < chibi.getY()+ chibi.getHeight())  {
119                    // Remove the current element from the iterator and the list.
120                    iterator.remove();
121
122                    // Create Explosion object.
123                    Bitmap bitmap = BitmapFactory.decodeResource(this.getResources(),R.drawable.explosion);
124                    Explosion explosion = new Explosion(this, bitmap,chibi.getX(),chibi.getY());
125
126                    this.explosionList.add(explosion);
127                }
128            }
129
130
131            for(ChibiCharacter chibi: chibiList) {
132                int movingVectorX =x-  chibi.getX() ;
133                int movingVectorY =y-  chibi.getY() ;
134                chibi.setMovingVector(movingVectorX, movingVectorY);
135            }
136            return true;
137        }
138        return false;
139    }
140
141    public void update()  {
142        for(ChibiCharacter chibi: chibiList) {
143            chibi.update();
144        }
145        for(Explosion explosion: this.explosionList)  {
146            explosion.update();
147        }
148
149        Iterator<Explosion> iterator= this.explosionList.iterator();
150        while(iterator.hasNext())  {
151            Explosion explosion = iterator.next();
152
153            if(explosion.isFinish()) {
154                // If explosion finish, Remove the current element from the iterator & list.
155                iterator.remove();
156                continue;
157            }
158        }
159    }
160
161    @Override
162    public void draw(Canvas canvas)  {
163        super.draw(canvas);
164
165        for(ChibiCharacter chibi: chibiList)  {
166            chibi.draw(canvas);
167        }
168
169        for(Explosion explosion: this.explosionList)  {
170            explosion.draw(canvas);
171        }
172
173    }
174
175    // Implements method of SurfaceHolder.Callback
176    @Override
177    public void surfaceCreated(SurfaceHolder holder) {
178        Bitmap chibiBitmap1 = BitmapFactory.decodeResource(this.getResources(),R.drawable.chibi1);
179        ChibiCharacter chibi1 = new ChibiCharacter(this,chibiBitmap1,100,50);
180
181        Bitmap chibiBitmap2 = BitmapFactory.decodeResource(this.getResources(),R.drawable.chibi2);
182        ChibiCharacter chibi2 = new ChibiCharacter(this,chibiBitmap2,300,150);
183
184        this.chibiList.add(chibi1);
185        this.chibiList.add(chibi2);
186
187        this.gameThread = new GameThread(this,holder);
188        this.gameThread.setRunning(true);
189        this.gameThread.start();
190    }
191
192    // Implements method of SurfaceHolder.Callback
193    @Override
194    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
195
196    }
197
198    // Implements method of SurfaceHolder.Callback
199    @Override
200    public void surfaceDestroyed(SurfaceHolder holder) {
201        boolean retry= true;
202        while(retry) {
203            try {
204                this.gameThread.setRunning(false);
205
206                // Parent thread must wait until the end of GameThread.
207                this.gameThread.join();
208            }catch(InterruptedException e)  {
209                e.printStackTrace();
210            }
211            retry= true;
212        }
213    }
214
215}