diff --git a/src/main/java/lab/BulletAnimated.java b/src/main/java/lab/BulletAnimated.java
index 148b2385fba57c7bbec6f4b56285ca7461ece9ea..fe6c559d98619b40b985ec3ad4123d111049e9da 100644
--- a/src/main/java/lab/BulletAnimated.java
+++ b/src/main/java/lab/BulletAnimated.java
@@ -5,13 +5,11 @@ import javafx.geometry.Rectangle2D;
 import javafx.scene.canvas.GraphicsContext;
 import javafx.scene.image.Image;
 
-public class BulletAnimated  {
+public class BulletAnimated extends WorldEntity implements Collisionable  {
 
-	private Point2D position;
 	private Point2D start;
 	private Point2D speed;
 	private Point2D initialSpeed;
-	private double size;
 	private double mass = 2;
 	private double strenghtOfCannon = 100;
 	private double cannonLength = 100;
@@ -22,7 +20,6 @@ public class BulletAnimated  {
 	private double dragCoefficient = 0.47;
 	
 	private Image image;
-	private World world;
 	private Cannon cannon;
 
 	public BulletAnimated(World world, Cannon cannon) {
@@ -30,24 +27,17 @@ public class BulletAnimated  {
 	}
 
 	public BulletAnimated(World world, Cannon cannon, Point2D start, Point2D speed, double size) {
+		super(world, start, new Point2D(size, size));
 		this.start = start;
-		this.position = this.start;
 		this.initialSpeed = speed;
 		this.speed = speed;
-		this.size = size;
-		this.world = world;
 		this.cannon = cannon;
 		image = new Image(getClass().getResourceAsStream("fireball-transparent.gif"), size, size,
 				true, true);
 	}
 
-	public void draw(GraphicsContext gc) {
-		gc.save();
-		Point2D canvasPosition = world.getCanvasPoint(position);
-		gc.drawImage(image, canvasPosition.getX(), canvasPosition.getY());
-		gc.restore();
-	}
 
+	@Override
 	public void simulate(double deltaT) {
 		if (accelerate && start.distance(position) < cannonLength) {
 			double cannonAngle = cannon.getAngle(); 
@@ -65,17 +55,41 @@ public class BulletAnimated  {
 		}
 		if (!hitToGround) {
 			position = position.add(speed.multiply(deltaT*100));
-			if (!accelerate && position.getY() <= size / 2) {
+			if (!accelerate && position.getY() <= dimension.getY() / 2) {
 				hitToGround = true;
-				position = new Point2D(position.getX(), size / 2);
+				position = new Point2D(position.getX(), dimension.getY() / 2);
 			}
 		} else {
 			reload();
 		}		
 	}
+	
+	@Override
+	public Rectangle2D getBB() {
+		return getBoundingBox();
+	}
+	
+	@Override
+	public boolean isInCollisionWith(Collisionable col) {
+		if (!(col instanceof Dragon)) {
+			return false;
+		}
+		return Collisionable.super.isInCollisionWith(col);
+	}
+	
+	@Override
+	public void hitBy(Collisionable col) {
+		reload();
+	}
+	
+	@Override
+	protected void drawInternal(GraphicsContext gc) {
+		Point2D canvasPosition = world.getCanvasPoint(position);
+		gc.drawImage(image, canvasPosition.getX(), canvasPosition.getY());
+	}
 
 	public Rectangle2D getBoundingBox() {
-		return new Rectangle2D(position.getX(), position.getY(), size, size);
+		return new Rectangle2D(position.getX(), position.getY() - dimension.getY(), dimension.getX(), dimension.getY());
 	}
 	
 	public boolean overlaps(Dragon dragon) {
diff --git a/src/main/java/lab/Cannon.java b/src/main/java/lab/Cannon.java
index b46745dc0779c5152639f0c4c9815c34f80d56fa..215b5ef904d6a68e88cef5d3f16cfe11abffabed 100644
--- a/src/main/java/lab/Cannon.java
+++ b/src/main/java/lab/Cannon.java
@@ -5,24 +5,16 @@ import javafx.scene.canvas.GraphicsContext;
 import javafx.scene.paint.Color;
 import javafx.scene.transform.Affine;
 
-public class Cannon {
+public class Cannon extends WorldEntity{
 
 	private int direction=-1;
 	private double angle = 0;
-	private Point2D position;
-	private Point2D size;
-	private World world;
 	
-	
-	 
-
 	public Cannon(World world, Point2D position, Point2D size) {
-		super();
-		this.world = world;
-		this.position = position;
-		this.size = size;
+		super(world, position, size);
 	}
 
+	@Override
 	public void simulate(double timeStep) {
 		angle = angle + direction*80*timeStep;
 		if(angle <=-90 || angle >= 0) {
@@ -30,20 +22,19 @@ public class Cannon {
 		}
 	}
 	
-	public void draw(GraphicsContext gc) {
-		gc.save();
+	public double getAngle() {
+		return (angle * -1) / 180 * Math.PI;
+	}
+
+	@Override
+	protected void drawInternal(GraphicsContext gc) {
 		Point2D worldPosition = world.getCanvasPoint(position);
 		gc.setFill(Color.BROWN);
-		gc.fillRect(worldPosition.getX()-10, worldPosition.getY()+size.getY(), size.getX()+20, size.getY()/2);
-		gc.fillOval(worldPosition.getX()-20, worldPosition.getY()+size.getY()/2, 40, 40);
-		gc.fillOval(worldPosition.getX()+size.getX(), worldPosition.getY()+size.getY()/2, 40, 40);
-		gc.setTransform(new Affine(Affine.rotate(angle, worldPosition.getX(), worldPosition.getY()+size.getY()/2)));
+		gc.fillRect(worldPosition.getX()-10, worldPosition.getY()+dimension.getY(), dimension.getX()+20, dimension.getY()/2);
+		gc.fillOval(worldPosition.getX()-20, worldPosition.getY()+dimension.getY()/2, 40, 40);
+		gc.fillOval(worldPosition.getX()+dimension.getX(), worldPosition.getY()+dimension.getY()/2, 40, 40);
+		gc.setTransform(new Affine(Affine.rotate(angle, worldPosition.getX(), worldPosition.getY()+dimension.getY()/2)));
 		gc.setFill(Color.BLACK);
-		gc.fillRect(worldPosition.getX(), worldPosition.getY(), size.getX(), size.getY());
-		gc.restore();
-	}
-
-	public double getAngle() {
-		return (angle * -1) / 180 * Math.PI;
+		gc.fillRect(worldPosition.getX(), worldPosition.getY(), dimension.getX(), dimension.getY());
 	}
 }
diff --git a/src/main/java/lab/Collisionable.java b/src/main/java/lab/Collisionable.java
new file mode 100644
index 0000000000000000000000000000000000000000..09bae275e68eb487b3ef468bda88649fe701f91d
--- /dev/null
+++ b/src/main/java/lab/Collisionable.java
@@ -0,0 +1,13 @@
+package lab;
+
+import javafx.geometry.Rectangle2D;
+
+public interface Collisionable {
+	Rectangle2D getBB();
+	
+	default boolean isInCollisionWith(Collisionable col) {
+		return getBB().intersects(col.getBB());
+	}
+	
+	void hitBy(Collisionable col);
+}
diff --git a/src/main/java/lab/Dragon.java b/src/main/java/lab/Dragon.java
index 216628afbd03d95d4896abc8b5175efcb25709c8..653f567f06f1a300036a766fd54a20930369dbc2 100644
--- a/src/main/java/lab/Dragon.java
+++ b/src/main/java/lab/Dragon.java
@@ -4,30 +4,17 @@ import javafx.geometry.Point2D;
 import javafx.geometry.Rectangle2D;
 import javafx.scene.canvas.GraphicsContext;
 
-public class Dragon {
-	
-	private Point2D position;
+public class Dragon extends WorldEntity implements Collisionable{
 	
 	private Point2D speed;
 	
-	private final World world;
-		
-	private final double size = 45;
 
 	public Dragon(World world, Point2D position, Point2D speed) {
-		super();
-		this.world = world;
-		this.position = position;
+		super(world, position, new Point2D(45, 45));
 		this.speed = speed;
 	}
 
-	
-	public void draw(GraphicsContext gc) {
-		Point2D canvasPosition = world.getCanvasPoint(position);
-		gc.drawImage(Constants.DRAGON_IMAGE, canvasPosition.getX(), canvasPosition.getY(), size, size);
-	}
-
-
+	@Override
 	public void simulate(double timeDelta) {
 		double timeDeltaS = timeDelta;
 		double newX = (position.getX() + speed.getX() * timeDeltaS + world.getWidth()) % world.getWidth(); 
@@ -35,9 +22,26 @@ public class Dragon {
 		position = new Point2D(newX, newY);
 	}
 
+	@Override
+	public Rectangle2D getBB() {
+		return getBoundingBox();
+	}
+	
+	@Override
+	public boolean isInCollisionWith(Collisionable col) {
+		if (!(col instanceof BulletAnimated)) {
+			return false;
+		}
+		return Collisionable.super.isInCollisionWith(col);
+	}
+	
+	@Override
+	public void hitBy(Collisionable col) {
+		hit();
+	}
 
 	public Rectangle2D getBoundingBox() {
-		return new Rectangle2D(position.getX(), position.getY(), size, size);
+		return new Rectangle2D(position.getX(), position.getY() - dimension.getY(), dimension.getX(), dimension.getY());
 	}
 
 
@@ -45,6 +49,12 @@ public class Dragon {
 		speed = speed.multiply(-1.);
 	}
 
+	@Override
+	protected void drawInternal(GraphicsContext gc) {
+		Point2D canvasPosition = world.getCanvasPoint(position);
+		gc.drawImage(Constants.DRAGON_IMAGE, canvasPosition.getX(), canvasPosition.getY(), dimension.getX(), dimension.getY());
+	}
+
 	
 	
 	
diff --git a/src/main/java/lab/DrawableSimulable.java b/src/main/java/lab/DrawableSimulable.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef438767f42f08d17fda7ff647ec06745ab495bb
--- /dev/null
+++ b/src/main/java/lab/DrawableSimulable.java
@@ -0,0 +1,11 @@
+package lab;
+
+import javafx.scene.canvas.GraphicsContext;
+
+public interface DrawableSimulable {
+	
+	void draw(GraphicsContext gc);
+	
+	void simulate(double deltaT);
+	
+}
\ No newline at end of file
diff --git a/src/main/java/lab/World.java b/src/main/java/lab/World.java
index c531c516d183793f4bc8eb3c381b6856c967e25f..6b3b7352062f10ec3e75350ff810e531b997acb0 100644
--- a/src/main/java/lab/World.java
+++ b/src/main/java/lab/World.java
@@ -6,19 +6,20 @@ import javafx.scene.canvas.GraphicsContext;
 public class World {
 	private double width;
 	private double height;
-	private BulletAnimated bulletAnimatted;
-	private Cannon cannon;
-	private Dragon[] dragons;
-
+	private DrawableSimulable[] objects;
+	
 	public World(double width, double height) {
 		super();
 		this.width = width;
 		this.height = height;
-		cannon = new Cannon(this, new Point2D(50, 50), new Point2D(100, 20));
-		bulletAnimatted = new BulletAnimated(this, cannon, new Point2D(30, 60), new Point2D(0, 0), 40);
-		dragons = new Dragon[] { new Dragon(this, new Point2D(50, 200), new Point2D(100, 5)),
-				new Dragon(this, new Point2D(50, 230), new Point2D(60, 5)),
-				new Dragon(this, new Point2D(50, 270), new Point2D(-50, 20)) };
+		Cannon cannon = new Cannon(this, new Point2D(50, 50), new Point2D(100, 20));
+		BulletAnimated bulletAnimatted = new BulletAnimated(this, cannon, new Point2D(30, 60), new Point2D(0, 0), 40);
+		
+		objects = new DrawableSimulable[] {
+					cannon,
+					bulletAnimatted, new Dragon(this, new Point2D(50, 200), new Point2D(100, 5)),
+					new Dragon(this, new Point2D(50, 230), new Point2D(60, 5)),
+					new Dragon(this, new Point2D(50, 270), new Point2D(-50, 20)) };
 	}
 
 	public Point2D getCanvasPoint(Point2D worldPoint) {
@@ -27,22 +28,30 @@ public class World {
 
 	public void draw(GraphicsContext gc) {
 		gc.clearRect(0, 0, width, height);
-		cannon.draw(gc);
-		bulletAnimatted.draw(gc);
-		for(Dragon dragon: dragons) {
-			dragon.draw(gc);
+		for (DrawableSimulable obj : objects) {
+			obj.draw(gc);
 		}
 	}
 
 	public void simulate(double timeDelta) {
-		bulletAnimatted.simulate(timeDelta);
-		cannon.simulate(timeDelta);
-		for(Dragon dragon: dragons) {
-			if (bulletAnimatted.overlaps(dragon)) {
-				dragon.hit();
-				bulletAnimatted.reload();
+		for (DrawableSimulable obj : objects) {
+			obj.simulate(timeDelta);
+			
+		}
+		
+		//solve collisions
+		for (DrawableSimulable obj1 : objects) {
+			if (obj1 instanceof Collisionable col1) {
+				for (DrawableSimulable obj2 : objects) {
+					if (obj1 != obj2 && obj2 instanceof Collisionable col2) {
+						if (col1.isInCollisionWith(col2)) {
+							col1.hitBy(col2);
+							col2.hitBy(col1);
+						}
+					}
+				}
+				
 			}
-			dragon.simulate(timeDelta);
 		}
 	}
 
diff --git a/src/main/java/lab/WorldEntity.java b/src/main/java/lab/WorldEntity.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed49e4991a3589bc9eeea869193436cd8b981553
--- /dev/null
+++ b/src/main/java/lab/WorldEntity.java
@@ -0,0 +1,28 @@
+package lab;
+
+import javafx.geometry.Point2D;
+import javafx.scene.canvas.GraphicsContext;
+
+public abstract class WorldEntity implements DrawableSimulable {
+
+	protected final World world;
+	
+	protected Point2D position;
+	
+	protected Point2D dimension;
+
+	protected WorldEntity(World world, Point2D position, Point2D dimension) {
+		this.world = world;
+		this.position = position;
+		this.dimension = dimension;
+	}
+
+	@Override
+	public void draw(GraphicsContext gc) {
+		gc.save();
+		drawInternal(gc);
+		gc.restore();
+	}
+
+	protected abstract void drawInternal(GraphicsContext gc);
+}