Currently showing ../../collision/tilemaps/src/org/newdawn/tilemap/Entity.java Line Numbers: [show|hide]

package org.newdawn.tilemap;

import java.awt.Graphics2D;
import java.awt.Image;

/**
 * A single entity moving round our map. It maintains its position 
 * in terms of grid cells. Note that the positions are floating 
 * point numbers allowing us to be partially across a cell.
 * 
 * @author Kevin Glass
 */
public class Entity {
	/** The x position of this entity in terms of grid cells */
	private float x;
	/** The y position of this entity in terms of grid cells */
	private float y;
	/** The image to draw for this entity */
	private Image image;
	/** The map which this entity is wandering around */
	private Map map;
	/** The angle to draw this entity at */
	private float ang;
	/** The size of this entity, this is used to calculate collisions with walls */
	private float size = 0.3f;
	
	/**
	 * Create a new entity in the game
	 * 
	 * @param image The image to represent this entity (needs to be 32x32)
	 * @param map The map this entity is going to wander around
	 * @param x The initial x position of this entity in grid cells
	 * @param y The initial y position of this entity in grid cells
	 */
	public Entity(Image image, Map map, float x, float y) {
		this.image = image;
		this.map = map;
		this.x = x;
		this.y = y;
	}
	
	/**
	 * Move this entity a given amount. This may or may not succeed depending
	 * on collisions
	 * 
	 * @param dx The amount to move on the x axis
	 * @param dy The amount to move on the y axis
	 * @return True if the move succeeded
	 */
	public boolean move(float dx, float dy) {
		// work out what the new position of this entity will be

		float nx = x + dx;
		float ny = y + dy;
		
		// check if the new position of the entity collides with

		// anything

		if (validLocation(nx, ny)) {
			// if it doesn't then change our position to the new position

			x = nx;
			y = ny;
			
			// and calculate the angle we're facing based on our last move

			ang = (float) (Math.atan2(dy, dx) - (Math.PI / 2));
			return true;
		}
		
		// if it wasn'n't do anything apart from 
		// tell the caller

		return false;
	}
	
	/**
	 * Check if the entity would be at a valid location if its position
	 * was as specified
	 * 
	 * @param nx The potential x position for the entity
	 * @param ny The potential y position for the entity
	 * @return True if the new position specified would be valid
	 */
	public boolean validLocation(float nx, float ny) {
		// here we're going to check some points at the corners of

		// the player to see whether we're at an invalid location

		// if any of them are blocked then the location specified

		// isn't valid

		if (map.blocked(nx - size, ny - size)) {
			return false;
		}
		if (map.blocked(nx + size, ny - size)) {
			return false;
		}
		if (map.blocked(nx - size, ny + size)) {
			return false;
		}
		if (map.blocked(nx + size, ny + size)) {
			return false;
		}
		
		// if all the points checked are unblocked then we're in an ok

		// location

		return true;
	}
	
	/**
	 * Draw this entity to the graphics context provided.
	 * 
	 * @param g The graphics context to which the entity should be drawn
	 */
	public void paint(Graphics2D g) {
		// work out the screen position of the entity based on the

		// x/y position and the size that tiles are being rendered at. So

		// if we'e'd render on screen 
		// at 15,15.

		int xp = (int) (Map.TILE_SIZE * x);
		int yp = (int) (Map.TILE_SIZE * y);
		
		// rotate the sprite based on the current angle and then

		// draw it

		g.rotate(ang, xp, yp);
		g.drawImage(image, (int) (xp - 16), (int) (yp - 16), null);
		g.rotate(-ang, xp, yp);
	}
}

Total 123 Lines of Code.
Source code formatted using showsrc by William Denniss