[Ajout] Pompier motorisé

src/main/java/model/Cloud.java

@@ -101,4 +101,5 @@ public class Cloud implements Entity{
     @Override
     public int getPriority(){ return this.priority;}
 
+
 }

src/main/java/model/Fire.java

@@ -6,7 +6,7 @@ import java.util.List;
 import javafx.scene.paint.Color;
 import util.Position;
 import util.PositionUtil;
-import util.PositionUtil;
+
 
 public class Fire implements Entity {
     Board<Square> b;
@@ -82,4 +82,26 @@ public class Fire implements Entity {
 
     @Override
     public int getPriority(){ return this.priority;}
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        Fire fire = (Fire) obj;
+        return age == fire.age &&
+               priority == fire.priority &&
+               (position == null ? fire.position == null : position.equals(fire.position)) &&
+               (b == null ? fire.b == null : b.equals(fire.b)) &&
+               (viewColor == null ? fire.viewColor == null : viewColor.equals(fire.viewColor));
+    }
+    
+    @Override
+    public int hashCode() {
+        int result = (b == null ? 0 : b.hashCode());
+        result = 31 * result + (position == null ? 0 : position.hashCode());
+        result = 31 * result + (viewColor == null ? 0 : viewColor.hashCode());
+        result = 31 * result + age;
+        result = 31 * result + priority;
+        return result;
+    }
 }

src/main/java/model/FireFighter.java

@@ -31,7 +31,6 @@ public class FireFighter implements Entity {
         // Vérifier s'il y a du feu dans une des positions adjacentes
         boolean hasFire = adjacentPositions.stream()
                 .anyMatch(p -> b.doesSquareContainEntity(p, Fire.class));
-
         if (hasFire) {
             // Si du feu est trouvé, on éteint les feux adjacents
             positions.addAll(extinguish(adjacentPositions, b));
@@ -59,7 +58,7 @@ public class FireFighter implements Entity {
         return positions;
     }
 
-    private List<Position> extinguish(List<Position> adjacentPositions, Board<Square> b) {
+    protected List<Position> extinguish(List<Position> adjacentPositions, Board<Square> b) {
         List<Position> extinguishedPositions = new ArrayList<>();
         for (Position p : adjacentPositions) {
             extinguishedPositions.addAll(adjacentPositions);
@@ -76,7 +75,7 @@ public class FireFighter implements Entity {
         return extinguishedPositions;
     }
 
-    private Position getNextPositionTowards(Position currentPos, Position targetPos, Board<Square> b) {
+    protected Position getNextPositionTowards(Position currentPos, Position targetPos, Board<Square> b) {
         // Générer les 8 positions adjacentes possibles
         List<Position> possibleMoves = PositionUtil.generateAllAdjacentPositions(currentPos, b);
 

src/main/java/model/FireFighterScenario.java

@@ -3,16 +3,12 @@ package model;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
-import java.util.Collections;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Random;
-import java.util.Random;
 
 import util.Matrix;
 import util.Position;
 import util.PositionUtil;
-import util.PositionUtil;
 
 public class FireFighterScenario extends EntityScenario implements Board<Square> {
 
@@ -48,7 +44,7 @@ public class FireFighterScenario extends EntityScenario implements Board<Square>
         positions.add(new Position(x, y));
       }
     }
-
+    setSquare(new Square(new Position(0,0), new MotorizedFireFighter(new Position(0,0), this)));
     while (fireCount < initialFireCount || fireFighterCount < initialFireFightersCount || cloudCount < intialCloudCount) {
       Collections.shuffle(positions); // Mélange les positions pour un parcours aléatoire
 
@@ -166,9 +162,8 @@ public class FireFighterScenario extends EntityScenario implements Board<Square>
       }
       List<Entity> entities = new ArrayList<>(s.getEntities());
       for (Entity e : entities) {
-        List<Position> entityUpdatedPositions = e.nextTurn(this);
         e.incrementAge();
-        changedPositions.addAll(entityUpdatedPositions);
+        changedPositions.addAll(e.nextTurn(this));
       }
 
     }
@@ -184,7 +179,6 @@ public class FireFighterScenario extends EntityScenario implements Board<Square>
 
     // Définir la distance maximale possible
     int maxDistance = rows + cols;
-
     // Parcourir les distances croissantes à partir de 1
     for (int distance = 1; distance < maxDistance; distance++) {
       List<Position> positionsAtDistance = PositionUtil.getPositionsAtManhattanDistance(fromPos, distance, rows, cols);

src/main/java/model/MotorizedFireFighter.java

+package model;
+
+import java.util.*;
+import javafx.scene.paint.Color;
+import util.*;
+
+public class MotorizedFireFighter extends FireFighter {
+    private final Color viewColor = Color.CYAN;
+    public MotorizedFireFighter(Position position, Board<Square> b){
+        super(position, b);
+    }
+    public List<Position> nextTurn(Board<Square> b) {
+        List<Position> positions = new ArrayList<>();
+
+        // Générer les positions adjacentes
+        List<Position> adjacentPositions = PositionUtil.generateAdjacentPositions(getPosition(), b);
+        adjacentPositions.removeIf( p -> b.doesSquareContainEntity(p, Mountain.class));
+
+        // Vérifier s'il y a du feu dans une des positions adjacentes
+        boolean hasFire = adjacentPositions.stream()
+                .anyMatch(p -> b.doesSquareContainEntity(p, Fire.class));
+        if (hasFire) {
+            // Si du feu est trouvé, on éteint les feux adjacents
+            positions.addAll(extinguish(adjacentPositions, b));
+        } else {
+            // Chercher la position du feu le plus proche
+            Position nearestFirePos = b.getNearestEntity(getPosition(), Fire.class);
+
+            if (nearestFirePos != null && !nearestFirePos.equals(getPosition())) {
+                // Trouver la meilleure position pour se rapprocher du feu
+                Position nextPos = getNextPositionTowards(getNextPositionTowards(getPosition(), nearestFirePos, b),nearestFirePos, b);
+                if (nextPos != null) {
+                    // Mettre à jour la position du pompier
+                    b.clearCaseFrom(this, getPosition()); // Vider l'ancienne case
+                    positions.add(new Position(getPosition().x(), getPosition().y()));
+                    setPosition(nextPos);
+                    b.addEntityAtSquare(this, nextPos); // Mettre à jour la nouvelle case
+                    positions.add(nextPos);
+                    adjacentPositions = PositionUtil.generateAdjacentPositions(nextPos, b);
+                    positions.addAll(extinguish(adjacentPositions, b));
+                }
+                // Aucun déplacement possible = le pompier reste sur place
+            }
+        }
+
+        return positions;
+    }
+    public Color getViewColor(){
+        return this.viewColor;
+    }
+
+}

src/main/java/util/PositionUtil.java

@@ -74,6 +74,18 @@ public class PositionUtil {
                 .collect(Collectors.toList());
     }
 
+    public static List<Position> generateAdjacentPositions(Position position, Board<Square> board, int distance) {
+        int x = position.x();
+        int y = position.y();
+
+        List<Position> positions = new ArrayList<Position>();
+        for(int i = 0; i < 4; i++){
+
+        }
+        return positions;
+    }
+
+
     // Méthode pour générer toutes les positions adjacentes (y compris les
     // diagonales)
     public static List<Position> generateAllAdjacentPositions(Position position, Board<Square> board) {