Solution

src/main/java/lab/BulletAnimated.java

@@ -5,7 +5,7 @@ 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;
@@ -22,7 +22,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 +29,24 @@ public class BulletAnimated  {
 	}
 
 	public BulletAnimated(World world, Cannon cannon, Point2D start, Point2D speed, double size) {
+		super(world);
 		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);
+	@Override
+	protected void drawInternal(GraphicsContext gc) {
+		Point2D canvasPosition = getWorld().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(); 
@@ -89,5 +88,12 @@ public class BulletAnimated  {
 		hitToGround = false;
 		accelerate = true;
 	}
+
+	@Override
+	public void hitBy(Collisionable collisionable) {
+		if (collisionable instanceof Dragon) {
+			reload();
+		}
+	}
 	
 }

src/main/java/lab/Cannon.java

@@ -5,24 +5,20 @@ 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;
+		super(world);
 		this.position = position;
 		this.size = size;
 	}
 
+	@Override
 	public void simulate(double timeStep) {
 		angle = angle + direction*80*timeStep;
 		if(angle <=-90 || angle >= 0) {
@@ -30,9 +26,9 @@ public class Cannon {
 		}
 	}
 	
-	public void draw(GraphicsContext gc) {
-		gc.save();
-		Point2D worldPosition = world.getCanvasPoint(position);
+	@Override
+	protected void drawInternal(GraphicsContext gc) {
+		Point2D worldPosition = getWorld().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);
@@ -40,7 +36,6 @@ public class Cannon {
 		gc.setTransform(new Affine(Affine.rotate(angle, worldPosition.getX(), worldPosition.getY()+size.getY()/2)));
 		gc.setFill(Color.BLACK);
 		gc.fillRect(worldPosition.getX(), worldPosition.getY(), size.getX(), size.getY());
-		gc.restore();
 	}
 
 	public double getAngle() {

src/main/java/lab/Collisionable.java

+package lab;
+
+import javafx.geometry.Rectangle2D;
+
+public interface Collisionable {
+	Rectangle2D getBoundingBox(); 
+	
+	void hitBy(Collisionable collisionable);
+
+	default void checkCollision(Object that) {
+		if (that instanceof Collisionable ca2 
+				&& this.getBoundingBox().intersects(ca2.getBoundingBox())) {
+				ca2.hitBy(this);
+		}
+	}
+	
+	
+}

src/main/java/lab/Dragon.java

@@ -4,48 +4,53 @@ import javafx.geometry.Point2D;
 import javafx.geometry.Rectangle2D;
 import javafx.scene.canvas.GraphicsContext;
 
-public class Dragon {
+public class Dragon extends WorldEntity implements Collisionable  {
 	
 	private Point2D position;
 	
 	private Point2D speed;
-	
-	private final World world;
 		
 	private final double size = 45;
 
 	public Dragon(World world, Point2D position, Point2D speed) {
-		super();
-		this.world = world;
+		super(world);
 		this.position = position;
 		this.speed = speed;
 	}
 
-	
-	public void draw(GraphicsContext gc) {
-		Point2D canvasPosition = world.getCanvasPoint(position);
+	@Override
+	protected void drawInternal(GraphicsContext gc) {
+		Point2D canvasPosition = getWorld().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(); 
-		double newY = (position.getY() + speed.getY() * timeDeltaS + world.getHeight()) % world.getHeight();
+		double newX = (position.getX() + speed.getX() * timeDeltaS + getWorld().getWidth()) % getWorld().getWidth(); 
+		double newY = (position.getY() + speed.getY() * timeDeltaS + getWorld().getHeight()) % getWorld().getHeight();
 		position = new Point2D(newX, newY);
 	}
 
-
+	@Override
 	public Rectangle2D getBoundingBox() {
 		return new Rectangle2D(position.getX(), position.getY(), size, size);
 	}
 
+	@Override
+	public void hitBy(Collisionable collisionable) {
+		if (collisionable instanceof BulletAnimated) {
+			hit();
+		}
+	}
 
 	public void hit() {
 		speed = speed.multiply(-1.);
 	}
 
 	
+
+	
 	
 	
 	

src/main/java/lab/DrawableSimulable.java

+package lab;
+
+import javafx.scene.canvas.GraphicsContext;
+
+public interface DrawableSimulable {
+	
+	void draw(GraphicsContext gc);
+	
+	void simulate(double deltaT);
+}
\ No newline at end of file

src/main/java/lab/World.java

@@ -6,19 +6,30 @@ import javafx.scene.canvas.GraphicsContext;
 public class World {
 	private double width;
 	private double height;
-	private BulletAnimated bulletAnimatted;
+	/*private BulletAnimated bulletAnimatted;
 	private Cannon cannon;
 	private Dragon[] dragons;
-
+*/
+	private DrawableSimulable[] entities;
+	
 	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));
+		/*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;
+		entities = new DrawableSimulable[] {
+				cannon = new Cannon(this, new Point2D(50, 50), new Point2D(100, 20)),
+				new BulletAnimated(this, cannon, new Point2D(30, 60), new Point2D(0, 0), 40),
+				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 +38,21 @@ 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 entity: entities) {
+			entity.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 entity: entities) {
+			entity.simulate(timeDelta);
+			if (entity instanceof Collisionable ca) {
+				for (DrawableSimulable that: entities) {
+					if (entity != that) {
+						ca.checkCollision(that);
+					}
+				}
 			}
-			dragon.simulate(timeDelta);
 		}
 	}
 

src/main/java/lab/WorldEntity.java

+package lab;
+
+import javafx.scene.canvas.GraphicsContext;
+
+public abstract class WorldEntity implements DrawableSimulable{
+	
+	private final World world;
+	
+	public WorldEntity(World world) {
+		this.world = world;
+	}
+
+	@Override
+	public final void draw(GraphicsContext gc) {
+	  gc.save();
+	  drawInternal(gc);
+	  gc.restore();
+	}
+	
+	protected World getWorld() {
+		return world;
+	}
+
+
+	protected abstract void drawInternal(GraphicsContext gc);
+}