collision detection (CLEAN) working

.gitignore

@@ -3,4 +3,5 @@
 /Zoelda/bin/
 /Zoelda/.settings/
 .classpath
-.project
+.project
+*.log

Zoelda/src/main/Entity.java

@@ -0,0 +1,83 @@
+package main;
+
+import ea.Ticker;
+
+public abstract class Entity implements Ticker {
+
+	protected float posX, posY;
+	protected float velX, velY;
+	protected float accelleration = 0.012f;
+	protected float friction = 0.2f;
+	protected float width = 1f, height = 1f;
+
+	@Override
+	public void tick() {
+		posX += velX;
+		posY += velY;
+		velX *= (1f - friction);
+		velY *= (1f - friction);
+		if (velX < 0.001f && velX > -0.001f) {
+			velX = 0f;
+		}
+		if (velY < 0.001f && velY > -0.001f) {
+			velY = 0f;
+		}
+		update();
+	}
+
+	protected abstract void update();
+
+	public void checkTileCollisions(Map map) {
+		for (int x = (int) (posX - 2); x < posX + 2; x++) {
+			for (int y = (int) (posY - 2); y < posY + 2; y++) {
+				if (x >= 0 && x < map.getWidth() && y >= 0 && y < map.getHeight()) {
+					if (map.getTile(x, y).isCollidable()) {
+						if (posY + height / 2 > y && posY - height / 2 < y + 1 && posX + width / 2 > x && posX - width / 2 < x + 1) {
+							float distN = Math.abs((y + 1 + height / 2) - posY);
+							float distE = Math.abs((x + 1 + width / 2) - posX);
+							float distS = Math.abs((y - height / 2) - posY);
+							float distW = Math.abs((x - width / 2) - posX);
+							if (distN <= distE && distN < distS && distN < distW) {
+								onBlockCollision(new boolean[] { true, false, false, false }, x, y);
+							} else if (distE <= distS && distE < distN && distE < distW) {
+								onBlockCollision(new boolean[] { false, true, false, false }, x, y);
+							} else if (distS <= distW && distS < distN && distS < distE) {
+								onBlockCollision(new boolean[] { false, false, true, false }, x, y);
+							} else if (distW <= distS && distW < distN && distW < distE) {
+								onBlockCollision(new boolean[] { false, false, false, true }, x, y);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	public void onBlockCollision(boolean[] sides, int blockX, int blockY) {
+		if (sides[0]) {
+			if (velY < 0) {
+				velY = 0;
+			}
+			posY = blockY + 1 + height / 2;
+		}
+		if (sides[1]) {
+			if (velX < 0) {
+				velX = 0;
+			}
+			posX = blockX + 1 + width / 2;
+		}
+		if (sides[2]) {
+			if (velY > 0) {
+				velY = 0;
+			}
+			posY = blockY - height / 2;
+		}
+		if (sides[3]) {
+			if (velX > 0) {
+				velX = 0;
+			}
+			posX = blockX - width / 2;
+		}
+	}
+
+}

Zoelda/src/main/LivingEntity.java

@@ -0,0 +1,49 @@
+package main;
+
+import ea.ActionFigur;
+import ea.Figur;
+
+public class LivingEntity extends Entity {
+
+	protected boolean side;
+	protected ActionFigur actionFigur;
+	protected float spriteOffsetX, spriteOffsetY;
+
+	public LivingEntity(Figur figur, String name) {
+		actionFigur = new ActionFigur(figur, name);
+	}
+
+	@Override
+	protected void update() {
+		if (velX < 0) {
+			side = true;
+		} else if (velX > 0) {
+			side = false;
+		}
+		int offsetX = (int) ((width * Tile.getSize()) / 2 - (actionFigur.getBreite()) / 2);
+		int offsetY = (int) ((height * Tile.getSize()) / 2 - (actionFigur.getHoehe()) / 2);
+		actionFigur.positionSetzen(posX * Tile.getSize() + offsetX + spriteOffsetX * Tile.getSize(),
+				posY * Tile.getSize() + offsetY + spriteOffsetY * Tile.getSize());
+	}
+
+	protected void moveLeft() {
+		velX -= accelleration;
+	}
+
+	protected void moveRight() {
+		velX += accelleration;
+	}
+
+	protected void moveUp() {
+		velY -= accelleration;
+	}
+
+	protected void moveDown() {
+		velY += accelleration;
+	}
+
+	protected void zustandSetzen(String name) {
+		actionFigur.spiegelXSetzen(side);
+		actionFigur.zustandSetzen(name);
+	}
+}

Zoelda/src/main/Malin.java

@@ -7,27 +7,26 @@ public class Malin extends Game {
 
 	private World world;
 	private Player player;
-	
+
 	public static final int WIDTH = 1440;
 	public static final int HEIGHT = 1056;
-	
+
 	public Malin() {
 		super(WIDTH, HEIGHT);
-		
+
 		player = new Player(this);
-		
+
 		world = new World(player);
 		wurzel.add(world);
-		
+
 		Manager manager = new Manager();
 		manager.anmelden(player, 20);
 	}
 
 	@Override
 	public void tasteReagieren(int code) {
-		
 	}
-	
+
 	public World getWorld() {
 		return world;
 	}

Zoelda/src/main/Map.java

@@ -32,7 +32,11 @@ public class Map extends Knoten {
 		return null;
 	}
 	
-//	public int[][] getCollisionMap(){
-//		
-//	}
+	public int getWidth() {
+		return map.length;
+	}
+	
+	public int getHeight() {
+		return map[0].length;
+	}
 }

Zoelda/src/main/Player.java

@@ -1,202 +1,69 @@
 package main;
 
-import ea.ActionFigur;
-import ea.Rechteck;
 import ea.Taste;
-import ea.Ticker;
 
-public class Player extends ActionFigur implements Ticker {
+public class Player extends LivingEntity {
 
 	private Malin main;
 	private static PlayerSheetLoader loader = new PlayerSheetLoader();
-	private boolean side;
-
-	private float velX, velY;
-	private int oldPosX, oldPosY;
-	private float accelleration = 0.15f;
-	private float friction = 0.2f;
-	private Rechteck hitBox = new Rechteck(0, 0, 0, 0);
 
 	public Player(Malin main) {
 		super(loader.getPlayer(0), "idle_left");
 		this.main = main;
 
-		neuerZustand(loader.getPlayer(1), "idle_right");
-		neuerZustand(loader.getPlayer(2), "walk_left");
-		neuerZustand(loader.getPlayer(3), "walk_right");
-		neuerZustand(loader.getPlayer(4), "strike_left");
-		neuerZustand(loader.getPlayer(5), "strike_right");
-		neuerZustand(loader.getPlayer(6), "swipe_left");
-		neuerZustand(loader.getPlayer(7), "swipe_right");
-		neuerZustand(loader.getPlayer(8), "die");
+		width = 0.7f;
+		height = 0.8f;
+		spriteOffsetY = -0.14f;
+		posX = 4f;
+		posY = 4f;
 
 		loader.getPlayer(0).animationsGeschwindigkeitSetzen(200);
-		loader.getPlayer(1).animationsGeschwindigkeitSetzen(200);
-		loader.getPlayer(2).animationsGeschwindigkeitSetzen(50);
-		loader.getPlayer(3).animationsGeschwindigkeitSetzen(50);
+		loader.getPlayer(1).animationsGeschwindigkeitSetzen(50);
 
-		positionSetzen(Tile.getSize() * 2, Tile.getSize() * 2);
+		actionFigur.neuerZustand(loader.getPlayer(0), "idle");
+		actionFigur.neuerZustand(loader.getPlayer(1), "walk");
+		actionFigur.neuerZustand(loader.getPlayer(2), "strike");
+		actionFigur.neuerZustand(loader.getPlayer(3), "swipe");
+		actionFigur.neuerZustand(loader.getPlayer(4), "die");
 	}
 
 	@Override
-	public void tick() {
-
-		if (!((aktuellesVerhalten() == "strike_left" || aktuellesVerhalten() == "strike_right")
-				&& aktuelleFigur().aktuellesBild() < aktuelleFigur().animation().length - 1)) {
-
-			if (main.tasteGedrueckt(Taste.W)) {
-				velY -= World.SCALE * accelleration;
-			}
-			if (main.tasteGedrueckt(Taste.S)) {
-				velY += World.SCALE * accelleration;
-			}
-			if (main.tasteGedrueckt(Taste.A)) {
-				velX -= World.SCALE * accelleration;
-				side = false;
-			}
-			if (main.tasteGedrueckt(Taste.D)) {
-				velX += World.SCALE * accelleration;
-				side = true;
-			}
-
-			setX(getX() + velX);
-			setY(getY() + velY);
-			velX *= (1f - friction);
-			velY *= (1f - friction);
-			if (velX < 0.2f && velX > -0.2f) {
-				velX = 0f;
-			}
-			if (velY < 0.2f && velY > -0.2f) {
-				velY = 0f;
-			}
-
-			hitBox.positionSetzen(positionX() + 103, positionY() + 35);
-			hitBox.breiteSetzen(50);
-			hitBox.hoeheSetzen(80);
-
-			final int xOffset = hitBox.positionX() - positionX();
-			final int yOffset = hitBox.positionY() - positionY();
-			int tileX, tileY;
-			Tile t;
-			// collision left
-			if (hitBox.positionX() - oldPosX < 0) {
-				tileX = hitBox.positionX() / Tile.getSize();
-				tileY = hitBox.positionY() / Tile.getSize();
-				t = main.getWorld().getCurrentMap().getTile(tileX, tileY);
-				if (t != null && t.isCollidable()) {
-					velX = 0;
-					int x = t.getRight() - xOffset;
-					oldPosX = x;
-					positionSetzen(x, positionY());
+	protected void update() {
+		System.out.println(posX);
+		if (!((actionFigur.aktuellesVerhalten().equals("strike"))
+				&& actionFigur.aktuelleFigur().aktuellesBild() < actionFigur.aktuelleFigur().animation().length - 1)) {
+			if (!((actionFigur.aktuellesVerhalten().equals("swipe"))
+					&& actionFigur.aktuelleFigur().aktuellesBild() < actionFigur.aktuelleFigur().animation().length - 1)) {
+				if (main.tasteGedrueckt(Taste.A)) {
+					moveLeft();
 				}
-				tileX = hitBox.positionX() / Tile.getSize();
-				tileY = (int) (hitBox.positionY() + hitBox.getHoehe()) / Tile.getSize();
-				t = main.getWorld().getCurrentMap().getTile(tileX, tileY);
-				if (t != null && t.isCollidable()) {
-					velX = 0;
-					int x = t.getRight() - xOffset;
-					oldPosX = x;
-					positionSetzen(x, positionY());
+				if (main.tasteGedrueckt(Taste.D)) {
+					moveRight();
 				}
-			}
-			// collision right
-			if (hitBox.positionX() - oldPosX > 0) {
-				tileX = (int) (hitBox.positionX() + hitBox.getBreite()) / Tile.getSize();
-				tileY = hitBox.positionY() / Tile.getSize();
-				t = main.getWorld().getCurrentMap().getTile(tileX, tileY);
-				if (t != null && t.isCollidable()) {
-					velX = 0;
-					int x = t.getLeft() - xOffset - (int) hitBox.getBreite();
-					oldPosX = x;
-					positionSetzen(x, positionY());
+				if (main.tasteGedrueckt(Taste.W)) {
+					moveUp();
 				}
-				tileX = (int) (hitBox.positionX() + hitBox.getBreite()) / Tile.getSize();
-				tileY = (int) (hitBox.positionY() + hitBox.getHoehe()) / Tile.getSize();
-				t = main.getWorld().getCurrentMap().getTile(tileX, tileY);
-				if (t != null && t.isCollidable()) {
-					velX = 0;
-					int x = t.getLeft() - xOffset - (int) hitBox.getBreite();
-					oldPosX = x;
-					positionSetzen(x, positionY());
+				if (main.tasteGedrueckt(Taste.S)) {
+					moveDown();
 				}
-			}
-			// collision top
-			if (hitBox.positionY() - oldPosY < 0) {
-				tileX = hitBox.positionX() / Tile.getSize();
-				tileY = hitBox.positionY() / Tile.getSize();
-				t = main.getWorld().getCurrentMap().getTile(tileX, tileY);
-				if (t != null && t.isCollidable()) {
-					velY = 0;
-					int y = t.getBottom() - yOffset;
-					oldPosY = y;
-					positionSetzen(positionX(), y);
-				}
-				tileX = (int) (hitBox.positionX() + hitBox.getBreite()) / Tile.getSize();
-				tileY = hitBox.positionY() / Tile.getSize();
-				t = main.getWorld().getCurrentMap().getTile(tileX, tileY);
-				if (t != null && t.isCollidable()) {
-					velY = 0;
-					int y = t.getBottom() - yOffset;
-					oldPosY = y;
-					positionSetzen(positionX(), y);
-				}
-			}
-			// collision bottom
-			if (hitBox.positionY() - oldPosY > 0) {
-				tileX = hitBox.positionX() / Tile.getSize();
-				tileY = (int) (hitBox.positionY() + hitBox.getHoehe()) / Tile.getSize();
-				t = main.getWorld().getCurrentMap().getTile(tileX, tileY);
-				if (t != null && t.isCollidable()) {
-					velY = 0;
-					int y = t.getTop() - (int) hitBox.getHoehe() - yOffset;
-					oldPosY = y;
-					positionSetzen(positionX(), y);
-				}
-				tileX = (int) (hitBox.positionX() + hitBox.getBreite()) / Tile.getSize();
-				tileY = (int) (hitBox.positionY() + hitBox.getHoehe()) / Tile.getSize();
-				t = main.getWorld().getCurrentMap().getTile(tileX, tileY);
-				if (t != null && t.isCollidable()) {
-					velY = 0;
-					int y = t.getTop() - (int) hitBox.getHoehe() - yOffset;
-					oldPosY = y;
-					positionSetzen(positionX(), y);
-				}
-			}
-
-			oldPosX = hitBox.positionX();
-			oldPosY = hitBox.positionY();
-
-			if (!((aktuellesVerhalten() == "swipe_left" || aktuellesVerhalten() == "swipe_right")
-					&& aktuelleFigur().aktuellesBild() < aktuelleFigur().animation().length - 1)) {
 				if (velX == 0 && velY == 0) {
-					if (side) {
-						zustandSetzen("idle_right");
-					} else {
-						zustandSetzen("idle_left");
-					}
+					zustandSetzen("idle");
 				} else {
-					if (side) {
-						zustandSetzen("walk_right");
-					} else {
-						zustandSetzen("walk_left");
-					}
+					zustandSetzen("walk");
 				}
 
 				if (main.tasteGedrueckt(Taste.LEERTASTE)) {
-					if (side) {
-						zustandSetzen("swipe_right");
-					} else {
-						zustandSetzen("swipe_left");
-					}
+					zustandSetzen("swipe");
 				}
 				if (main.tasteGedrueckt(Taste.Q)) {
-					if (side) {
-						zustandSetzen("strike_right");
-					} else {
-						zustandSetzen("strike_left");
-					}
+					zustandSetzen("strike");
 				}
 			}
+			checkTileCollisions(main.getWorld().getCurrentMap());
+			super.update();
+		} else {
+			velX = 0;
+			velY = 0;
 		}
 	}
 }

Zoelda/src/main/PlayerSheetLoader.java

@@ -19,29 +19,21 @@ public class PlayerSheetLoader {
 		try {
 			BufferedImage sheet = ImageIO.read(Tile.class.getResourceAsStream("/res/images/player_sprite_sheet.png"));
 
-			PixelFeld[][] sprites = new PixelFeld[9][];
+			PixelFeld[][] sprites = new PixelFeld[5][];
 			sprites[0] = new PixelFeld[5];
-			sprites[1] = new PixelFeld[5];
-			sprites[2] = new PixelFeld[8];
-			sprites[3] = new PixelFeld[8];
+			sprites[1] = new PixelFeld[8];
+			sprites[2] = new PixelFeld[7];
+			sprites[3] = new PixelFeld[6];
 			sprites[4] = new PixelFeld[7];
-			sprites[5] = new PixelFeld[7];
-			sprites[6] = new PixelFeld[6];
-			sprites[7] = new PixelFeld[6];
-			sprites[8] = new PixelFeld[7];
 
-			loadSprites(sprites[0], 0, 64, 32, sheet, true);
-			loadSprites(sprites[1], 0, 64, 32, sheet, false);
-			loadSprites(sprites[2], 1, 64, 32, sheet, true);
-			loadSprites(sprites[3], 1, 64, 32, sheet, false);
-			loadSprites(sprites[4], 2, 64, 32, sheet, true);
-			loadSprites(sprites[5], 2, 64, 32, sheet, false);
-			loadSprites(sprites[6], 3, 64, 32, sheet, true);
-			loadSprites(sprites[7], 3, 64, 32, sheet, false);
-			loadSprites(sprites[8], 7, 64, 32, sheet, false);
+			loadSprites(sprites[0], 0, 64, 32, sheet);
+			loadSprites(sprites[1], 1, 64, 32, sheet);
+			loadSprites(sprites[2], 2, 64, 32, sheet);
+			loadSprites(sprites[3], 3, 64, 32, sheet);
+			loadSprites(sprites[4], 4, 64, 32, sheet);
 
 			Figur fig;
-			player = new Figur[9];
+			player = new Figur[5];
 			for (int i = 0; i < player.length; i++) {
 				fig = new Figur();
 				fig.animationSetzen(sprites[i]);
@@ -57,7 +49,7 @@ public class PlayerSheetLoader {
 		return player[y];
 	}
 
-	private void loadSprites(PixelFeld[] sprites, int row, int w, int h, BufferedImage sheet, boolean reverse) {
+	private void loadSprites(PixelFeld[] sprites, int row, int w, int h, BufferedImage sheet) {
 		for (int s = 0; s < sprites.length; s++) {
 			sprites[s] = new PixelFeld(w * (int) (World.SCALE / SCALE_DIV), h * (int) (World.SCALE / SCALE_DIV), 1);
 			for (int x = 0; x < w; x++) {
@@ -72,15 +64,6 @@ public class PlayerSheetLoader {
 					}
 				}
 			}
-			if (reverse) {
-				PixelFeld copy = new PixelFeld(sprites[s].breite(), sprites[s].hoehe(), 1);
-				for (int x = 0; x < sprites[s].breite(); x++) {
-					for (int y = 0; y < sprites[s].hoehe(); y++) {
-						copy.farbeSetzen(sprites[s].breite() - x - 1, y, sprites[s].getPic()[x][y]);
-					}
-				}
-				sprites[s] = copy;
-			}
 		}
 	}
 }

Zoelda/src/main/World.java

@@ -4,7 +4,7 @@ import ea.Knoten;
 
 public class World extends Knoten {
 	
-	public static final int SCALE = 3;
+	public static final int SCALE = 6;
 
 	private Map currentMap;
 	
@@ -12,7 +12,7 @@ public class World extends Knoten {
 		
 		currentMap = new Map();
 		add(currentMap);
-		add(player);
+		add(player.actionFigur);
 	}
 	
 	public Map getCurrentMap() {