animationspeed of rick edited

.gitignore

@@ -8,3 +8,4 @@
 /.idea/
 /out/
 /Zoelda.iml
+/bin/

Zoelda/src/main/DoorTile.java

@@ -2,10 +2,10 @@ package main;
 
 import ea.Ticker;
 import main.entities.player.Player;
-import main.maps.ImageMap;
+import main.maps.Map;
 
 public class DoorTile extends Tile implements Ticker {
-	
+
 	public static final int TOP = 0;
 	public static final int BOTTOM = 1;
 	public static final int LEFT = 2;
@@ -13,11 +13,11 @@ public class DoorTile extends Tile implements Ticker {
 
 	private int side;
 	private DoorTile connected;
-	private ImageMap map;
+	private Map map;
 	private boolean waitForLeave;
 
-	public DoorTile(float x, float y, ImageMap map) {
+	public DoorTile(int id, float x, float y, Map map) {
-		super(Tile.DOOR, x, y);
+		super(id, x, y);
 		this.map = map;
 	}
 
@@ -28,8 +28,9 @@ public class DoorTile extends Tile implements Ticker {
 			float dist = player.dist(posX + 0.5f, posY + 0.5f);
 			if (dist < 0.5f) {
 				if (!waitForLeave) {
-					Main.instance.getWorld().changeMap(this);
+					if (connected != null) {
-					waitForLeave = true;
+						Main.instance.getWorld().changeMap(this);
+					}
 				}
 			} else {
 				waitForLeave = false;
@@ -44,20 +45,33 @@ public class DoorTile extends Tile implements Ticker {
 	public void setSide(int side) {
 		this.side = side;
 	}
-	
+
 	public void setConnectedDoor(DoorTile door) {
 		connected = door;
 	}
-	
+
 	public DoorTile getConnectedDoor() {
 		return connected;
 	}
 
-	public ImageMap getMap() {
+	public Map getMap() {
 		return map;
 	}
 
 	public void waitForLeave() {
 		waitForLeave = true;
 	}
+
+	@Override
+	public DoorTile clone() {
+		DoorTile t = new DoorTile(getID(), posX, posY, map);
+		t.setConnectedDoor(connected);
+		t.side = side;
+		t.map = map;
+		return t;
+	}
+
+	public void setMap(Map map) {
+		this.map = map;
+	}
 }

Zoelda/src/main/HUD/HUD.java

@@ -0,0 +1,28 @@
+package main.HUD;
+
+import java.awt.Graphics2D;
+
+import ea.BoundingRechteck;
+import ea.Knoten;
+import main.Main;
+
+public class HUD extends Knoten{
+	
+	public final Herzen herzen;
+	public final Inventory inventory;
+
+
+	public HUD()  {
+		herzen = new Herzen();
+		inventory = new Inventory();
+		add(herzen);
+		add(inventory);
+		Main.instance.manager.anmelden(herzen, 60);
+		Main.instance.manager.anmelden(inventory, 50);
+	}
+	@Override
+	public void zeichnen(Graphics2D g, BoundingRechteck r) {
+		herzen.zeichnen(g);
+		inventory.zeichnen(g);
+	}
+}

Zoelda/src/main/HUD/Herzen.java

@@ -1,25 +1,33 @@
-package main;
+package main.HUD;
 
 import java.awt.Graphics2D;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
+
 import javax.imageio.ImageIO;
-import ea.BoundingRechteck;
+
 import ea.Knoten;
 import ea.Ticker;
+import main.Main;
 
-public class HUD extends Knoten implements Ticker {
+public class Herzen extends Knoten implements Ticker{
+	private final static int SCALE = 50;
 	private BufferedImage volles_Herz;
 	private BufferedImage halbes_Herz;
 	private BufferedImage leeres_Herz;
 	private BufferedImage hauptBild;
 	private BufferedImage[] HPLeiste;
-	private final static int SCALE = 50;
+	private boolean shakingSwitch;
+	private float HPVel = 0.3f;
+	private int counter = 0;
+	private float lastHP;
+	private int y;
+	private int HPLeisteY[];
 
-	public HUD() {
+	public Herzen() {
 		// inizialisieren der Variablen, laden der Bilder und für den ticker anmelden
-		HPLeiste = new BufferedImage[3];
+		HPLeiste = new BufferedImage[5];
-		Main.instance.manager.anmelden(this, 50);
+		HPLeisteY = new int [HPLeiste.length];
 		try {
 			hauptBild = ImageIO.read(HUD.class.getResourceAsStream("/res/images/icons.png"));
 		} catch (IOException e) {
@@ -40,16 +48,40 @@ public class HUD extends Knoten implements Ticker {
 		HPLeiste[2] = volles_Herz;
 	}
 
-	//wird alle 50ms ausgeführt:
+	private int shakeY() {
-	@Override
+		shakingSwitch = !shakingSwitch;
+			if (shakingSwitch == true) {
+				return 3;
+			}
+		return 0;
+	}
+	
+	private int regenY() {
+		if (HPVel > 0) {
+			if (counter < HPLeiste.length + 1) {
+				counter++;
+				if (counter * 4 < HPLeiste.length + 1) {
+					return 3;
+				} else {
+					return 0;
+				}
+			} else {
+				counter = 0;
+			}
+		}
+		return 0;
+	}
+
+	// wird alle 200ms ausgeführt:
 	public void tick() {
 		// teilt den Wert der HP in Teile auf, welche der Anzahl der Herzen entspricht
 		// und prüft dann für den eigenen Teil des Herzens, ob das jeweilige Herz voll,
 		// halb oder leer ist (BIG BRAIN):
+		HPVel = Main.instance.getWorld().getPlayer().getHP() - lastHP;
+		lastHP = Main.instance.getWorld().getPlayer().getHP();
 		float localeHP;
 		for (int i = 0; i < HPLeiste.length; i++) {
 			localeHP = Main.instance.getWorld().getPlayer().getHP();
-			;
 			localeHP -= ((float) i) * (1f / HPLeiste.length);
 			if (localeHP <= 0f) {
 				HPLeiste[i] = leeres_Herz;
@@ -59,14 +91,24 @@ public class HUD extends Knoten implements Ticker {
 				HPLeiste[i] = volles_Herz;
 			}
 		}
-	}
+		if(Main.instance.getWorld().getPlayer().getHP() < 0.33f) {
+			y = shakeY();
+		} else	{
+			for (int i = 0; i < HPLeiste.length; i++) {
+				HPLeisteY[i] = regenY();
+			}
 
-	//Zeichnet alle Herzen im Array HPLeiste[] auf den Bildschirm
-	@Override
-	public void zeichnen(Graphics2D g, BoundingRechteck r) {
-		for (int i = 0; i < HPLeiste.length; i++) {
-			g.drawImage(HPLeiste[i], i * SCALE, 0, SCALE, SCALE, null);
 		}
 	}
 
+	// Zeichnet alle Herzen im Array HPLeiste[] auf den Bildschirm
+	public void zeichnen(Graphics2D g) {
+		for (int i = 0; i < HPLeiste.length; i++) {
+			if(Main.instance.getWorld().getPlayer().getHP() < 0.33f) {
+				g.drawImage(HPLeiste[i], (i + 2) * SCALE, y , SCALE, SCALE, null);
+			} else {
+				g.drawImage(HPLeiste[i], (i + 2) * SCALE, HPLeisteY[i] , SCALE, SCALE, null);
+			}
+		}
+	}
 }

Zoelda/src/main/HUD/Inventory.java

@@ -0,0 +1,51 @@
+package main.HUD;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+import ea.Knoten;
+import ea.Ticker;
+import main.Main;
+import main.entities.player.PlayerInventory;
+import main.worlds.World;
+
+public class Inventory extends Knoten implements Ticker {
+
+	private static final int SCALE = 50;
+	private BufferedImage inventoryFrame;
+	private BufferedImage coinCounterIcon;
+	private PlayerInventory inventory;
+
+	public Inventory() {
+		inventory = Main.instance.getWorld().getPlayer().getInventory();
+		try {
+			inventoryFrame = ImageIO.read(HUD.class.getResourceAsStream("/res/images/inventory.png"));
+			coinCounterIcon = ImageIO.read(HUD.class.getResourceAsStream("/res/images/coins.png"));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		coinCounterIcon = coinCounterIcon.getSubimage(0, 20, 7, 4);
+
+	}
+
+	public void style(Graphics2D g) {
+		Font currentFont = g.getFont();
+		Font newFont = currentFont.deriveFont(Font.BOLD, 20);
+		g.setFont(newFont);
+	}
+
+	public void zeichnen(Graphics2D g) {
+		style(g);
+		g.drawImage(inventoryFrame, 0, 0, SCALE * 2, SCALE * 2, null);
+		g.drawString(String.valueOf(inventory.getCoins()), SCALE + 10, 145);
+		g.drawImage(coinCounterIcon, 0, 125, coinCounterIcon.getWidth() * World.SCALE_FACTOR,
+				coinCounterIcon.getHeight() * World.SCALE_FACTOR, null);
+	}
+
+	// wird alle 50ms ausgef<65>hrt:
+	public void tick() {
+	}
+}

Zoelda/src/main/Main.java

@@ -1,31 +1,43 @@
 package main;
 
 import ea.Game;
+import ea.Taste;
+import main.HUD.HUD;
+import main.worlds.TestWorld;
+import main.worlds.World;
 
 /**
  * Von hier wird alles initialisiert. Das ist die höchste Klasse.
  */
 public class Main extends Game {
-	
+
 	public static Main instance;
+	public static boolean SHOW_DEBUG = false;
 
 	private World world;
 	private HUD hud;
+	private Sounds sounds;
 
 	public Main() {
 		super(World.SCALE * 15, World.SCALE * 11, 16);
 		instance = this;
 
-		// Welt initialisieren und Spieler hinzufügen
+		// Welt initialisieren und Spieler hinzufügen und die Welt zu EA hinzufügen
-		world = new World();
+		world = new TestWorld();
-		hud = new HUD();
+		manager.anmelden(world.getPlayer(), 20);
-		// die Welt zu EA hinzufügen
+		world.start();
 		wurzel.add(world);
+		hud = new HUD();
 		wurzel.add(hud);
+//		sounds = new Sounds();
+//		sounds.playSound(2);
 	}
 
 	@Override
 	public void tasteReagieren(int code) {
+		if (code == Taste.O) {
+			SHOW_DEBUG = !SHOW_DEBUG;
+		}
 	}
 
 	public World getWorld() {

Zoelda/src/main/SheetLoader.java

@@ -12,44 +12,46 @@ import ea.internal.gra.PixelFeld;
 public class SheetLoader {
 
 	private Figur[] figures;
+	private BufferedImage sheet;
 
 	/**
 	 * Macht aus einem Spritesheet Figuren.
-	 * @param path - Der pfad zum sheet
+	 * 
-	 * @param width - die Breite von einem Bild
+	 * @param path    - Der pfad zum sheet
-	 * @param height - die Höhe von einem Bild (nicht das ganze sheet)
+	 * @param width   - die Breite von einem Bild
+	 * @param height  - die Höhe von einem Bild (nicht das ganze sheet)
 	 * @param lengths - die Anzahl der Frames der verschiedenen Animationen
 	 */
-	public SheetLoader(String path, int width, int height, int[] frames) {
+	public SheetLoader(String path) {
-		
 		try {
 			// Bild laden
-			BufferedImage sheet = ImageIO.read(Tile.class.getResourceAsStream(path));
+			sheet = ImageIO.read(Tile.class.getResourceAsStream(path));
-			
-			// Anzahl der Animationen
-			int rows = frames.length;
-			
-			// Sprites anordnen *magie*
-			PixelFeld[][] sprites = new PixelFeld[rows][];
-			for (int i = 0; i < frames.length; i++) {
-				sprites[i] = new PixelFeld[frames[i]];
-			}
-			for (int i = 0; i < sprites.length; i++) {
-				loadSprites(sprites[i], i, width, height, sheet);
-			}
-			Figur fig;
-			figures = new Figur[rows];
-			for (int i = 0; i < figures.length; i++) {
-				fig = new Figur();
-				fig.animationSetzen(sprites[i]);
-				figures[i] = fig;
-			}
-			
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 	}
 
+	public void generateFigures(int width, int height, int[] frames) {
+		// Anzahl der Animationen
+		int rows = frames.length;
+
+		// Sprites anordnen *magie*
+		PixelFeld[][] sprites = new PixelFeld[rows][];
+		for (int i = 0; i < frames.length; i++) {
+			sprites[i] = new PixelFeld[frames[i]];
+		}
+		for (int i = 0; i < sprites.length; i++) {
+			loadSprites(sprites[i], i, width, height, sheet);
+		}
+		Figur fig;
+		figures = new Figur[rows];
+		for (int i = 0; i < figures.length; i++) {
+			fig = new Figur();
+			fig.animationSetzen(sprites[i]);
+			figures[i] = fig;
+		}
+	}
+
 	public Figur getFigur(int y) {
 		return figures[y];
 	}

Zoelda/src/main/Sounds.java

@@ -0,0 +1,45 @@
+package main;
+
+import ea.Sound;
+
+public class Sounds {
+	private Sound[] sounds;
+	
+	public Sounds() {
+		sounds = new Sound[6];
+		for(int i = 0; i < sounds.length; i++) {
+			sounds[i] = new Sound(getPathFromId(i));
+		}
+	}
+	
+	public void playSound(int id) {
+		sounds[id].play();
+	}
+	
+	public void loopSound(int id) {
+		sounds[id].loop();
+	}
+	
+	public void stopSound(int id) {
+		sounds[id].stop();
+	}
+	
+	private String getPathFromId(int id) {
+		switch(id) {
+			case 0:
+				return "/res/sounds/Water-Balloon-Maniacs.mp3";
+			case 1:
+				return "/res/sounds/Runaway-Food-Truck.mp3";
+			case 2:
+				return "/res/sounds/Hypnotic-Puzzle2.mp3" ;
+			case 3:
+				return "/res/sounds/Game-Menu_v001.mp3" ;
+			case 4:
+				return "/res/sounds/Blob-Monsters-on-the-Loose.mp3";
+			case 5:
+				return "/res/sounds/And-the-Machines-Came-at-Midnight.mp3";
+			default:
+				return null;
+		}
+	}
+}

Zoelda/src/main/Tile.java

@@ -7,6 +7,7 @@ import javax.imageio.ImageIO;
 
 import ea.Bild;
 import ea.Knoten;
+import main.worlds.World;
 
 /**
  * Ein feld auf der Map
@@ -14,18 +15,26 @@ import ea.Knoten;
 public class Tile extends Knoten {
 
 	// IDs der Tiles
+	public static final int VOID = -1;
 	public static final int GRASS = 0;
 	public static final int WALL_TOP = 1;
 	public static final int WALL_BOTTOM = 2;
 	public static final int STONE_WALL = 3;
 	public static final int STONE_WALL_BOTTOM = 4;
 	public static final int STONE_FLOOR = 5;
-	public static final int VOID = 6;
+	public static final int STONE_FLOOR_SHADOW_LEFT = 6;
-	public static final int DOOR = 7;
+	public static final int DOOR_LEFT = 7;
-
+	public static final int DOOR_RIGHT_LEFT_TOP = 8;
+	public static final int DISCO = 9;
+	public static final int DOOR_RIGHT = 10;
+	public static final int DOOR_TOP = 11;
+	public static final int DOOR_BOTTOM = 12;
+	
 	private Bild img; // Bild, das gerendert wird
-	private int id; // Die id dises Tiles
+	private int id; // Die id dises Tiles//
 	protected float posX, posY; // Position dieses Tiles
+	
+	private static Bild[] images;
 
 	/**
 	 * @param id
@@ -33,40 +42,47 @@ public class Tile extends Knoten {
 	 * @param y  - Y-Koordinate in units
 	 */
 	public Tile(int id, float x, float y) {
+		
+		if (images == null) {
+			loadImages();
+		}
+		
 		this.id = id;
 		posX = x;
 		posY = y;
 
 		if (id != VOID) {
-			// Das Bild laden
+			img = images[id].clone();
+			img.positionSetzen(posX * World.SCALE, posY * World.SCALE);
+			// Bild zu EA hinzuf<75>gen.
+			add(img);
+		}
+	}
+	
+	private static void loadImages() {
+		images = new Bild[13];
+		for (int i = 0; i < images.length; i++) {
 			try {
-				BufferedImage buff = ImageIO.read(Tile.class.getResourceAsStream(getPathFromId(id)));
+				BufferedImage buff = ImageIO.read(Tile.class.getResourceAsStream(getPathFromId(i)));
-				// Gras hat 8 verschiedene Texturen von denen eine zufällig ausgewählt werden
+				// Gras hat 8 verschiedene Texturen von denen eine zufaellig ausgewaehlt werden
 				// muss.
-				if (id == GRASS) {
+				if (i == GRASS) {
 					buff = buff.getSubimage(16 * (int) (Math.random() * 8), 0, 16, 16);
 				}
-				// if (id == STONE_FLOOR) {
-				// buff = buff.getSubimage(16 * (int) (Math.random() * 10), 0, 16, 16);
-				// }
 				// Skalieren
 				BufferedImage scaled = new BufferedImage(World.SCALE, World.SCALE, BufferedImage.TYPE_INT_RGB);
 				scaled.getGraphics().drawImage(buff, 0, 0, World.SCALE, World.SCALE, null);
-				img = new Bild(x * World.SCALE, y * World.SCALE, scaled);
+				images[i] = new Bild(0, 0, scaled);
-
 			} catch (IOException e) {
 				e.printStackTrace();
 			} 
-			// Bild zu EA hinzufügen.
-			add(img);
 		}
-
 	}
 
 	/**
-	 * @return den Pfad der zu der Id gehört.
+	 * @return den Pfad der zu der Id gehoert.
 	 */
-	private String getPathFromId(int id) {
+	private static String getPathFromId(int id) {
 		switch (id) {
 		case GRASS:
 			return "/res/images/tiles/grass.png";
@@ -75,21 +91,33 @@ public class Tile extends Knoten {
 		case WALL_BOTTOM:
 			return "/res/images/tiles/wall_bottom.png";
 		case STONE_WALL:
-			return "/res/images/tiles/test.png";
+			return "/res/images/tiles/stone_wall.png";
 		case STONE_WALL_BOTTOM:
 			return "/res/images/tiles/stone_wall_bottom.png";
 		case STONE_FLOOR:
-			return "/res/images/tiles/TestTest.png";
+			return "/res/images/tiles/stone_floor.png";
-		case DOOR:
+		case STONE_FLOOR_SHADOW_LEFT:
-			return "/res/images/tiles/door.png";
+			return "/res/images/tiles/stone_floor_shadow_left.png";
+		case DOOR_LEFT:
+			return "/res/images/tiles/door_left.png";
+		case DOOR_RIGHT_LEFT_TOP:
+			return "/res/images/tiles/door_right_left_top.png";
+		case DISCO:
+			return "/res/images/tiles/disco_sprite_sheet.png";
+		case DOOR_RIGHT:
+			return "/res/images/tiles/door_right.png";
+		case DOOR_TOP:
+			return "/res/images/tiles/door_top.png";
+		case DOOR_BOTTOM:
+			return "/res/images/tiles/door_bottom.png";
 		}
 		return null;
 	}
 
 	/**
-	 * @return die Größe der Textur
+	 * @return die Groesse der Textur
 	 */
-	public static int getSize() {
+	private static int getSize() {
 		return 16;
 	}
 
@@ -97,34 +125,34 @@ public class Tile extends Knoten {
 	 * @return ob man durch das Tile durchgehen kann
 	 */
 	public boolean isCollidable() {
-		// Alle Tiles durch die man nicht laufen soll müssen hier true zurückgeben,
+		// Alle Tiles durch die man nicht laufen soll muessen hier true zurueckgeben,
-		// sonst werden sie bei der Collisiondetection nicht berücksichtigt.
+		// sonst werden sie bei der Collisiondetection nicht ber<EFBFBD>cksichtigt.
 		return id == WALL_TOP || id == STONE_WALL;
 	}
 
 	/**
-	 * Kleine Hifsmethode un die koordinate der Top-Kante rurückzugenben.
+	 * Kleine Hifsmethode um die Koordinate der Top-Kante zurueckzugenben.
 	 */
 	public int getTop() {
 		return positionY();
 	}
 
 	/**
-	 * Kleine Hifsmethode un die koordinate der Bottom-Kante rurückzugenben.
+	 * Kleine Hifsmethode um die Koordinate der Bottom-Kante zurueckzugenben.
 	 */
 	public int getBottom() {
 		return positionY() + getSize();
 	}
 
 	/**
-	 * Kleine Hifsmethode un die koordinate der Left-Kante rurückzugenben.
+	 * Kleine Hifsmethode um die Koordinate der Left-Kante zurueckzugenben.
 	 */
 	public int getLeft() {
 		return positionX();
 	}
 
 	/**
-	 * Kleine Hifsmethode un die koordinate der Right-Kante rurückzugenben.
+	 * Kleine Hifsmethode um die Koordinate der Right-Kante zurueckzugenben.
 	 */
 	public int getRight() {
 		return positionX() + getSize();
@@ -133,4 +161,17 @@ public class Tile extends Knoten {
 	public int getID() {
 		return id;
 	}
+	
+	public float getPosX() {
+		return posX;
+	}
+	
+	public float getPosY() {
+		return posY;
+	}
+	
+	@Override
+	public Tile clone() {
+		return new Tile(id, posX, posY);
+	}
 }

Zoelda/src/main/World.java

@@ -1,63 +0,0 @@
-package main;
-
-import java.util.ArrayList;
-
-import ea.Knoten;
-import main.entities.player.Player;
-import main.maps.ImageMap;
-import main.maps.Map;
-
-/**
- * Hier werden alle Maps gespeichert.
- */
-public class World extends Knoten {
-
-	public static final int SCALE_FACTOR = 4; // Der Basis Zoomfaktor
-	public static final int SCALE = SCALE_FACTOR * Tile.getSize(); // Eine Gameunit ist so viele pixel lang
-
-	private ImageMap currentMap; // Die Map die aktuell angezeigt werden soll.
-	private ArrayList<ImageMap> dungeon;
-	
-	private Player player;
-
-	public World() {
-
-		dungeon = new ArrayList<>(50);
-		
-		ImageMap start = new ImageMap("/res/images/maps/map2.png");
-		dungeon.add(start);
-		currentMap = start;
-		currentMap.start();
-		
-		start.generate(dungeon, DoorTile.BOTTOM);
-		
-		
-		player = new Player();
-		currentMap.getEntities().add(player);
-		currentMap.add(player.actionFigur);
-		Main.instance.manager.anmelden(player, 20);
-		
-		add(currentMap);
-		
-	}
-	
-	public Map getCurrentMap() {
-		return currentMap;
-	}
-	
-	public Player getPlayer() {
-		return player;
-	}
-	
-	public void changeMap(DoorTile door) {
-		currentMap.stop();
-		currentMap.entfernen(player.actionFigur);
-		entfernen(currentMap);
-		currentMap = door.getConnectedDoor().getMap();
-		currentMap.add(player.actionFigur);
-		add(currentMap);
-		currentMap.start();
-		door.getConnectedDoor().waitForLeave();
-		player.setPos(door.getConnectedDoor().posX + 0.5f, door.getConnectedDoor().posY + 0.5f);
-	}
-}

Zoelda/src/main/entities/AnimatedEntity.java

@@ -0,0 +1,77 @@
+package main.entities;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+
+import ea.ActionFigur;
+import ea.BoundingRechteck;
+import ea.Figur;
+import ea.internal.gra.PixelFeld;
+import main.Main;
+import main.worlds.World;
+
+public abstract class AnimatedEntity extends Entity {
+
+	public ActionFigur actionFigur; // Sprite des Entities
+	protected float spriteScale = 1f; // Skalierung des Sprites
+	protected float spriteOffsetX, spriteOffsetY; // Offset des Sprites. Hier kann man die relative render-Position
+													// nachjustieren.
+	protected boolean side;
+
+	private static Figur noTexture = new Figur();
+
+	static {
+		PixelFeld[] img = new PixelFeld[1];
+		img[0] = new PixelFeld(16, 16, 1);
+		for (int x = 0; x < 16; x++) {
+			for (int y = 0; y < 16; y++) {
+				img[0].farbeSetzen(x, y, Color.MAGENTA);
+			}
+		}
+		noTexture.animationSetzen(img);
+	}
+
+	public AnimatedEntity() {
+		actionFigur = new ActionFigur(noTexture, "undefined") {
+			// DEBUG: render boxes
+
+			@Override
+			public void zeichnen(Graphics2D g, BoundingRechteck r) {
+				super.zeichnen(g, r);
+				if (Main.SHOW_DEBUG) {
+					g.setColor(Color.CYAN);
+					g.drawRect((int) actionFigur.positionX(), (int) actionFigur.positionY(),
+							(int) actionFigur.getBreite(), (int) actionFigur.getHoehe());
+					g.setColor(Color.GREEN);
+					g.drawRect((int) ((posX - width / 2) * World.SCALE), (int) ((posY - height / 2) * World.SCALE),
+							(int) (width * World.SCALE), (int) (height * World.SCALE));
+				}
+			}
+		};
+	}
+
+	@Override
+	protected void update() {
+
+		checkTileCollision(Main.instance.getWorld().getCurrentMap());
+		checkEntityCollision(Main.instance.getWorld().getCurrentMap());
+
+		// Packt das Sprite an die richtige Stelle
+		actionFigur.faktorSetzen((int) (spriteScale * World.SCALE_FACTOR));
+		float offsetX = width / 2 + spriteOffsetX - width / 2;
+		float offsetY = height / 2 + spriteOffsetY - height / 2;
+		actionFigur.positionSetzen((posX + offsetX) * World.SCALE - actionFigur.getBreite() / 2,
+				(posY + offsetY) * World.SCALE - actionFigur.getHoehe() / 2);
+	}
+
+	/**
+	 * Spiegelt die figur autmatisch, wenn nötig.
+	 */
+	protected void zustandSetzen(String name) {
+		actionFigur.spiegelXSetzen(side);
+		if (!actionFigur.aktuellesVerhalten().equals(name)) {
+			actionFigur.zustandSetzen(name);
+			actionFigur.aktuelleFigur().animationsBildSetzen(0);
+		}
+	}
+}

Zoelda/src/main/entities/Coin.java

@@ -0,0 +1,57 @@
+package main.entities;
+
+import main.Main;
+import main.SheetLoader;
+import main.entities.player.Player;
+
+public class Coin extends AnimatedEntity {
+
+	private static SheetLoader loader = new SheetLoader("/res/images/coins.png");
+	private boolean moveToCounterAnimation;
+	private float animationDestX = 0.2f;
+	private float animationDestY = 2.0f;
+
+	public Coin() {
+		loader.generateFigures(8, 8, new int[] { 8, 8, 1 });
+
+		loader.getFigur(0).animationsGeschwindigkeitSetzen(100);
+		loader.getFigur(1).animationsGeschwindigkeitSetzen(100);
+		loader.getFigur(2).animationsGeschwindigkeitSetzen(100);
+
+		actionFigur.neuerZustand(loader.getFigur(0), "gold");
+		actionFigur.neuerZustand(loader.getFigur(1), "silver");
+		actionFigur.neuerZustand(loader.getFigur(2), "bronze");
+		zustandSetzen("bronze");
+
+		posX = 4f;
+		posY = 4f;
+		width = 0.375f;
+		height = 0.25f;
+		spriteOffsetY = -0.1f;
+		enablePushBack = false;
+	}
+
+	@Override
+	protected void update() {
+		super.update();
+
+		if (moveToCounterAnimation) {
+			float distX = animationDestX - posX;
+			float distY = animationDestY - posY;
+			posX += distX / 10f;
+			posY += distY / 10f;
+			if (distX < 0.05f && distX > -0.05f && distY < 0.05f && distY > -0.05f) {
+				deleteEntity();
+				Main.instance.getWorld().getPlayer().getInventory().addCoins(1);
+			}
+		}
+	}
+
+	@Override
+	public void onEntityCollision(Entity e) {
+		if (e instanceof Player && !moveToCounterAnimation) {
+			moveToCounterAnimation = true;
+			enableTileCollisions = false;
+		}
+	}
+}

Zoelda/src/main/entities/Entity.java

@@ -18,6 +18,8 @@ public abstract class Entity implements Ticker {
 	protected float friction = 0.2f; // Entschleunigung des entities in gameunits pro frame.
 	protected float width = 1f, height = 1f; // Breite und Höhe der Hitbox.
 	private boolean deleteEntity; // Wenn true wird dieses Entity von der map gelöscht
+	protected boolean enablePushBack = true; // Ob das Entity von anderen Entities weggedrückt werden kann.
+	protected boolean enableTileCollisions = true; // Ob das Entity von Wänden abprallen soll
 
 	// Das ist die Ticker-Methode von ea; wird jeden frame ausgeführt (frameloop)
 	@Override
@@ -49,12 +51,16 @@ public abstract class Entity implements Ticker {
 	/**
 	 * Checkt collision mit tiles von der map. Fertig, clean, nie wieder ändern.
 	 */
-	public void checkTileCollisions(Map map) {
+	public void checkTileCollision(Map map) {
+		if (!enableTileCollisions) {
+			return;
+		}
 		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) {
+						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);
@@ -75,6 +81,37 @@ public abstract class Entity implements Ticker {
 		}
 	}
 
+	public void checkEntityCollision(Map map) {
+		for (int i = 0; i < map.getEntities().size(); i++) {
+			Entity e = map.getEntities().get(i);
+			if (e != this) {
+				float esize = (e.getWidth() + e.getHeight()) / 2;
+				float size = (width + height) / 2;
+				float dist = dist(e);
+				float sizes = esize / 2 + size / 2;
+				if (dist < sizes) {
+					if (enablePushBack && e.enablePushBack) {
+						float overlap = dist - sizes;
+						float xDist = e.posX - posX;
+						float yDist = e.posY - posY;
+						if (xDist == 0f) {
+							xDist = (float) (Math.random() - 0.5f) * 0.01f;
+						}
+						if (yDist == 0f) {
+							yDist = (float) (Math.random() - 0.5f) * 0.01f;
+						}
+						posX += (overlap * xDist);
+						posY += (overlap * yDist);
+					}
+					onEntityCollision(e);
+				}
+			}
+		}
+	}
+
+	public void onEntityCollision(Entity e) {
+	}
+
 	/**
 	 * Gehört mit zur collision detection. Hier werden kollisionen aufgelöst.
 	 */
@@ -104,32 +141,33 @@ public abstract class Entity implements Ticker {
 			posX = blockX - width / 2;
 		}
 	}
-	
+
 	/**
 	 * @return die entifernung zu diesem Entity
 	 */
 	public float dist(Entity e) {
 		return (float) Math.sqrt((e.posX - posX) * (e.posX - posX) + (e.posY - posY) * (e.posY - posY));
 	}
-	
+
 	/**
 	 * @return die entifernung zu dieser Koordinate
 	 */
 	public float dist(float x, float y) {
 		return (float) Math.sqrt((x - posX) * (x - posX) + (y - posY) * (y - posY));
 	}
-	
+
 	/**
 	 * Generiert einen vektor von diesm Entity zu einem anderen
 	 */
 	public Vektor vectorToEntity(Entity e) {
-		Vektor v = new Vektor(e.posX - posX, e.posY - posY);;
+		Vektor v = new Vektor(e.posX - posX, e.posY - posY);
+		;
 		if (v.x == 0 && v.y == 0) {
-			return new Vektor(0.0000001f, 0.0000001f);
+			return new Vektor(0.001f, 0.001f);
 		}
 		return v;
 	}
-	
+
 	protected boolean lineOfSightClear(Entity e) {
 		Vektor direct = vectorToEntity(e).normiert();
 		direct = direct.teilen(4f);
@@ -152,6 +190,7 @@ public abstract class Entity implements Ticker {
 
 	/**
 	 * Gibt den velX Wert zurück.
+	 * 
 	 * @return gibt den velX Wert als float zurück.
 	 */
 	public float getVelX() {
@@ -160,6 +199,7 @@ public abstract class Entity implements Ticker {
 
 	/**
 	 * Gibt den velY Wert zurück.
+	 * 
 	 * @return gibt den velY Wert als float zurück.
 	 */
 	public float getVelY() {
@@ -168,6 +208,7 @@ public abstract class Entity implements Ticker {
 
 	/**
 	 * Setzt eine neue velX velocity.
+	 * 
 	 * @param velX neuer float velX Wert.
 	 */
 	public void setVelX(float velX) {
@@ -176,30 +217,47 @@ public abstract class Entity implements Ticker {
 
 	/**
 	 * Setzt eine neue Y velocity.
+	 * 
 	 * @param velY neuer float velY Wert.
 	 */
 	public void setVelY(float velY) {
 		this.velY = velY;
 	}
-	
+
 	public void setPosX(float x) {
 		posX = x;
 	}
-	
+
 	public void setPosY(float y) {
 		posY = y;
 	}
-	
+
 	public void setPos(float x, float y) {
 		posX = x;
 		posY = y;
 	}
 	
+	public float getPosX() {
+		return posX;
+	}
+	
+	public float getPosY() {
+		return posY;
+	}
+
 	public void deleteEntity() {
 		deleteEntity = true;
 	}
-	
+
 	public boolean isReadyToDelete() {
 		return deleteEntity;
 	}
+
+	public float getWidth() {
+		return width;
+	}
+
+	public float getHeight() {
+		return height;
+	}
 }

Zoelda/src/main/entities/LivingEntity.java

@@ -1,76 +1,34 @@
 package main.entities;
 
-import ea.ActionFigur;
-import ea.Figur;
-import main.World;
-
 /*
  * Alles was zustände hat und sich Bewegen kann, ist ein LivingEntity.
  */
-public abstract class LivingEntity extends Entity {
+public abstract class LivingEntity extends AnimatedEntity {
 
-	protected boolean side; // true = gespiegelt, false = nicht
+	protected boolean mirrored; // true = gespiegelt, false = nicht
-	public ActionFigur actionFigur; // Sprite des Entities
-	protected float spriteScale = 1f; // Skalierung des Sprites
-	protected float spriteOffsetX, spriteOffsetY; // Offset des Sprites. Hier kann man die relative render-Position nachjustieren.
 	protected float hp = 1f; //hp des Entitys
-	protected boolean mirrored;
-	
-	/**
-	 * @param figur - erstes (standart) Sprite
-	 * @param name  - name des Zustands
-	 */
-	public LivingEntity(Figur figur, String name) {
-		actionFigur = new ActionFigur(figur, name) {
-			// DEBUG: render boxes
-
-//			@Override
-//			public void zeichnen(Graphics2D g, BoundingRechteck r) {
-//				g.setColor(Color.GREEN);
-//				g.drawRect((int) actionFigur.positionX(), (int) actionFigur.positionY(), (int) actionFigur.getBreite(), (int) actionFigur.getHoehe());
-//				g.drawRect((int) ((posX - width / 2) * World.SCALE), (int) ((posY - height / 2) * World.SCALE), (int) (width * World.SCALE), (int) (height * World.SCALE));
-//				super.zeichnen(g, r);
-//			}
-		};
-	}
 
 	@Override
 	protected void update() {
 		// Prüft zu welcher seite man guckt
 		if (velX < 0) {
-			side = true;
+			side = !mirrored;
 		} else if (velX > 0) {
-			side = false;
+			side = mirrored;
 		}
 		
 		if (hp <= 0) {
 			actionFigur.zustandSetzen(getDeathAnimationName());
 			velX = 0;
 			velY = 0;
-			if (actionFigur.aktuelleFigur().aktuellesBild() == actionFigur.aktuelleFigur().animation().length - 1) {
+			if (actionFigur.aktuelleFigur().aktuellesBild() == actionFigur.aktuelleFigur().animation().length - 1 && !isReadyToDelete()) {
 				deleteEntity();
+				onDeath();
 			}
 		}
-
+		super.update();
-		// Packt das Sprite an die richtige Stelle
-		actionFigur.faktorSetzen((int) (spriteScale * World.SCALE_FACTOR));
-		float offsetX = width / 2 + spriteOffsetX - width / 2;
-		float offsetY = height / 2 + spriteOffsetY - height / 2;
-		actionFigur.positionSetzen((posX + offsetX) * World.SCALE - actionFigur.getBreite() / 2, (posY + offsetY) * World.SCALE - actionFigur.getHoehe() / 2);
 	}
 
-	/**
-	 * Spiegelt die figur autmatisch, wenn nötig.
-	 */
-	protected void zustandSetzen(String name) {
-		actionFigur.spiegelXSetzen(mirrored ? !side : side);
-		if (!actionFigur.aktuellesVerhalten().equals(name)) {
-			actionFigur.zustandSetzen(name);
-			actionFigur.aktuelleFigur().animationsBildSetzen(0);
-		}
-	}
-	
-
 	public float getHP() {
 		return hp;
 	}
@@ -83,4 +41,7 @@ public abstract class LivingEntity extends Entity {
 	
 	public abstract String getDeathAnimationName();
 	public abstract String getDamageAnimationName();
+	
+	protected void onDeath() {
+	}
 }

Zoelda/src/main/entities/Rick.java

@@ -0,0 +1,36 @@
+package main.entities;
+
+import main.SheetLoader;
+
+public class Rick extends LivingEntity{
+	
+	private static SheetLoader loader = new SheetLoader("/res/images/rick_sprite_sheet.png");
+	
+	public Rick() {
+		loader.generateFigures(24, 24, new int[] {4});
+
+		width = 0.7f;
+		height = 0.8f;
+		spriteOffsetY = -0.14f;
+		spriteScale = 0.8f;
+		posX = 4f;
+		posY = 4f;
+		mirrored = true;
+
+		loader.getFigur(0).animationsGeschwindigkeitSetzen(265);
+		actionFigur.neuerZustand(loader.getFigur(0), "dancin");
+		zustandSetzen("dancin");
+	}
+
+	@Override
+	public String getDeathAnimationName() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public String getDamageAnimationName() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+}

Zoelda/src/main/entities/Snake.java

@@ -7,12 +7,13 @@ import main.entities.player.Player;
 
 public class Snake extends LivingEntity {
 
-	private static SheetLoader loader = new SheetLoader("/res/images/snake_spritesheet_calciumtrice.png", 32, 32,
+	private static SheetLoader loader = new SheetLoader("/res/images/snake_spritesheet_calciumtrice.png");
-			new int[] { 10, 10, 10, 10, 13, 8 });
+
+	private float damage = 0.1f;
+	private boolean attackOnce;
 
 	public Snake() {
-		super(loader.getFigur(0), "idle");
+		loader.generateFigures(32, 32, new int[] { 10, 10, 10, 10, 13, 8 });
-
 		posX = 9f;
 		posY = 9f;
 		accelleration = 0.006f;
@@ -21,6 +22,7 @@ public class Snake extends LivingEntity {
 		height = 0.8f;
 		mirrored = true;
 
+		actionFigur.neuerZustand(loader.getFigur(0), "idle");
 		actionFigur.neuerZustand(loader.getFigur(1), "lost_sight");
 		actionFigur.neuerZustand(loader.getFigur(2), "walk");
 		actionFigur.neuerZustand(loader.getFigur(3), "attack");
@@ -38,6 +40,14 @@ public class Snake extends LivingEntity {
 			if (lineOfSightClear(player)) {
 				if (dist(player) < 1f) {
 					zustandSetzen("attack");
+					if (actionFigur.aktuelleFigur().aktuellesBild() == 6) {
+						if (!attackOnce) {
+							attackOnce = true;
+							player.takeDamage(damage, this);
+						}
+					} else {
+						attackOnce = false;
+					}
 				} else {
 					Vektor toPlayer = vectorToEntity(player).normiert();
 					velX += toPlayer.x * accelleration;
@@ -47,7 +57,8 @@ public class Snake extends LivingEntity {
 			} else {
 				if (!actionFigur.aktuellesVerhalten().equals("idle")) {
 					zustandSetzen("lost_sight");
-					if (actionFigur.aktuelleFigur().aktuellesBild() == actionFigur.aktuelleFigur().animation().length - 1) {
+					if (actionFigur.aktuelleFigur().aktuellesBild() == actionFigur.aktuelleFigur().animation().length
+							- 1) {
 						zustandSetzen("idle");
 					}
 				}
@@ -57,7 +68,6 @@ public class Snake extends LivingEntity {
 				zustandSetzen("walk");
 			}
 		}
-		this.checkTileCollisions(Main.instance.getWorld().getCurrentMap());
 		super.update();
 	}
 
@@ -70,4 +80,16 @@ public class Snake extends LivingEntity {
 	public String getDamageAnimationName() {
 		return "damage";
 	}
+	
+	@Override
+	protected void onDeath() {
+		int count = (int) (Math.random() * 3);
+		for (int i = 0; i < count; i++) {
+			Coin c = new Coin();
+			float x = posX + (float) Math.random() * width - width / 2;
+			float y = posY + (float) Math.random() * height - height / 2;
+			c.setPos(x, y);
+			Main.instance.getWorld().getCurrentMap().addAnimatedEntity(c);
+		}
+	}
 }

Zoelda/src/main/entities/Spider.java

@@ -7,10 +7,10 @@ import main.entities.player.Player;
 
 public class Spider extends LivingEntity {
 
-	private static SheetLoader loader = new SheetLoader("/res/images/spider_sprite_sheet.png", 32, 32, new int[] { 5, 3, 6, 9, 9, 8 });
+	private static SheetLoader loader = new SheetLoader("/res/images/spider_sprite_sheet.png");
 
 	public Spider() {
-		super(loader.getFigur(0), "idle");
+		loader.generateFigures(32, 32, new int[] { 5, 3, 6, 9, 9, 8 });
 
 		width = 0.7f;
 		height = 0.8f;
@@ -19,7 +19,8 @@ public class Spider extends LivingEntity {
 		posX = 4f;
 		posY = 4f;
 		mirrored = true;
-		
+
+		actionFigur.neuerZustand(loader.getFigur(0), "idle");
 		actionFigur.neuerZustand(loader.getFigur(1), "lost_sight");
 		actionFigur.neuerZustand(loader.getFigur(2), "walk");
 		actionFigur.neuerZustand(loader.getFigur(3), "attack");
@@ -55,7 +56,6 @@ public class Spider extends LivingEntity {
 				zustandSetzen("walk");
 			}
 		}
-		this.checkTileCollisions(Main.instance.getWorld().getCurrentMap());
 		super.update();
 	}
 

Zoelda/src/main/entities/player/Player.java

@@ -11,13 +11,13 @@ import main.entities.LivingEntity;
 
 public class Player extends LivingEntity {
 
-	private static SheetLoader loader = new SheetLoader("/res/images/player_sprite_sheet.png", 64, 32,
+	private static SheetLoader loader = new SheetLoader("/res/images/player_sprite_sheet.png");
-			new int[] { 5, 8, 7, 6, 2, 5, 4, 7 });
 	private boolean onlyAttackOnceTrigger;
 	private float range = 1.2f; // die reichweite der Attacke
+	private PlayerInventory inventory;
 
 	public Player() {
-		super(loader.getFigur(0), "idle");
+		loader.generateFigures(64, 32, new int[] { 5, 8, 7, 6, 2, 5, 4, 7 });
 
 		// Entity-Eigenschaften werden festgelegt
 		width = 0.7f;
@@ -26,23 +26,23 @@ public class Player extends LivingEntity {
 		spriteScale = 0.8f;
 		posX = 7.5f;
 		posY = 5.5f;
-		
-		// XXX
-		accelleration = 0.05f;
 
 		// unterschiedliche Animationsgeschwindigkeiten
-		// für idle
+		// f<EFBFBD>r idle
 		loader.getFigur(0).animationsGeschwindigkeitSetzen(200);
-		// fürs laufen
+		// f<EFBFBD>rs laufen
 		loader.getFigur(1).animationsGeschwindigkeitSetzen(50);
 
-		// Zustände werden hinzugefügt
+		// Zust<EFBFBD>nde werden hinzugef<EFBFBD>gt
 		actionFigur.neuerZustand(loader.getFigur(0), "idle");
 		actionFigur.neuerZustand(loader.getFigur(1), "walk");
 		actionFigur.neuerZustand(loader.getFigur(2), "strike");
 		actionFigur.neuerZustand(loader.getFigur(3), "swipe");
 		actionFigur.neuerZustand(loader.getFigur(6), getDamageAnimationName());
 		actionFigur.neuerZustand(loader.getFigur(7), getDeathAnimationName());
+
+		//Spieler Inventar
+		inventory = new PlayerInventory(5);
 	}
 
 	@Override
@@ -50,7 +50,7 @@ public class Player extends LivingEntity {
 		// Bei dieser animation bleibt man sofort stehen.
 		if (!((actionFigur.aktuellesVerhalten().equals("strike"))
 				&& actionFigur.aktuelleFigur().aktuellesBild() < actionFigur.aktuelleFigur().animation().length - 1)) {
-			// Bei diser soll man sich nicht bewegen können aber weiter rutschen
+			// Bei diser soll man sich nicht bewegen k<EFBFBD>nnen aber weiter rutschen
 			if (!((actionFigur.aktuellesVerhalten().equals("swipe")) && actionFigur.aktuelleFigur()
 					.aktuellesBild() < actionFigur.aktuelleFigur().animation().length - 1)) {
 
@@ -87,9 +87,6 @@ public class Player extends LivingEntity {
 				}
 				onlyAttackOnceTrigger = false;
 			}
-
-			// auf Kollisionen prüfen
-			checkTileCollisions(Main.instance.getWorld().getCurrentMap());
 			// LivingEntity auch updaten lassen
 			super.update();
 		} else {
@@ -97,23 +94,22 @@ public class Player extends LivingEntity {
 			velY = 0;
 		}
 
-		// auf Kollisionen prüfen
+		if (!actionFigur.aktuellesVerhalten().equals(getDamageAnimationName())) {
-		checkTileCollisions(Main.instance.getWorld().getCurrentMap());
+			if (!onlyAttackOnceTrigger && actionFigur.aktuellesVerhalten().equals("swipe")
-
+					&& actionFigur.aktuelleFigur().aktuellesBild() == 1) {
-		if (!onlyAttackOnceTrigger && actionFigur.aktuellesVerhalten().equals("swipe")
+				onlyAttackOnceTrigger = true;
-				&& actionFigur.aktuelleFigur().aktuellesBild() == 1) {
+				ArrayList<Entity> entities = Main.instance.getWorld().getCurrentMap().getEntities();
-			onlyAttackOnceTrigger = true;
+				for (Entity e : entities) {
-			ArrayList<Entity> entities = Main.instance.getWorld().getCurrentMap().getEntities();
+					if (e instanceof LivingEntity && e != this && e.dist(this) <= range) {
-			for (Entity e : entities) {
+						LivingEntity le = (LivingEntity) e;
-				if (e instanceof LivingEntity && e != this && e.dist(this) <= range) {
+						if (le.getHP() > 0) {
-					LivingEntity le = (LivingEntity) e;
+							Vektor toE = vectorToEntity(le);
-					if (le.getHP() > 0) {
+							toE = toE.normiert();
-						Vektor toE = vectorToEntity(le);
+							if ((toE.x > 0 && !side) || (toE.x <= 0 && side)) {
-						toE = toE.normiert();
+								le.setVelX(le.getVelX() + toE.x * 0.1f);
-						if ((toE.x > 0 && !side) || (toE.x <= 0 && side)) {
+								le.setVelY(le.getVelY() + toE.y * 0.1f);
-							le.setVelX(le.getVelX() + toE.x * 0.1f);
+								le.takeDamage(0.1f, this);
-							le.setVelY(le.getVelY() + toE.y * 0.1f);
+							}
-							le.takeDamage(0.1f, this);
 						}
 					}
 				}
@@ -121,6 +117,10 @@ public class Player extends LivingEntity {
 		}
 	}
 
+	public PlayerInventory getInventory() {
+		return inventory;
+	}
+
 	@Override
 	public String getDeathAnimationName() {
 		return "die";

Zoelda/src/main/maps/Corridor.java

@@ -7,32 +7,37 @@ public class Corridor extends Map {
 	public Corridor() {
 		super(15, 11);
 
-		for (int x = 0; x < map.length; x++) {
+		for (int x = 0; x < tiles.length; x++) {
-			for (int y = 0; y < map[0].length; y++) {
+			for (int y = 0; y < tiles[0].length; y++) {
 				// Wand
 				if ((y == 0 || x == 5 || y == 10 || x == 9) && x != 7 && x >= 5 && x <= 9) {
-					map[x][y] = new Tile(Tile.STONE_WALL, x, y);
+					tiles[x][y] = new Tile(Tile.STONE_WALL, x, y);
-					add(map[x][y]);
+					add(tiles[x][y]);
 				}
 				// 3D-Wand
 				else if (y == 1 && (x != 0 || x != 4) && x != 7 && x >= 6 && x <= 8) {
-					map[x][y] = new Tile(Tile.STONE_WALL_BOTTOM, x, y);
+					tiles[x][y] = new Tile(Tile.STONE_WALL_BOTTOM, x, y);
-					add(map[x][y]);
+					add(tiles[x][y]);
 				}
 				// Steinboden
 				else if (x >= 6 && x <= 8) {
-					if (x == 7 && (y == 0 || y == map[0].length - 1)) {
+					if (x == 7 && (y == 0 || y == tiles[0].length - 1)) {
 					} else {
-						map[x][y] = new Tile(Tile.STONE_FLOOR, x, y);
+						tiles[x][y] = new Tile(Tile.STONE_FLOOR, x, y);
-						add(map[x][y]);
+						add(tiles[x][y]);
 					}
 				} else {
-					map[x][y] = new Tile(Tile.VOID, x, y);
+					tiles[x][y] = new Tile(Tile.VOID, x, y);
-					add(map[x][y]);
+					add(tiles[x][y]);
 				}
 			}
 		}
-		
+	}
-		registerEntities();
+
+	@Override
+	public Map clone() {
+		Corridor c = new Corridor();
+		c.cloneTiles(this);
+		return c;
 	}
 }

Zoelda/src/main/maps/ImageMap.java

@@ -3,35 +3,26 @@ package main.maps;
 import java.awt.Color;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
-import java.util.ArrayList;
 
 import javax.imageio.ImageIO;
 
 import main.DoorTile;
-import main.Main;
 import main.Tile;
 
 public class ImageMap extends Map {
 
+	// Erstellung der abzulesenden Tiles (einem Tile wird eine Farbe zugewiesen)
+
 	private static PixelTile[] pixels = { 
 			new PixelTile(Tile.STONE_WALL, new Color(100, 100, 100)),
 			new PixelTile(Tile.STONE_FLOOR, new Color(127, 127, 127)), 
 			new PixelTile(Tile.VOID, new Color(0, 0, 0)),
-			new PixelTile(Tile.DOOR, new Color(255, 0, 0)) };
+			new PixelTile(Tile.DOOR_LEFT, new Color(255, 150, 0)),
-
+			new PixelTile(Tile.DOOR_RIGHT, new Color(69, 150, 0)),
-	public DoorTile topDoor;
+			new PixelTile(Tile.DOOR_BOTTOM, new Color(150, 150, 0)),
-	public DoorTile leftDoor;
+			new PixelTile(Tile.DOOR_TOP, new Color(0, 147, 150)),
-	public DoorTile rightDoor;
+			new PixelTile(Tile.STONE_WALL_BOTTOM, new Color(145, 145, 145)),
-	public DoorTile bottomDoor;
+			new PixelTile(Tile.STONE_FLOOR_SHADOW_LEFT, new Color(251, 251, 129)) };
-	
-	private static ImageMap[] maps;
-	
-	static {
-		maps = new ImageMap[8];
-		for (int i = 0; i < maps.length; i++) {
-			maps[i] = new ImageMap("/res/images/maps/map" + (i + 1) + ".png");
-		}
-	}
 
 	public ImageMap(String path) {
 		super(15, 11);
@@ -51,31 +42,41 @@ public class ImageMap extends Map {
 							break;
 						}
 					}
-					if (id == Tile.DOOR) {
+					if (id == Tile.DOOR_LEFT) {
-						DoorTile door = new DoorTile(x, y, this);
+						DoorTile door = new DoorTile(id, x, y, this);
-						map[x][y] = door;
+						leftDoor = door;
-						if (x == 7) {
+						door.setSide(DoorTile.LEFT);
-							if (y < 5) {
+						tiles[x][y] = door;
-								topDoor = door;
+						add(tiles[x][y]);
-								door.setSide(DoorTile.TOP);
+						continue;
-							} else {
-								bottomDoor = door;
-								door.setSide(DoorTile.BOTTOM);
-							}
-						}
-						if (y == 5) {
-							if (x < 7) {
-								leftDoor = door;
-								door.setSide(DoorTile.LEFT);
-							} else {
-								rightDoor = door;
-								door.setSide(DoorTile.RIGHT);
-							}
-						}
-					} else {
-						map[x][y] = new Tile(id, x, y);
 					}
-					add(map[x][y]);
+					if (id == Tile.DOOR_RIGHT ) {
+						DoorTile door = new DoorTile(id, x, y, this);
+						rightDoor = door;
+						door.setSide(DoorTile.RIGHT);
+						tiles[x][y] = door;
+						add(tiles[x][y]);
+						continue;
+					}
+					if (id == Tile.DOOR_TOP) {
+						DoorTile door = new DoorTile(id, x, y, this);
+						topDoor = door;
+						door.setSide(DoorTile.TOP);
+						tiles[x][y] = door;
+						add(tiles[x][y]);
+						continue;
+					}
+					if (id == Tile.DOOR_BOTTOM) {
+						DoorTile door = new DoorTile(id, x, y, this);
+						bottomDoor = door;
+						door.setSide(DoorTile.BOTTOM);
+						tiles[x][y] = door;
+						add(tiles[x][y]);
+						continue;
+					}
+					
+					tiles[x][y] = new Tile(id, x, y);
+					add(tiles[x][y]);
 				}
 			}
 		} catch (IOException e) {
@@ -83,6 +84,11 @@ public class ImageMap extends Map {
 		}
 	}
 
+	public ImageMap(ImageMap map) {
+		super(map.getWidth(), map.getHeight());
+		cloneTiles(map);
+	}
+
 	private static class PixelTile {
 		public final int c;
 		public final int id;
@@ -93,107 +99,8 @@ public class ImageMap extends Map {
 		}
 	}
 
-	public void generate(ArrayList<ImageMap> dungeon, int fromSide) {
+	@Override
-		if (topDoor != null && fromSide != DoorTile.TOP) {
+	public ImageMap clone() {
-			ImageMap map;
+		return new ImageMap(this);
-			do {
-				map = nextMap();
-			} while (!connectDoors(topDoor, map));
-			dungeon.add(map);
-			map.generate(dungeon, DoorTile.BOTTOM);
-		}
-		if (bottomDoor != null && fromSide != DoorTile.BOTTOM) {
-			ImageMap map;
-			do {
-				map = nextMap();
-			} while (!connectDoors(bottomDoor, map));
-			dungeon.add(map);
-			map.generate(dungeon, DoorTile.TOP);
-		}
-		if (leftDoor != null && fromSide != DoorTile.LEFT) {
-			ImageMap map;
-			do {
-				map = nextMap();
-			} while (!connectDoors(leftDoor, map));
-			dungeon.add(map);
-			map.generate(dungeon, DoorTile.RIGHT);
-		}
-		if (rightDoor != null && fromSide != DoorTile.RIGHT) {
-			ImageMap map;
-			do {
-				map = nextMap();
-			} while (!connectDoors(rightDoor, map));
-			dungeon.add(map);
-			map.generate(dungeon, DoorTile.LEFT);
-		}
-		System.out.println();
-	}
-
-	private ImageMap nextMap() {
-		return new ImageMap("/res/images/maps/map" + ((int) (Math.random() * 6) + 3) + ".png");
-	}
-
-	private boolean connectDoors(DoorTile door, ImageMap otherMap) {
-		switch (door.getSide()) {
-		case DoorTile.TOP:
-			if (otherMap.bottomDoor == null) {
-				return false;
-			}
-			door.setConnectedDoor(otherMap.bottomDoor);
-			otherMap.bottomDoor.setConnectedDoor(door);
-			return true;
-		case DoorTile.BOTTOM:
-			if (otherMap.topDoor == null) {
-				return false;
-			}
-			door.setConnectedDoor(otherMap.topDoor);
-			otherMap.topDoor.setConnectedDoor(door);
-			return true;
-		case DoorTile.LEFT:
-			if (otherMap.rightDoor == null) {
-				return false;
-			}
-			door.setConnectedDoor(otherMap.rightDoor);
-			otherMap.rightDoor.setConnectedDoor(door);
-			return true;
-		case DoorTile.RIGHT:
-			if (otherMap.leftDoor == null) {
-				return false;
-			}
-			door.setConnectedDoor(otherMap.leftDoor);
-			otherMap.leftDoor.setConnectedDoor(door);
-			return true;
-		}
-		return true;
-	}
-
-	public void start() {
-		if (topDoor != null) {
-			Main.instance.manager.anmelden(topDoor, 50);
-		}
-		if (bottomDoor != null) {
-			Main.instance.manager.anmelden(bottomDoor, 50);
-		}
-		if (leftDoor != null) {
-			Main.instance.manager.anmelden(leftDoor, 50);
-		}
-		if (rightDoor != null) {
-			Main.instance.manager.anmelden(rightDoor, 50);
-		}
-	}
-	
-	public void stop() {
-		if (topDoor != null) {
-			Main.instance.manager.abmelden(topDoor);
-		}
-		if (bottomDoor != null) {
-			Main.instance.manager.abmelden(bottomDoor);
-		}
-		if (leftDoor != null) {
-			Main.instance.manager.abmelden(leftDoor);
-		}
-		if (rightDoor != null) {
-			Main.instance.manager.abmelden(rightDoor);
-		}
 	}
 }

Zoelda/src/main/maps/Map.java

@@ -4,22 +4,29 @@ import java.util.ArrayList;
 
 import ea.Knoten;
 import ea.Ticker;
+import main.DoorTile;
 import main.Main;
 import main.Tile;
+import main.entities.AnimatedEntity;
 import main.entities.Entity;
-import main.entities.LivingEntity;
+import main.entities.player.Player;
 
 /**
  * Auf der Map sind alle Entities, sowie die Tiles gespiechert.
  */
 public abstract class Map extends Knoten implements Ticker {
 
-	protected Tile[][] map; // Die Tiles der map in einem 2D Array.
+	protected Tile[][] tiles; // Die Tiles der map in einem 2D Array.
 	private ArrayList<Entity> entities;
-	
+	private boolean started;
+
+	public DoorTile topDoor;
+	public DoorTile leftDoor;
+	public DoorTile rightDoor;
+	public DoorTile bottomDoor;
 
 	public Map(int width, int height) {
-		map = new Tile[width][height];
+		tiles = new Tile[width][height];
 
 		entities = new ArrayList<>(100);
 
@@ -31,8 +38,8 @@ public abstract class Map extends Knoten implements Ticker {
 	 * existiert)
 	 */
 	public Tile getTile(int x, int y) {
-		if (x >= 0 && x < map.length && y >= 0 && y < map[0].length) {
+		if (x >= 0 && x < tiles.length && y >= 0 && y < tiles[0].length) {
-			return map[x][y];
+			return tiles[x][y];
 		}
 		return null;
 	}
@@ -42,8 +49,8 @@ public abstract class Map extends Knoten implements Ticker {
 		for (int i = 0; i < entities.size(); i++) {
 			Entity e = entities.get(i);
 			if (e.isReadyToDelete()) {
-				if (e instanceof LivingEntity) {
+				if (e instanceof AnimatedEntity) {
-					entfernen(((LivingEntity) e).actionFigur);
+					entfernen(((AnimatedEntity) e).actionFigur);
 				}
 				Main.instance.manager.abmelden(e);
 				entities.remove(e);
@@ -52,20 +59,99 @@ public abstract class Map extends Knoten implements Ticker {
 	}
 
 	public int getWidth() {
-		return map.length;
+		return tiles.length;
 	}
 
 	public int getHeight() {
-		return map[0].length;
+		return tiles[0].length;
 	}
 
 	public ArrayList<Entity> getEntities() {
 		return entities;
 	}
 
-	public void registerEntities() {
+	public void addAnimatedEntity(AnimatedEntity e) {
-		for (Entity e : getEntities()) {
+		entities.add(e);
+		add(e.actionFigur);
+		if (started) {
 			Main.instance.manager.anmelden(e, 20);
 		}
 	}
+
+	public abstract Map clone();
+
+	public void cloneTiles(Map map) {
+		for (int x = 0; x < map.getWidth(); x++) {
+			for (int y = 0; y < map.getHeight(); y++) {
+				tiles[x][y] = map.getTile(x, y).clone();
+				if (tiles[x][y] instanceof DoorTile) {
+					DoorTile dt = (DoorTile) tiles[x][y];
+					if (dt.getSide() == DoorTile.TOP) {
+						topDoor = dt;
+						topDoor.setMap(this);
+					}
+					if (dt.getSide() == DoorTile.BOTTOM) {
+						bottomDoor = dt;
+						bottomDoor.setMap(this);
+					}
+					if (dt.getSide() == DoorTile.LEFT) {
+						leftDoor = dt;
+						leftDoor.setMap(this);
+					}
+					if (dt.getSide() == DoorTile.RIGHT) {
+						rightDoor = dt;
+						rightDoor.setMap(this);
+					}
+				}
+				add(tiles[x][y]);
+			}
+		}
+	}
+
+	public void start() {
+		if (topDoor != null) {
+			Main.instance.manager.anmelden(topDoor, 50);
+		}
+		if (bottomDoor != null) {
+			Main.instance.manager.anmelden(bottomDoor, 50);
+		}
+		if (leftDoor != null) {
+			Main.instance.manager.anmelden(leftDoor, 50);
+		}
+		if (rightDoor != null) {
+			Main.instance.manager.anmelden(rightDoor, 50);
+		}
+		for (Entity e : entities) {
+			if (!(e instanceof Player)) {
+				Main.instance.manager.anmelden(e, 20);
+			}
+		}
+		started = true;
+	}
+
+	public void stop() {
+		if (topDoor != null) {
+			Main.instance.manager.abmelden(topDoor);
+		}
+		if (bottomDoor != null) {
+			Main.instance.manager.abmelden(bottomDoor);
+		}
+		if (leftDoor != null) {
+			Main.instance.manager.abmelden(leftDoor);
+		}
+		if (rightDoor != null) {
+			Main.instance.manager.abmelden(rightDoor);
+		}
+		for (Entity e : entities) {
+			if (!(e instanceof Player)) {
+				Main.instance.manager.abmelden(e);
+			}
+		}
+		started = false;
+	}
+
+	public void connectDoors(DoorTile door, DoorTile door2) {
+		door.setConnectedDoor(door2);
+		door2.setConnectedDoor(door);
+	}
 }

Zoelda/src/main/maps/Map01.java

@@ -1,25 +0,0 @@
-package main.maps;
-
-import main.Tile;
-
-public class Map01 extends Map {
-	
-	public Map01 () {
-		super (15,11);
-		for (int x = 0; x < map.length; x++) {
-			for (int y = 0; y < map[0].length; y++) {
-				//Wand
-				if((x == 4 || y == 9 || x == 10) && x > 3 && y > 0 && x < 11 && y < 10 && x != 7 ) {
-					map[x][y] = new Tile(3, x, y);
-					add(map[x][y]);
-				} 
-				//Boden
-				else if(x > 3 && y > 0 && x < 11 && y < 10) {
-					map[x][y] = new Tile(5, x, y);
-						add(map[x][y]);
-				}
-			}
-		}
-	}
-	
-}

Zoelda/src/main/maps/Map02.java

@@ -1,38 +0,0 @@
-package main.maps;
-
-import main.Tile;
-
-public class Map02 extends Map {
-
-	public Map02() {
-		super(15, 11);
-
-		for (int x = 0; x < map.length; x++) {
-			for (int y = 0; y < map[0].length; y++) {
-				// Wand
-				if (y == 0 || x == 0 || y == 10 || x == 14) {
-					// Übergang, Tür
-					if (y == 10) {
-						if (x > 4 && x < 10) {
-							map[x][y] = new Tile(5, x, y);
-							add(map[x][y]);
-							continue;
-						}
-					}
-					map[x][y] = new Tile(3, x, y);
-					add(map[x][y]);
-				}
-				// 3D-Wand
-				 else if(y == 1 ) {
-					 map[x][y] = new Tile(4, x, y);
-					 add(map[x][y]);
-				}
-				// Steinboden
-				else {
-					map[x][y] = new Tile(5, x, y);
-					add(map[x][y]);
-				}
-			}
-		}
-	}
-}

Zoelda/src/main/maps/TestMap.java

@@ -1,17 +0,0 @@
-package main.maps;
-
-import main.Tile;
-
-public class TestMap extends Map {
-
-	public TestMap() {
-		super(15, 11);
-		
-		for (int x = 0; x < map.length; x++) {
-			for (int y = 0; y < map[0].length; y++) {
-				map[x][y] = new Tile(Math.random() * 5 < 1 ? 1 : 0, x, y);
-				add(map[x][y]);
-			}
-		}
-	}
-}

Zoelda/src/main/maps/TutorialMap.java

@@ -8,37 +8,34 @@ public class TutorialMap extends Map {
 	
 	public TutorialMap() {
 		super(15, 11);
-		for (int x = 0; x < map.length; x++) {
+		for (int x = 0; x < tiles.length; x++) {
-			for (int y = 0; y < map[0].length; y++) {
+			for (int y = 0; y < tiles[0].length; y++) {
 				//Wand, Sichtschutz
-				if (y == 0 ||y == map[0].length - 1 || x == 0 || x == map.length - 1 || ((y == 4|| y == 5) && x == 10 )) {
+				if (y == 0 ||y == tiles[0].length - 1 || x == 0 || x == tiles.length - 1 || ((y == 4|| y == 5) && x == 10 )) {
-					map[x][y] = new Tile (1, x, y);
+					tiles[x][y] = new Tile (1, x, y);
-					add(map [x][y]);
+					add(tiles [x][y]);
 				}
 				//3D-Wand, 3F-Sichtschutz
 				else if(y == 1 || ( y == 6 && x == 10)) {
-					map[x][y] = new Tile (2, x, y);
+					tiles[x][y] = new Tile (2, x, y);
-					add(map [x][y]);
+					add(tiles [x][y]);
 				}
 				//Grasboden
 				else{
-					map[x][y] = new Tile(0, x, y);
+					tiles[x][y] = new Tile(0, x, y);
-					add(map[x][y]);
+					add(tiles[x][y]);
 				}
 			}
 		}
 
-		// und Spinnen auch
+		addAnimatedEntity(new Spider());
-		Spider spider = new Spider();
+		addAnimatedEntity(new Snake());
-		add(spider.actionFigur);
+	}
-		getEntities().add(spider);
+	
-		
+	@Override
-		//und 
+	public Map clone() {
-		Snake snake = new Snake();
+		TutorialMap c = new TutorialMap();
-		add(snake.actionFigur);
+		c.cloneTiles(this);
-		getEntities().add(snake);
+		return c;
-		
-		// Alle Entities als ticker registrieren (triggert dann die update methoden)
-		registerEntities();
 	}
 }

Zoelda/src/main/worlds/TestWorld.java

@@ -0,0 +1,41 @@
+package main.worlds;
+
+import main.entities.Coin;
+import main.entities.Rick;
+import main.entities.Snake;
+import main.entities.Spider;
+import main.maps.Map;
+
+public class TestWorld extends World {
+
+	public TestWorld() {
+		super(4);
+
+		Map m2 = maps[3].clone();
+		getCurrentMap().connectDoors(getCurrentMap().bottomDoor, m2.topDoor);
+
+		for (int i = 0; i < 15; i++) {
+			Coin c = new Coin();
+			c.setPosX(i * 0.5f + 4);
+			getCurrentMap().addAnimatedEntity(c);
+		}
+		
+		for (int i = 0; i < 2; i++) {
+			Snake s = new Snake();
+			s.setPosX((float) (Math.random() * 5 + 2));
+			getCurrentMap().addAnimatedEntity(s);
+		}
+		
+		for (int i = 0; i < 3; i++) {
+			Spider spooda = new Spider();
+			spooda.setPosX((float) (Math.random() * 5 + 2));
+			getCurrentMap().addAnimatedEntity(spooda);
+		}
+		
+		for (int i = 0; i < 1; i++) {	
+			Rick astley = new Rick();
+			astley.setPosX((float) (Math.random() * 5 + 2));
+			getCurrentMap().addAnimatedEntity(astley);
+		}
+	}
+}

Zoelda/src/main/worlds/World.java

@@ -0,0 +1,67 @@
+package main.worlds;
+
+import ea.Knoten;
+import main.DoorTile;
+import main.entities.player.Player;
+import main.maps.ImageMap;
+import main.maps.Map;
+
+/**
+ * Hier werden alle Maps gespeichert.
+ */
+public abstract class World extends Knoten {
+
+	public static final int SCALE_FACTOR = 4; // Der Basis Zoomfaktor
+	public static final int SCALE = SCALE_FACTOR * 16; // Eine Gameunit ist so viele pixel lang
+
+	private Map currentMap; // Die Map die aktuell angezeigt werden soll.
+
+	private Player player;
+
+	protected static Map[] maps;
+
+	public World(int startMap) {
+		if (maps == null) {
+			maps = new ImageMap[8];
+			for (int i = 0; i < maps.length; i++) {
+				maps[i] = new ImageMap("/res/images/maps/map" + i + "a.png");
+			}
+		}
+		init(maps[startMap]);
+	}
+
+	public World(Map startMap) {
+		init(startMap);
+	}
+
+	private void init(Map startMap) {
+		currentMap = startMap;
+		player = new Player();
+		add(currentMap);
+	}
+
+	public Map getCurrentMap() {
+		return currentMap;
+	}
+
+	public Player getPlayer() {
+		return player;
+	}
+
+	public void changeMap(DoorTile door) {
+		currentMap.stop();
+		currentMap.entfernen(player.actionFigur);
+		entfernen(currentMap);
+		currentMap = door.getConnectedDoor().getMap();
+		add(currentMap);
+		currentMap.add(player.actionFigur);
+		currentMap.start();
+		player.setPos(door.getConnectedDoor().getPosX() + 0.5f, door.getConnectedDoor().getPosY() + 0.5f);
+		door.getConnectedDoor().waitForLeave();
+	}
+
+	public void start() {
+		currentMap.addAnimatedEntity(player);
+		currentMap.start();
+	}
+}