redid nearly everything

src/main/java/model/FFBehavior.java

@@ -8,17 +8,5 @@ import java.util.List;
 import java.util.Map;
 
 public abstract class FFBehavior implements Behavior {
-    public ModelElement element;
-    public FFBehavior(ModelElement element) {
-        this.element = element;
-    }
-
-    @Override
-    public Map<Position, List<Position>> legalNeighbors(BoardData boardData) {
-        Map<Position,List<Position>> neighbors=new HashMap<>();
-        for (Map.Entry<Position,List<Position>> entry: boardData.getNeighbors().entrySet()) {
-                neighbors.put(entry.getKey(),new ArrayList<Position>(List.copyOf(entry.getValue())));
-        }
-        return neighbors;
-    }
+    public Element element;
 }
\ No newline at end of file

src/main/java/model/FFBoard.java

@@ -3,6 +3,7 @@ package model;
 import util.Position;
 import util.TargetStrategy;
 
+import java.lang.reflect.InvocationTargetException;
 import java.util.*;
 
 
@@ -11,9 +12,7 @@ public class FFBoard implements Board<List<ModelElement>> {
   private final int rowCount;
   private final int initialFireCount;
   private final int initialFirefighterCount;
-  private final TargetStrategy targetStrategy = new TargetStrategy();
   private BoardData boardData;
-  private final Position[][] positions;
   private FFUpdater FFUpdater ;
   private final Random randomGenerator = new Random();
 
@@ -22,19 +21,6 @@ public class FFBoard implements Board<List<ModelElement>> {
     FFUpdater=new FFUpdater();
     this.columnCount = columnCount;
     this.rowCount = rowCount;
-    this.positions = new Position[rowCount][columnCount];
-    for (int column = 0; column < columnCount; column++)
-      for (int row = 0; row < rowCount; row++)
-        positions[row][column] = new Position(row, column);
-    for (int column = 0; column < columnCount; column++)
-      for (int row = 0; row < rowCount; row++) {
-        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]);
-        boardData.getNeighbors().put(positions[row][column], list);
-      }
     this.initialFireCount = initialFireCount;
     this.initialFirefighterCount = initialFirefighterCount;
     initializeElements();
@@ -44,13 +30,13 @@ public class FFBoard implements Board<List<ModelElement>> {
     boardData.initialize();
     FFUpdater= new FFUpdater();
     for (int index = 0; index < initialFireCount; index++)
-      boardData.getPositions().get(ModelElement.FIRE.ordinal()).add(randomPosition());
+      boardData.addElement(new StandardFire(randomPosition()));
      for (int index = 0; index < initialFirefighterCount; index++)
-      boardData.getPositions().get(ModelElement.FIREFIGHTER.ordinal()).add(randomPosition());
+       boardData.addElement(new StandardFireFighter(randomPosition()));
     for (int index = 0; index < 10; index++)
-      boardData.getPositions().get(ModelElement.CLOUD.ordinal()).add(randomPosition());
+      boardData.addElement(new Cloud(randomPosition()));
     for (int index = 0; index < 50; index++)
-      boardData.getPositions().get(ModelElement.MOUNTAIN.ordinal()).add(randomPosition());
+      boardData.addElement(new Mountain(randomPosition()));
 
   }
 
@@ -61,10 +47,8 @@ public class FFBoard implements Board<List<ModelElement>> {
   @Override
   public List<ModelElement> getState(Position position) {
     List<ModelElement> result=new ArrayList<>();
-    for (ModelElement e:ModelElement.values()) {
-      for (Position p : boardData.getPositions().get(e.ordinal()))
-        if (p.equals(position))
-          result.add(e);
+    for (Element e:boardData.getCell(position).Content) {
+      result.add(e.getType());
     }
     return result;
   }
@@ -85,49 +69,18 @@ public class FFBoard implements Board<List<ModelElement>> {
     boardData.setStep(boardData.getStep()+1);
     return modifiedPositions;
   }
-
-
   @Override
   public int stepNumber() {
     return boardData.getStep();
   }
-
-  /*private List<Position> updateFirefighters() {
-    List<Position> modifiedPosition = new ArrayList<>();
-    List<Position> firefighterPositions = boardData.getPositions().get(ModelElement.FIREFIGHTER.ordinal());
-    List<Position> firePositions = boardData.getPositions().get(ModelElement.FIRE.ordinal());
-    List<Position> firefighterNewPositions = new ArrayList<>();
-    for (Position firefighterPosition : firefighterPositions) {
-      Position newFirefighterPosition =
-              targetStrategy.neighborClosestToFire(firefighterPosition,
-                      firePositions, boardData.getNeighbors());
-      firefighterNewPositions.add(newFirefighterPosition);
-      extinguish(newFirefighterPosition);
-      modifiedPosition.add(firefighterPosition);
-      modifiedPosition.add(newFirefighterPosition);
-      List<Position> neighborFirePositions = boardData.getNeighbors().get(newFirefighterPosition).stream()
-              .filter(firePositions::contains).toList();
-      for (Position firePosition : neighborFirePositions)
-        extinguish(firePosition);
-      modifiedPosition.addAll(neighborFirePositions);
-    }
-    firefighterPositions = firefighterNewPositions;
-    return modifiedPosition;
-  }*/
-
   @Override
   public void reset() {
     initializeElements();
   }
-
-
   @Override
   public void setState(List<ModelElement> state, Position position) {
-    for (ModelElement e:ModelElement.values()) {
-        boardData.getPositions().get(e.ordinal()).remove(position);
-    }
-    for (ModelElement e:state) {
-      boardData.getPositions().get(e.ordinal()).add(position);
+    for (ModelElement modelElement: state) {
+        boardData.addElement(modelElement.instanciate(position));
     }
   }
 }
\ No newline at end of file

src/main/java/model/FFBoardData.java

@@ -5,11 +5,12 @@ import util.Position;
 import java.util.*;
 
 public class FFBoardData implements BoardData{
-    private List<List<Position>> positions;
+
+    private List<List<Element>> elementList;
     private Map<Position, List<Position>> neighbors = new HashMap<Position, List<Position>>();
     private int step;
     private int columnCount,rowCount;
-
+    private List<List<Cell<Element>>> cells;
     public FFBoardData(int columnCount, int rowCount) {
         this.columnCount=columnCount;
         this.rowCount=rowCount;
@@ -19,9 +20,14 @@ public class FFBoardData implements BoardData{
         step=0;
         neighbors = new HashMap<Position, List<Position>>();
         Position[][] ps = new Position[rowCount][columnCount];
-        for (int column = 0; column < columnCount; column++)
-            for (int row = 0; row < rowCount; row++)
+        cells=new ArrayList<>();
+        for (int column = 0; column < columnCount; column++){
+            cells.add(new ArrayList<>());
+            for (int row = 0; row < rowCount; row++){
                 ps[row][column] = new Position(row, column);
+                cells.get(column).add(new Cell<>(ps[row][column]));
+            }
+        }
         for (int column = 0; column < columnCount; column++)
             for (int row = 0; row < rowCount; row++) {
                 List<Position> list = new ArrayList<>();
@@ -31,28 +37,37 @@ public class FFBoardData implements BoardData{
                 if (column < columnCount - 1) list.add(ps[row][column + 1]);
                 getNeighbors().put(ps[row][column], list);
             }
-        positions = new ArrayList<>();
+        elementList = new ArrayList<>();
         for (int i = 0; i < ModelElement.values().length; i++) {
-            positions.add(new ArrayList<>());
+            elementList.add(new ArrayList<>());
         }
     }
 
-    public  List<List<Position>> getPositions() {
-        return positions;
-    }
-    public  List<Position> getPositions(ModelElement modelElement) {
-        return positions.get(modelElement.ordinal());
-    }
-    public void setPositions( List<List<Position>> Positions) {
-        this.positions = Positions;
+
+    @Override
+    public List<List<Element>> getElements() {
+        return elementList;
     }
+
     public Map<Position, List<Position>> getNeighbors() {
         return neighbors;
     }
     public List<Position> getNeighbor(Position position) {
         return neighbors.get(position);
     }
-
+    public void addElement(Element element){
+        elementList.get(element.getType().ordinal()).add(element);
+        getCell(element.getPosition()).Content.add(element);
+        FFUpdater.modifiedPositions.add(element.getPosition());
+    }
+    public void removeElement(Element element){
+        FFUpdater.modifiedPositions.add(element.getPosition());
+        elementList.get(element.getType().ordinal()).remove(element);
+        getCell(element.getPosition()).Content.remove(element);
+    }
+    public Cell<Element> getCell(Position position){
+        return cells.get(position.column()).get(position.row());
+    }
     @Override
     public int getStep() {
         return step;

src/main/java/model/FFUpdater.java

@@ -3,24 +3,35 @@ package model;
 import util.Position;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 public class FFUpdater implements Updater {
-    Element[] elements;
+    List<Updatable> updatables;
+    static List<Position> modifiedPositions=new ArrayList<>();
 
     public FFUpdater() {
-        this.elements=new Element[ModelElement.values().length];
-        for (int i = 0; i < ModelElement.values().length; i++) {
-            this.elements[i]=ModelElement.values()[i].instanciate();
+        updatables=new ArrayList<>();
+    }
+
+    public void updateSetup(BoardData boardData) {
+        updatables.clear();
+        modifiedPositions=new ArrayList<Position>();
+        for (ModelElement modelElement: ModelElement.values()) {
+        System.out.println(modelElement+" "+modelElement.isUpdatabale());
+        if (modelElement.isUpdatabale())
+            for (Element e:boardData.getElements().get(modelElement.ordinal())) {
+                updatables.add((Updatable) e);
+            }
         }
     }
 
     @Override
     public List<Position> updateAll(BoardData boardData) {
-        List<Position> modifiedList=new ArrayList<Position>();
-        for (int i = 0; i < ModelElement.values().length; i++) {
-            modifiedList=this.elements[i].Update(boardData,modifiedList);
+        updateSetup(boardData);
+        for (Updatable u:updatables){
+            u.updateSelf(boardData);
         }
-        return modifiedList;
+        return modifiedPositions;
     }
 }

src/main/java/model/Fire.java

@@ -2,25 +2,45 @@ package model;
 
 import util.Position;
 
-import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
 
-public class Fire extends Element{
+public abstract class Fire implements Element,Updatable{
+    int delay;
+    ModelElement type;
+    Position position;
+    static Behavior behavior=new FireBehavior();
+    Map<ModelElement,ModelElement> FireDictionary=new HashMap<>(); //.put(MAISON,FEUMAISON)
 
-    public Fire() {
-            super(ModelElement.FIRE,
-                    new FireBehavior(ModelElement.FIRE));
+    public Fire(int delay, ModelElement type, Position position) {
+        this.delay = delay;
+        this.type = type;
+        this.position = position;
+    }
+    @Override
+    public Position getPosition() {
+        return position;
     }
-
     @Override
-    public List<Position> Update(BoardData boardData, List<Position> modifPositions) {
-        List<Position> firePositions = boardData.getPositions().get(this.type.ordinal());
-        List<Position> modifiedPositions = new ArrayList<Position>(modifPositions);
-        List<Position> newFirePositions = behavior.getNext(boardData);
-        firePositions.removeAll(newFirePositions);
-        firePositions.addAll(newFirePositions);
-        modifiedPositions.removeAll(newFirePositions);
-        modifiedPositions.addAll(newFirePositions);
-        return modifiedPositions;
+    public ModelElement getType() {
+        return type;
+    }
+    private Fire getNewFireByType(BoardData boardData,Position position){
+        List<ModelElement> s = boardData.getCell(position).Content.stream().map(x -> x.getType()).toList();
+        for(Map.Entry<ModelElement,ModelElement> entry: FireDictionary.entrySet()){
+            if (s.contains(entry.getKey())) return (Fire) entry.getValue().instanciate(position);
+        }
+        return new StandardFire(position);
+    }
+    @Override
+    public List<Position> updateSelf(BoardData boardData) {
+        List<Position> positions=behavior.update(boardData,this);
+        for (Position p:positions) {
+
+            boardData.addElement(new StandardFire(p));
+        }
+        return positions;
     }
 }

src/main/java/model/FireBehavior.java

@@ -5,15 +5,41 @@ import util.Position;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
-public class FireBehavior extends FFBehavior implements TangibleBehavior<ModelElement> {
+public class FireBehavior extends FFBehavior /*implements TangibleBehavior<ModelElement>*/ {
     private List<ModelElement> obstacles=List.of(ModelElement.MOUNTAIN);
 
-    public FireBehavior(ModelElement element) {
-        super(element);
+    @Override
+    public List<Position> update(BoardData boardData,Element element) {
+        List<Position> positions=new ArrayList<>();
+        if (boardData.getStep()%((Fire)element).delay==0){
+            positions=legalNeighbors(boardData,element.getPosition());
+        }
+        return positions;
+    }
+        @Override
+        public List<Position> legalNeighbors(BoardData boardData,Position position) {
+            List<Position> neighbors=new ArrayList<>(boardData.getNeighbor(position));
+            for (Position p:boardData.getNeighbor(position)) {
+                for (Element e:boardData.getCell(p).Content) {
+                    if (e instanceof Fire) neighbors.remove(p);
+                    for(ModelElement o:obstacles)
+                        if (e.getType()==o) neighbors.remove(p);
+                }
+            }
+            return neighbors;
         }
-
     @Override
+    public Map<Position, List<Position>> allLegalNeighbors(BoardData boardData) {
+        Map<Position, List<Position>> neighbors=Map.copyOf(boardData.getNeighbors());
+        Set<Position> positions =boardData.getNeighbors().keySet();
+            for (Position pkey: positions) {
+                neighbors.replace(pkey,legalNeighbors(boardData,pkey));
+            }
+            return neighbors;
+    }
+    /*@Override
     public List<Position> getNext(BoardData boardData) {
         List<Position> firePositions = boardData.getPositions().get(element.ordinal());
         List<Position> newFirePositions = new ArrayList<>();
@@ -42,5 +68,5 @@ public class FireBehavior extends FFBehavior implements TangibleBehavior<ModelEl
             }
         }
         return neigbors;
-    }
+    }*/
 }

src/main/java/model/FireFighter.java

+package model;
+
+import util.Position;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class FireFighter implements Element,Updatable{
+        int speed;
+        ModelElement type;
+        Position position;
+static Behavior behavior=new FireFighterBehavior();
+
+public FireFighter(int speed, ModelElement type, Position position) {
+        this.speed = speed;
+        this.type = type;
+        this.position = position;
+        }
+@Override
+public Position getPosition() {
+        return position;
+        }
+@Override
+public ModelElement getType() {
+        return type;
+        }
+@Override
+public List<Position> updateSelf(BoardData boardData) {
+        List<Position> positions=behavior.update(boardData,this);
+        List<Position> modifPositions=new ArrayList<>(positions);
+        modifPositions.add(this.getPosition());
+        for (Position p:positions) {
+            boardData.removeElement(this);
+            this.position=p;
+            boardData.addElement(this);
+        }
+        return modifPositions;
+        }
+}

src/main/java/model/FireFighterBehavior.java

+package model;
+
+import util.Position;
+import util.TargetStrategy;
+import java.util.*;
+
+public class FireFighterBehavior extends FFBehavior implements TangibleBehavior<ModelElement> {
+    private List<ModelElement> obstacles=List.of(ModelElement.MOUNTAIN);
+    private TargetStrategy ts=new TargetStrategy();
+
+    List<Position> initializeTargets(BoardData boardData){
+        List<Position> targets=new ArrayList<>();
+        for (ModelElement me:ModelElement.values()) {
+            if (me.isFire()){
+                System.out.println("0");
+                for (Element e:boardData.getElements().get(me.ordinal())) {
+                    targets.add(e.getPosition());
+                }}
+        }
+        return targets;
+    }
+    @Override
+    public List<Position> update(BoardData boardData,Element element) {
+        Position position=element.getPosition();
+        List<Position> targets=initializeTargets(boardData);
+        for (int i=0;i<((FireFighter)element).speed;i++) {
+            position=ts.neighborClosestToFire(position,targets,allLegalNeighbors(boardData));
+            extinguish(boardData,position);
+            targets.remove(position);
+            targets.removeAll(boardData.getNeighbor(position));
+        }
+        return List.of(position);
+    }
+
+    @Override
+    public List<ModelElement> getObstacles() {
+        return obstacles;
+    }
+
+    public void extinguish(BoardData boardData, Position position){
+        List<Position> l=new ArrayList<>(legalNeighbors(boardData,position));
+        l.add(position);
+        for (Position p:l) {
+            List<Element> c=new ArrayList<>(boardData.getCell(p).Content);
+            for (Element e:c) {
+                if (e instanceof Fire){
+                    boardData.removeElement(e);}
+            }
+        }
+    }
+    @Override
+    public List<Position> legalNeighbors(BoardData boardData,Position position) {
+        List<Position> neighbors=new ArrayList<>(boardData.getNeighbor(position));
+        for (Position p:boardData.getNeighbor(position)) {
+            for (Element e:boardData.getCell(p).Content) {
+                for(ModelElement o:getObstacles())
+                    if (e.getType()==o) neighbors.remove(p);
+            }
+        }
+        return neighbors;
+    }
+    @Override
+    public Map<Position, List<Position>> allLegalNeighbors(BoardData boardData) {
+        Map<Position, List<Position>> neighbors= new HashMap<>(Map.copyOf(boardData.getNeighbors()));
+        for (Position pkey: boardData.getNeighbors().keySet()) {
+            neighbors.replace(pkey,legalNeighbors(boardData,pkey));
+        }
+        return neighbors;
+    }
+}

src/main/java/model/FirefighterBehavior.java

-package model;
-
-import util.Position;
-import util.TargetStrategy;
-
-import java.util.*;
-
-public class FirefighterBehavior extends FFBehavior implements TangibleBehavior<ModelElement>,RemoverBehavior<ModelElement> {
-    List<ModelElement> obstacles=List.of(ModelElement.MOUNTAIN);
-    ModelElement removedElement=ModelElement.FIRE;
-    TargetStrategy targetStrategy=new TargetStrategy();
-
-    public FirefighterBehavior(ModelElement modelElement) {
-        super(modelElement);
-    }
-
-
-    @Override
-    public List<Position> getNext(BoardData boardData) {
-        List<Position> firefighterPositions = boardData.getPositions().get(element.ordinal());
-        List<Position> firePositions = new ArrayList<>(List.copyOf(boardData.getPositions().get(ModelElement.FIRE.ordinal())));
-        List<Position> firefighterNewPositions = new ArrayList<>();
-        Map<Position,List<Position>> neigbours=legalNeighbors(boardData);
-        for (Position firefighterPosition : firefighterPositions) {
-            Position newFirefighterPosition = targetStrategy.neighborClosestToFire(firefighterPosition,firePositions, neigbours);
-            firefighterNewPositions.add(newFirefighterPosition);
-            firePositions.remove(newFirefighterPosition);
-            firePositions.remove(boardData.getNeighbors().get(newFirefighterPosition));
-        }
-        return firefighterNewPositions;
-    }
-    public List<Position> remove(BoardData boardData,Position p){
-        List<Position> firePositions = boardData.getPositions().get(getElementToRemove().ordinal());
-        List<Position> neighborFirePositions = boardData.getNeighbors().get(p).stream()
-                .filter(firePositions::contains).toList();
-        removePartial(boardData,p);
-        for (Position firePosition : neighborFirePositions)
-            removePartial(boardData,firePosition);
-        return neighborFirePositions;
-    }
-
-
-    @Override
-    public List<ModelElement> getObstacles() {
-        return obstacles;
-    }
-
-    @Override
-    public void removePartial(BoardData boardData,Position p) {
-        List<Position> firePositions = boardData.getPositions().get(getElementToRemove().ordinal());
-        firePositions.remove(p);
-    }
-
-    @Override
-    public Map<Position, List<Position>> legalNeighbors(BoardData boardData) {
-        Map<Position,List<Position>> neigbours= Map.copyOf(super.legalNeighbors(boardData));
-        for (Map.Entry<Position,List<Position>> entry: neigbours.entrySet()) {
-            for (ModelElement e:getObstacles()) {
-                entry.getValue().removeAll(boardData.getPositions().get(e.ordinal()));
-            }
-        }
-        return neigbours;
-    }
-
-    @Override
-    public ModelElement getElementToRemove() {
-        return removedElement;
-    }
-}

src/main/java/model/ModelElement.java

 package model;
 
+import util.Position;
+
 import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.List;
 
 public enum ModelElement {
 
 
-  FIREFIGHTER(StandardFirefighter.class),
-  FIRE(Fire.class),
+  FIREFIGHTER(StandardFireFighter.class),
+  FIRE(StandardFire.class),
   CLOUD(Cloud.class),
   MOUNTAIN(Mountain.class);
 
+
   public final Class<?> c;
   ModelElement(Class<?>c) {
     this.c =c;
     System.out.println(c);
   }
-  public Element instanciate(){
-    Object o=null;
+  public boolean isUpdatabale(){
+    List<Class<?>> Interfaces= Arrays.asList(c.getInterfaces());
+    return Interfaces.contains(Updatable.class);
+  }
+  public boolean isPrintable(){
+    Class<?> currentClass=c;
+    while(!currentClass.equals(Object.class)){
+      if (Arrays.asList(currentClass.getInterfaces()).contains(Printable.class)) return true;
+      currentClass=currentClass.getSuperclass();
+    }
+    return false;
+  }
+  public boolean isFire(){
+    Class<?> currentClass=c;
+    while(!currentClass.equals(Object.class)){
+      System.out.println(currentClass+" "+currentClass.equals(Fire.class));
+      if (currentClass.equals(Fire.class)) return true;
+      currentClass=currentClass.getSuperclass();
+    }
+    return false;
+  }
+  public Element instanciate(Position position){
+    Class<?>[] cs=new Class<?>[]{Position.class};
+    Element e= null;
     try {
-      o = c.getDeclaredConstructor().newInstance();
-      o = c.cast(o);
-    } catch (InstantiationException e) {
-      throw new RuntimeException(e);
-    } catch (IllegalAccessException e) {
-      throw new RuntimeException(e);
-    } catch (InvocationTargetException e) {
-      throw new RuntimeException(e);
-    } catch (NoSuchMethodException e) {
-      throw new RuntimeException(e);
-    }
-    return (Element) o;
+      e = (Element) c.getDeclaredConstructor(cs).newInstance(position);
+    } catch (InstantiationException ex) {
+      throw new RuntimeException(ex);
+    } catch (IllegalAccessException ex) {
+      throw new RuntimeException(ex);
+    } catch (InvocationTargetException ex) {
+      throw new RuntimeException(ex);
+    } catch (NoSuchMethodException ex) {
+      throw new RuntimeException(ex);
+    }
+    return e;
   }
 }

src/main/java/model/Mountain.java

 package model;
 
+import model.Element;
 import util.Position;
 
 import java.util.List;
 
-public class Mountain extends Element{
+public class Mountain implements Element {
+    Position position;
+    ModelElement type;
 
-    public Mountain() {
-            super(ModelElement.MOUNTAIN,
-                    new NoBehavior(ModelElement.MOUNTAIN));
+    public Mountain(Position position) {
+        this.position = position;
+        type=ModelElement.MOUNTAIN;
     }
 
     @Override
-    public List<Position> Update(BoardData boardData, List<Position> modifPositions) {
-        return modifPositions;
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ModelElement getType() {
+        return type;
     }
 }

src/main/java/model/NoBehavior.java

-package model;
-
-import util.Position;
-
-import java.util.List;
-
-public class NoBehavior extends FFBehavior {
-
-
-    public NoBehavior(ModelElement element) {
-        super(element);
-    }
-
-    @Override
-    public List<Position> getNext(BoardData boardData) {
-        return null;
-    }
-}

src/main/java/model/Printable.java

+package model;
+
+import util.Position;
+
+import java.util.List;
+
+public interface Printable {
+
+}

src/main/java/model/RemoverBehavior.java

@@ -5,7 +5,5 @@ import util.Position;
 import java.util.List;
 
 public interface RemoverBehavior<E> extends Behavior {
-    public void removePartial(BoardData boardData,Position p);
-    public  List<Position> remove(BoardData boardData,Position p);
-    public E getElementToRemove();
+
 }

src/main/java/model/StandardFire.java

+package model;
+
+import util.Position;
+
+public class StandardFire extends Fire implements Updatable{
+    public StandardFire(Position position) {
+        super(2, ModelElement.FIRE, position);
+    }
+}

src/main/java/model/StandardFireFighter.java

+package model;
+
+import util.Position;
+
+public class StandardFireFighter extends FireFighter implements Updatable{
+    public StandardFireFighter(Position position) {
+        super(1, ModelElement.FIREFIGHTER, position);
+    }
+}

src/main/java/model/StandardFirefighter.java

-package model;
-
-import util.Position;
-import util.TargetStrategy;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class StandardFirefighter extends Element {
-
-    private TargetStrategy targetStrategy=new TargetStrategy();
-
-    public StandardFirefighter() {
-            super(ModelElement.FIREFIGHTER,
-                    new FirefighterBehavior(ModelElement.FIREFIGHTER));
-    }
-
-    @Override
-    public List<Position> Update(BoardData boardData, List<Position> modifiedPositions) {
-        List<Position> firefighterPositions = boardData.getPositions().get(type.ordinal());
-        List<Position> firefighterNewPositions = behavior.getNext(boardData);
-        List<Position> neighborFirePositions = new ArrayList<>();
-
-        modifiedPositions.removeAll(firefighterPositions);
-        modifiedPositions.removeAll(firefighterNewPositions);
-        modifiedPositions.addAll(firefighterPositions);
-        modifiedPositions.addAll(firefighterNewPositions);
-        for (Position p :firefighterNewPositions) {
-            neighborFirePositions.addAll(((RemoverBehavior)behavior).remove(boardData,p));
-        }
-        modifiedPositions.removeAll(neighborFirePositions);
-        modifiedPositions.addAll(neighborFirePositions);
-        boardData.getPositions().set(type.ordinal(),firefighterNewPositions);
-        return modifiedPositions;
-    }
-
-    public void remove(BoardData boardData,Position p) {
-        List<Position> firePositions = boardData.getPositions().get(ModelElement.FIRE.ordinal());
-        firePositions.remove(p);
-    }
-}

src/main/java/model/TangibleBehavior.java

@@ -6,5 +6,5 @@ import java.util.List;
 
 public interface TangibleBehavior<E> extends Behavior {
     public List<E> getObstacles();
-
+    public void extinguish(BoardData boardData,Position position);
 }

src/main/java/model/Updatable.java

+package model;
+
+import util.Position;
+
+import java.util.List;
+
+public interface Updatable {
+    public List<Position> updateSelf(BoardData boardData);
+}

src/test/java/view/StandardFirefighterGridTest.java → src/test/java/view/FirefighterManagerGridTest.java

@@ -4,7 +4,7 @@ import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class StandardFirefighterGridTest {
+public class FirefighterManagerGridTest {
   @Test
   void testColumnCount(){
     Grid<ViewElement> grid = new FirefighterGrid();