为了复习一下SurfaceView的使用，在此写了一个经典的小球碰撞检测例子程序，希望能够够帮助正在学习游戏的人。
先看一下效果图：
下面我们就来逐一分析一下它的实现过程：
1.启动入口：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import
android.os.Bundle;
import
android.app.Activity;
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);
this
.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
//将画布放进去
GameView gameView =
new
GameView(
this
);
setContentView(gameView);
}
}
|
2.小球类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
import
android.graphics.Canvas;
import
android.graphics.Color;
import
android.graphics.Paint;
/**
* 小球实例
* @author ZHF
*
*/
public
class
Ball {
int
x, y;
//小球的实时位置
int
startX, startY;
//小球的初始位置
float
vX, vY;
//小球的速度
int
r;
//小球的半径
double
startTimeX;
//开始时间
double
startTimeY;
//开始时间
BallThread ballThread;
//小球移动线程
Paint paint =
new
Paint();
//画笔
public
Ball(
int
x,
int
y,
float
vX,
float
vY,
int
r) {
this
.x = x;
this
.y = y;
this
.startX = x;
this
.startY = y;
this
.vX = vX;
this
.vY = vY;
this
.r = r;
//为每个小球实例化一个独立的线程，在抬手时开启线程
ballThread =
new
BallThread(
this
);
paint.setColor(Color.RED);
//小球为红色实心
}
/**绘画方法**/
public
void
drawSelf(Canvas canvas) {
canvas.drawCircle(x, y, r, paint);
}
}
|
3.障碍物类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
import
android.graphics.Canvas;
import
android.graphics.Color;
import
android.graphics.Paint;
/**
* 障碍物
*
* @author ZHF
*
*/
public
class
Obstruction {
int
x, y;
int
hWeight;
//宽度和高度一样
Paint paint =
new
Paint();
public
Obstruction(
int
x,
int
y,
int
hWeight) {
this
.x = x;
this
.y = y;
this
.hWeight = hWeight;
paint.setColor(Color.GREEN);
//设置画笔颜色
}
public
void
drawSelf(Canvas canvas) {
canvas.drawRect(x - hWeight, y - hWeight, x + hWeight, y + hWeight, paint);
}
}
|
以上代码比较简单，在此不多做解释，下面主要来看一下两个主要线程类：
4.小球移动线程（碰撞检测）：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
/**
* 小球移动和碰撞检测线程
* @author ZHF
*
*/
public
class
BallThread
extends
Thread {
boolean
flag;
//标记线程是否开启
Ball ball;
//小球
double
currentTime;
//当前时间
public
BallThread(Ball ball) {
flag =
true
;
this
.ball = ball;
}
@Override
public
void
run() {
while
(flag) {
//调试：碰撞检测开始时间
long
startTime = System.currentTimeMillis();
//计算出小球移动的时间片：将每次刷新分成若干时间小片段，用于计算每次时间小片段小球移动的距离
currentTime = System.nanoTime();
double
timeSpanX = (currentTime - ball.startTimeX) /
1000
/
1000
/
1000
;
double
timeSpanY = (currentTime - ball.startTimeY) /
1000
/
1000
/
1000
;
int
xBackup = ball.x;
//保存小球的碰撞前的位置
int
yBackup = ball.y;
ball.x = (
int
) (ball.startX + ball.vX * timeSpanX);
//小球移动的距离
ball.y = (
int
) (ball.startY + ball.vY * timeSpanY);
//边界碰撞检测
if
((ball.vX >
0
&& (ball.x + ball.r) >=
479
) || (ball.vX <
0
&& (ball.x - ball.r) <=
0
)) {
ball.x = xBackup;
ball.vX =
0
- ball.vX;
//速度反向
ball.startTimeX = System.nanoTime();
//重新记录开始时间
ball.startX = ball.x;
//重新记录开始位置
}
if
((ball.vY >
0
&& (ball.y + ball.r) >=
799
) || (ball.vY <
0
&& (ball.y - ball.r) <=
0
)) {
ball.y = yBackup;
ball.vY =
0
- ball.vY;
//速度反向
ball.startTimeY = System.nanoTime();
//重新记录开始时间
ball.startY = ball.y;
//重新记录开始位置
}
//障碍物碰撞检测
for
(
int
i =
0
; i < GameView.obstructList.size(); i++) {
Obstruction o = GameView.obstructList.get(i);
if
(Math.abs(ball.x - o.x) < (ball.r + o.hWeight) && Math.abs(ball.y - o.y) < (ball.r + o.hWeight)){
if
(Math.abs(xBackup - o.x) >= (ball.r + o.hWeight)) {
ball.x = xBackup;
ball.vX =
0
- ball.vX;
ball.startTimeX = System.nanoTime();
ball.startX = ball.x;
}
if
(Math.abs(yBackup - o.y) >= (ball.r + o.hWeight)) {
ball.y = yBackup;
ball.vY =
0
- ball.vY;
ball.startTimeY = System.nanoTime();
ball.startY = ball.y;
}
break
;
//跳出循环
}
}
//调试：碰撞检测结束时间 实验证明碰撞加测基本不耗时间
long
endTime = System.currentTimeMillis();
System.out.println(endTime +
"----"
+ startTime +
"= "
+(endTime - startTime));
try
{
Thread.sleep(
10
);
}
catch
(Exception e) {
e.printStackTrace();
}
}
}
}
|
分析：
1.我们将刷新时间分割成：将每次刷新时间分成若干时间小片段timeSpanX和timeSpanY，用于计算每次时间小片段小球移动的距离.
2.我们在小球与边界碰撞之前，记录一下时间startTime，在其与边界碰撞之后，我们将其x轴、y轴方向上做一系列的操作（方向取反，回到碰撞前位置，重新记录开始时间）其实，我通过调试发现碰撞时间基本可以忽略.
3.我们这里的碰撞检测是边界检测，只考虑小球与障碍物、边界的碰撞，没有考虑小球之间的碰撞，有兴趣的同学可以自行研究一下。
5.绘画线程：
2
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
import
android.graphics.Canvas;
import
android.util.Log;
import
android.view.SurfaceHolder;
/**
* 绘画主界面线程
* @author ZHF
*
*/
public
class
DrawThread
extends
Thread {
boolean
flag;
//标记线程是否开启
GameView gameView;
SurfaceHolder holder;
Canvas canvas;
public
DrawThread(GameView gameView) {
flag =
true
;
this
.gameView = gameView;
holder = gameView.getHolder();
//获取画布锁
}
@Override
public
void
run() {
while
(flag) {
//获取当前绘画开始时间
long
startTime = System.currentTimeMillis();
synchronized
(holder) {
canvas = holder.lockCanvas();
//获取当前被锁住的画布
if
(canvas !=
null
) {
gameView.draw(canvas);
//对画布进行操作
holder.unlockCanvasAndPost(canvas);
//释放画布
}
}
long
endTime = System.currentTimeMillis();
int
diffTime = (
int
) (endTime - startTime);
Log.d(
"DrawTime"
, diffTime+
""
);
while
(diffTime <=
2
) {
diffTime = (
int
) (System.currentTimeMillis() - startTime);
Thread.yield();
//将线程的所有权交给另一个线程
}
}
}
}
|
分析：
1. 首先，我们将画布锁住之后，对其进行绘画，画完之后自然要释放画布啦
2. 为了优化程序，我们计算出绘画所用时间，当绘画时间过长时，暂停当前正在执行的线程对象，通知CPU来执行其他线程（注意：这里的其他也包含当前线程）
6.主界面：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
import
java.util.ArrayList;
import
java.util.Random;
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;
/**
* 游戏主界面
* @author ZHF
*
*/
public
class
GameView
extends
SurfaceView
implements
SurfaceHolder.Callback {
SurfaceHolder holder;
DrawThread drawThread;
//绘画线程
Ball[] ballArray =
new
Ball[
5
];
//装小球的数组
int
ballPointer =
0
;
//当前指向数组中第几个球
static
ArrayList<Obstruction> obstructList =
new
ArrayList<Obstruction>();
//装障碍物的集合
int
xDown, yDown;
//记录手指按下时的坐标
public
GameView(Context context) {
super
(context);
holder = getHolder();
//获取画布锁
holder.addCallback(
this
);
//添加回调
//初始化障碍物
Random random =
new
Random();
for
(
int
i =
0
; i <
3
; i++) {
Obstruction o =
new
Obstruction(random.nextInt(
380
) +
50
, random.nextInt(
700
) +
50
,
50
);
obstructList.add(o);
//将创出的障碍物对象添加到集合中去
}
}
@Override
public
void
surfaceCreated(SurfaceHolder holder) {
drawThread =
new
DrawThread(
this
);
drawThread.start();
//开启绘画线程
}
@Override
public
void
surfaceChanged(SurfaceHolder holder,
int
format,
int
width,
int
height) {
//画布发生变化，eg:转屏操作,处理画布操作
}
@Override
public
void
surfaceDestroyed(SurfaceHolder holder) {
//销毁画布操作
drawThread.flag =
false
;
//停掉线程
drawThread =
null
;
//GC会及时发现并处理掉该对象
}
public
void
draw(Canvas canvas) {
canvas.drawColor(Color.BLACK);
//背景颜色
Paint paint =
new
Paint();
paint.setTextSize(
25
);
paint.setColor(Color.WHITE);
//文字颜色
canvas.drawText(
"小球碰撞检测"
,
50
,
20
, paint);
//画出小球
for
(
int
i =
0
; i <
5
; i++) {
if
(ballArray[i] !=
null
) {
ballArray[i].drawSelf(canvas);
//当前小球绘画出自己
}
}
//画出障碍物
for
(
int
i =
0
; i < obstructList.size(); i++) {
obstructList.
get
(i).drawSelf(canvas);
}
}
@Override
public
boolean onTouchEvent(MotionEvent event) {
int
x = (
int
) event.getX();
int
y = (
int
) event.getY();
if
(event.getAction() ==
0
) {
//按下
//记录按下时X，Y的坐标
xDown = x;
yDown = y;
//生成第一个球
Ball ball =
new
Ball(x, y,
0
,
0
,
20
);
if
(ballArray[ballPointer] !=
null
) {
ballArray[ballPointer].ballThread.flag =
false
;
//关闭小球移动线程
ballArray[ballPointer].ballThread =
null
;
}
ballArray[ballPointer] = ball;
}
else
if
(event.getAction() ==
1
) {
//抬起
int
xOffset = x - xDown;
int
yOffset = y - yDown;
double sin = yOffset / Math.sqrt(xOffset * xOffset + yOffset * yOffset);
double cos = xOffset / Math.sqrt(xOffset * xOffset + yOffset * yOffset);
ballArray[ballPointer].startTimeX = System.nanoTime();
//当前小球开始时间
ballArray[ballPointer].startTimeY = System.nanoTime();
ballArray[ballPointer].vX = (float) (
500
* cos);
//当前小球的速度
ballArray[ballPointer].vY = (float) (
500
* sin);
ballArray[ballPointer].ballThread.start();
//开启小球移动线程
ballPointer ++;
//下一个小球
if
(ballPointer >=
5
) {
ballPointer =
0
;
}
}
return
true
;
}
}
|
分析：
1.这里我们启动小球移动线程方式：采用手指触屏滑动，记录按下、抬起位置，通过计算角度得出算出发射方向。
2.每次发出小球后下标ballPointer ++指向下一个小球，当到达数组上限后，重新返回到下标0.
ok! 到此功能已经实现，想要完整源码在此下载：http://download.csdn.net/detail/zhf651555765/5775035
附件：http://down.51cto.com/data/2363159
本文转自zhf651555765 51CTO博客，原文链接：http://blog.51cto.com/smallwoniu/1251882，如需转载请自行联系原作者
