Android游戏开发学习之引擎用法实例详解

本文实例讲述了Android游戏开发学习之引擎用法。分享给大家供大家参考。具体如下：

汽车引擎是汽车的心脏，其决定了汽车的性能和稳定性，是人们在购车时相当关注的。而游戏中的物理引擎就如汽车的引擎一样，占据了非常重要的位置。一款好的物理引擎可以非常真实地模拟现实世界，使得游戏更加逼真，提供更好的娱乐体验。

一、JBox2D简介

JBox2D是开源物理引擎Box2D的Java版本，可以直接用于Android。由于JBox2D的图形渲染使用的是Processing库，因此在Android平台上使用JBox2D时，图形渲染工作只能自行开发。该引擎能够根据开发人员设定的参数，如重力、密度、摩擦系数和弹性系数等，自动地进行2D刚体物理运动的全方位模拟。

二、示例

1.小球弹跳进阶版

在第1节中小球的下落、碰撞、弹起都是用代码来维护的，下面使用物理引擎来实现，并且加入了刚体之间的碰撞。

(1)常量类Constant

package box2d.bheap;
public class Constant {
  public static final float RATE=10; //屏幕与现实世界的比例
  public static final boolean DRAW_THREAD_FLAG=true; //绘制线程工作标识位
  public static final float TIME_STEP=2.0f/60.0f; //模拟的频率
  public static final int ITERA=10; //迭代次数
  public static int SCREEN_WIDTH; //屏幕宽度
  public static int SCREEN_HEIGHT; //屏幕高度
}

(2)抽象类MyBody

该类为自定义的抽象类，是所有自定义刚体类的基类。由于JBox2D中的刚体类对象仅具有物理仿真计算的功能，并没有提供Android平台下的绘制功能，直接使用不是很方便。因此，这里定义了MyBody对自定义刚体的绘制及JBox2D物理仿真对象进行了封装。

package box2d.bheap;
import org.jbox2d.dynamics.Body;
import android.graphics.Canvas;
import android.graphics.Paint;
public abstract class MyBody {
  Body body; //JBox2D物理引擎中的刚体
  int color; //刚体的颜色
  public abstract void drawSelf(Canvas canvas,Paint paint); //绘制的方法
}

(3)圆形刚体类MyCircleColor

package box2d.bheap;
import org.jbox2d.dynamics.Body;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import static box2d.bheap.Constant.*; //静态导入
public class MyCircleColor extends MyBody {
  float radius; //圆形半径
  public MyCircleColor(Body body,float radius,int color) {
    this.body=body;
    this.radius=radius;
    this.color=color;
  }
  @Override
  public void drawSelf(Canvas canvas, Paint paint) {
    paint.setColor(color&0xCFFFFFF); //设置颜色
    float x=body.getPosition().x*RATE;
    float y=body.getPosition().y*RATE;
    canvas.drawCircle(x, y, radius, paint); //画圆
    paint.setStyle(Style.STROKE); //设置空心无填充
    paint.setStrokeWidth(1);
    paint.setColor(color); //画边
    canvas.drawCircle(x, y, radius, paint);
    paint.reset(); //恢复画笔设置
  }
}

(4)矩形刚体类MyRectColor

package box2d.bheap;
import static box2d.bheap.Constant.RATE;
import org.jbox2d.dynamics.Body;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
public class MyRectColor extends MyBody {
  float halfWidth;//半宽
  float halfHeight;//半高
  public MyRectColor(Body body,float halfWidth,float halfHeight,int color)
  {
    this.body=body;
    this.halfWidth=halfWidth;
    this.halfHeight=halfHeight;
    this.color=color;
  }
  public void drawSelf(Canvas canvas,Paint paint)
  {
    paint.setColor(color&0x8CFFFFFF);
    float x=body.getPosition().x*RATE;
    float y=body.getPosition().y*RATE;
    float angle=body.getAngle();
    canvas.save();
    Matrix m1=new Matrix();
    m1.setRotate((float)Math.toDegrees(angle),x, y);
    canvas.setMatrix(m1);
    canvas.drawRect(x-halfWidth, y-halfHeight, x+halfWidth, y+halfHeight, paint);
    paint.setStyle(Paint.Style.STROKE);
    paint.setStrokeWidth(1);//设置线条宽度
    paint.setColor(color);
    canvas.drawRect(x-halfWidth, y-halfHeight, x+halfWidth, y+halfHeight, paint);
    paint.reset();
    canvas.restore();
  }
}

(5)生成刚体形状的工具类Box2DUtil

package box2d.bheap;
import static box2d.bheap.Constant.RATE;
import org.jbox2d.collision.CircleDef;
import org.jbox2d.collision.PolygonDef;
import org.jbox2d.dynamics.Body;
import org.jbox2d.dynamics.BodyDef;
import org.jbox2d.dynamics.World;
public class Box2DUtil {
  /**
   * 创建矩形物体（颜色）
   */
  public static MyRectColor createBox (
      float x,
      float y,
      float halfWidth,
      float halfHeight,
      boolean isStatic, //是否为静止的
      World world,
      int color
  ) {
    PolygonDef shape=new PolygonDef(); //创建多边形描述对象
    if(isStatic) {
      shape.density=0;
    } else {
      shape.density=1.0f;
    }
    shape.friction=0.0f; //设置摩擦系数
    shape.restitution=0.6f; //设置能量损失率
    shape.setAsBox(halfWidth/RATE, halfHeight/RATE);
    BodyDef bodyDef=new BodyDef(); //创建刚体描述对象
    bodyDef.position.set(x/RATE,y/RATE); //设置位置
    Body bodyTemp=world.createBody(bodyDef); //在世界中创建刚体
    bodyTemp.createShape(shape); //指定刚体形状
    bodyTemp.setMassFromShapes(); //设置物体质量
    return new MyRectColor(bodyTemp, halfWidth, halfHeight, color);
  }
  /**
   * 创建圆形物体（颜色）
   */
  public static MyCircleColor createCircle (
      float x,
      float y,
      float radius,
      World world,
      int color
  ) {
    CircleDef shape=new CircleDef(); //创建圆描述对象
    shape.density=2; //设置密度
    shape.friction=0.0f; //设置摩擦系数
    shape.restitution=0.95f; //设置能量损失率
    shape.radius=radius/RATE;//设置半径
    BodyDef bodyDef=new BodyDef(); //创建刚体描述对象
    bodyDef.position.set(x/RATE,y/RATE); //设置位置
    Body bodyTemp=world.createBody(bodyDef); //在世界中创建刚体
    bodyTemp.createShape(shape); //指定刚体形状
    bodyTemp.setMassFromShapes(); //设置物体质量
    return new MyCircleColor(bodyTemp, radius, color);
  }
}

(6)颜色工具类ColorUtil

package box2d.bheap;
public class ColorUtil {
  static int[][] result=
    {
      {56,225,254},
      {41,246,239},
      {34,244,197},
      {44,241,161},
      {65,239,106},
      {45,238,59},
      {73,244,51},
      {99,233,58},
      {129,243,34},
      {142,245,44},
      {187,243,32},
      {232,250,28},
      {242,230,46},
      {248,196,51},
      {244,125,31},
      {247,88,46},
      {249,70,40},
      {249,70,40},
      {248,48,48},
      {250,30,30},
      {252,15,15},
      {255,0,0},
    };
    public static int getColor(int index)
    {
      int[] rgb=result[index%result.length];
      int result=0xff000000;
      result=result|(rgb[0]<<16);
      result=result|(rgb[1]<<8);
      result=result|(rgb[2]);
      return result;
    }
}

(7)主控制类MyBox2dActivity

package box2d.bheap;
import java.util.ArrayList;
import java.util.Random;
import org.jbox2d.collision.AABB;
import org.jbox2d.common.Vec2;
import org.jbox2d.dynamics.World;
import android.app.Activity;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.view.Window;
import android.view.WindowManager;
import static box2d.bheap.Constant.*;
public class MyBox2dActivity extends Activity
{
  AABB worldAABB;//创建 一个管理碰撞的世界
  World world;
  Random random=new Random();
  //物体列表
  ArrayList<MyBody> bl=new ArrayList<MyBody>();
  public void onCreate(Bundle savedInstanceState)
  {
    super.onCreate(savedInstanceState);
    //设置为全屏
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    getWindow().setFlags(WindowManager.LayoutParams. FLAG_FULLSCREEN ,
    WindowManager.LayoutParams. FLAG_FULLSCREEN);
    //设置为横屏模式
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    //获取屏幕尺寸
    DisplayMetrics dm=new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(dm);
    if(dm.widthPixels<dm.heightPixels)
    {
       SCREEN_WIDTH=dm.widthPixels;
       SCREEN_HEIGHT=dm.heightPixels;
    }
    else
    {
      SCREEN_WIDTH=dm.heightPixels;
      SCREEN_HEIGHT=dm.widthPixels;
    }
    worldAABB = new AABB();
    //上下界，以屏幕的左上方为 原点，如果创建的刚体到达屏幕的边缘的话，会停止模拟
    worldAABB.lowerBound.set(-100.0f,-100.0f);
    worldAABB.upperBound.set(100.0f, 100.0f);//注意这里使用的是现实世界的单位
    Vec2 gravity = new Vec2(0.0f,10.0f);
    boolean doSleep = true;
    //创建世界
    world = new World(worldAABB, gravity, doSleep);
    //创建4边
    final int kd=40;//宽度或高度
    MyRectColor mrc=Box2DUtil.createBox(kd/4, SCREEN_HEIGHT/2, kd/4, SCREEN_HEIGHT/2, true,world,0xFFe6e4FF);
    bl.add(mrc);
    mrc=Box2DUtil.createBox(SCREEN_WIDTH-kd/4, SCREEN_HEIGHT/2, kd/4, SCREEN_HEIGHT/2, true,world,0xFFe6e4FF);
    bl.add(mrc);
    mrc=Box2DUtil.createBox(SCREEN_WIDTH/2, kd/4, SCREEN_WIDTH/2, kd/4, true,world,0xFFe6e4FF);
    bl.add(mrc);
    mrc=Box2DUtil.createBox(SCREEN_WIDTH/2, SCREEN_HEIGHT-kd/4, SCREEN_WIDTH/2, kd/4, true,world,0xFFe6e4FF);
    bl.add(mrc);
    //创建砖块
    //砖块间距 行间距为20   模块宽度为10 最多一行为9块
    final int bs=20;
    final int bw=(int)((SCREEN_WIDTH-2*kd-11*bs)/18);
    //============================================================
    for(int i=2;i<10;i++)
    {
      if((i%2)==0)
      {
        //左侧蓝木块
        for(int j=0;j<9-i;j++)
        {
          mrc=Box2DUtil.createBox
          (
            kd/2+bs+bw/2+i*(kd+5)/2+j*(kd+5)+3,
            SCREEN_HEIGHT+bw-i*(bw+kd)/2,
            bw/2,
            kd/2,
            false,
            world,
            ColorUtil.getColor(Math.abs(random.nextInt()))
          );
          bl.add(mrc);
        }
        //右侧蓝木块
        for(int j=0;j<9-i;j++)
        {
          mrc=Box2DUtil.createBox
          (
            3*kd/2+bs-bw/2+i*(kd+5)/2+j*(kd+5)-3,
            SCREEN_HEIGHT+bw-i*(bw+kd)/2,
            bw/2,
            kd/2,
            false,
            world,
            ColorUtil.getColor(Math.abs(random.nextInt()))
          );
          bl.add(mrc);
        }
      }
      if((i%2)!=0)
      {
        for(int j=0;j<10-i;j++)
        {
          mrc=Box2DUtil.createBox
          (
            kd/2+bs+kd/2+(i-1)*(kd+5)/2+j*(kd+5),
            SCREEN_HEIGHT-(kd-bw)/2-(i-1)*(bw+kd)/2,
            kd/2,
            bw/2,
            false,
            world,
            ColorUtil.getColor(Math.abs(random.nextInt()))
          );
          bl.add(mrc);
        }
      }
    }
    mrc=Box2DUtil.createBox
    (
      5*kd+bs+20,
      SCREEN_HEIGHT-(kd+bw)*4-kd,
      bw/2,
      kd/2,
      false,
      world,
      ColorUtil.getColor(Math.abs(random.nextInt()))
    );
    bl.add(mrc);
    //创建球
    MyCircleColor ball=Box2DUtil.createCircle(SCREEN_WIDTH/2-24, kd, kd/2, world,ColorUtil.getColor(Math.abs(random.nextInt())));
    bl.add(ball);
    ball.body.setLinearVelocity(new Vec2(0,50));
    GameView gv= new GameView(this);
    setContentView(gv);
  }
}

(8)显示界面类GameView

package box2d.bheap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;
public class GameView extends SurfaceView implements Callback{
  MyBox2dActivity activity;
  Paint paint;
  DrawThread dt;
  public GameView(MyBox2dActivity activity) {
    super(activity);
    this.activity=activity;
    this.getHolder().addCallback(this);
    paint =new Paint();
    paint.setAntiAlias(true);
    dt=new DrawThread(this);
    dt.start();
  }
  public void onDraw(Canvas canvas) {
    if(canvas==null) {
      return ;
    }
    canvas.drawARGB(255, 255, 255, 255); //设置背景颜色白色
    for (MyBody mb : activity.bl) {
      mb.drawSelf(canvas, paint);
    }
  }
  @Override
  public void surfaceChanged(SurfaceHolder holder, int format, int width,
      int height) {
  }
  @Override
  public void surfaceCreated(SurfaceHolder holder) {
        repaint();
  }
  @Override
  public void surfaceDestroyed(SurfaceHolder holder) {
  }
  public void repaint() {
    SurfaceHolder holder=this.getHolder();
    Canvas canvas=holder.lockCanvas();
    try {
      synchronized(holder){
        onDraw(canvas);
      }
    } catch(Exception e){
      e.printStackTrace();
    } finally {
      if(canvas!=null) {
        holder.unlockCanvasAndPost(canvas);
      }
    }
  }
}

(9)绘制线程类DrawThread

package box2d.bheap;
import static box2d.bheap.Constant.*;
//绘制线程
public class DrawThread extends Thread
{
  GameView gv;
  public DrawThread(GameView gv)
  {
    this.gv=gv;
  }
  @Override
  public void run()
  {
    while(DRAW_THREAD_FLAG)
    {
      gv.activity.world.step(TIME_STEP, ITERA);//开始模拟
      gv.repaint();
      try
      {
        Thread.sleep(20);
      } catch (InterruptedException e)
      {
        e.printStackTrace();
      }
    }
  }
}

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