Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • main
  • variant
2 results

Target

Select target project
  • l22015417/firefighterstarter
  • m19023837/firefighter-starter-mansour-chadi-chahine-rami
  • r24025701/firefighterstarter
  • n24026202/firefighterstarter
  • couetoux.b/firefighterstarter
  • b23027938/firefighterstarter
  • z20039716/fire-fighter
  • a18023913/firefighterstarter
  • o22010261/firefighterstarter
  • b22015516/firefighterstarter
  • alaboure/firefighter-template
  • p21211679/firefighter-luis-parra-yanis-lounadi
  • v23014723/firefighter-project
  • k20014011/firefighter-template
  • m23022217/firefighter-template
  • p20006624/firefighter-template
  • l21221596/firefighter-template
  • s21232465/firefighter-template
  • y21224754/firefighter-template
  • w21225935/firefighter-template
  • h22023886/firefighter-template
  • b21221604/firefighter-template-boucenna-yacine-zeghar-mohamed-lamine
  • c23025119/firefighterstarter
  • b20031964/firefighterstarter
24 results
Select Git revision
  • main
  • variant
2 results
Show changes
Showing
with 542 additions and 121 deletions
package model;
import util.Position;
import java.util.*;
import static model.BoardFireFighterBehavior.*;
public class FireMovements implements Movements{
private final ElementFactory<Fire> fireFactory;
private Set<Position> firePositions;
public FireMovements(ElementFactory<Fire> fireFactory) {
this.fireFactory = fireFactory;
this.firePositions = new HashSet<>();
}
@Override
public void initializeElement(int rowCount, int columnCount) {
// Feux
List<Fire> fires = fireFactory.createElements(rowCount, columnCount);
for (Fire fire : fires) {
firePositions.add(fire.getPosition());
}
}
@Override
public Collection<Position> getPositions() {
return firePositions;
}
@Override
public List<Position> updateElements() {
List<Position> modifiedPositions = new ArrayList<>();
if (getStep() % 2 == 0) {
List<Position> newFirePositions = new ArrayList<>();
// Pour chaque feu existant, vérifier ses voisins
for (Position fire : firePositions) {
// Si la position voisine est libre (non occupée par un feu ou un pompier), le feu peut se propager
for (Position neighbor : getNeighbors().get(fire)) {
// Vérifier si le feu peut se propager à cette position (pas de feu déjà là et pas un terrain bloqué)
if (canMoveTo(neighbor, firePositions, (List<Position>) getFireFighterMovements().getPositions()) && !firePositions.contains(neighbor)) {
newFirePositions.add(neighbor);
}
}
}
// Ajouter les nouvelles positions de feu à la liste des feux existants
firePositions.addAll(newFirePositions);
modifiedPositions.addAll(newFirePositions);
}
return modifiedPositions;
}
}
......@@ -4,29 +4,36 @@ import util.Position;
import java.util.*;
public class FirefighterBoard implements Board<List<ModelElement>> {
private final int columnCount;
private final int rowCount;
private final int initialFireCount;
private final int initialFirefighterCount;
private final TargetStrategy targetStrategy = new TargetStrategy();
private List<Position> firefighterPositions;
private Set<Position> firePositions;
private Map<Position, List<Position>> neighbors = new HashMap();
private final Position[][] positions;
private int step = 0;
private final BoardFireFighterBehavior behavior;
private final BoardFirefighterProperties properties;
private final Random randomGenerator = new Random();
public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount) {
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++)
public FirefighterBoard(int columnCount, int rowCount, int initialFireCount, int initialFirefighterCount,int initialCloud,int initialMotorized,
int initialRocky) {
Map<Position, List<Position>> neighbors = initializeNeighbors(rowCount, columnCount);
this.properties = new BoardFirefighterProperties(rowCount, columnCount);
this.behavior = new BoardFireFighterBehavior(neighbors,new FireFactory(randomGenerator,initialFireCount),new FirefighterFactory(randomGenerator,initialFirefighterCount),
new CloudFactory(randomGenerator,initialCloud),new MotorizedFactory(randomGenerator,initialMotorized),new RockyFactory(randomGenerator,initialRocky));
behavior.initializeElements( properties.rowCount(), properties.columnCount());
}
private Map<Position, List<Position>> initializeNeighbors(int rowCount, int columnCount) {
Map<Position, List<Position>> neighbors = new HashMap<>();
Position[][] positions = new Position[rowCount][columnCount];
for (int row = 0; row < rowCount; row++) {
for (int column = 0; column < columnCount; column++) {
positions[row][column] = new Position(row, column);
for (int column = 0; column < columnCount; column++)
}
}
for (int row = 0; row < rowCount; row++) {
for (int column = 0; column < columnCount; column++) {
List<Position> list = new ArrayList<>();
if (row > 0) list.add(positions[row - 1][column]);
if (column > 0) list.add(positions[row][column - 1]);
......@@ -34,114 +41,78 @@ public class FirefighterBoard implements Board<List<ModelElement>> {
if (column < columnCount - 1) list.add(positions[row][column + 1]);
neighbors.put(positions[row][column], list);
}
this.initialFireCount = initialFireCount;
this.initialFirefighterCount = initialFirefighterCount;
initializeElements();
}
public void initializeElements() {
firefighterPositions = new ArrayList<>();
firePositions = new HashSet<>();
for (int index = 0; index < initialFireCount; index++)
firePositions.add(randomPosition());
for (int index = 0; index < initialFirefighterCount; index++)
firefighterPositions.add(randomPosition());
return neighbors;
}
private Position randomPosition() {
return new Position(randomGenerator.nextInt(rowCount), randomGenerator.nextInt(columnCount));
}
@Override
public List<ModelElement> getState(Position position) {
List<ModelElement> result = new ArrayList<>();
for (Position firefighterPosition : firefighterPositions)
if (firefighterPosition.equals(position))
result.add(ModelElement.FIREFIGHTER);
if (firePositions.contains(position))
result.add(ModelElement.FIRE);
return result;
}
@Override
public int rowCount() {
return rowCount;
}
// Filtrage des éléments Fire (en transformant les positions en objets Fire)
behavior.getFirePositions().stream()
.filter(pos -> pos.isAtPosition(position)) // Vérifier si la position correspond
.forEach(pos -> result.add(new Fire(pos))); // Créer un objet Fire à partir de Position
// Filtrage des éléments Firefighter (en transformant les positions en objets FireFighter)
behavior.getFireFighterMovements().getPositions().stream()
.filter(pos -> pos.isAtPosition(position)) // Vérifier si la position correspond
.forEach(pos -> result.add(new FireFighter(pos))); // Créer un objet Firefighter à partir de Position
// Filtrage des éléments Cloud
behavior.getCloudPositions().stream()
.filter(pos -> pos.isAtPosition(position))
.forEach(pos -> result.add(new Cloud(pos)));
// Filtrage des éléments Motorized
behavior.getMotorizedFighters().stream()
.filter(pos -> pos.isAtPosition(position))
.forEach(pos -> result.add(new MotorizedFireFighter(pos)));
behavior.getTerrainMap().forEach((pos, value) -> {
if (pos.isAtPosition(position) && value instanceof Mountain) {
result.add((Mountain) value); // Ajouter uniquement un objet Mountain
}
});
behavior.getTerrainMap().forEach((pos, value) -> {
if (pos.isAtPosition(position) && value instanceof Road) {
result.add((Road) value); // Ajouter uniquement un objet Mountain
}
});
// Filtrage des éléments Rocky
behavior.getRocky().stream()
.filter(pos -> pos.isAtPosition(position))
.forEach(pos -> result.add(new Rocky(pos)));
@Override
public int columnCount() {
return columnCount;
return result;
}
public List<Position> updateToNextGeneration() {
List<Position> modifiedPositions = updateFirefighters();
modifiedPositions.addAll(updateFires());
step++;
return modifiedPositions;
}
private List<Position> updateFires() {
List<Position> modifiedPositions = new ArrayList<>();
if (step % 2 == 0) {
List<Position> newFirePositions = new ArrayList<>();
for (Position fire : firePositions) {
newFirePositions.addAll(neighbors.get(fire));
public void reset() {
behavior.reset();
behavior.initializeElements(properties.rowCount(), properties.columnCount());
}
firePositions.addAll(newFirePositions);
modifiedPositions.addAll(newFirePositions);
public void setState(List<ModelElement> state, Position position) {
// Pour chaque élément dans l'état, on l'ajoute sur le plateau
state.forEach(element -> addElementToBoard(element, position));
}
return modifiedPositions;
private void addElementToBoard(ModelElement element, Position position) {
if (element instanceof Fire) {
behavior.getFirePositions().add(position); // Ajouter un Fire
} else if (element instanceof FireFighter) {
behavior.getFirefighterPositions().add(position); // Ajouter un Firefighter
} else if (element instanceof Cloud) {
behavior.getCloudPositions().add(position);
} else if (element instanceof MotorizedFireFighter) {
behavior.getMotorizedFighters().add(position);
}else if(element instanceof Rocky)
{
behavior.getRocky().add(position);
}
@Override
public int stepNumber() {
return step;
}
private List<Position> updateFirefighters() {
List<Position> modifiedPosition = new ArrayList<>();
List<Position> firefighterNewPositions = new ArrayList<>();
for (Position firefighterPosition : firefighterPositions) {
Position newFirefighterPosition =
targetStrategy.neighborClosestToFire(firefighterPosition,
firePositions, neighbors);
firefighterNewPositions.add(newFirefighterPosition);
extinguish(newFirefighterPosition);
modifiedPosition.add(firefighterPosition);
modifiedPosition.add(newFirefighterPosition);
List<Position> neighborFirePositions = neighbors.get(newFirefighterPosition).stream()
.filter(firePositions::contains).toList();
for (Position firePosition : neighborFirePositions)
extinguish(firePosition);
modifiedPosition.addAll(neighborFirePositions);
}
firefighterPositions = firefighterNewPositions;
return modifiedPosition;
public BoardFireFighterBehavior getBehavior() {
return behavior;
}
@Override
public void reset() {
step = 0;
initializeElements();
}
private void extinguish(Position position) {
firePositions.remove(position);
}
@Override
public void setState(List<ModelElement> state, Position position) {
firePositions.remove(position);
for (; ; ) {
if (!firefighterPositions.remove(position)) break;
}
for (ModelElement element : state) {
switch (element) {
case FIRE -> firePositions.add(position);
case FIREFIGHTER -> firefighterPositions.add(position);
}
}
public BoardFirefighterProperties getProperties() {
return properties;
}
}
package model;
import util.Position;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class FirefighterFactory implements ElementFactory<FireFighter>, PositionGenerator{
private final Random random;
private int count;
public FirefighterFactory(Random random,int count) {
this.random = random;
this.count=count;
}
@Override
public List<FireFighter> createElements(int rowCount, int columnCount) {
List<FireFighter> firefighters = new ArrayList<>();
for (int i = 0; i < count; i++) {
Position randomPosition = generateRandomPosition(rowCount, columnCount);
firefighters.add(new FireFighter(randomPosition));
}
return firefighters;
}
@Override
public Position generateRandomPosition(int rowCount, int columnCount) {
int row = random.nextInt(rowCount);
int column = random.nextInt(columnCount);
return new Position(row, column);
}
public int getCount() {
return count;
}
}
package model;
public enum ModelElement {
FIREFIGHTER, FIRE
import util.Position;
public interface ModelElement {
public Position getPosition();
}
package model;
import util.Position;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class MotorizedFactory implements ElementFactory<MotorizedFireFighter>, PositionGenerator{
private final Random random;
private int count;
public MotorizedFactory(Random random, int count) {
this.random = random;
this.count = count;
}
@Override
public List<MotorizedFireFighter> createElements(int rowCount, int columnCount) {
List<MotorizedFireFighter> firefighters = new ArrayList<>();
for (int i = 0; i < count; i++) {
Position randomPosition = generateRandomPosition(rowCount, columnCount);
firefighters.add(new MotorizedFireFighter(randomPosition));
}
return firefighters;
}
@Override
public Position generateRandomPosition(int rowCount, int columnCount) {
int row = random.nextInt(rowCount);
int column = random.nextInt(columnCount);
return new Position(row, column);
}
public int getCount() {
return count;
}
}
package model;
import util.Position;
import util.TargetStrategy;
import java.util.*;
public class MotorizedFireFighter extends BoardElement{
private final TargetStrategy targetStrategy = new TargetStrategy();
public MotorizedFireFighter(Position position) {
super(position);
}
@Override
public String getType() {
return "MotorizedFireFighter";
}
@Override
public String toString() {
return null;
}
/**
* Déplace le pompier motorisé en deux étapes maximum vers un feu.
*
* @param firePositions Les positions des feux.
* @param neighbors Les positions voisines accessibles.
* @return La nouvelle position du pompier.
*/
public Position move(Set<Position> firePositions, Map<Position, List<Position>> neighbors) {
// Première étape
Position firstStep = targetStrategy.neighborClosestToTarget(getPosition(), firePositions, neighbors);
if (firstStep == null) {
return getPosition(); // Aucun déplacement possible
}
// Deuxième étape
Position secondStep = targetStrategy.neighborClosestToTarget(firstStep, firePositions, neighbors);
// Mise à jour de la position
Position newPosition = (secondStep != null) ? secondStep : firstStep;
setPosition(newPosition); // Mettre à jour la position interne
return newPosition;
}
}
package model;
import util.Position;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import static model.BoardFireFighterBehavior.*;
public class MotorizedMovements implements Movements{
private final ElementFactory<MotorizedFireFighter> motorizedFactory;
private List<Position> motorizedFighters;
public MotorizedMovements(ElementFactory<MotorizedFireFighter> motorizedFactory) {
this.motorizedFactory = motorizedFactory;
this.motorizedFighters = new ArrayList<>();
}
@Override
public List<Position> updateElements() {
List<Position> modifiedPositions = new ArrayList<>();
List<Position> newPositions = new ArrayList<>();
for (Position currentPosition : motorizedFighters) {
// Vérification de validité de la position actuelle
if (!getNeighbors().containsKey(currentPosition)) {
System.err.println("Position actuelle invalide : " + currentPosition);
newPositions.add(currentPosition);
continue;
}
// Étape 1 : Calcul du premier déplacement
Position firstStep = getTargetStrategy().neighborClosestToTarget(currentPosition, fireMovements.getPositions(), getNeighbors());
if (firstStep == null || !getNeighbors().containsKey(firstStep)) {
// Aucun déplacement possible, rester sur place
System.out.println("Pas de première étape possible pour : " + currentPosition);
newPositions.add(currentPosition);
continue;
}
// Étape 2 : Calcul du deuxième déplacement
Position secondStep = getTargetStrategy().neighborClosestToTarget(firstStep, fireMovements.getPositions(), getNeighbors());
Position finalPosition = (secondStep != null && getNeighbors().containsKey(secondStep)) ? secondStep : firstStep;
// Ajout de la position finale aux nouvelles positions
newPositions.add(finalPosition);
// Mise à jour des positions modifiées
modifiedPositions.add(currentPosition); // Ancienne position
modifiedPositions.add(finalPosition); // Nouvelle position
// Étape 3 : Éteindre les feux à la position finale
extinguish(finalPosition);
extinguishNearbyFires(finalPosition, modifiedPositions);
}
// Mettre à jour les positions globales
motorizedFighters = newPositions;
return modifiedPositions;
}
@Override
public void initializeElement(int rowCount, int columnCount) {
motorizedFighters = new ArrayList<>();
List<MotorizedFireFighter> motorizedFirefighters = motorizedFactory.createElements(rowCount, columnCount);
for (MotorizedFireFighter motorizedFirefighter : motorizedFirefighters) {
motorizedFighters.add(motorizedFirefighter.getPosition());
}
}
@Override
public Collection<Position> getPositions() {
return this.motorizedFighters;
}
}
package model;
import util.Position;
public class Mountain extends BoardElement implements Terrain {
public Mountain(Position position) {
super(position);
}
@Override
public String getType() {
return null;
}
@Override
public String toString() {
return null;
}
@Override
public boolean isTraversableByFire() {
return false; // Les montagnes ne sont pas franchissables par le feu
}
@Override
public boolean isTraversableByFirefighter() {
return false; // Les pompiers ne peuvent pas passer non plus
}
}
package model;
import util.Position;
import java.util.Collection;
import java.util.List;
public interface Movements {
public List<Position> updateElements();
public void initializeElement(int rowCount, int columnCount);
Collection<Position> getPositions();
}
package model;
import util.Position;
public interface PositionGenerator {
public Position generateRandomPosition(int rowCount, int columnCount);
}
package model;
import util.Position;
public class Road extends BoardElement implements Terrain{
public Road(Position position) {
super(position);
}
@Override
public String getType() {
return null;
}
@Override
public String toString() {
return null;
}
@Override
public boolean isTraversableByFire() {
return false;
}
@Override
public boolean isTraversableByFirefighter() {
return true;
}
}
package model;
import util.Position;
public class Rocky extends BoardElement{
private static int firePropagationCounter;
public Rocky(Position position) {
super(position);
}
public static boolean canFirePropagate() {
// Le feu ne peut se propager que tous les 4 tours
if (firePropagationCounter >= 4) {
firePropagationCounter = 0; // Reset le compteur
return true;
}
firePropagationCounter++;
return false;
}
@Override
public String getType() {
return null;
}
@Override
public String toString() {
return null;
}
public static int getFirePropagationCounter() {
return firePropagationCounter;
}
}
package model;
import util.Position;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class RockyFactory implements ElementFactory<Rocky>,PositionGenerator{
private final Random random;
private int count;
public RockyFactory(Random random, int count) {
this.random = random;
this.count = count;
}
@Override
public List<Rocky> createElements(int rowCount, int columnCount) {
List<Rocky> rocky = new ArrayList<>();
for (int i = 0; i < count; i++) {
Position randomPosition = generateRandomPosition(rowCount, columnCount);
rocky.add(new Rocky(randomPosition));
}
return rocky;
}
@Override
public int getCount() {
return count;
}
@Override
public Position generateRandomPosition(int rowCount, int columnCount) {
int row = random.nextInt(rowCount);
int column = random.nextInt(columnCount);
return new Position(row, column);
}
}
package model;
public interface Terrain {
boolean isTraversableByFire();
boolean isTraversableByFirefighter();
}
package util;
public record Position(int row, int column) {
public boolean isAtPosition(Position position) {
return row == position.row() && column == position.column();
}
}
package util;
import view.ViewElement;
import java.util.Collection;
import java.util.List;
import java.util.Map;
public interface Strategy {
Position neighborClosestToTarget(Position position, Collection<Position> targets, Map<Position, List<Position>> neighbors);
}
package model;
package util;
import util.Position;
import view.ViewElement;
import java.util.*;
public class TargetStrategy {
public class TargetStrategy implements Strategy{
/**
......@@ -12,7 +13,7 @@ public class TargetStrategy {
* @param targets positions that are targeted.
* @return the position next to the current position that is on the path to the closest target.
*/
Position neighborClosestToFire(Position position, Collection<Position> targets,
public Position neighborClosestToTarget(Position position, Collection<Position> targets,
Map<Position, List<Position>> neighbors) {
Set<Position> seen = new HashSet<Position>();
HashMap<Position, Position> firstMove = new HashMap<Position, Position>();
......@@ -21,6 +22,7 @@ public class TargetStrategy {
firstMove.put(initialMove, initialMove);
while (!toVisit.isEmpty()) {
Position current = toVisit.poll();
// if (grid[current.row()][current.column()] == ViewElement.MOUNTAIN) continue;
if (targets.contains(current))
return firstMove.get(current);
for (Position adjacent : neighbors.get(current)) {
......
......@@ -96,4 +96,5 @@ public class FirefighterGrid extends Canvas implements Grid<ViewElement>{
private void clearBox(int row, int column){
getGraphicsContext2D().clearRect(column * boxWidth,row * boxHeight, boxWidth, boxHeight);
}
}
\ No newline at end of file
......@@ -3,7 +3,8 @@ package view;
import javafx.scene.paint.Color;
public enum ViewElement {
FIREFIGHTER(Color.BLUE), FIRE(Color.RED), EMPTY(Color.WHITE);
FIREFIGHTER(Color.BLUE), FIRE(Color.RED), EMPTY(Color.WHITE) , CLOUD(Color.GRAY),MOTORIZED(Color.BLACK) , MOUNTAIN(Color.GREEN), ROCKY(Color.BISQUE),
ROAD(Color.BROWN);
final Color color;
ViewElement(Color color) {
this.color = color;
......
......@@ -10,7 +10,7 @@
<?import javafx.scene.control.Label?>
<HBox styleClass="background" stylesheets="@DarkTheme.css"
xmlns="http://javafx.com/javafx" xmlns:fx="http://javafx.com/fxml"
fx:controller="controller.Controller">
fx:controller="controller.Controller" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity">
<VBox>
<Separator maxHeight="-Infinity" maxWidth="-Infinity"
prefHeight="24.0" prefWidth="200.0"/>
......