当前位置： 移动技术网 > 移动技术>移动开发>Android > Android游戏开发学习①弹跳小球实现方法

Android游戏开发学习①弹跳小球实现方法

2019年07月24日  | 移动技术网移动技术  | 我要评论

本文实例讲述了android游戏开发学习①弹跳小球实现方法。分享给大家供大家参考。具体如下：

在学习了一点点android之后，觉得有必要记录下来，于是就开了这个新坑，慢慢来填吧。

1.运动体movable类

本例主要模拟了一组大小不一的球以一定的水平初速度从高处落下的运动轨迹。其中的小球为一个可移动物体movable对象，该类中除了包含小球图片对象之外，还包括了如位置坐标、水平速度、垂直速度等一系列用于模拟小球运动的成员变量和一些方法。

movable类：

package com.ball; 
import android.graphics.bitmap; 
import android.graphics.canvas; 
public class movable { 
 int startx = 0;    // 初始x坐标 
 int starty = 0;    // 初始y坐标 
 int x;    // 实时x坐标 
 int y;    // 实时y坐标 
 float startvx = 0f;   // 初始水平方向的速度 
 float startvy = 0f;   // 初始竖直方向的速度 
 float v_x = 0f;    // 实时水平方向的速度 
 float v_y = 0f;   // 实时竖直方向的速度 
 int r;    // 可移动物体半径 
 double timex;   // x方向上的运动时间 
 double timey;   // y方向上的运动时间 
 bitmap bitmap=null;   // 可移动物体图片 
 ballthread bt=null;   // 负责小球移动 
 boolean bfall=false;  // 小球是否已经从木板上下落 
 float impactfactor=0.25f;  // 小球撞地后速度的损失系数 
 public movable(int x,int y,int r,bitmap bitmap) { 
  this.startx=x; 
  this.x=x; 
  this.starty=y; 
  this.y=y; 
  this.r=r; 
  this.bitmap=bitmap; 
  timex=system.nanotime(); // 获取系统时间初始化timex 
  this.v_x=ballview.v_min+(int)((ballview.v_max-ballview.v_min)*math.random()); 
  bt=new ballthread(this); // 创建并启动ballthread 
  bt.start(); 
 } 
 public void drawself(canvas canvas) { 
  canvas.drawbitmap(bitmap,x,y,null); 
 } 
}

startx和starty变量记录每一个运动阶段（如从最高点下落到最低点）开始时小球的初始x、y坐标，在随后的物理计算中，小球的实时x、y坐标将会是初始坐标加上这段时间内的位移。

startvx和startvy是小球每一个运动阶段初始时刻在水平方向x和竖直方向y方向上的速度，两者将用于计算小球的实时速度v_x和v_y。

timex和timey分别代表小球在水平和竖直方向上运动的持续时间，当小球从一个阶段运行到下一个阶段时（如从下落阶段弹起后转入上抛阶段），timex和timey将会被重置。

ballthread对象继承自thread线程类，起到了物理引擎的作用，负责根据物理公式对球的位置坐标等属性进行修改，从而改变球的运动轨迹。

布尔变量bfall用于标识小球是否已经从木板上落下，在程序运行时屏幕的左上部分会有一个木板，所有的小球从木板开始向右进行平抛运动。bfall为false时代表小球仍然在木板上移动，还未落下。

float变量impactfactor作用是当小球撞到地面上后根据其值对小球水平和竖直方向的速度进行衰减。

构造函数中对部分成员变量进行初始化，并启动物理引擎。

构造函数中ballview类的两个常量v_min和v_max分别代表小球水平方向速度的最小值和最大值，此处用于生成小球的随机水平速度。

2.小球物理引擎ballthread类

首先解释一下此物理引擎的工作机制，了解其是如何改变小球的运动轨迹的。
运动阶段，本例中将小球的运动按照竖直方向的速度分为若干个阶段，每个阶段中小球在竖直方向上的速度的大小或者是一直增大（下落），或者是一直减小（上升）。即每当小球在竖直方向上的速度发生改变时（如撞地或达到空中最高点），小球就结束该阶段的运动进入一个新的阶段。

数值计算，在每个阶段开始，都会记录下开始的时间，同时还会记录在这个阶段小球的初始x、y坐标，初始x、y方向上的速度等物理量。之后在这个阶段的运动中，小球的各项实时数据都根据这些记录的物理量以及当前时间计算得出。

为零判断，在小球上升的运动中和小球撞击地面后，都需要判断小球的速度是否为零。但是不同于真实的世界，在程序中小球的各项物理量都是离散的（即每隔固定的时间计算出这些物理量的值），小球实际的运动轨迹为一个个离散点。这种情况下如果还采用判断是否为零的方式就有可能出现错误（如在前一次的计算中小球速度为正，下一次的计算为负，跳过了速度为零这个转折点，小球将永远不可能出现为零这个时刻）。所以在程序中使用了阈值的方式，小球的速度一旦小于某个阈值，就将其认定为零。

ballthread类：

package com.ball; 
public class ballthread extends thread { 
 movable father; // movable对象引用 
 boolean flag = false; // 线程执行标识位 
 int sleepspan = 40; // 休眠时间 
 float g = 200; // 球下落的加速度 
 double current; // 记录当前时间 
 public ballthread(movable father) { 
  this.father = father; 
  this.flag = true; 
 } 
 @override 
 public void run() { 
  while (flag) { 
   current = system.nanotime(); // 获取当前时间，单位为纳秒，处理水平方向上的运动 
   double timespanx = (double) ((current - father.timex) / 1000 / 1000 / 1000); // 获取水平方向走过的时间 
   father.x = (int) (father.startx + father.v_x * timespanx); 
   if (father.bfall) { // 处理竖直方向上的运动，判断球是否已经移出挡板 
    double timespany = (double) ((current - father.timey) / 1000 / 1000 / 1000); 
    father.y = (int) (father.starty + father.startvy * timespany + timespany 
      * timespany * g / 2); 
    father.v_y = (float) (father.startvy + g * timespany); 
    //此处先省略检测和处理特殊事件的代码，随后补全 
   } else if (father.x + father.r / 2 >= ballview.wood_edge) {// 通过x坐标判断球是否移出了挡板 
    father.timey = system.nanotime(); 
    father.bfall = true; // 确定下落 
   } 
   try { 
    thread.sleep(sleepspan); 
   } catch (exception e) { 
    e.printstacktrace(); 
   } 
  } 
 } 
}

代表重力加速度的变量g初始化为200，此值是经过测试得出的较为合理的值。

run方法处理小球在水平方向的运动时，先根据当前时间获得本阶段中从开始到现在小球在水平方向上运动的时间，然后用该阶段中到目前为止小球的位移加上小球在该阶段的初始位置，求出小球此时的x坐标。

run方法处理小球在竖直方向的运动时，先检查小球的bfall是否为true，如果为true表明小球已经可以下落，进行物理计算；如果为false则使用x坐标进行判断是否需要将其设置为true。

使用到的ballview类的常量wood_edge记录着木板图片的最右边的x坐标值，如果小球的水平位置超过该值就需要下落了。

刚才省略的检测代码如下：

// 判断小球是否到达最高点 
if (father.startvy < 0 && math.abs(father.v_y) <= ballview.up_zero) { 
 father.timey = system.nanotime(); 
 father.v_y = 0; 
 father.startvy = 0; 
 father.starty = father.y; 
} 
// 判断小球是否撞地 
if (father.y + father.r * 2 >= ballview.ground_ling && father.v_y > 0) { 
 father.v_x = father.v_x * (1 - father.impactfactor); // 衰减水平方向的速度 
 father.v_y = 0 - father.v_y * (1 - father.impactfactor); // 衰减竖直方向的速度并改变方向 
 if (math.abs(father.v_y) < ballview.down_zero) { // 判断撞地衰减后的速度，太小就停止运动 
  this.flag = false; 
 } else { 
  // 撞地后的速度还可以弹起继续下一阶段的运动 
  father.startx = father.x; 
  father.timex = system.nanotime(); 
  father.starty = father.y; 
  father.timey = system.nanotime(); 
  father.startvy = father.v_y; 
 } 
}

3.视图类ballview

ballview是负责画面渲染的视图类，其中声明了一些物理计算时要使用的静态常量，同时还声明了程序中要绘制的图片资源以及要绘制的小球对象列表。ballview类继承自android.view包下surfaceview类。surfaceview不同于普通的view，其具有不同的绘制机理，适合用于开发游戏程序。使用surfaceview需要实现surfaceholder.callback接口，该接口可以对surfaceview进行编辑等操作，还可以监控surfaceview的变化。

ballview类：

package com.ball; 
import java.util.arraylist; 
import java.util.random; 
import android.content.context; 
import android.content.res.resources; 
import android.graphics.bitmap; 
import android.graphics.bitmapfactory; 
import android.graphics.canvas; 
import android.graphics.color; 
import android.graphics.paint; 
import android.view.surfaceholder; 
import android.view.surfaceholder.callback; 
import android.view.surfaceview; 
import com.bp.r; 
public class ballview extends surfaceview implements callback { 
 public static final int v_max=35; 
 public static final int v_min=15; 
 public static final int wood_edge=60; 
 public static final int ground_ling=450; //代表地面的y坐标，小球下落到此会弹起 
 public static final int up_zero=30; //小球在上升过程中，速度小于该值就算0 
 public static final int down_zero=60; //小球在撞击地面后，速度小于该值就算0 
 bitmap[] bitmaparray =new bitmap[6]; 
 bitmap bmpback; //背景图片 
 bitmap bmpwood; // 挡板图片 
 string fps="fps:n/a"; //用于显示帧速率的字符串 
 int ballnumber =8; //小球数目 
 arraylist<movable> almovable=new arraylist<movable>(); //小球对象数组 
 drawthread dt; //后台屏幕绘制线程 
 public ballview(context activity) { 
  super(activity); 
  getholder().addcallback(this); 
  initbitmaps(getresources()); //初始化图片 
  initmovables(); //初始化小球 
  dt=new drawthread(this,getholder()); //初始化重绘线程 
 } 
 public void initbitmaps(resources r) { 
  bitmaparray[0]=bitmapfactory.decoderesource(r, r.drawable.ball_red_small); 
  bitmaparray[1]=bitmapfactory.decoderesource(r, r.drawable.ball_purple_small); 
  bitmaparray[2]=bitmapfactory.decoderesource(r, r.drawable.ball_green_small); 
  bitmaparray[3]=bitmapfactory.decoderesource(r, r.drawable.ball_red); 
  bitmaparray[4]=bitmapfactory.decoderesource(r, r.drawable.ball_purple); 
  bitmaparray[5]=bitmapfactory.decoderesource(r, r.drawable.ball_green); 
  bmpback=bitmapfactory.decoderesource(r, r.drawable.back); 
  bmpwood=bitmapfactory.decoderesource(r, r.drawable.wood); 
 } 
 public void initmovables() { 
  random r=new random(); 
  for(int i=0;i<ballnumber;i++) { 
   int index=r.nextint(32); 
   bitmap tempbitmap=null; 
   if(i<ballnumber/2) { //如果是初始化前一半球，就从大球中随机找一个 
    tempbitmap=bitmaparray[3+index%3]; 
   } else { //如果是初始化前一半球，就从小球中随机找一个 
    tempbitmap=bitmaparray[index%3]; 
   } 
   //创建movable对象 
   movable m=new movable(0, 70-tempbitmap.getheight(), tempbitmap.getwidth()/2, tempbitmap); 
   almovable.add(m); //加入列表中 
  } 
 } 
 public void dodraw(canvas canvas) { //绘制程序中需要的图片等信息 
  canvas.drawbitmap(bmpback, 0, 0,null); 
  canvas.drawbitmap(bmpwood, 0, 60,null); 
  for (movable m : almovable) { //遍历绘制每个movable对象 
   m.drawself(canvas); 
  } 
  paint p=new paint(); 
  p.setcolor(color.blue); 
  p.settextsize(18); 
  p.setantialias(true); //设置抗锯齿 
  canvas.drawtext(fps, 30, 30, p); //画出帧速率字符串 
 } 
 @override 
 public void surfacechanged(surfaceholder arg0, int arg1, int arg2, int arg3) { 
 } 
 @override 
 public void surfacecreated(surfaceholder arg0) { 
  if(!dt.isalive()) { 
   dt.start(); 
  } 
 } 
 @override 
 public void surfacedestroyed(surfaceholder arg0) { 
  dt.flag=false; 
  dt=null; 
 } 
}

因为bitmaparray数组中的图片分为大尺寸和小尺寸，为了绘制图片时，小尺寸图片不会被挡住，所以先使用大尺寸图片。

dodraw方法会在drawthread中调用，用于绘制图片和帧速率。

4.绘制线程drawthread类

drawthread类：

package com.ball; 
import android.graphics.canvas; 
import android.view.surfaceholder; 
public class drawthread extends thread { 
 ballview bv; 
 surfaceholder surfaceholder; 
 boolean flag=false; 
 int sleepspan=30; 
 long start =system.nanotime(); //记录起始时间，该变量用于计算帧速率 
 int count=0 ; //记录帧数 
 public drawthread(ballview bv,surfaceholder surfaceholder) { 
  this.bv=bv; 
  this.surfaceholder=surfaceholder; 
  this.flag=true; 
 } 
 public void run() { 
  canvas canvas=null; 
  while(flag) { 
   try { 
    canvas=surfaceholder.lockcanvas(null); //获取ballview的画布 
    synchronized (surfaceholder) { 
     bv.dodraw(canvas); 
    } 
   } catch (exception e) { 
    e.printstacktrace(); 
   } finally { 
    if(canvas!=null) { 
     surfaceholder.unlockcanvasandpost(canvas); // surfaceholder解锁，并将画布传回 
    } 
   } 
   this.count++; 
   if(count==20) { //计满20帧时计算一次帧速率 
    count=0; 
    long tempstamp=system.nanotime(); 
    long span=tempstamp-start; 
    start=tempstamp; 
    double fps=math.round(100000000000.0/span*20)/100.0; 
    bv.fps="fps:"+fps; 
   } 
   try { 
    thread.sleep(sleepspan); 
   } catch (interruptedexception e) { 
    e.printstacktrace(); 
   } 
  } 
 } 
}

代码中调用了ballview的屏幕重绘函数dodraw，其实现机制是现将balview的画布加锁，然后调用ballview的dodraw方法对ballview的画布进行重新绘制。最后解锁ballview的画布并将其传回。

计算帧速率的方法是，首先求出程序绘制20帧所消耗的时间span，然后计算100s内能够包含几个span。100s内包含的span个数乘以20就能得出100s内能够绘制几帧，再除以100就可求得1s内绘制的帧数。

5.mainactivity类

mainactivity类：

package com.ball; 
import android.app.activity; 
import android.os.bundle; 
import android.view.window; 
import android.view.windowmanager; 
public class mainactivity extends activity { 
 ballview bv; 
 @override 
 public void oncreate(bundle savedinstancestate) { 
  super.oncreate(savedinstancestate); 
  requestwindowfeature(window.feature_no_title); //设置不显示标题
  getwindow().setflags(windowmanager.layoutparams.flag_fullscreen, windowmanager.layoutparams.flag_fullscreen); //设置全屏
  bv=new ballview(this); 
  setcontentview(bv);
 }
}

运行效果图：

使用到的资源文件：

希望本文所述对大家的android程序设计有所帮助。

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网