Gravity och Jump funktion i mitt Javaspel

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

import se.egy.graphics.Drawable;

public class Entity implements Drawable{
	// x, y position på figuren i px
	private double x, y;

	// Rörelseriktiningen på entiteten */
	private int dx = 0, dy = 0;

	// Hastigheten på spelfiguren i px/s
	private int speed;

	// Bilden som representerar figuren
	private Image image;

	// Rutnätet med spelplanen
	private Map map;
	
	// Värde i rutnätet som inte spelfiguren kan gå till, typ en vägg.
	private int blocked = 1;
	
	// jump value 
	protected boolean jumping = false;
	
	// falling value
	protected boolean falling = true;
	
	// gravity 
	protected double gravity = 0.0;
	
	// maximal hastighet
	protected double maxDY = 0.0;
	
	
	
	
	
	
	
	
	
	
	/**
	 * Konstruktor
	 * 
	 * @param image	bilden som representerar spelfiguren
	 * @param map	rutnätet med spelplanen
	 * @param x		x-position på skärmen
	 * @param y		y-position på skärmen
	 * @param speed	rörelsehastighet i px/s som figuren skall röra sig med
	 * @param gravity graviditeten spelaren ska ha
	 */
	
	
	public Entity(Image image, Map map, double x, double y, int speed) {
		this.image = image;
		this.map = map;
		this.x = x;
		this.y = y;
		this.speed = speed;
		this.gravity = 0.5;
		this.falling = true;
		this.jumping = false;
	}


	/**
	 * Förflyttar spelfiguren beroende på förfluten tid
	 * @param deltaTime tid som förflutit sedan förra uppdateringen i nano sekunder
	 */
	public void move(long deltaTime) {
		double nx = x + dx*speed*(deltaTime/200000000.0);
		double ny = y + dy*speed*(deltaTime/200000000.0);


		// Kontrollerar om den nya positionen fungerar
		if (!validLocation(nx, ny)) {
			if (validLocation(nx, y)) {
				// if it doesn't then change our position to the new position
				x = nx;
			}

			if (validLocation(x, ny)) {
				// if it doesn't then change our position to the new position
				y = ny;
			}	
		}else {
			x = nx;
			y = ny;
		}
	}


	/**
	 * Kontrollerar om en position på skärmen inte är blockerd
	 * @param nx
	 * @param ny
	 * @return
	 */
	public boolean validLocation(double nx, double ny) {
		if(hitTile(nx, ny, blocked).x != -1) {
			return false;
		}else {
			return true;
		} 
	}
	

	private Point hitTile(double xPos, double yPos, int tileValue) {
		int x = -1, y = -1;
		
		if (map.getTileFromPx(xPos, yPos) == tileValue) {
			x = (int)xPos/map.getTileSize();
			y = (int)yPos/map.getTileSize();
			return new Point(x, y);
		}
		if (map.getTileFromPx(xPos + image.getWidth(null)-1, yPos) == tileValue) {
			x = (int)(xPos + image.getWidth(null)-1)/map.getTileSize();
			y = (int)yPos/map.getTileSize();
			return new Point(x, y);
		}
		if (map.getTileFromPx(xPos + image.getWidth(null)-1, yPos + image.getHeight(null)-1) == tileValue) {
			x = (int)(xPos + image.getWidth(null)-1)/map.getTileSize();
			y = (int)(yPos + image.getHeight(null)-1)/map.getTileSize();
			return new Point(x, y);
		}
		if (map.getTileFromPx(xPos, yPos + image.getHeight(null)-1) == tileValue) {
			x = (int)(xPos)/map.getTileSize();
			y = (int)(yPos + image.getHeight(null)-1)/map.getTileSize();
			return new Point(x, y);
		}
		
		return new Point(x, y);
	}
	/**
	 * Kontrollerar om spelfiguren ligger på en ruta med ett visst värde.
	 * 
	 * @param tileValue
	 * @return koordinaten på rutan i rutnätet med sökt värde Om den inte finns returneras(-1,-1)
	 */
	public Point  hitTile(int tileValue) {		
		return hitTile(x, y, tileValue);
	}
	/**
	 * Draw this entity to the graphics context provided.
	 * 
	 * @param g The graphics context to which the entity should be drawn
	 */
	public void draw(Graphics2D g) {
		g.drawImage(image, (int)x, (int)y, null);
	}

	// Getters och Setters
	public int getDx() {
		return dx;
	}

	public void setDx(int dx) {
		this.dx = dx;
	}

	public int getDy() {
		return dy;
	}

	public void setDy(int dy) {
		this.dy = dy;
	}


	public double getX() {
		return x;
	}


	public void setX(double x) {
		this.x = x;
	}


	public double getY() {
		return y;
	}


	public void setY(double y) {
		this.y = y;
		
	}
	
	
	// Falling funktion
	
protected void fall() {
	if(falling) {
		dy += gravity;
		if(dy > maxDY) dy = (int) maxDY;
	}
	
}
	

	
}

import java.awt.Image;
import java.awt.Point;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.HashMap;
import javax.swing.ImageIcon;
import se.egy.graphics.GameScreen;


public class Game implements KeyListener {

	boolean gameRunning = true;
	int points = 0;
	
	private HashMap<String, Boolean> keyDown = new HashMap<String, Boolean>();

	private Map map;

	private Entity player;

	private GameScreen gameScreen = new GameScreen("Game", 1215, 576, false); // OBS! Skall Vara false.
	
	
	// Nu kommer klassen 
	
	
	

	public Game(){
		map = new Map("map2.txt", 32);
		gameScreen.setBackground(map);
		
		gameScreen.setKeyListener(this);
		
		keyDown.put("left", false);
		keyDown.put("right", false);
		keyDown.put("up", false);
		keyDown.put("down", false);

		loadImages();
		gameLoop();
	}

	public void loadImages(){
		Image img = new ImageIcon(getClass().getResource("/rsz_clank.png")).getImage();		
		player = new Entity(img, map, 45, 45, 40);
	}

	public void update(long delta){

		player.setDx(0);
		player.setDy(0);
		
		if (keyDown.get("left")) {
			player.setDx(-1);
		}
		if (keyDown.get("right")) {
			player.setDx(1);
		}
		if (keyDown.get("up")) {
			player.setDy(-1);
		}
		if (keyDown.get("down")) {
			player.setDy(1);;
		}

		player.move(delta);
		
		Point hitTile = player.hitTile(2);
		
		if(hitTile.x != -1) {
			points++;
			map.setTile(hitTile.x, hitTile.y, 0);
		}
	}

	public void render(){
		gameScreen.render(player);
	}

	public void gameLoop(){
		long last = System.nanoTime();
		while(gameRunning){
			long delta = (System.nanoTime() - last);
			last = System.nanoTime();
			update(delta);
			render();
			// Fördröjning
			try { Thread.sleep(4); } catch (Exception e) {};
		}
	}

	/** Spelets tangentbordslyssnare */
	public void keyTyped(KeyEvent e) {
	}

	public void keyPressed(KeyEvent e) {
		// check the keyboard and record which keys are pressed

		if (e.getKeyCode() == KeyEvent.VK_LEFT) {
			keyDown.put("left", true);
		}
		if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
			keyDown.put("right", true);
		}
		if (e.getKeyCode() == KeyEvent.VK_DOWN) {
			keyDown.put("down", true);
		}
		if (e.getKeyCode() == KeyEvent.VK_UP) {
			keyDown.put("up", true);
		}
	}

	public void keyReleased(KeyEvent e) {
		// check the keyboard and record which keys are released

		if (e.getKeyCode() == KeyEvent.VK_LEFT) {
			keyDown.put("left", false);
		}
		if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
			keyDown.put("right", false);
		}
		if (e.getKeyCode() == KeyEvent.VK_DOWN) {
			keyDown.put("down", false);
		}
		if (e.getKeyCode() == KeyEvent.VK_UP) {
			keyDown.put("up", false);
		}
	}

	public static void main(String[] args) {
		new Game();
	}
}