libgdx游戏引擎开发笔记（十一）SuperJumper游戏例子的讲解（篇五）---- .游戏中的物体的创建
游戏中物体比较多，这里源码里用了两个类封装了游戏中物体的主要属性，方便游戏中物体的封装。
1.GameObject类：
package com.zhf.mylibgdx;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;
/**
* 所有的游戏物体都会在一个平面内绘制（或者说在屏幕大小内绘制），那么所有的物体都应该包含一个位置(position) 和一个作用范围(bounds)
* @author ZHF
*
*/
public class GameObject {
public final Vector2 position; //位置
public final Rectangle bounds; //作用范围
/**postion在这里是指游戏物体的中心点，而bounds中的x ，y 坐标是指这个游戏原素在屏幕坐标系中的作用起点，也就是矩形的左下角顶点**/
public GameObject(float x, float y, float width, float height) {
this.position = new Vector2(x, y);
this.bounds = new Rectangle(x - width / 2, y - height / 2, width, height);
}
}
2.DynamicGameObject类
package com.zhf.mylibgdx;
import com.badlogic.gdx.math.Vector2;
/**
* 会移动的游戏物体
* @author ZHF
*
*/
public class DynamicGameObject extends GameObject {
//包含了 x, y 轴方向相关的运动信息。
public final Vector2 velocity; //速度
public final Vector2 accel; //加速度
public DynamicGameObject (float x, float y, float width, float height) {
super(x, y, width, height);
velocity = new Vector2();
accel = new Vector2();
}
}
接下来就是让游戏中的物体来分别根据自己的情况去继承它们：
Bob ------> 主角
Castle -----> 城堡
Coin -----> 金币
Platform ------> 平台
Spring -------> 弹簧
Squirrel -------> 空中飞行的松鼠
这里我们先将这六个类写出来，待会实现一下跳板是如何显示出来，我们就大体知道了整个游戏的逻辑了。ok！ 上代码！
1.Bob类：
package com.zhf.mylibgdx;
/**
* 主角
* @author ZHF
*
*/
public class Bob extends DynamicGameObject {
//主角状态
public static final int BOB_STATE_JUMP = 0; //跳跃
public static final int BOB_STATE_FALL = 1; //下落
public static final int BOB_STATE_HIT = 2; //碰撞
//速度
public static final float BOB_JUMP_VELOCITY = 11; //跳跃的速度
public static final float BOB_MOVE_VELOCITY = 20; //移动的速度
//宽和高
public static final float BOB_WIDTH = 0.8f;
public static final float BOB_HEIGHT = 0.8f;
int state; //状态
float stateTime; //状态持时间
public Bob(float x, float y) {
super(x, y, BOB_WIDTH, BOB_HEIGHT);
//初始化状态
state = BOB_STATE_FALL;
stateTime = 0;
}
/**刷新**/
public void update (float deltaTime) {
//x,y轴速度的大小
velocity.add(World.gravity.x * deltaTime, World.gravity.y * deltaTime);
//主角当前移动的位置
position.add(velocity.x * deltaTime, velocity.y * deltaTime);
bounds.x = position.x - bounds.width / 2;
bounds.y = position.y - bounds.height / 2;
//跳跃状态
if (velocity.y > 0 && state != BOB_STATE_HIT) {
if (state != BOB_STATE_JUMP) {
state = BOB_STATE_JUMP;
stateTime = 0;
}
}
//下落状态
if (velocity.y < 0 && state != BOB_STATE_HIT) {
if (state != BOB_STATE_FALL) {
state = BOB_STATE_FALL;
stateTime = 0;
}
}
//边界限制
if (position.x < 0) position.x = World.WORLD_WIDTH;
if (position.x > World.WORLD_WIDTH) position.x = 0;
//状态持续时间
stateTime += deltaTime;
}
/**撞到松鼠**/
public void hitSquirrel () {
velocity.set(0, 0);
state = BOB_STATE_HIT;
stateTime = 0;
}
/**撞到跳板**/
public void hitPlatform () {
velocity.y = BOB_JUMP_VELOCITY;
state = BOB_STATE_JUMP;
stateTime = 0;
}
/**撞到弹簧**/
public void hitSpring () {
velocity.y = BOB_JUMP_VELOCITY * 1.5f;
state = BOB_STATE_JUMP;
stateTime = 0;
}
}
2.Castle类：
package com.zhf.mylibgdx;
/**
* 城堡
* @author ZHF
*
*/
public class Castle extends GameObject {
//宽和高
public static float CASTLE_WIDTH = 1.7f;
public static float CASTLE_HEIGHT = 1.7f;
public Castle(float x, float y) {
super(x, y, CASTLE_WIDTH, CASTLE_HEIGHT);
}
}
3.Coin类：
package com.zhf.mylibgdx;
/**
* 金币
* @author ZHF
*
*/
public class Coin extends GameObject {
// 宽和高
public static final float COIN_WIDTH = 0.5f;
public static final float COIN_HEIGHT = 0.8f;
// 金币的分值
public static final int COIN_SCORE = 10;
float stateTime; // 状态持续时间
public Coin(float x, float y) {
super(x, y, COIN_WIDTH, COIN_HEIGHT);
stateTime = 0;
}
/**刷新**/
public void update(float deltaTime) {
stateTime += deltaTime;
}
}
4.Platform类：
package com.zhf.mylibgdx;
/**
* 跳板
* @author ZHF
*
*/
public class Platform extends DynamicGameObject {
//宽和高
public static final float PLATFORM_WIDTH = 2;
public static final float PLATFORM_HEIGHT = 0.5f;
//跳板的类型
public static final int PLATFORM_TYPE_STATIC = 0; //静止
public static final int PLATFORM_TYPE_MOVING = 1; //运动
//跳板的状态
public static final int PLATFORM_STATE_NORMAL = 0; //正常
public static final int PLATFORM_STATE_PULVERIZING = 1; //破碎
public static final float PLATFORM_PULVERIZE_TIME = 0.2f * 4; //破碎所需时间
public static final float PLATFORM_VELOCITY = 2; //跳板移动速度
int type; //类型 ：静止、移动
int state; //状态：正常、破碎
float stateTime; //状态持续时间
public Platform (int type, float x, float y) {
super(x, y, PLATFORM_WIDTH, PLATFORM_HEIGHT);
this.type = type;
this.state = PLATFORM_STATE_NORMAL; //正常状态
this.stateTime = 0;
//若为移动类型，赋值移动速度
if (type == PLATFORM_TYPE_MOVING) {
velocity.x = PLATFORM_VELOCITY;
}
}
/**刷新**/
public void update (float deltaTime) {
//移动跳板
if (type == PLATFORM_TYPE_MOVING) {
//跳板移动位置
position.add(velocity.x * deltaTime, 0);
bounds.x = position.x - PLATFORM_WIDTH / 2;
bounds.y = position.y - PLATFORM_HEIGHT / 2;
//左边界限制
if (position.x < PLATFORM_WIDTH / 2) {
velocity.x = -velocity.x;
position.x = PLATFORM_WIDTH / 2;
}
//右边界限制
if (position.x > World.WORLD_WIDTH - PLATFORM_WIDTH / 2) {
velocity.x = -velocity.x;
position.x = World.WORLD_WIDTH - PLATFORM_WIDTH / 2;
}
}
//状态持续时间
stateTime += deltaTime;
}
/**破碎**/
public void pulverize () {
state = PLATFORM_STATE_PULVERIZING;
stateTime = 0;
velocity.x = 0;
}
}
5.Spring类：
package com.zhf.mylibgdx;
/**
* 弹簧
* @author ZHF
*
*/
public class Spring extends GameObject {
//宽和高
public static float SPRING_WIDTH = 0.3f;
public static float SPRING_HEIGHT = 0.3f;
public Spring(float x, float y) {
super(x, y, SPRING_WIDTH, SPRING_HEIGHT);
}
}
6.Squirrel类：
package com.zhf.mylibgdx;
/**
* 松鼠
* @author ZHF
*
*/
public class Squirrel extends DynamicGameObject {
//宽和高
public static final float SQUIRREL_WIDTH = 1;
public static final float SQUIRREL_HEIGHT = 0.6f;
//速度
public static final float SQUIRREL_VELOCITY = 3f;
float stateTime = 0; //状态持续时间
public Squirrel (float x, float y) {
super(x, y, SQUIRREL_WIDTH, SQUIRREL_HEIGHT);
//为松鼠x轴方向赋值
velocity.set(SQUIRREL_VELOCITY, 0);
}
/**刷新**/
public void update (float deltaTime) {
//松鼠移动位置
position.add(velocity.x * deltaTime, velocity.y * deltaTime);
bounds.x = position.x - SQUIRREL_WIDTH / 2;
bounds.y = position.y - SQUIRREL_HEIGHT / 2;
//左边界限制
if (position.x < SQUIRREL_WIDTH / 2) {
position.x = SQUIRREL_WIDTH / 2;
velocity.x = SQUIRREL_VELOCITY;
}
//右边界限制
if (position.x > World.WORLD_WIDTH - SQUIRREL_WIDTH / 2) {
position.x = World.WORLD_WIDTH - SQUIRREL_WIDTH / 2;
velocity.x = -SQUIRREL_VELOCITY;
}
//状态持续时间
stateTime += deltaTime;
}
}
以上就是游戏中六个物体类的代码，都十分的相似，代码里都注释了，这里不再一一讲解，可能有些变量没有完全写出，大家还是以源码为主，接下来我们要干的工作就是如何在游戏界面里显示出跳板？
首先，在World类中：
package com.zhf.mylibgdx;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import com.badlogic.gdx.math.Vector2;
/**
* 统一管理世界中各个部分
* @author ZHF
*
*/
public class World {
/**世界监听器接口**/
public interface WorldListener {
//跳跃
public void jump ();
//高跳
public void highJump ();
//碰撞
public void hit ();
//收集金币
public void coin ();
}
//宽和高
public static final float WORLD_WIDTH = 10;
public static final float WORLD_HEIGHT = 15 * 20;
//状态
public static final int WORLD_STATE_RUNNING = 0; //运行
public static final int WORLD_STATE_NEXT_LEVEL = 1; //下一关
public static final int WORLD_STATE_GAME_OVER = 2; //游戏结束
//世界监听器
public WorldListener listener;
//重力
public static final Vector2 gravity = new Vector2(0, -12);
//随机数
public Random rand;
//游戏中物体
public final List<Platform> platforms; //跳板
public World(WorldListener listener) {
this.listener = listener;
this.platforms = new ArrayList<Platform>();
rand = new Random();
generateLevel();
}
/**生成关卡中除了Bob外所有的物体**/
private void generateLevel() {
float y = Platform.PLATFORM_HEIGHT / 2;
float maxJumpHeight = Bob.BOB_JUMP_VELOCITY * Bob.BOB_JUMP_VELOCITY / (2 * -gravity.y);
while (y < WORLD_HEIGHT - WORLD_WIDTH / 2) {
int type = rand.nextFloat() > 0.8f ? Platform.PLATFORM_TYPE_MOVING : Platform.PLATFORM_TYPE_STATIC;
float x = rand.nextFloat() * (WORLD_WIDTH - Platform.PLATFORM_WIDTH) + Platform.PLATFORM_WIDTH / 2;
Platform platform = new Platform(type, x, y);
platforms.add(platform);
y += (maxJumpHeight - 0.5f);
y -= rand.nextFloat() * (maxJumpHeight / 3);
}
}
/**刷新界面**/
public void update(float deltaTime, float accelX) {
updatePlatforms(deltaTime);
}
/**刷新跳板**/
private void updatePlatforms(float deltaTime) {
int len = platforms.size();
for (int i = 0; i < len; i++) {
Platform platform = platforms.get(i);
//取出集合中的跳板对象，调用其自身的刷新方法
platform.update(deltaTime);
//若状态为破碎状态，将该跳板对象移除出去
if (platform.state == Platform.PLATFORM_STATE_PULVERIZING && platform.stateTime > Platform.PLATFORM_PULVERIZE_TIME) {
platforms.remove(platform);
len = platforms.size();
}
}
}
}
分析：这里我们还是在上一讲的代码的基础上，增加了platform对象及其实例化，还有与其相关的刷新方法。最重要的是在World的构造方法中，初始化跳板集合，并且调用了 generateLevel()方法来生成关卡中除了Bob外所有的物体。
游戏中物体的创建主要是围绕Platform来生成的。在While循环内，通过不断增加y坐标的值，使用随机数rand 和 物体的内置属性来生成不同的游戏物体。比如，对于Playform 有移动和不移动两种，同时它内置的宽度为2（每单位为32个像素），高度为0.5，结合rand就能达到随机生成Playform的效果。
其次就是WorldRenderer类：
package com.zhf.mylibgdx;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
/**
* 用来把每个对象关联相应的图片资源，同时控制相机，实现动画。
* @author ZHF
*
*/
public class WorldRenderer {
//宽和高
static final float FRUSTUM_WIDTH = 10;
static final float FRUSTUM_HEIGHT = 15;
World world; //世界
OrthographicCamera cam; //相机
SpriteBatch batch; //用于绘画
TextureRegion background; //背景图片
public WorldRenderer(SpriteBatch batch, World world) {
this.world = world;
//OrthographicCamera 被定义成 宽度为10，高度为15，同样的也把相机对准中心点。
this.cam = new OrthographicCamera(FRUSTUM_WIDTH, FRUSTUM_HEIGHT);
//它指定了和屏幕一样大小的 OrthographicCamera ，并把相机对准屏幕的中心。
this.cam.position.set(FRUSTUM_WIDTH / 2, FRUSTUM_HEIGHT / 2, 0);
this.batch = batch;
}
/**渲染**/
public void render () {
cam.update();
//它的作用都是通过把映射矩阵绑定给SpritBatch，告诉SpritBatch怎么去绘制图形
batch.setProjectionMatrix(cam.combined);
//渲染背景
renderBackground();
//渲染游戏中各种元素（Bob,跳板，松鼠，弹簧。。）下一讲中会具体讲到
renderObjects();
}
/**渲染游戏中各种物体（Bob,跳板，松鼠，弹簧，城堡，金币）**/
private void renderObjects() {
batch.enableBlending();
batch.begin();
//绘制跳板
renderPlatforms();
batch.end();
}
/**渲染背景**/
public void renderBackground () {
batch.disableBlending();
batch.begin();
batch.draw(Assets.backgroundRegion, cam.position.x - FRUSTUM_WIDTH / 2, cam.position.y - FRUSTUM_HEIGHT / 2, FRUSTUM_WIDTH,
FRUSTUM_HEIGHT);
batch.end();
}
/**渲染跳板**/
private void renderPlatforms () {
int len = world.platforms.size();
for (int i = 0; i < len; i++) {
Platform platform = world.platforms.get(i);
TextureRegion keyFrame = Assets.platform;
// if (platform.state == Platform.PLATFORM_STATE_PULVERIZING) {
// keyFrame = Assets.brakingPlatform.getKeyFrame(platform.stateTime, Animation.ANIMATION_NONLOOPING);
// }
batch.draw(keyFrame, platform.position.x - 1, platform.position.y - 0.25f, 2, 0.5f);
}
}
}
分析：
1.在该类中，我们写了一个方法renderObjects()用于渲染游戏中各种物体（Bob,跳板，松鼠，弹簧，城堡，金币）
2.渲染跳板renderPlatforms ()方法里我们取出集合中的跳板对象，对应加载资源，并将其绘制出来。
最后，就是在Asset类中加载跳板资源
声明：
//游戏中各种物体 public static TextureRegion platform; //跳板
实例化：
//游戏中各个物体
platform = new TextureRegion(items, 64, 160, 64, 16); //跳板
运行一下，效果图：（每次运行起来跳板的位置都是随机的）
目前游戏还是没有主人公哦，在下一讲中，我们会加上主人公，同时显示出其他游戏物体，当然还有最重要的游戏碰撞检测，以及场景的移动。
源码下载：http://down.51cto.com/data/896982