devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

android 2D 游戏的开发的方法_利用android studio开发二维游戏平台

作者：2023面试高手 | 2024-02-23 02:10:29

赞

踩

利用android studio开发二维游戏平台

                                 最近学习了android 2D 应用的开发，拿来和大家分享一下，学习2D 开发前我们先了解一下SurfaceView的使用以及贴图技术的使用，最后呢，是一个简单的2的游戏的实现。


 1.SurfaceView的一些用法


                     提供了一个专门的绘图渲染的图形嵌入在一个视图层次;SurfaceView负责将图形正确的显示在屏幕上，访问底层图形是通过SurfaceHolder提供接口,可通过调用getHolder()，图形创建SurfaceView的窗口是可见的;实现方法是surfaceCreated(SurfaceHolder)和surfaceDestroyed(SurfaceHolder)销毁图形

 


                    简单的例子如下

  1. package com.nyist.wj;
  2.  
  3. import android.app.Activity;
  4. import android.content.Context;
  5. import android.graphics.Canvas;
  6. import android.graphics.Color;
  7. import android.graphics.Paint;
  8. import android.graphics.Rect;
  9. import android.graphics.RectF;
  10. import android.graphics.Paint.Style;
  11. import android.os.Bundle;
  12. import android.view.SurfaceHolder;
  13. import android.view.SurfaceView;
  14.  
  15. public class SurfaceViewActivity extends Activity {
  16. 	MySurfaceView mySurfaceView;
  17.  
  18. 	/** Called when the activity is first created. */
  19. 	@Override
  20. 	public void onCreate(Bundle savedInstanceState) {
  21. 		super.onCreate(savedInstanceState);
  22.  
  23. 		mySurfaceView = new MySurfaceView(this);
  24. 		setContentView(mySurfaceView);
  25.  
  26. 	}
  27. 	public class MySurfaceView extends SurfaceView implements
  28. 	SurfaceHolder.Callback {
  29. SurfaceViewActivity surfaceViewActivity; // Activity的引用
  30. Paint paint; // 画笔的引用
  31.  
  32. public MySurfaceView(Context context) // 构造器
  33. {
  34. 	super(context);
  35. 	this.surfaceViewActivity = (SurfaceViewActivity) context; // 拿到Activity引用
  36. 	this.getHolder().addCallback(this); // 设置生命周期回调接口的实现者
  37. 	paint = new Paint(); // 创建画笔
  38. 	paint.setAntiAlias(true); // 打开抗锯齿
  39. }
  40.  
  41. @Override
  42. protected void onDraw(Canvas canvas) // onDraw方法
  43. {
  44. 	paint.setColor(Color.WHITE); // 设置画笔颜色为白色
  45. 	canvas.drawRect(0, 0, getWidth(), getHeight(), paint); // 绘制白色矩形背景
  46. 	paint.reset(); // 清除画笔设置
  47. 	paint.setARGB(50, 0, 255, 0); // 设置画笔颜色和透明度
  48. 	paint.setStrokeWidth(5); // 设置画笔宽度
  49. 	RectF rf = new RectF(50, 100, 160, 180); // 创建一个矩形
  50. 	canvas.drawRect(rf, paint); // 绘制矩形
  51. 	paint.setARGB(50, 0, 0, 255); // 设置画笔颜色和透明度
  52. 	paint.setStyle(Style.STROKE); // 设置风格为边框
  53. 	paint.setStrokeWidth(5); // 设置画笔宽度
  54. 	Rect r = new Rect(200, 100, 300, 180); // 创建一个矩形
  55. 	canvas.drawRect(r, paint); // 画一个矩形边框
  56. 	paint.setColor(Color.RED); // 设置画笔颜色
  57. 	paint.setAntiAlias(true); // 打开抗锯齿
  58. 	canvas.drawCircle(100, 250, 30, paint);// 画一个圆
  59. 	paint.setColor(Color.YELLOW); // 设置画笔颜色
  60. 	rf = new RectF(200, 250, 300, 300); // 创建一个矩形
  61. 	canvas.drawOval(rf, paint); // 画一个椭圆，充满矩形
  62. 	paint.reset(); // 清除画笔设置
  63. 	paint.setColor(Color.RED); // 设置画笔颜色
  64.  
  65. 	paint.setTextSize(40); // 设置文字大小
  66. 	paint.setStyle(Style.FILL_AND_STROKE);
  67. 	canvas.drawText("loading...", 50, 350, paint); // 画一个字符串
  68. }
  69.  
  70. @Override
  71. public void surfaceCreated(SurfaceHolder holder) // 创建时被调用
  72. {
  73. 	Canvas canvas = holder.lockCanvas(); // 获取画布
  74. 	try {
  75. 		synchronized (holder) {
  76. 			onDraw(canvas);
  77. 		} // 绘制
  78. 	} catch (Exception e) {
  79. 		e.printStackTrace();
  80. 	} finally {
  81. 		if (canvas != null) {
  82. 			holder.unlockCanvasAndPost(canvas);
  83. 		}
  84. 	}
  85. }
  86.  
  87. @Override
  88. public void surfaceDestroyed(SurfaceHolder holder) {
  89. } // 继承方法，空实现
  90.  
  91. @Override
  92. // 继承方法，空实现
  93. public void surfaceChanged(SurfaceHolder holder, int format, int width,
  94. 		int height) {
  95. }
  96. }
  97.  
  98. }

实现的效果是：

2.贴图技术的使用

    贴图技术主要包括图片的移动、旋转、透明度、等变化

下面是关于贴图技术的使用方法  首先是自定义的一个布局

  1.  <com.nyist.wj.MysurfaceView
  2.         android:id="@+id/mysurfaceview"
  3.         android:layout_width="fill_parent"
  4.         android:layout_height="fill_parent" />

然后就是实现自定义布局引用的类

  1. package com.nyist.wj;
  2.  
  3. import android.content.Context;
  4. import android.graphics.Bitmap;
  5. import android.graphics.BitmapFactory;
  6. import android.graphics.Canvas;
  7. import android.graphics.Matrix;
  8. import android.graphics.Paint;
  9. import android.util.AttributeSet;
  10. import android.view.View;
  11.  
  12. public class MysurfaceView extends View {
  13.  
  14.  Bitmap bitmap;
  15.  Paint paint;
  16.  public MysurfaceView(Context context,AttributeSet attributeSet) {
  17.   super(context,attributeSet);
  18.   // TODO Auto-generated constructor stub
  19.   this.initBitmap();
  20.   
  21.  }
  22.  public  void initBitmap() {
  23.   // TODO Auto-generated method stub
  24.   paint=new Paint();
  25.   bitmap=BitmapFactory.decodeResource(getResources(), R.drawable.ball);
  26.   
  27.  }
  28.  @Override
  29.  protected void onDraw(Canvas canvas) {
  30.   // TODO Auto-generated method stub
  31.   super.onDraw(canvas);
  32.   //打开抗锯齿
  33.   paint.setAntiAlias(true);
  34.   canvas.drawBitmap(bitmap, 50,50,paint);
  35.   canvas.save();
  36.   
  37.   Matrix matrix=new Matrix();
  38.   //移动
  39.   matrix.setTranslate(100, 100);
  40.   Matrix matrix2=new Matrix();
  41. //  旋转
  42.   matrix2.setRotate(50);
  43.   Matrix matrix3=new Matrix();
  44.   matrix3.setConcat(matrix, matrix2);
  45.   //缩放
  46.   matrix.setScale(0.5f, 0.5f);
  47.   matrix2.setConcat(matrix3, matrix);
  48.   canvas.drawBitmap(bitmap, matrix2, paint);
  49.   canvas.restore();
  50.   canvas.save();
  51.   paint.setAlpha(200);
  52.   matrix.setTranslate(150, 150);
  53.   //放大
  54.   matrix2.setScale(1.3f, 1.3f);
  55.   //设置总矩阵
  56.   matrix3.setConcat(matrix, matrix2);
  57.   canvas.drawBitmap(bitmap, matrix3, paint);
  58.   paint.reset();
  59.   
  60.  }
  61.  
  62.  
  63.  
  64. }
  65.  
  66.


实现的效果如下   解释一下：这是横屏显示的结果，左上方是原图片大小  接着是缩放的和放大的图片

3.广告条的实现方法

广告虽不好，但是这确实为android开发者提供了一点微薄的力量，下面就看看广告条的开发

效果图：

实现的过程有自定义的View

  1. <com.nyist.wj.myView
  2.         android:layout_width="fill_parent"
  3.         android:layout_height="50dip"
  4.         />

实现view的方法

  1. package com.nyist.wj;
  2.  
  3. import android.content.Context;
  4. import android.content.Intent;
  5. import android.content.res.Resources;
  6. import android.graphics.Bitmap;
  7. import android.graphics.BitmapFactory;
  8. import android.graphics.Canvas;
  9. import android.graphics.Matrix;
  10. import android.graphics.Paint;
  11. import android.os.Bundle;
  12. import android.util.AttributeSet;
  13. import android.view.MotionEvent;
  14. import android.view.View;
  15.  
  16. public class myView extends View {
  17. 	Bitmap[] bitmap;
  18. 	int currentindex = 1;
  19. 	int time = 3000;
  20. 	boolean isAnima = false;
  21. 	Paint paint;
  22. 	int[] imageID;
  23. 	// 初始化图片数阻
  24. 	boolean initFlag = false;
  25. 	float prex, prey;
  26. 	int xoffset;
  27.  
  28. 	public myView(Context context, AttributeSet attributeSet) {
  29. 		super(context, attributeSet);
  30. 		// TODO Auto-generated constructor stub
  31. 		this.imageID = new int[] { R.drawable.test1, R.drawable.test2,
  32. 				R.drawable.test3, R.drawable.test4 };
  33. 		// 生成图片数组
  34. 		bitmap = new Bitmap[imageID.length];
  35. 		paint = new Paint();
  36. 		// 抗锯齿
  37. 		paint.setFlags(Paint.ANTI_ALIAS_FLAG);
  38. 		this.setOnTouchListener(null);
  39. 		new Thread() {
  40. 			public void run() {
  41.  
  42. 				while (true) {
  43. 					if (!isAnima) {
  44. 						currentindex = (currentindex + 1) % imageID.length;
  45.  
  46. 					}
  47. 					// 刷帧重绘
  48. 					myView.this.postInvalidate();
  49. 					try {
  50. 						Thread.sleep(time);
  51. 					} catch (Exception e) {
  52. 						// TODO: handthele exception
  53. 					}
  54.  
  55. 				}
  56.  
  57. 			};
  58. 		}.start();
  59.  
  60. 	}
  61.  
  62. 	public void initBitmap() {
  63. 		Resources resources = this.getResources();
  64. 		for (int i = 0; i < imageID.length; i++) {
  65. 			// ------------------------------
  66. 			// 实现图片 的缩放
  67. 			bitmap[i] = scaleChange(BitmapFactory.decodeResource(resources,
  68. 					imageID[i]
  69.  
  70. 			));
  71. 		}
  72.  
  73. 	}
  74.  
  75. 	public static Bitmap scaleChange(Bitmap bitmap) {
  76. 		int w = bitmap.getWidth();
  77. 		int h = bitmap.getHeight();
  78. 		double xratio = (double) Constant.SCREEN_WIDTH / w;
  79. 		double yratio = 50.0 / h;
  80. 		// 生成矩阵
  81. 		Matrix matrix = new Matrix();
  82. 		matrix.postScale((float) xratio, (float) yratio);
  83. 		Bitmap result = Bitmap.createBitmap(bitmap, 0, 0, w, h, matrix, true);
  84.  
  85. 		return result;
  86.  
  87. 	}
  88.  
  89. 	@Override
  90. 	public void onDraw(Canvas canvas) {
  91. 		// TODO Auto-generated method stub
  92. 		// 第一次运行onDraw方法的时候，调用初始化图片数组的方法
  93. 		if (!initFlag) {
  94. 			initBitmap();
  95. 			initFlag = true;
  96. 		}
  97. 		if (canvas == null) {
  98. 			return;
  99. 		}
  100. 		if (!isAnima) {
  101. 			// -------------------------------------
  102. 			// 当没有播放动画时候绘制当前图片
  103. 			drawAD(canvas, xoffset, currentindex);
  104. 		}
  105. 		if (isAnima) {
  106. 			// 当向右滑动时候
  107. 			if (xoffset > 0) {
  108. 				int size = imageID.length;
  109. 				// 得到上一张图片的索引
  110. 				int preIndex = (currentindex - 1 + size) % size;
  111. 				// 根据x轴偏移量，算出上一张图片绘制时的x坐标
  112. 				int nextIndex = xoffset - Constant.SCREEN_WIDTH;
  113. 				// 绘制当前索引图片
  114. 				drawAD(canvas, xoffset, (preIndex + 1) % size);
  115. 				drawAD(canvas, nextIndex, preIndex);
  116.  
  117. 			} // 当往左抹时
  118. 			else if (xoffset < 0) {
  119. 				int size = imageID.length;
  120. 				// 得到下一张图片的索引
  121. 				int preIndex = (currentindex + 1 + size) % size;
  122. 				int nextIndex = xoffset + Constant.SCREEN_WIDTH;
  123. 				// 绘制当前图片的索引
  124. 				drawAD(canvas, xoffset, (preIndex - 1 + size) % size);
  125. 				drawAD(canvas, nextIndex, preIndex);
  126.  
  127. 			}
  128. 		}
  129.  
  130. 	}
  131.  
  132. 	public void drawAD(Canvas canvas, int offset, int Index) {
  133. 		canvas.drawBitmap(bitmap[Index], offset, 0, paint);
  134.  
  135. 	}
  136.  
  137. 	@Override
  138. 	public boolean onTouchEvent(MotionEvent event) {
  139. 		// TODO Auto-generated method stub
  140.  
  141. 		float x = event.getX();
  142. 		float y = event.getY();
  143. 		switch (event.getAction()) {
  144. 		case MotionEvent.ACTION_DOWN:
  145. 			prex = x;
  146. 			prey = y;
  147. 			System.out.println("------------------------------------");
  148. 			System.out.println("+++++++++++++++++++++++++++++++++++"
  149. 					+ currentindex);
  150.  
  151. 			return true;
  152. 		case MotionEvent.ACTION_MOVE:
  153. 			if (!isAnima && Math.abs(x - prex) > 10) {
  154. 				isAnima = true;
  155. 			}
  156. 			if (isAnima) {
  157. 				xoffset = (int) (xoffset + x - prex);
  158. 				prex = x;
  159. 				prey = y;
  160.  
  161. 			}
  162. 			this.postInvalidate();
  163. 			return true;
  164. 		case MotionEvent.ACTION_UP:
  165.  
  166. 			if (isAnima) {
  167. 				if (x < Constant.SCREEN_WIDTH / 4 && xoffset < 0) {
  168. 					int size = imageID.length;
  169. 					currentindex = (currentindex + 1) % size;
  170.  
  171. 				} else if (x > Constant.SCREEN_WIDTH * 3 / 4 && xoffset > 0) {
  172. 					int size = imageID.length;
  173. 					currentindex = (currentindex - 1 + size) % size;
  174.  
  175. 				}
  176.  
  177. 			}
  178. 			isAnima = false;
  179. 			xoffset = 0;
  180. 			this.postInvalidate();
  181. 			return true;
  182.  
  183. 		}
  184.  
  185. 		return false;
  186. 	}
  187.  
  188. }


接着是在activity中的插入

  1. package com.nyist.wj;
  2.  
  3.  
  4. import android.app.Activity;
  5. import android.content.pm.ActivityInfo;
  6. import android.os.Bundle;
  7. import android.util.DisplayMetrics;
  8. import android.view.Window;
  9. import android.view.WindowManager;
  10.  
  11. public class GuangGaoActivity extends Activity {
  12.     /** Called when the activity is first created. */
  13.     @Override
  14.     public void onCreate(Bundle savedInstanceState) {
  15.         super.onCreate(savedInstanceState);
  16.         requestWindowFeature(Window.FEATURE_NO_TITLE);
  17.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
  18. //        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
  19.         
  20.         
  21.         setContentView(R.layout.main);
  22.         DisplayMetrics displayMetrics=new DisplayMetrics();
  23.         getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
  24.         Constant.SCREEN_HEIGHT=displayMetrics.heightPixels;	//获取具体的屏幕分辨率数值
  25.         Constant.SCREEN_WIDTH=displayMetrics.widthPixels;
  26.     }
  27. }

 

4.下面是介绍2D下简单的游戏开发

效果图如下

主要用到的SurfaceView 和贴图技术以及声音的处理

用到的处理方法共有5个类

1.BallGameActivity                        设置屏幕的相关属性

2.GameSurfaceView                    实现显示界面的设置

3.ThreadForDraw                       刷帧线程重新绘制游戏界面

4.ThreadForGo                            控制小球移动

5.ThreadForTimecControl         计算小球运行的时间

下面分别介绍每个类是如何实现的

1.BallGameActivity 

  1. package com.nyist.wj;
  2.  
  3. import java.util.HashMap;
  4.  
  5. import org.apache.http.auth.AUTH;
  6.  
  7. import android.app.Activity;
  8. import android.content.Context;
  9. import android.media.AudioManager;
  10. import android.media.SoundPool;
  11. import android.os.Bundle;
  12. import android.view.Window;
  13. import android.view.WindowManager;
  14.  
  15. public class BallGameActivity extends Activity {
  16. 	GameSurfaceView gameSurfaceView;
  17. 	// 声音缓冲池
  18. 	SoundPool soundPool;
  19. 	// 存放声音ID的 map
  20. 	HashMap<Integer, Integer> soundpoolMap;
  21.  
  22. 	/** Called when the activity is first created. */
  23. 	@Override
  24. 	public void onCreate(Bundle savedInstanceState) {
  25. 		super.onCreate(savedInstanceState);
  26.  
  27. 		// 初始化声音
  28. 		initSounds();
  29. 		// 设置全屏
  30. 		requestWindowFeature(Window.FEATURE_NO_TITLE);
  31. 		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
  32. 				WindowManager.LayoutParams.FLAG_FULLSCREEN);
  33.  
  34. 		gameSurfaceView = new GameSurfaceView(this);
  35. 		setContentView(gameSurfaceView);
  36. 		// 循环播放音乐
  37. 		playSound(1, -1);
  38.  
  39. 	}
  40.  
  41. 	public void playSound(int sound, int loop) {
  42. 		// TODO Auto-generated method stub
  43. 		// 播放声音的方法
  44. 		AudioManager audioManager = (AudioManager) this
  45. 				.getSystemService(Context.AUDIO_SERVICE);
  46. 		float streamVolumeMax = audioManager
  47. 				.getStreamMaxVolume(audioManager.STREAM_MUSIC);
  48. 		float streamVolumeCurrent = audioManager
  49. 				.getStreamVolume(AudioManager.STREAM_MUSIC);
  50. 		float volume = streamVolumeCurrent / streamVolumeMax;
  51. 		// 参数 声音资源的ID 左声道 右声道 优先级 循环次数 回访速度
  52. 		soundPool.play(soundpoolMap.get(sound), volume, volume, 1, loop, 0.5f);
  53. 	}
  54.  
  55. 	public void initSounds() {
  56. 		// TODO Auto-generated method stub
  57. 		// 参数 播放的个数 音频类型 播放的质量
  58. 		soundPool = new SoundPool(4, AudioManager.STREAM_MUSIC, 100);
  59. 		// 创建声音资源的MAP
  60. 		soundpoolMap = new HashMap<Integer, Integer>();
  61. 		// 将加载声音的资源 放在map中
  62. 		soundpoolMap.put(1, soundPool.load(this, R.raw.bg, 1));
  63.  
  64. 	}
  65. }


 

2.GameSurfaceView 

  1. package com.nyist.wj;
  2.  
  3. import android.graphics.Bitmap;
  4. import android.graphics.BitmapFactory;
  5. import android.graphics.Canvas;
  6. import android.view.MotionEvent;
  7. import android.view.SurfaceHolder;
  8. import android.view.SurfaceView;
  9.  
  10. public class GameSurfaceView extends SurfaceView implements
  11. 		SurfaceHolder.Callback {
  12.  
  13. 	BallGameActivity ballGameActivity;
  14. 	ThreadForTimecControl threadForTimecControl;
  15. 	ThreadForGo threadForGo;
  16. 	ThreadForDraw threadForDraw;
  17.  
  18. 	int backSize = 16; // 背景块大小
  19. 	int screenWidth = 320; // 屏幕宽度
  20. 	int screenHeight = 480; // 屏幕高度
  21. 	int bannerWidth = 40; // 挡板宽度
  22. 	int bannerHeight = 6; // 挡板高度
  23. 	int bottomSpance = 16; // 下端留白
  24. 	int bannerSpan = 5; // 板每次移动的距离
  25. 	int ballSpan = 8; // 球每次移动的距离
  26. 	int ballSize = 16; // 小球大小
  27. 	int hintWidth = 100; // 游戏说明宽度
  28. 	int hintHeight = 20; // 游戏说明高度
  29. 	int status = 0; // 游戏状态控制 0-等待开始 1-进行中 2-游戏结束 3-游戏胜利
  30. 	int score = 0; // 得分
  31. 	int ballx; // 小球x坐标
  32. 	int bally; // 小球y坐标
  33. 	int direction = 0; // 小球方向
  34. 	int bannerX; // 挡板X坐标
  35. 	int bannerY; // 挡板Y坐标
  36. 	int scoreWidth = 32;
  37. 	Bitmap iback; // 背景图
  38. 	Bitmap[] iscore = new Bitmap[10];// 得分图
  39. 	Bitmap iball; // 小球用图
  40. 	Bitmap ibanner; // 挡板用图
  41. 	Bitmap ibegin; // 开始用图
  42. 	Bitmap igameover; // 游戏结束用图
  43. 	Bitmap iwin; // 游戏结束用图
  44. 	Bitmap iexit; // 退出用图
  45. 	Bitmap ireplay; // 重玩用图
  46.  
  47. 	public GameSurfaceView(BallGameActivity ballGameActivity) {
  48. 		super(ballGameActivity);
  49. 		// 注册回调接口
  50. 		getHolder().addCallback(this);
  51. 		this.ballGameActivity = ballGameActivity;
  52.  
  53. 		initBitmap();
  54. 		// /----------------------------------------------
  55. 		threadForDraw = new ThreadForDraw(this);
  56. 		// TODO Auto-generated constructor stub
  57. 	}
  58.  
  59. 	public void initBitmap() {
  60. 		iback = BitmapFactory.decodeResource(getResources(), R.drawable.back);
  61. 		iscore[0] = BitmapFactory.decodeResource(getResources(), R.drawable.d0);
  62. 		iscore[1] = BitmapFactory.decodeResource(getResources(), R.drawable.d1);
  63. 		iscore[2] = BitmapFactory.decodeResource(getResources(), R.drawable.d2);
  64. 		iscore[3] = BitmapFactory.decodeResource(getResources(), R.drawable.d3);
  65. 		iscore[4] = BitmapFactory.decodeResource(getResources(), R.drawable.d4);
  66. 		iscore[5] = BitmapFactory.decodeResource(getResources(), R.drawable.d5);
  67. 		iscore[6] = BitmapFactory.decodeResource(getResources(), R.drawable.d6);
  68. 		iscore[7] = BitmapFactory.decodeResource(getResources(), R.drawable.d7);
  69. 		iscore[8] = BitmapFactory.decodeResource(getResources(), R.drawable.d8);
  70. 		iscore[9] = BitmapFactory.decodeResource(getResources(), R.drawable.d9);
  71. 		iball = BitmapFactory.decodeResource(getResources(), R.drawable.ball);
  72. 		ibanner = BitmapFactory.decodeResource(getResources(),
  73. 				R.drawable.banner);
  74. 		ibegin = BitmapFactory.decodeResource(getResources(), R.drawable.begin);
  75. 		igameover = BitmapFactory.decodeResource(getResources(),
  76. 				R.drawable.gameover);
  77. 		iwin = BitmapFactory.decodeResource(getResources(), R.drawable.win);
  78. 		iexit = BitmapFactory.decodeResource(getResources(), R.drawable.exit);
  79. 		ireplay = BitmapFactory.decodeResource(getResources(),
  80. 				R.drawable.replay);
  81. 		// 初始化小球位置及板X坐标
  82. 		initBallAndBanner();
  83. 	}
  84.  
  85. 	public void initBallAndBanner() {
  86. 		// 初始化小球位置
  87. 		bally = screenHeight - bottomSpance - bannerHeight - ballSize;
  88. 		ballx = screenWidth / 2 - ballSize / 2;
  89. 		// 初始化板X坐标
  90. 		bannerX = screenWidth / 2 - bannerWidth / 2;
  91. 		bannerY = screenHeight - bottomSpance - bannerHeight;
  92. 	}
  93.  
  94. 	public void replay() {
  95.  
  96. 		if (status == 2 || status == 3) {
  97. 			// 初始化小球的位置
  98. 			initBallAndBanner();
  99. 			score = 0;
  100. 			status = 0;
  101. 			direction = 3;
  102.  
  103. 		}
  104. 	}
  105.  
  106. 	@Override
  107. 	protected void onDraw(Canvas canvas) {
  108. 		// TODO Auto-generated method stub
  109.  
  110. 		super.onDraw(canvas);
  111. 		// 清除背景
  112. 		int colum = screenWidth / backSize
  113. 				+ ((scoreWidth % backSize == 0) ?0:1);
  114. 		int rows = screenHeight / backSize
  115. 				+ ((screenHeight % backSize == 0) ? 0 : 1);
  116. 		for (int i = 0; i < rows; i++) {
  117. 			for (int j = 0; j < colum; j++) {
  118.  
  119. 				canvas.drawBitmap(iback, 16*j, 16*i, null);
  120.  
  121. 			}
  122. 		}
  123. 		// 绘制得分
  124. 		String scorestr = score + "";
  125. 		int loop = 3 - scorestr.length();
  126. 		for (int i = 0; i < loop; i++) {
  127.  
  128. 			scorestr = "0" + scorestr;
  129. 		}
  130. 		int startX = screenWidth - scoreWidth * 3 - 10;
  131. 		for (int i = 0; i < 3; i++) {
  132. 			int tempScore = scorestr.charAt(i) - '0';
  133. 			canvas.drawBitmap(iscore[tempScore], startX + i * scoreWidth, 5,
  134. 					null);
  135.  
  136. 		}
  137. 		// 绘制小球
  138. 		canvas.drawBitmap(iball, ballx, bally, null);
  139. 		// 绘制板
  140. 		canvas.drawBitmap(ibanner, bannerX, bannerY, null);
  141. 		// 绘制开始提示
  142. 		if (status == 0) {
  143. 			canvas.drawBitmap(ibegin, screenWidth / 2 - hintWidth / 2,
  144. 					screenHeight / 2 - hintHeight / 2, null);
  145.  
  146. 		}
  147. 		// 绘制失败提示
  148. 		if (status == 2) {
  149. 			canvas.drawBitmap(igameover, screenWidth / 2 - hintWidth / 2,
  150. 					screenHeight / 2 - hintHeight / 2, null);
  151.  
  152. 		}
  153. 		// 绘制胜利提示
  154. 		if (status == 3) {
  155. 			canvas.drawBitmap(iwin, screenWidth / 2 - hintWidth / 2,
  156. 					screenHeight / 2 - hintHeight / 2, null);
  157.  
  158. 		}
  159. 		// 绘制退出提示
  160. 		canvas.drawBitmap(iexit, screenWidth - 32, screenHeight - 16, null);
  161. 		// /绘制重玩提示
  162. 		if (status == 2 || status == 3) {
  163. 			canvas.drawBitmap(ireplay, 0, screenHeight - 16, null);
  164.  
  165. 		}
  166.  
  167. 	}
  168.  
  169. 	@Override
  170. 	public boolean onTouchEvent(MotionEvent event) {
  171.  
  172. 		int x = (int) event.getX();
  173. 		int y = (int) event.getY();
  174. 		if (x < screenWidth && x > screenWidth - 32 && y < screenHeight
  175. 				&& y > screenHeight - 16) {
  176. 			// ----------------------------------------------------------
  177. 			// 按下退出选项退出系统
  178. 			ballGameActivity.soundPool.stop(1);
  179. 			System.exit(0);
  180. 		}
  181. 		// 等待状态
  182. 		if (status == 0) {
  183. 			status = 1;
  184. 			// ----------------------------------------------
  185. 			threadForTimecControl = new ThreadForTimecControl(this);
  186. 			threadForGo = new ThreadForGo(this);
  187. 			threadForTimecControl.start();
  188. 			threadForGo.start();
  189. 		} else if (status == 1) {
  190. 			bannerX = x;
  191. 		} else if (status == 2 || status == 3) {
  192. 			if (x < 32 && x > 0 && y < screenHeight && y > screenHeight - 16) {
  193. 				//按下重玩
  194. 				replay();
  195.  
  196. 			}
  197.  
  198. 		}
  199.  
  200. 		// TODO Auto-generated method stub
  201. 		return super.onTouchEvent(event);
  202.  
  203. 	}
  204.  
  205. 	@Override
  206. 	public void surfaceChanged(SurfaceHolder holder, int format, int width,
  207. 			int height) {
  208.  
  209. 		// TODO Auto-generated method stub
  210.  
  211. 	}
  212.  
  213. 	@Override
  214. 	public void surfaceCreated(SurfaceHolder holder) {
  215. 		// TODO Auto-generated method stub
  216. 		// ----------------------------------
  217. 		// 创建时候启动相关进程
  218. 		this.threadForDraw.flag = true;
  219. 		threadForDraw.start();
  220.  
  221. 	}
  222.  
  223. 	@Override
  224. 	public void surfaceDestroyed(SurfaceHolder holder) {
  225.  
  226. 		// 释放相应的进程
  227. 		boolean retry = true;
  228. 		this.threadForDraw.flag = false;
  229. 		// 不断的循环知道刷帧结束
  230. 		while (retry) {
  231. 			try {
  232. 				threadForDraw.join();
  233. 				retry = false;
  234.  
  235. 			} catch (InterruptedException e) {
  236. 				// TODO: handle exception
  237. 			}
  238.  
  239. 		}
  240.  
  241. 	}
  242.  
  243. }


 

3.ThreadForDraw 

  1. package com.nyist.wj;
  2.  
  3. import android.graphics.Canvas;
  4. import android.view.SurfaceHolder;
  5.  
  6. public class ThreadForDraw extends Thread {
  7. boolean flag=true;
  8. int sleep=100;
  9. GameSurfaceView gameSurfaceView;
  10. SurfaceHolder surfaceHolder;
  11.  
  12. public ThreadForDraw (GameSurfaceView gameSurfaceView){
  13. 	
  14. 	
  15. 	this.gameSurfaceView=gameSurfaceView;
  16. 	this.surfaceHolder=gameSurfaceView.getHolder();
  17. 	
  18. }
  19.  
  20. @Override
  21. public void run() {
  22. 	// TODO Auto-generated method stub
  23. 	
  24. 	Canvas canvas;
  25. 	while (this.flag) {
  26. 		
  27. 		canvas=null;
  28. 		try {
  29. 			canvas=this.surfaceHolder.lockCanvas(null);
  30. 			synchronized (this.surfaceHolder) {
  31. 				gameSurfaceView.onDraw(canvas);
  32. 			}
  33. 		} catch (Exception e) {
  34. 		
  35. 		}finally{
  36. 			if (canvas!=null) {
  37. 				this.surfaceHolder.unlockCanvasAndPost(canvas);
  38. 				
  39. 			}
  40. 		}
  41. 		try {
  42. 			Thread.sleep(sleep);
  43. 		} catch (Exception e) {
  44. 			// TODO: handle exception
  45. 		}
  46. 	}
  47. 	super.run();
  48. }
  49.  
  50.  
  51.  
  52.  
  53. }


 

4.ThreadForGo

  1. package com.nyist.wj;
  2.  
  3. //游戏过程中移动小球的线程
  4. public class ThreadForGo extends Thread {
  5. 	// 设置线程执行的标志
  6. 	boolean flag = true;
  7. 	// 游戏界面的引用
  8. 	GameSurfaceView gameSurfaceView;
  9.  
  10. 	public ThreadForGo(GameSurfaceView gameSurfaceView) {
  11. 		this.gameSurfaceView = gameSurfaceView;
  12. 	}
  13.  
  14. 	@Override
  15. 	public void run() {
  16. 		// TODO Auto-generated method stub
  17. 		while (flag) {
  18. 			switch (gameSurfaceView.direction) {
  19.  
  20. 			case 0:
  21. 				// 右上控制当前方向移动球
  22. 				gameSurfaceView.ballx = gameSurfaceView.ballx
  23. 						+ gameSurfaceView.ballSpan;
  24. 				gameSurfaceView.bally = gameSurfaceView.bally
  25. 						- gameSurfaceView.ballSpan;
  26. 				// 判断是否碰壁
  27. 				if (gameSurfaceView.ballx >= gameSurfaceView.screenWidth
  28. 						- gameSurfaceView.ballSize) {
  29. 					// 碰到上壁
  30. 					gameSurfaceView.direction = 3;
  31. 				} else if (gameSurfaceView.bally <= 0) {
  32. 					gameSurfaceView.direction = 1;
  33.  
  34. 				}
  35.  
  36. 				break;
  37.  
  38. 			case 1:
  39. 				// 右下
  40. 				gameSurfaceView.ballx = gameSurfaceView.ballx
  41. 						+ gameSurfaceView.ballSpan;
  42. 				gameSurfaceView.bally = gameSurfaceView.bally
  43. 						+ gameSurfaceView.ballSpan;
  44. 				// 碰到下壁
  45. 				if (gameSurfaceView.bally >= gameSurfaceView.screenHeight
  46. 						- gameSurfaceView.bannerHeight
  47. 						- gameSurfaceView.bottomSpance
  48. 						- gameSurfaceView.ballSize) {
  49. 					// /-----------------------------------------
  50. 					checkCollision(1);
  51. 					// 碰到右臂
  52. 				} else if (gameSurfaceView.ballx >= gameSurfaceView.screenWidth
  53. 						- gameSurfaceView.ballSize) {
  54. 					gameSurfaceView.direction = 2;
  55. 				}
  56.  
  57. 				break;
  58. 			case 2:
  59. 				// 左下
  60. 				gameSurfaceView.ballx = gameSurfaceView.ballx
  61. 						- gameSurfaceView.ballSpan;
  62. 				gameSurfaceView.bally = gameSurfaceView.bally
  63. 						+ gameSurfaceView.ballSpan;
  64. 				// 碰到下壁
  65. 				if (gameSurfaceView.bally >= gameSurfaceView.screenHeight
  66. 						- gameSurfaceView.bannerHeight
  67. 						- gameSurfaceView.bottomSpance
  68. 						- gameSurfaceView.ballSize) {
  69. 					// -----------------------------------
  70. 					checkCollision(2);
  71.  
  72. 				}
  73. 				// 碰到左壁
  74. 				else if (gameSurfaceView.ballx <= 0) {
  75.  
  76. 					gameSurfaceView.direction = 1;
  77.  
  78. 				}
  79.  
  80. 				break;
  81.  
  82. 			case 3:
  83. 				gameSurfaceView.ballx = gameSurfaceView.ballx
  84. 						- gameSurfaceView.ballSpan;
  85. 				gameSurfaceView.bally = gameSurfaceView.bally
  86. 						- gameSurfaceView.ballSpan;
  87. 				// /碰到左壁
  88. 				if (gameSurfaceView.ballx <= 0) {
  89. 					gameSurfaceView.direction = 0;
  90. 				}
  91. 				// 碰到上壁
  92. 				else if (gameSurfaceView.bally <= 0) {
  93. 					gameSurfaceView.direction = 2;
  94. 				}
  95.  
  96. 				break;
  97.  
  98. 			default:
  99. 				break;
  100.  
  101. 			}
  102. 			try {
  103. 				Thread.sleep(100);
  104. 			} catch (Exception e) {
  105. 				// TODO: handle exception
  106. 			}
  107. 		}
  108. 	}
  109.  
  110. 	public void checkCollision(int dirction) {
  111. 		if (gameSurfaceView.ballx >= gameSurfaceView.bannerX
  112. 				- gameSurfaceView.ballSize
  113. 				&& gameSurfaceView.ballx <= gameSurfaceView.bannerX
  114. 						+ gameSurfaceView.bannerWidth) {
  115. 			switch (dirction) {
  116. 			case 1:
  117. 				gameSurfaceView.direction = 0;
  118. 				break;
  119. 			case 2:
  120. 				gameSurfaceView.direction = 3;
  121. 				break;
  122. 			default:
  123. 				break;
  124. 			}
  125. 		} else {
  126. 			// 没有碰到板
  127. 			gameSurfaceView.threadForTimecControl.flag = false;
  128. 			gameSurfaceView.threadForGo.flag = false;
  129. 			gameSurfaceView.status = 2;
  130. 		}
  131.  
  132. 	}
  133. }


 

 

 5.ThreadForTimecControl

 

  1. package com.nyist.wj;
  2.  
  3. public class ThreadForTimecControl extends Thread {
  4. 	//计算生存时间的线程
  5. 	//判断是否胜利的值
  6. 	int highest = 200;
  7. //	游戏界面的引入
  8. 	GameSurfaceView gameSurfaceView;
  9. 	//线程标志位
  10. 	boolean flag = true;
  11.  
  12. 	public ThreadForTimecControl(GameSurfaceView gameSurfaceView) {
  13.  
  14. 		this.gameSurfaceView = gameSurfaceView;
  15. 	}
  16.  
  17. 	@Override
  18. 	public void run() {
  19. 		// TODO Auto-generated method stub
  20. 		while(flag){
  21. 			
  22. 			gameSurfaceView.score++;
  23. 			if (gameSurfaceView.score==highest) {
  24. 				//游戏胜利
  25. 				gameSurfaceView.status=3;
  26. 				//----------------------------------------
  27. 				gameSurfaceView.threadForTimecControl.flag=false;
  28. 				gameSurfaceView.threadForGo.flag=false;
  29. 				
  30. 			}
  31. 			try {
  32. 				Thread.sleep(1000);
  33. 				
  34. 			} catch (Exception e) {
  35. 				// TODO: handle exception
  36. 			}
  37. 		}
  38. 	
  39. 	}
  40.  
  41. }



 

ps：个人总结

小球的初始位置确定

代码是

  1. 	// 初始化小球位置
  2. 		bally = screenHeight - bottomSpance - bannerHeight - ballSize;
  3. 		ballx = screenWidth / 2 - ballSize / 2;
  4. 		// 初始化板X坐标
  5. 		bannerX = screenWidth / 2 - bannerWidth / 2;
  6. 		bannerY = screenHeight - bottomSpance - bannerHeight;


 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/132918
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号