Android游戏开发之摄像头的原理以及更新 （五）

带你走进游戏开发的世界之摄像头的原理以及更新

游戏中摄像头的原理介绍

       在游戏开发中更新摄像头的位置可以决定屏幕显示的内容，尤其是RPG类游戏摄像头有着非常重要的作用，我举一个例子 有时候我们在玩RPG游戏的时候进入一个新的场景 触发一段脚本后 发现镜头开始向上移动 根据镜头移动玩家可以大概浏览一下这个场景有什么东西 ，触发什么样的剧情。这个实现的方式就是游戏摄像头原理。


如图所示：首先摄像头显示的区域也是手机屏幕显示的区域 如果需要更改摄像头的位置  其实是更改背景地图的位置 利用程序拖动背景地图  给玩家一种假象让玩家感觉像是摄像头在移动而不是背景地图在移动。

游戏中地图的绘制原理介绍

       根据地图编辑器生成的出来的数组的每一个tile 的 ID 找到每一个tile的地图资源原始文件的XY坐标 算出来图片的显示位置利用程序的切割的方法把每一个tile切割出来显示在手机屏幕中。

切割图片的代码所示：

1.         /**
   
2.          * 绘制图片中的一部分图片
   
3.          * 
   
4.          * @param canvas
   
5.          * @param paint
   
6.          * @param bitmap
   
7.          * @param x
   
8.          * @param y
   
9.          * @param src_x
   
10.          * @param src_y
    
11.          * @param src_width
    
12.          * @param src_Height
    
13.          */
    
14.         private void DrawClipImage(Canvas canvas, Paint paint, Bitmap bitmap,
    
15.                 int x, int y, int src_x, int src_y, int src_xp, int src_yp) {
    
16.             canvas.save();
    
17.             canvas.clipRect(x, y, x + src_xp, y + src_yp);
    
18.             canvas.drawBitmap(bitmap, x - src_x, y - src_y, paint);
    
19.             canvas.restore();
    
20.         }

复制代码

canvas.save();
切割图片之前先把Canvas保存起来 然后在切割  绘制结束后
canvas.restore();
在把Canvas的在状态重置回来 如果不这么做的话 第一张图片切割后就会挡住以后所有的图片，所以大家一定要记住这一点喔。

       如图所示：每一张tile的绘制原理就是这样，说到这里有些朋友可能就要问 如果我的地图无限大那根据这个方法岂不是要循环无限次？其实屏幕须要绘制的tile数量只需要绘制屏幕显示区域以内的， 屏幕现实区域以外的我们不用考虑绘制 只需要更新地图的坐标数据就可以，比如我的模拟器屏幕的大小是320X480 那么我实际绘制的tile数量只是 10 X15 (块)。其实游戏开发绘制中还有一个更重要的绘制技术就是双缓冲技术它可以用来解决屏幕闪烁问题，下一章中我会详细介绍。

        
       昨天有朋友跟我提出这种用数组的方式来绘制地图不科学我很同意他的观点，为什么不科学？ 原因是现在我们只有一个场景我们用一个数组来绘制地图 万一我们的游戏有100个场景 我们岂不是要在程序中写100个数组了？其实在实际开发中我们是把这些地图的信息转成xml文件 打到游戏的包中 玩家在切换游戏场景的时候便会读取当前游戏场景中的地图xml文件。其实这些xml文件中也是保存这地图的二位数组信息 但是这样做的好处就是数据驱动  程序员不用定义N个数组 做N种判断 只须要根据当前切换的场景的ID就可以得到地图的信息 十分方便 也可以避免代码中由于笔误造成的的错误 何乐而不为。

       但是不管用任何方法处理数据 它的绘制原理都是一样的。

如何更新游戏中摄像头

效果图：程序取随机数更新游戏摄像头 

        目前以每10000毫秒更新一下摄像头的位置 (随机数) 我们有了摄像头的位置以后 就可以在算出背景图片的相对显示位置 移动背景图片的位置后就可以给玩家制造出一种摄像头在移动的假象了。

             地图块是我新拼的 长宽的tile块数是20X20。

1. package cn.m15.xys;
   
2. 
   
3. import java.io.InputStream;
   
4. import java.util.Random;
   
5. 
   
6. 
   
7. import android.app.Activity;
   
8. import android.content.Context;
   
9. import android.content.res.Resources;
   
10. import android.graphics.Bitmap;
    
11. import android.graphics.BitmapFactory;
    
12. import android.graphics.Canvas;
    
13. import android.graphics.Color;
    
14. import android.graphics.Paint;
    
15. import android.os.Bundle;
    
16. import android.view.Display;
    
17. import android.view.View;
    
18. import android.view.Window;
    
19. import android.view.WindowManager;
    
20. 
    
21. public class CameraAcitvity extends Activity {
    
22. 
    
23.     MapView mMapView = null;
    
24.     @Override
    
25.     public void onCreate(Bundle savedInstanceState) {
    
26.         super.onCreate(savedInstanceState);
    
27.         // 全屏显示窗口
    
28.         requestWindowFeature(Window.FEATURE_NO_TITLE);
    
29.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
    
30.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);
    
31.         // 获取屏幕宽高
    
32.         Display display = getWindowManager().getDefaultDisplay();
    
33.         // 显示自定义的游戏View
    
34.         mMapView = new MapView(this,display.getWidth(), display.getHeight());
    
35.         setContentView(mMapView);
    
36.     }
    
37. 
    
38.     public class MapView extends View {
    
39. 
    
40.         // tile块的宽高
    
41.         public final static int TILE_WIDTH = 32;
    
42.         public final static int TILE_HEIGHT = 32;
    
43. 
    
44.         // tile块的宽高的数量
    
45.         public final static int TILE_WIDTH_COUNT = 20;
    
46.         public final static int TILE_HEIGHT_COUNT = 20;
    
47. 
    
48.         // 地图的宽高的
    
49.         public final static int MAP_WIDTH = 640;
    
50.         public final static int MAP_HEIGHT = 640;
    
51.         
    
52.         //镜头移动范围
    
53.         public final static int CAMERA_MOVE = 10;
    
54.         
    
55.         // 屏幕的宽高
    
56.         public int mScreenWidth = 0;
    
57.         public int mScreenHeight = 0;
    
58.         
    
59.         // 数组元素为0则什么都不画
    
60.         public final static int TILE_NULL = 0;
    
61.         // 第一层游戏View地图数组
    
62.         public int[][] mMapView = {
    
63.                 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 1, 1, 1,
    
64.                         1, 1, 1 },
    
65.                 { 1, 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 137, 1, 1, 1,
    
66.                         1, 1, 1, 1 },
    
67.                 { 1, 1, 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 1, 1, 1, 1,
    
68.                         1, 1, 1 },
    
69.                 { 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 137, 137, 137, 1, 1,
    
70.                         1, 1, 1, 1, 1 },
    
71.                 { 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
    
72.                         137, 137, 137, 137, 137, 1, 1, 1 },
    
73.                 { 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
    
74.                         137, 137, 137, 137, 137, 1, 1, 1 },
    
75.                 { 137, 137, 137, 1, 1, 137, 137, 137, 137, 137, 137, 137, 137,
    
76.                         137, 137, 137, 1, 1, 1, 1 },
    
77.                 { 1, 137, 137, 1, 1, 1, 137, 137, 137, 137, 137, 137, 137, 137,
    
78.                         137, 137, 137, 1, 137, 1 },
    
79.                 { 1, 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 137, 137, 137,
    
80.                         137, 137, 137, 137, 1 },
    
81.                 { 1, 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 1, 1, 1, 137, 137,
    
82.                         137, 137, 137, 137 },
    
83.                 { 1, 1, 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 1, 1, 1, 137,
    
84.                         137, 137, 137, 1 },
    
85.                 { 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 137, 137, 1, 1, 1,
    
86.                         1, 137, 137, 137 },
    
87.                 { 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 1, 1, 1, 1, 1, 1,
    
88.                         1, 137, 137 },
    
89.                 { 1, 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 1, 1, 1, 1, 1, 1,
    
90.                         137, 137, 137 },
    
91.                 { 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 137, 137, 1, 1, 1, 1,
    
92.                         1, 137, 137, 137 },
    
93.                 { 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 137, 1, 1, 1, 1,
    
94.                         1, 1, 1, 1 },
    
95.                 { 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 1, 1, 1, 1, 1, 1,
    
96.                         1, 1, 1 },
    
97.                 { 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 1, 1, 1, 1, 1, 1,
    
98.                         1, 1, 1 },
    
99.                 { 1, 1, 1, 1, 1, 1, 137, 137, 137, 137, 137, 1, 1, 1, 1, 1, 1,
    
100.                         1, 1, 1 },
     
101.                 { 1, 1, 1, 1, 1, 1, 1, 137, 137, 137, 1, 1, 1, 1, 1, 1, 1, 1,
     
102.                         1, 1 } };
     
103. 
     
104.         // 第二层游戏实体actor数组
     
105.         public int[][] mMapAcotor = {
     
106.                 { 143, 144, 0, 102, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
107.                     185, 186, 187, 188 },
     
108.                     { 151, 152, 0, 110, 112, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
109.                     193, 194, 195, 196 },
     
110.                     { 159, 160, 0, 110, 112, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
111.                     201, 202, 203, 204 },
     
112.                     { 0, 0, 0, 126, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
113.                     209, 210, 211, 212 },
     
114.                     { 0, 0, 0, 134, 136, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
115.                     0, 218, 219, 220 },
     
116.                     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
117.                     0, 0, 227, 228 },
     
118.                     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
119.                     0, 0, 0, 0 },
     
120.                     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
121.                     0, 0, 0, 0 },
     
122.                     { 102, 103, 103, 103, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
123.                     0, 0, 0, 0 },
     
124.                     { 110, 111, 111, 111, 112, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
125.                     0, 0, 0, 0 },
     
126.                     { 110, 111, 111, 111, 112, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
127.                     0, 0, 0, 0 },
     
128.                     { 126, 127, 127, 127, 128, 0, 0, 0, 0, 0, 0, 0, 165, 166, 0, 0, 
     
129.                     0, 0, 0, 0 },
     
130.                     { 123, 124, 124, 124, 125, 0, 0, 0, 0, 0, 0, 0, 173, 174, 175, 176, 
     
131.                     0, 0, 0, 0 },
     
132.                     { 229, 230, 231, 232, 0, 0, 0, 0, 0, 0, 0, 0, 181, 182, 183, 184, 
     
133.                     0, 0, 0, 0 },
     
134.                     { 237, 238, 239, 240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
135.                     0, 0, 0, 0 },
     
136.                     { 245, 246, 247, 248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     
137.                     0, 0, 0, 0 },
     
138.                     { 0, 254, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 233, 234, 235, 
     
139.                     236, 0, 0, 0 },
     
140.                     { 0, 262, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241, 242, 243, 
     
141.                     244, 0, 0, 0 },
     
142.                     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 250, 251, 
     
143.                     0, 0, 0, 0 },
     
144.                     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 258, 259, 
     
145.                     0, 0, 143, 144 }
     
146.                     };
     
147. 
     
148.         // 第三层游戏碰撞物理层数组
     
149.         // 下一章介绍
     
150.         // ....................
     
151. 
     
152.         // 游戏地图资源
     
153.         Bitmap mBitmap = null;
     
154. 
     
155.         // 资源文件
     
156.         Resources mResources = null;
     
157. 
     
158.         // 游戏画笔
     
159.         Paint mPaint = null;
     
160. 
     
161.         // 横向纵向tile块的数量
     
162.         int mWidthTileCount = 0;
     
163.         int mHeightTileCount = 0;
     
164. 
     
165.         // 横向纵向tile块的数量
     
166.         int mBitMapWidth = 0;
     
167.         int mBitMapHeight = 0;
     
168. 
     
169.         //摄像头的焦点  0.0点为焦点在中心。
     
170.         int mCameraPosX = 0; 
     
171.         int mCameraPosY = 0; 
     
172.         
     
173.         //地图左上角锚点坐标
     
174.         int mMapPosX =0;
     
175.         int mMapPosY =0;
     
176.         
     
177.         //记录上次时间
     
178.         
     
179.         private long statrTime = 0;
     
180.         
     
181.         /**
     
182.          * 构造方法
     
183.          * 
     
184.          * @param context
     
185.          */
     
186.         public MapView(Context context,int screenWidth, int screenHeight) {
     
187.             super(context);
     
188.             mScreenHeight = screenHeight;
     
189.             mScreenWidth = screenWidth;
     
190.             mPaint = new Paint();
     
191.             mBitmap = ReadBitMap(context, R.drawable.map);
     
192.             mBitMapWidth = mBitmap.getWidth();
     
193.             mBitMapHeight = mBitmap.getHeight();
     
194.             mWidthTileCount = mBitMapWidth / TILE_WIDTH;
     
195.             mHeightTileCount = mBitMapHeight / TILE_HEIGHT;
     
196.             statrTime = System.currentTimeMillis();
     
197.         }
     
198. 
     
199.         @Override
     
200.         protected void onDraw(Canvas canvas) {
     
201.             UpdateCamera();
     
202.             DrawMap(canvas, mBitmap);
     
203.             DrawRectText(canvas);
     
204.             super.onDraw(canvas);
     
205.             invalidate();
     
206.         }
     
207. 
     
208.         private void DrawMap(Canvas canvas, Bitmap bitmap) {
     
209.             int i, j;
     
210.             for (i = 0; i < TILE_HEIGHT_COUNT; i++) {
     
211.                 for (j = 0; j < TILE_WIDTH_COUNT; j++) {
     
212.                     int ViewID = mMapView[i][j];
     
213.                     int ActorID = mMapAcotor[i][j];
     
214.                     int x = (j* TILE_WIDTH) + mMapPosX;
     
215.                     int y = (i* TILE_HEIGHT) + mMapPosY;
     
216.                     // 绘制地图第一层
     
217.                     if (ViewID > TILE_NULL) {
     
218.                         DrawMapTile(ViewID, canvas, mPaint, bitmap, x, y);
     
219.                     }
     
220. 
     
221.                     // 绘制地图第二层
     
222.                     if (ActorID > TILE_NULL) {
     
223.                         DrawMapTile(ActorID, canvas, mPaint, bitmap, x, y);
     
224.                     }
     
225.                 }
     
226.             }
     
227.         }
     
228.         private void DrawRectText(Canvas canvas) {
     
229.             canvas.clipRect(0, 0,mScreenWidth, 30);
     
230.             mPaint.setColor(Color.WHITE);
     
231.             canvas.drawRect(0, 0,mScreenWidth, 30, mPaint);
     
232.             mPaint.setColor(Color.RED);
     
233.             canvas.drawText("当前摄像头X坐标：" + mCameraPosX + "当前摄像头Y坐标 ：" + mCameraPosY, 0, 20, mPaint);
     
234.         }
     
235.         private void UpdateCamera() {
     
236.             long nowTime = System.currentTimeMillis();
     
237.             //每100毫秒更新一下摄像头的位置
     
238.             if(nowTime - statrTime > 1000) {
     
239.                 //随机获得摄像头的坐标
     
240.                 mCameraPosX = UtilRandom(0,MAP_WIDTH - mScreenWidth);
     
241.                 mCameraPosY = UtilRandom(0,MAP_HEIGHT - mScreenHeight);
     
242.                 //根据摄像头的坐标更新地图坐标
     
243.                 mMapPosX = -mCameraPosX;
     
244.                 mMapPosY = -mCameraPosY;
     
245.                 statrTime = nowTime;
     
246.             }
     
247.         }
     
248.         
     
249.         /**
     
250.         * 返回一个随机数
     
251.         * @param botton
     
252.         * @param top
     
253.         * @return
     
254.         */
     
255.         private int UtilRandom(int botton, int top) {
     
256.             return ((Math.abs(new Random().nextInt()) % (top - botton)) + botton);
     
257.         }
     
258.         /**
     
259.          * 根据ID绘制一个tile块
     
260.          * 
     
261.          * @param id
     
262.          * @param canvas
     
263.          * @param paint
     
264.          * @param bitmap
     
265.          */
     
266.         private void DrawMapTile(int id, Canvas canvas, Paint paint,
     
267.                 Bitmap bitmap, int x, int y) {
     
268.             // 根据数组中的ID算出在地图资源中的XY 坐标
     
269.             // 因为编辑器默认0 所以第一张tile的ID不是0而是1 所以这里 -1
     
270.             id--;
     
271.             int count = id / mWidthTileCount;
     
272.             int bitmapX = (id - (count * mWidthTileCount)) * TILE_WIDTH;
     
273.             int bitmapY = count * TILE_HEIGHT;
     
274.             DrawClipImage(canvas, paint, bitmap, x, y, bitmapX, bitmapY,
     
275.                     TILE_WIDTH, TILE_HEIGHT);
     
276.         }
     
277. 
     
278.         /**
     
279.          * 读取本地资源的图片
     
280.          * 
     
281.          * @param context
     
282.          * @param resId
     
283.          * @return
     
284.          */
     
285.         public Bitmap ReadBitMap(Context context, int resId) {
     
286.             BitmapFactory.Options opt = new BitmapFactory.Options();
     
287.             opt.inPreferredConfig = Bitmap.Config.RGB_565;
     
288.             opt.inPurgeable = true;
     
289.             opt.inInputShareable = true;
     
290.             // 获取资源图片
     
291.             InputStream is = context.getResources().openRawResource(resId);
     
292.             return BitmapFactory.decodeStream(is, null, opt);
     
293.         }
     
294. 
     
295.         /**
     
296.          * 绘制图片中的一部分图片
     
297.          * 
     
298.          * @param canvas
     
299.          * @param paint
     
300.          * @param bitmap
     
301.          * @param x
     
302.          * @param y
     
303.          * @param src_x
     
304.          * @param src_y
     
305.          * @param src_width
     
306.          * @param src_Height
     
307.          */
     
308.         private void DrawClipImage(Canvas canvas, Paint paint, Bitmap bitmap,
     
309.                 int x, int y, int src_x, int src_y, int src_xp, int src_yp) {
     
310.             canvas.save();
     
311.             canvas.clipRect(x, y, x + src_xp, y + src_yp);
     
312.             canvas.drawBitmap(bitmap, x - src_x, y - src_y, paint);
     
313.             canvas.restore();
     
314.         }
     
315.         
     
316.     }
     
317. }

复制代码

最后如果你还是觉得我写的不够详细 看的不够爽 不要紧我把源代码的下载地址贴出来 欢迎大家一起讨论学习
  第二讲游戏摄像头.rar (196.18 KB, 下载次数: 444)