tache 1 a finir

src/main/java/App.java

+import grid.Grid;
 import javafx.application.Application;
 import javafx.scene.Group;
 import javafx.scene.Scene;

src/main/java/Clouds.java

-import java.util.List;
-
-public class Clouds {
-
-}

src/main/java/AntiFire.java → src/main/java/fightfire/AntiFire.java

+package fightfire;
+
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
+import grid.Grid;
+
 public abstract class AntiFire {
     Set<Position> fires = new HashSet<>();
     Grid grid;
 
     int colCount, rowCount;
+    public abstract void initiali(int number);
 
     public abstract void activation();
     public abstract Position activateFighter(Position position);
@@ -17,7 +22,7 @@ public abstract class AntiFire {
 
     public  void extinguish(Position position){
         fires.remove(position);
-        grid.paint(position.row, position.col);
+        grid.paint(position.row(), position.col());
     }
     public Position randomPosition() {
         return new Position((int) (Math.random()*rowCount), (int) (Math.random()*colCount));

src/main/java/fightfire/Clouds.java

+package fightfire;
+
+import fightfire.AntiFire;
+
+import java.util.*;
+
+public class Clouds extends AntiFire {
+    List<Position> ccNewPositions;
+    List<Position> clouds = new ArrayList<>();
+
+    @Override
+    public void initiali(int number) {
+        for(int index=0; index<number;index++)
+            clouds.add(randomPosition());
+
+    }
+
+    @Override
+    public void activation() {
+        ccNewPositions = new ArrayList<>();
+        for(Position cc : clouds){
+            Position newPosition = activateFighter(cc);
+            grid.paint(cc.row(), cc.row());
+            grid.paintMF(newPosition.row(), newPosition.col());
+            ccNewPositions.add(newPosition);
+        }
+        clouds = ccNewPositions;
+
+    }
+
+    @Override
+    public Position activateFighter(Position position) {
+        Position randomPosition = moveTowardFire(position);
+        //next(position).get((int) (Math.random()*next(position).size()));
+        List<Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
+        extinguish(randomPosition);
+        for (Position fire : nextFires)
+            extinguish(fire);
+        return randomPosition;
+    }
+
+    @Override
+    public List<Position> next(Position position) {
+        List<Position> list = new ArrayList<>();
+        if(position.row()>0) list.add(new Position(position.row()-1, position.col()));
+        if(position.col()>0) list.add(new Position(position.row(), position.col()-1));
+        if(position.row()<rowCount-1) list.add(new Position(position.row()+1, position.col()));
+        if(position.col()<colCount-1) list.add(new Position(position.row(), position.col()+1));
+        return list;
+    }
+
+    @Override
+    public Position moveTowardFire(Position position) {
+        return next(position).get((int) (Math.random()*next(position).size()));
+    }
+
+}

src/main/java/fightfire/FireFigher.java

+package fightfire;
+
+import fightfire.AntiFire;
+
+import java.util.*;
+
+public class FireFigher extends AntiFire {
+    List<Position>ffNewPositions= new ArrayList<>();
+    List<Position>firefighters=new ArrayList<>();
+    @Override
+    public void initiali(int number) {
+        for(int index=0; index<number;index++)
+            firefighters.add(randomPosition());
+
+    }
+
+    @Override
+    public void activation() {
+        ffNewPositions = new ArrayList<>();
+        for(Position ff : firefighters){
+            Position newPosition = activateFighter(ff);
+            grid.paint(ff.row(),ff.col());
+            grid.paintFF(newPosition.row(), newPosition.col());
+            ffNewPositions.add(newPosition);
+        }
+
+    }
+
+    @Override
+    public Position activateFighter(Position position) {
+        Position randomPosition = moveTowardFire(position);
+        //next(position).get((int) (Math.random()*next(position).size()));
+        List<Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
+        extinguish(randomPosition);
+        for (Position fire : nextFires)
+            extinguish(fire);
+        return randomPosition;
+    }
+
+
+    @Override
+    public List<Position> next(Position position) {
+        List<Position> list = new ArrayList<>();
+        if(position.row()>0) list.add(new Position(position.row()-1, position.col()));
+        if(position.col()>0) list.add(new Position(position.row(), position.col()-1));
+        if(position.row()<rowCount-1) list.add(new Position(position.row()+1, position.col()));
+        if(position.col()<colCount-1) list.add(new Position(position.row(), position.col()+1));
+        return list;
+    }
+
+    @Override
+    public Position moveTowardFire(Position position) {
+        Queue<Position> toVisit = new LinkedList<>();
+        Set<Position> seen = new HashSet<>();
+        HashMap<Position, Position> firstMove = new HashMap<>();
+        toVisit.addAll(next(position));
+        for(Position initialMove : toVisit)
+            firstMove.put(initialMove,initialMove);
+        while(!toVisit.isEmpty()){
+            Position current = toVisit.poll();
+            if(fires.contains(current))
+                return firstMove.get(current);
+            for(Position adjacent : next(current)){
+                if(seen.contains(adjacent)) continue;
+                toVisit.add(adjacent);
+                seen.add(adjacent);
+                firstMove.put(adjacent, firstMove.get(current));
+            }
+        }
+        return position;
+    }
+}

src/main/java/MotoFighter.java → src/main/java/fightfire/MotoFighter.java

+package fightfire;
+
+import fightfire.AntiFire;
+
 import java.util.*;
 
 public class MotoFighter extends AntiFire {
@@ -5,6 +9,11 @@ public class MotoFighter extends AntiFire {
     List<Position> motofighter = new ArrayList<>();
 
 
+    @Override
+    public void initiali(int number) {
+        for(int index=0; index<number;index++)
+            motofighter.add(randomPosition());
+    }
 
     @Override
     public void activation() {

src/main/java/Grid.java → src/main/java/grid/Grid.java

+package grid;
+
 import javafx.scene.canvas.Canvas;
 import javafx.scene.canvas.GraphicsContext;
 import javafx.scene.input.MouseEvent;
 import javafx.scene.paint.Color;
+import model.Model;
 
 public class Grid extends Canvas{
-    int width, height, colCount, rowCount;
-    Model model;
+    int width;
+    int height;
+    public int colCount;
+    public int rowCount;
+    public Model model;
 
 
     public Grid(int width, int height, int colCount, int rowCount) {
@@ -17,7 +23,7 @@ public class Grid extends Canvas{
         setFocusTraversable(true);
         setOnMousePressed(this::mousePressed);
         model = new Model(this);
-        model.initialisation(3,1,2,1);
+        model.initialisation(3,1,2,2);
     }
 
     public void restart(MouseEvent mouseEvent){
@@ -34,7 +40,7 @@ public class Grid extends Canvas{
             model.click((int)x*rowCount/height,(int)y*colCount/width);*/
     }
 
-    void repaint(){
+    public void repaint(){
         for(int col=0; col<colCount; col++)
             getGraphicsContext2D().strokeLine(0, col*width/colCount,height, col*width/colCount);
         for(int row=0; row<rowCount;row++)
@@ -42,7 +48,7 @@ public class Grid extends Canvas{
 
     }
 
-    void paint(int row, int col){
+    public void paint(int row, int col){
         getGraphicsContext2D().setFill(Color.WHITE);
         getGraphicsContext2D().fillRect(row*height/rowCount,col*width/colCount,height/rowCount,width/colCount);
     }

src/main/java/model/Fire.java

+package model;
+
+import grid.Grid;
+import position.Position;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Fire {
+    int step =0;
+    Grid grid;
+    int rowCount,colCount;
+
+    Set<Position> fires = new HashSet<>();
+
+    public void initiali(int fireNumber){
+        for(int index=0; index<fireNumber;index++)
+            fires.add(new Position((int) (Math.random()*rowCount), (int) (Math.random()*colCount)));}
+
+    public void activation() {
+        if(step%2==0){
+            List<Position> newFires = new ArrayList<>();
+            for(Position fire : fires){
+                newFires.addAll(activateFire(fire));
+            }
+            for(Position newFire : newFires)
+                grid.paintFire(newFire.row(), newFire.col());
+
+            fires.addAll(newFires);}
+        step++;
+    }
+    private List<Position> activateFire(Position position) {
+        return next(position);
+    }
+
+    private List<Position> next(Position position){
+        List<Position> list = new ArrayList<>();
+        if(position.row()>0) list.add(new Position(position.row()-1, position.col()));
+        if(position.col()>0) list.add(new Position(position.row(), position.col()-1));
+        if(position.row()<rowCount-1) list.add(new Position(position.row()+1, position.col()));
+        if(position.col()<colCount-1) list.add(new Position(position.row(), position.col()+1));
+        return list;
+    }
+
+
+}
\ No newline at end of file

src/main/java/Model.java → src/main/java/model/Model.java

+package model;
+
+import fightfire.Clouds;
+import fightfire.FireFigher;
+import fightfire.MotoFighter;
+import grid.Grid;
+
+import model.Model;
+import position.Position;
+
 import java.util.*;
 
 
@@ -5,11 +15,13 @@ public class Model  {
     Grid grid;
     int colCount, rowCount;
     MotoFighter motoFighter =new MotoFighter();
-    List<Position>linefite=new ArrayList<>();
+
+    FireFigher fireFigher = new FireFigher();
+    Clouds clouds=new Clouds();
 
     List<Position> firefighters = new ArrayList<>();
-    List<Position> clouds = new ArrayList<>();
-    Set<Position> fires = new HashSet<>();
+    Fire fires = new Fire();
+
     List<Position> ffNewPositions;
     List<Position> cNewPositions;
 
@@ -24,160 +36,175 @@ public class Model  {
 
 
     public void initialisation(int fireNumber, int fireFighterNumber,int cloudNumber,int motoFighterNumber){
-        for(int index=0; index<fireNumber;index++)
-            fires.add(randomPosition());
-        for(int index=0; index<fireFighterNumber;index++)
+
+        fires.initiali(fireNumber);
+        fireFigher.initiali(fireFighterNumber);
+        clouds.initiali(cloudNumber);
+        motoFighter.initiali(motoFighterNumber);
+
+
+
+        /*for(int index=0; index<fireFighterNumber;index++)
             firefighters.add(randomPosition());
         for(int index=0; index<cloudNumber;index++)
-            clouds.add(randomPosition());
-        for(int index=0; index<motoFighterNumber;index++)
-            linefite.add(randomPosition());
-        motoFighter.motofighter.add(randomPosition().row());
-    }
+            clouds.add(randomPosition());*/
 
-    private Position randomPosition() {
-        return new Position((int) (Math.random()*rowCount), (int) (Math.random()*colCount));
     }
 
+   /*private position.Position randomPosition() {
+        return new position.Position((int) (Math.random()*rowCount), (int) (Math.random()*colCount));
+    }*/
+
+
 
 
     public void activation(){
+
+
+
+       /*
         ffNewPositions = new ArrayList<>();
-        for(Position ff : firefighters){
-            Position newPosition = activateFirefighter(ff);
+        for(position.Position ff : firefighters){
+            position.Position newPosition = activateFirefighter(ff);
             grid.paint(ff.row(),ff.col());
             grid.paintFF(newPosition.row(), newPosition.col());
             ffNewPositions.add(newPosition);
         }
+        firefighters = ffNewPositions;
+        */
+
+        fireFigher.activation();
 
-        cNewPositions = new ArrayList<>();
+       /* cNewPositions = new ArrayList<>();
 
-        for(Position cc : clouds){
-            Position newPosition = activeCloud(cc);
+        for(position.Position cc : clouds){
+            position.Position newPosition = activeCloud(cc);
             grid.paint(cc.row(),cc.col());
             grid.paintCC(newPosition.row(), newPosition.col());
             cNewPositions.add(newPosition);
         }
 
-       /* for(Position mF : motofighter){
-            Position newPosition = motoFighter.activateFighter(mF);
+         clouds = cNewPositions;
+
+        */
+        clouds.activation();
+
+       /* for(position.Position mF : motofighter){
+            position.Position newPosition = motoFighter.activateFighter(mF);
             grid.paint(mF.row,mF.col);
             grid.paintMF(newPosition.row, newPosition.col);
             mfNewPositions.add(newPosition);
         }*/
 
-        firefighters = ffNewPositions;
-
-        clouds = cNewPositions;
-
         motoFighter.activation();
 
 
 
-        if(step%2==0){
-            List<Position> newFires = new ArrayList<>();
-            for(Position fire : fires){
+       /* if(step%2==0){
+            List<position.Position> newFires = new ArrayList<>();
+            for(position.Position fire : fires){
                 newFires.addAll(activateFire(fire));
             }
-            for(Position newFire : newFires)
+            for(position.Position newFire : newFires)
                 grid.paintFire(newFire.row(), newFire.col());
 
             fires.addAll(newFires);}
-        step++;
+        step++;8*/
+        fires.activation();
 
     }
 
-    private List<Position> activateFire(Position position) {
+   /* private List<position.Position> activateFire(position.Position position) {
         return next(position);
-    }
+    }*/
 
-    private Position activeCloud(Position position){
-        Position randomPosition=next(position).get((int) (Math.random()*next(position).size()));
-        List<Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
+   /* private position.Position activeCloud(position.Position position){
+        position.Position randomPosition=next(position).get((int) (Math.random()*next(position).size()));
+        List<position.Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
         extinguish(randomPosition);
-        for (Position fire : nextFires)
+        for (position.Position fire : nextFires)
             extinguish(fire);
         return randomPosition;
 
-    }
+    }*/
 
-  /*  private Position activateMotofighter(Position position) {
-        Position randomPosition = tStepTowardFire(position);
+  /*  private position.Position activateMotofighter(position.Position position) {
+        position.Position randomPosition = tStepTowardFire(position);
         //next(position).get((int) (Math.random()*next(position).size()));
-        List<Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
+        List<position.Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
         extinguish(randomPosition);
-        for (Position fire : nextFires)
+        for (position.Position fire : nextFires)
             extinguish(fire);
         return randomPosition;
     }*/
 
 
 
-    private Position activateFirefighter(Position position) {
-        Position randomPosition = aStepTowardFire(position);
+   /* private position.Position activateFirefighter(position.Position position) {
+        position.Position randomPosition = aStepTowardFire(position);
                 //next(position).get((int) (Math.random()*next(position).size()));
-        List<Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
+        List<position.Position> nextFires = next(randomPosition).stream().filter(fires::contains).toList();
         extinguish(randomPosition);
-            for (Position fire : nextFires)
+            for (position.Position fire : nextFires)
                 extinguish(fire);
             return randomPosition;
-        }
+        }*/
 
-        private void extinguish(Position position) {
+       /* private void extinguish(position.Position position) {
         fires.remove(position);
         grid.paint(position.row(), position.col());
-    }
-
-    private List<Position> next(Position position){
-        List<Position> list = new ArrayList<>();
-        if(position.row()>0) list.add(new Position(position.row()-1, position.col()));
-        if(position.col()>0) list.add(new Position(position.row(), position.col()-1));
-        if(position.row()<rowCount-1) list.add(new Position(position.row()+1, position.col()));
-        if(position.col()<colCount-1) list.add(new Position(position.row(), position.col()+1));
+    }*/
+/*
+    private List<position.Position> next(position.Position position){
+        List<position.Position> list = new ArrayList<>();
+        if(position.row()>0) list.add(new position.Position(position.row()-1, position.col()));
+        if(position.col()>0) list.add(new position.Position(position.row(), position.col()-1));
+        if(position.row()<rowCount-1) list.add(new position.Position(position.row()+1, position.col()));
+        if(position.col()<colCount-1) list.add(new position.Position(position.row(), position.col()+1));
         return list;
-    }
-   /* private List<Position> nextTwo(Position position){
-        List<Position> list = new ArrayList<>();
-        if(position.row>0) list.add(new Position(position.row-2, position.col));
-        if(position.col>0) list.add(new Position(position.row, position.col-2));
-        if(position.row<rowCount-1) list.add(new Position(position.row+2, position.col));
-        if(position.col<colCount-1) list.add(new Position(position.row, position.col+2));
+    }*/
+   /* private List<position.Position> nextTwo(position.Position position){
+        List<position.Position> list = new ArrayList<>();
+        if(position.row>0) list.add(new position.Position(position.row-2, position.col));
+        if(position.col>0) list.add(new position.Position(position.row, position.col-2));
+        if(position.row<rowCount-1) list.add(new position.Position(position.row+2, position.col));
+        if(position.col<colCount-1) list.add(new position.Position(position.row, position.col+2));
         return list;
     }*/
 
-    private Position aStepTowardFire(Position position){
-        Queue<Position> toVisit = new LinkedList<>();
-        Set<Position> seen = new HashSet<>();
-        HashMap<Position,Position> firstMove = new HashMap<>();
+  /*  private position.Position aStepTowardFire(position.Position position){
+        Queue<position.Position> toVisit = new LinkedList<>();
+        Set<position.Position> seen = new HashSet<>();
+        HashMap<position.Position,position.Position> firstMove = new HashMap<>();
         toVisit.addAll(next(position));
-        for(Position initialMove : toVisit)
+        for(position.Position initialMove : toVisit)
             firstMove.put(initialMove,initialMove);
         while(!toVisit.isEmpty()){
-            Position current = toVisit.poll();
+            position.Position current = toVisit.poll();
             if(fires.contains(current))
                 return firstMove.get(current);
-            for(Position adjacent : next(current)){
+            for(position.Position adjacent : next(current)){
                 if(seen.contains(adjacent)) continue;
                 toVisit.add(adjacent);
                 seen.add(adjacent);
                 firstMove.put(adjacent, firstMove.get(current));
             }
         }
-        return position;
-    }
 
-  /*  private Position tStepTowardFire(Position position){
-        Queue<Position> toVisit = new LinkedList<>();
-        Set<Position> seen = new HashSet<>();
-        HashMap<Position,Position> firstMove = new HashMap<>();
+    }*/
+
+  /*  private position.Position tStepTowardFire(position.Position position){
+        Queue<position.Position> toVisit = new LinkedList<>();
+        Set<position.Position> seen = new HashSet<>();
+        HashMap<position.Position,position.Position> firstMove = new HashMap<>();
         toVisit.addAll(nextTwo(position));
-        for(Position initialMove : toVisit)
+        for(position.Position initialMove : toVisit)
             firstMove.put(initialMove,initialMove);
         while(!toVisit.isEmpty()){
-            Position current = toVisit.poll();
+            position.Position current = toVisit.poll();
             if(fires.contains(current))
                 return firstMove.get(current);
-            for(Position adjacent : next(current)){
+            for(position.Position adjacent : next(current)){
                 if(seen.contains(adjacent)) continue;
                 toVisit.add(adjacent);
                 seen.add(adjacent);

src/main/java/Position.java → src/main/java/position/Position.java

+package position;
+
 public record Position(int row , int col) {
 }