Libgdx tutorial beginner Part 5 – Collision, Camera

Like the previous part for animations heere we will look into collision and camera logic.

Bounds is a rectangle that we check for collision with tiles on the map.
We get the tiles for collision using fetchCollidableRects.
We do two checks for collision, one for left/right and the other for top/bottom
In fetchCollidableRects we get the tiles around the player, in case CUBE is fixed we also get its tile


	private void tryMove () {

		bounds.x += vel.x;

		fetchCollidableRects();

		for (int i = 0; i < collisionRectangles.length; i++) {
			Rectangle rect = collisionRectangles[i];
			if (bounds.overlaps(rect)) {
				if (vel.x < 0)
					bounds.x = rect.x + rect.width + 0.01f;
				else
					bounds.x = rect.x - bounds.width - 0.01f;
				vel.x = 0;
			}
		}

		bounds.y += vel.y;

		fetchCollidableRects();

		for (int i = 0; i < collisionRectangles.length; i++) {
			Rectangle rect = collisionRectangles[i];
			if (bounds.overlaps(rect)) {
				if (vel.y < 0) {
					bounds.y = rect.y + rect.height + 0.01f;
					grounded = true;
					if (state != DYING && state != SPAWN) state = Math.abs(accel.x) > 0.1f ? RUN : IDLE;
				} else
					bounds.y = rect.y - bounds.height - 0.01f;
				vel.y = 0;
			}
		}

		pos.x = bounds.x - 0.2f;
		pos.y = bounds.y;
	}

private void tryMove () {

bounds.x += vel.x;

fetchCollidableRects();

for (int i = 0; i < collisionRectangles.length; i++) {

Rectangle rect = collisionRectangles[i];

if (bounds.overlaps(rect)) {

if (vel.x < 0)

bounds.x = rect.x + rect.width + 0.01f;

else

bounds.x = rect.x - bounds.width - 0.01f;

vel.x = 0;

}

bounds.y += vel.y;

fetchCollidableRects();

for (int i = 0; i < collisionRectangles.length; i++) {

Rectangle rect = collisionRectangles[i];

if (bounds.overlaps(rect)) {

if (vel.y < 0) {

bounds.y = rect.y + rect.height + 0.01f;

grounded = true;

if (state != DYING && state != SPAWN) state = Math.abs(accel.x) > 0.1f ? RUN : IDLE;

} else

bounds.y = rect.y - bounds.height - 0.01f;

vel.y = 0;

}

pos.x = bounds.x - 0.2f;

pos.y = bounds.y;

}


	private void fetchCollidableRects () {

		int p1x = (int)bounds.x;
		int p1y = (int)Math.floor(bounds.y);
		int p2x = (int)(bounds.x + bounds.width);
		int p2y = (int)Math.floor(bounds.y);
		int p3x = (int)(bounds.x + bounds.width);
		int p3y = (int)(bounds.y + bounds.height);
		int p4x = (int)bounds.x;
		int p4y = (int)(bounds.y + bounds.height);

		int[][] tiles = map.tiles;
		
		int tile1 = tiles[p1x][map.tiles[0].length - 1 - p1y];
		int tile2 = tiles[p2x][map.tiles[0].length - 1 - p2y];
		int tile3 = tiles[p3x][map.tiles[0].length - 1 - p3y];
		int tile4 = tiles[p4x][map.tiles[0].length - 1 - p4y];

		if (state != DYING && (map.isDeadly(tile1) || map.isDeadly(tile2) || map.isDeadly(tile3) || map.isDeadly(tile4))) {
			state = DYING;
			stateTime = 0;
		}

		if (tile1 == Map.TILE)
		{
			collisionRectangles[0].set(p1x, p1y, 1, 1);
		}
		else
		{
			collisionRectangles[0].set(-1, -1, 0, 0);
		}
		if (tile2 == Map.TILE)
		{
			collisionRectangles[1].set(p2x, p2y, 1, 1);
		}
		else
		{
			collisionRectangles[1].set(-1, -1, 0, 0);
		}
		if (tile3 == Map.TILE)
		{
			collisionRectangles[2].set(p3x, p3y, 1, 1);
		}
		else
		{
			collisionRectangles[2].set(-1, -1, 0, 0);
		}
		if (tile4 == Map.TILE)
		{
			collisionRectangles[3].set(p4x, p4y, 1, 1);
		}
		else
		{
			collisionRectangles[3].set(-1, -1, 0, 0);
		}

		if (map.cube.state == Cube.FIXED) {
			collisionRectangles[4].x = map.cube.bounds.x;
			collisionRectangles[4].y = map.cube.bounds.y;
			collisionRectangles[4].width = map.cube.bounds.width;
			collisionRectangles[4].height = map.cube.bounds.height;
		} else
			collisionRectangles[4].set(-1, -1, 0, 0);
	}

private void fetchCollidableRects () {

int p1x = (int)bounds.x;

int p1y = (int)Math.floor(bounds.y);

int p2x = (int)(bounds.x + bounds.width);

int p2y = (int)Math.floor(bounds.y);

int p3x = (int)(bounds.x + bounds.width);

int p3y = (int)(bounds.y + bounds.height);

int p4x = (int)bounds.x;

int p4y = (int)(bounds.y + bounds.height);

int[][] tiles = map.tiles;

int tile1 = tiles[p1x][map.tiles[0].length - 1 - p1y];

int tile2 = tiles[p2x][map.tiles[0].length - 1 - p2y];

int tile3 = tiles[p3x][map.tiles[0].length - 1 - p3y];

int tile4 = tiles[p4x][map.tiles[0].length - 1 - p4y];

if (state != DYING && (map.isDeadly(tile1) || map.isDeadly(tile2) || map.isDeadly(tile3) || map.isDeadly(tile4))) {

state = DYING;

stateTime = 0;

}

if (tile1 == Map.TILE)

{

collisionRectangles[0].set(p1x, p1y, 1, 1);

}

else

{

collisionRectangles[0].set(-1, -1, 0, 0);

}

if (tile2 == Map.TILE)

{

collisionRectangles[1].set(p2x, p2y, 1, 1);

}

else

{

collisionRectangles[1].set(-1, -1, 0, 0);

}

if (tile3 == Map.TILE)

{

collisionRectangles[2].set(p3x, p3y, 1, 1);

}

else

{

collisionRectangles[2].set(-1, -1, 0, 0);

}

if (tile4 == Map.TILE)

{

collisionRectangles[3].set(p4x, p4y, 1, 1);

}

else

{

collisionRectangles[3].set(-1, -1, 0, 0);

}

if (map.cube.state == Cube.FIXED) {

collisionRectangles[4].x = map.cube.bounds.x;

collisionRectangles[4].y = map.cube.bounds.y;

collisionRectangles[4].width = map.cube.bounds.width;

collisionRectangles[4].height = map.cube.bounds.height;

} else

collisionRectangles[4].set(-1, -1, 0, 0);

}

OrthographicCamera is our camera that follows bob. Constructs a new OrthographicCamera, using the given viewport width and height.
At start it will be positioned in the same position as Bob.
To change its position we are using lerp. Lerp linearly interpolates between this vector and the target vector by alpha which is in the range [0,1]. The result is stored in this vector.
If we are following cube, cubes position will be used.


	public void render (float deltaTime) {
		
		if (map.cube.state != Cube.CONTROLLED){
			cam.position.lerp(lerpTarget.set(map.bob.pos.x, map.bob.pos.y, 0), 2f * deltaTime);
		}else{
			cam.position.lerp(lerpTarget.set(map.cube.pos.x, map.cube.pos.y, 0), 2f * deltaTime);

		}
		
		cam.update();

		cache.setProjectionMatrix(cam.combined);
		
		Gdx.gl.glDisable(GL20.GL_BLEND);
		cache.begin();
		
		for (int blockY = 0; blockY < 4; blockY++) {
			for (int blockX = 0; blockX < 6; blockX++) {
				cache.draw(blocks[blockX][blockY]);
			}
		}
		
		cache.end();
		stateTime += deltaTime;
		
		batch.setProjectionMatrix(cam.combined);
		batch.begin();

		renderBob();
		renderCube();
		renderDispensers();

		batch.end();

	}

public void render (float deltaTime) {

if (map.cube.state != Cube.CONTROLLED){

cam.position.lerp(lerpTarget.set(map.bob.pos.x, map.bob.pos.y, 0), 2f * deltaTime);

}else{

cam.position.lerp(lerpTarget.set(map.cube.pos.x, map.cube.pos.y, 0), 2f * deltaTime);

}

cam.update();

cache.setProjectionMatrix(cam.combined);

Gdx.gl.glDisable(GL20.GL_BLEND);

cache.begin();

for (int blockY = 0; blockY < 4; blockY++) {

for (int blockX = 0; blockX < 6; blockX++) {

cache.draw(blocks[blockX][blockY]);

}

cache.end();

stateTime += deltaTime;

batch.setProjectionMatrix(cam.combined);

batch.begin();

renderBob();

renderCube();

renderDispensers();

batch.end();

}

This entry was posted in Libgdx and tagged libgdx,platformer on June 5, 2014

Libgdx tutorial beginner Part 5 – Collision, Camera

Recent Posts

Categories