mehdi : creating Extinguisher abstract class to avoid code repetition and...

mehdi : creating Extinguisher abstract class to avoid code repetition and improving classes FireFighter Road and FirefighterBoard

src/main/java/model/Cloud.java

@@ -2,20 +2,30 @@ package model;
 
 import util.Position;
 
-public class Cloud {
+import java.util.ArrayList;
+import java.util.List;
+
+public class Cloud extends Extinguisher {
 
-    private Position position;
 
     public Cloud(Position position) {
-        this.position = position;
+        super(position);
+        element = ModelElement.CLOUD;
     }
 
-    public Position getPosition() {
-        return position;
-    }
+    public List<Position>update(FirefighterBoard firefighterBoard){
+        List<Position> modifiedPositions = new ArrayList<>();
+
+        Position currentPosition = this.getPosition();
+        Position newPosition = firefighterBoard.randomNeighbor(currentPosition);
+        this.setPosition(newPosition);
+        modifiedPositions.add(currentPosition);
+        modifiedPositions.add(newPosition);
+
+
+        firefighterBoard.extinguish(newPosition);
 
-    public void setPosition(Position position) {
-        this.position = position;
+        return modifiedPositions;
     }
 
 

src/main/java/model/Element.java

+package model;
+
+import util.Position;
+
+import java.util.List;
+
+public interface Element {
+
+    boolean contains(List<Position>positions);
+
+    Position getPosition();
+
+    ModelElement getElement();
+
+    List<Position> update(FirefighterBoard firefighterBoard);
+
+}

src/main/java/model/Extinguisher.java

+package model;
+
+import util.Position;
+
+import java.util.List;
+
+public abstract class Extinguisher implements Element{
+
+    protected Position position;
+    protected ModelElement element;
+    public Extinguisher(Position position){
+        this.position = position;
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+    @Override
+    public boolean contains(List<Position> positions) {
+        return positions.contains(this.getPosition());
+    }
+
+
+
+    public ModelElement getElement(){
+        return this.element;
+    }
+
+    public abstract List<Position> update(FirefighterBoard firefighterBoard);
+
+}

src/main/java/model/Fire.java

@@ -2,13 +2,19 @@ package model;
 
 import util.Position;
 
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 
-public class Fire {
+public class Fire implements Element {
 
     private Position position;
 
 
+    private ModelElement modelElement = ModelElement.FIRE;
+
+
     public Fire(Position position){
         this.position = position;
     }
@@ -18,11 +24,23 @@ public class Fire {
         return position;
     }
 
+    @Override
+    public ModelElement getElement() {
+        return modelElement;
+    }
+
     public void setPosition(Position position) {
         this.position = position;
     }
 
+    public List<Position> update(FirefighterBoard firefighterBoard){
+        return null;
+    }
+
+    public boolean contains(List<Position> positions) {
+        return positions.contains(this.getPosition());
 
+    }
 
 
 

src/main/java/model/FireFighter.java

 package model;
 
 import util.Position;
+import util.TargetStrategy;
 
+import java.util.ArrayList;
+import java.util.List;
 
-public class FireFighter {
 
-    private Position position;
+public class FireFighter extends Extinguisher {
+
+
+    private final TargetStrategy targetStrategy = new TargetStrategy();
 
 
     public FireFighter(Position position){
-        this.position = position;
+        super(position);
+        element = ModelElement.FIREFIGHTER;
     }
 
 
-    public Position getPosition() {
-        return position;
-    }
+    public List<Position> update(FirefighterBoard firefighterBoard){
+        List<Position> modifiedPositions = new ArrayList<>();
 
-    public void setPosition(Position position) {
-        this.position = position;
-    }
+        Position currentPosition = this.getPosition();
+        Position newPosition = targetStrategy.neighborClosestToFire(currentPosition, firefighterBoard.getFires().keySet(), firefighterBoard.getNeighbors());
 
+        this.setPosition(newPosition);
+        modifiedPositions.add(currentPosition);
+        modifiedPositions.add(newPosition);
 
+        firefighterBoard.extinguish(newPosition);
+
+        for (Position neighbor : firefighterBoard.getNeighbors().get(newPosition)) {
+            firefighterBoard.extinguish(neighbor);
+            modifiedPositions.add(neighbor);
+        }
+
+        return modifiedPositions;
+    }
 
 
 

src/main/java/model/FirefighterBoard.java

@@ -13,9 +13,10 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   private final int initialFirefighterCount;
   private final int initialCloudCount;
   private final int initialRoadCount;
-  private final TargetStrategy targetStrategy = new TargetStrategy();
   private List<FireFighter> firefighters;
-  private List<Road> roads;
+
+
+  private List<Element> elements;
   private Map<Position, Fire> fires = new HashMap<>();
   private List<Cloud> clouds;
   private final Map<Position, List<Position>> neighbors = new HashMap<>();
@@ -51,20 +52,13 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     }
   }
 
-  private List<Position> calculateNeighbors(int row, int column) {
-    List<Position> list = new ArrayList<>();
-    if (row > 0) list.add(positions[row - 1][column]);
-    if (column > 0) list.add(positions[row][column - 1]);
-    if (row < rowCount - 1) list.add(positions[row + 1][column]);
-    if (column < columnCount - 1) list.add(positions[row][column + 1]);
-    return list;
-  }
+
 
   public void initializeElements() {
-    firefighters = new ArrayList<>();
-    clouds = new ArrayList<>();
+    elements = new ArrayList<>();
+
     fires.clear();
-    roads = new ArrayList<>();
+
 
     for (int index = 0; index < initialFireCount; index++) {
       Position position = randomPosition();
@@ -72,16 +66,26 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
     }
 
     for (int index = 0; index < initialFirefighterCount; index++) {
-      firefighters.add(new FireFighter(randomPosition()));
+      elements.add(new FireFighter(randomPosition()));
     }
     for (int index = 0; index < initialCloudCount; index++) {
-      clouds.add(new Cloud(randomPosition()));
+
+      elements.add(new Cloud(randomPosition()));
     }
 
     for (int index = 0; index < initialRoadCount; index++) {
-      roads.add(new Road(randomPosition()));
+      elements.add(new Road(randomPosition()));
+    }
+
   }
 
+  private List<Position> calculateNeighbors(int row, int column) {
+    List<Position> list = new ArrayList<>();
+    if (row > 0) list.add(positions[row - 1][column]);
+    if (column > 0) list.add(positions[row][column - 1]);
+    if (row < rowCount - 1) list.add(positions[row + 1][column]);
+    if (column < columnCount - 1) list.add(positions[row][column + 1]);
+    return list;
   }
 
   private Position randomPosition() {
@@ -92,57 +96,17 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
   public List<ModelElement> getState(Position position) {
     List<ModelElement> result = new ArrayList<>();
 
-    for (FireFighter firefighter : firefighters) {
-      if (firefighter.getPosition().equals(position)) result.add(ModelElement.FIREFIGHTER);
+    for(Element element : elements){
+      if(element.getPosition().equals(position))result.add(element.getElement());
     }
     if (fires.containsKey(position)) result.add(ModelElement.FIRE);
 
-    for (Cloud cloud : clouds) {
-      if (cloud.getPosition().equals(position)) result.add(ModelElement.CLOUD);
-    }
-    for (Road road : roads) {
-      if (road.getPosition().equals(position)) result.add(ModelElement.ROAD);
-    }
     return result;
   }
 
-  private List<Position> updateClouds() {
-    List<Position> modifiedPositions = new ArrayList<>();
-    for (Cloud cloud : clouds) {
-      Position currentPosition = cloud.getPosition();
-      Position newPosition = randomNeighbor(currentPosition);
-      cloud.setPosition(newPosition);
-      modifiedPositions.add(currentPosition);
-      modifiedPositions.add(newPosition);
-
-
-      extinguish(newPosition);
-    }
-    return modifiedPositions;
-  }
-  private Position randomNeighbor(Position position) {
-    List<Position> neighborPositions = neighbors.get(position);
-    return neighborPositions.get(randomGenerator.nextInt(neighborPositions.size()));
-  }
-
 
-  @Override
-  public int rowCount() {
-    return rowCount;
-  }
 
-  @Override
-  public int columnCount() {
-    return columnCount;
-  }
 
-  public List<Position> updateToNextGeneration() {
-    List<Position> modifiedPositions = updateFirefighters();
-    modifiedPositions.addAll(updateClouds());
-    modifiedPositions.addAll(updateFires());
-    step++;
-    return modifiedPositions;
-  }
 
 
   private List<Position> updateFires() {
@@ -151,8 +115,7 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
       Set<Position> newFirePositions = new HashSet<>();
       for (Position fire : new HashSet<>(fires.keySet())) {
         List<Position> neighboursAvaiable = neighbors.get(fire);
-
-
+        neighboursAvaiable.removeAll(getRoadsPosition());
         newFirePositions.addAll(neighbors.get(fire));
       }
       for (Position position : newFirePositions) {
@@ -167,50 +130,91 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
 
 
 
-  @Override
-  public int stepNumber() {
-    return step;
-  }
 
-  private List<Position> updateFirefighters() {
-    List<Position> modifiedPositions = new ArrayList<>();
-    for (FireFighter firefighter : firefighters) {
-      Position currentPosition = firefighter.getPosition();
-      Position newPosition = targetStrategy.neighborClosestToFire(currentPosition, fires.keySet(), neighbors);
 
-      firefighter.setPosition(newPosition);
-      modifiedPositions.add(currentPosition);
-      modifiedPositions.add(newPosition);
 
-      extinguish(newPosition);
 
-      for (Position neighbor : neighbors.get(newPosition)) {
-        extinguish(neighbor);
-        modifiedPositions.add(neighbor);
+
+  public List<Position> updateElements(){
+    List<Position> modifiedPositions = new ArrayList<>();
+    for (Element element : elements) {
+      if(element.getClass().equals(Road.class)){
+        continue;
+      }
+      modifiedPositions.addAll(element.update(this));
+    }
+    return modifiedPositions;
   }
+
+
+  public Position randomNeighbor(Position position) {
+    List<Position> neighborPositions = neighbors.get(position);
+    return neighborPositions.get(randomGenerator.nextInt(neighborPositions.size()));
   }
+
+
+
+
+  public List<Position> updateToNextGeneration() {
+    List<Position> modifiedPositions = updateElements();
+    modifiedPositions.addAll(updateFires());
+    step++;
     return modifiedPositions;
   }
 
 
+  @Override
+  public int stepNumber() {
+    return step;
+  }
+
+  @Override
+  public int rowCount() {
+    return rowCount;
+  }
+
+  @Override
+  public int columnCount() {
+    return columnCount;
+  }
+
   @Override
   public void reset() {
     step = 0;
     initializeElements();
   }
 
-  private void extinguish(Position position) {
+  public void extinguish(Position position) {
     if (fires.containsKey(position)) {
       fires.remove(position);
     }
   }
 
 
+  public Map<Position,Fire> getFires(){
+    return this.fires;
+  }
+
+  public Map<Position, List<Position>> getNeighbors() {
+    return neighbors;
+  }
+
+  public List<Position> getRoadsPosition(){
+    List<Position>roadPosition = new ArrayList<>();
+    for(Element road: elements){
+      if(road.getClass().equals(Road.class)){
+        roadPosition.add(road.getPosition());
+      }
+    }
+    return roadPosition;
+  }
+
+
   @Override
   public void setState(List<ModelElement> state, Position position) {
     extinguish(position);
-    firefighters.removeIf(firefighter -> firefighter.getPosition().equals(position));
-    firefighters.removeIf(cloud -> cloud.getPosition().equals(position));
+    elements.removeIf(element -> element.getPosition().equals(position));
+
 
     for (ModelElement element : state) {
       switch (element) {

src/main/java/model/Road.java

@@ -2,8 +2,12 @@ package model;
 
 import util.Position;
 
-public class Road {
+import java.util.List;
 
+public class Road implements Element {
+
+
+    private ModelElement element = ModelElement.ROAD;
     private final Position position;
 
 
@@ -15,10 +19,17 @@ public class Road {
         return this.position;
     }
 
+    public boolean contains(List<Position> positions) {
+        return positions.contains(this.getPosition());
 
+    }
 
+    public ModelElement getElement() {
+        return element;
+    }
 
-
-
-
+    @Override
+    public List<Position> update(FirefighterBoard firefighterBoard) {
+        return null;
+    }
 }