libgdx游戏引擎开发笔记（十一）SuperJumper游戏例子的讲解（篇五）---- .游戏中的物体的创建

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);
}
}

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();
}
}

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;
}
}

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);
}
}

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;
}
}

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;
}
}

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);
}
}

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;
}
}

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();
}
}
}
}

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);
}
}
}

//游戏中各种物体
public static TextureRegion platform;  //跳板

//游戏中各个物体
platform = new TextureRegion(items, 64, 160, 64, 16);  //跳板