PlayingGameState.java

package uk.co.flyingsquirrels.gamestates;

import org.jbox2d.collision.AABB;
import org.jbox2d.common.Vec2;
import org.jbox2d.dynamics.World;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.state.BasicGameState;
import org.newdawn.slick.state.StateBasedGame;

import uk.co.flyingsquirrels.AdAstra;
import uk.co.flyingsquirrels.SelfRenderable;
import uk.co.flyingsquirrels.models.Ground;
import uk.co.flyingsquirrels.models.Vehicle;
import uk.co.flyingsquirrels.rendering.AdAstraDebugDraw;

public class PlayingGameState extends BasicGameState {

	public static final int ID = 3;

	private static final int WORLD_STEP_ITERATIONS = 10;

	private static final int VIEW_SCALE_FACTOR = 10;

	private static final int WORLD_WIDTH = 16000;
	private static final int WORLD_HEIGHT = 16000;
	private static final int GROUND_RESOLUTION = 100;
	private static final int MAX_GROUND_ELEVATION = 3;
	private static final int MIN_GROUND_ELEVATION = -100;

	private StateBasedGame game;

	private int viewTransX;
	private int viewTransY;
	private World world;
	private AdAstraDebugDraw debugDraw;

	private Vehicle vehicle;


	@Override
	public int getID() {
		return ID;
	}

	public void init(GameContainer container, StateBasedGame game)
			throws SlickException {
		this.game = game;
		viewTransX = AdAstra.DISPLAY_WIDTH / VIEW_SCALE_FACTOR / 2;
		viewTransY = AdAstra.DISPLAY_HEIGHT / VIEW_SCALE_FACTOR / 2;
		debugDraw = new AdAstraDebugDraw(container.getDefaultFont());

		createWorld();
		createGround();
		
		createVehicle();
		vehicle.setPosition(new Vec2(0, MAX_GROUND_ELEVATION).add(vehicle
				.getInitialPosition()));
		vehicle.setVelocity(vehicle.getInitialVelocity());
	}

	private void createWorld() {
		AABB worldAABB = new AABB();
		worldAABB.lowerBound = new Vec2(-WORLD_WIDTH, MIN_GROUND_ELEVATION);
		worldAABB.upperBound = new Vec2(WORLD_WIDTH, WORLD_HEIGHT);
		Vec2 gravity = new Vec2(0.0f, -10.0f);
		world = new World(worldAABB, gravity, false);
	}

	private void createGround() {
		new Ground(world, WORLD_WIDTH, GROUND_RESOLUTION, MAX_GROUND_ELEVATION,
				MIN_GROUND_ELEVATION);
	}

	private void createVehicle() {
		Class<? extends Vehicle> selectedVehicleClass = AdAstra
				.getSelectedVehicleClass();
		try {
			vehicle = selectedVehicleClass.getConstructor(World.class)
					.newInstance(world);
		} catch (Exception e) {
			throw new RuntimeException("Could not create new instance of "
					+ selectedVehicleClass, e);
		}
	}

	public void update(GameContainer container, StateBasedGame game, int delta)
			throws SlickException {
		vehicle.handleInput(container.getInput());
		vehicle.update(delta / 1000f);
		world.step(delta / 1000f, WORLD_STEP_ITERATIONS);
	}

	public void render(GameContainer container, StateBasedGame game, Graphics g)
			throws SlickException {
		Vec2 vehiclePosition = vehicle.getPosition();

		g.scale(VIEW_SCALE_FACTOR, -VIEW_SCALE_FACTOR);
		g.translate(-vehiclePosition.x + viewTransX, -1
				* (vehiclePosition.y + viewTransY));

		doDebugDraw(g);

		if (vehicle instanceof SelfRenderable) {
			SelfRenderable selfRenderable = (SelfRenderable) vehicle;
			selfRenderable.renderToWorld(g);
			g.resetTransform();
			selfRenderable.renderToScreen(AdAstra.DISPLAY_WIDTH, AdAstra.DISPLAY_HEIGHT, g);
		}
	}

	private void doDebugDraw(Graphics g) {
		world.setDebugDraw(debugDraw);
		debugDraw.setGraphics(g);
		world.drawDebugData();
		world.setDebugDraw(null);
	}

	public void keyReleased(int key, char c) {
		if (key == Input.KEY_ESCAPE) {
			game.enterState(OptionsMenuGameState.ID);
		}
	}
}