diff --git a/src/main/java/app/SimulatorApplication.java b/src/main/java/app/SimulatorApplication.java index 86abb8525b4a41c5a54cea60981c01025d5ae3f8..a3b7996590737c56174cfc1539078b8028b19bbe 100644 --- a/src/main/java/app/SimulatorApplication.java +++ b/src/main/java/app/SimulatorApplication.java @@ -19,6 +19,7 @@ public class SimulatorApplication extends javafx.application.Application { private static final int BOX_HEIGHT = 25; public static final int INITIAL_FIRE_COUNT = 3; public static final int INITIAL_FIREFIGHTER_COUNT = 6; + public static final int INITIAL_CLOUD_COUNT = 6; private Stage primaryStage; private Parent view; @@ -44,7 +45,7 @@ public class SimulatorApplication extends javafx.application.Application { view = loader.load(); Controller controller = loader.getController(); controller.initialize(BOX_WIDTH, BOX_HEIGHT, COLUMN_COUNT, ROW_COUNT, - INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT); + INITIAL_FIRE_COUNT, INITIAL_FIREFIGHTER_COUNT, INITIAL_CLOUD_COUNT); } private void showScene() { diff --git a/src/main/java/controller/Controller.java b/src/main/java/controller/Controller.java index 154a1b81d01ae5805d59c55456aa57465a1e6b38..244f1381f64685a5307a517584e162e16b2aa1e6 100644 --- a/src/main/java/controller/Controller.java +++ b/src/main/java/controller/Controller.java @@ -62,9 +62,12 @@ public class Controller { List<Position> updatedPositions = board.updateToNextGeneration(); List<Pair<Position, ViewElement>> updatedSquares = new ArrayList<>(); for(Position updatedPosition : updatedPositions){ - Entity squareState = board.getState(updatedPosition); - ViewElement viewElement = getViewElement(squareState); - updatedSquares.add(new Pair<>(updatedPosition, viewElement)); + for (Entity e : board.getState(updatedPosition )){ + Entity squareState = e; + + ViewElement viewElement = getViewElement(squareState); + updatedSquares.add(new Pair<>(updatedPosition, viewElement));} + } grid.repaint(updatedSquares); updateGenerationLabel(board.stepNumber()); @@ -76,7 +79,9 @@ public class Controller { ViewElement[][] viewElements = new ViewElement[rowCount][columnCount]; for(int column = 0; column < columnCount; column++) for(int row = 0; row < rowCount; row++) - viewElements[row][column] = getViewElement(board.getState(new Position(row, column))); + for (Entity e : board.getState(new Position(row, column))) { + viewElements[row][column] = getViewElement(e); + } grid.repaint(viewElements); updateGenerationLabel(board.stepNumber()); } @@ -118,9 +123,9 @@ public class Controller { } public void initialize(int squareWidth, int squareHeight, int columnCount, - int rowCount, int initialFireCount, int initialFirefighterCount) { + int rowCount, int initialFireCount, int initialFirefighterCount, int initialCloudCount) { grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight); - this.setModel(new FireFighterScenario(columnCount, rowCount, initialFireCount, initialFirefighterCount)); + this.setModel(new FireFighterScenario(columnCount, rowCount, initialFireCount, initialFirefighterCount, initialCloudCount)); repaintGrid(); } diff --git a/src/main/java/model/Board.java b/src/main/java/model/Board.java index 1326ce88c7878fd042329c66fe7cdaa66941452f..beb1e8232823ed1ac938c4021e0ffcf1a01d404f 100644 --- a/src/main/java/model/Board.java +++ b/src/main/java/model/Board.java @@ -1,5 +1,6 @@ package model; +import java.util.ArrayList; import java.util.List; import util.Position; @@ -17,7 +18,7 @@ public interface Board<S> { * @param position The position on the board for which to retrieve the state. * @return The state at the specified position. */ - S getState(Position position); + ArrayList<S> getState(Position position); /** * Set the state of a specific position on the board to the specified state. diff --git a/src/main/java/model/Fire.java b/src/main/java/model/Fire.java index 019137ed7268f5d7ff88db50ca42d89afdda1fb2..68856d9f0a5c27e6628580607c9e1dcde178e2a8 100644 --- a/src/main/java/model/Fire.java +++ b/src/main/java/model/Fire.java @@ -27,8 +27,8 @@ public class Fire implements Entity{ if(board.getStepNumber() % 2 == 0)return new ArrayList<Position>(); List<Position> positions = PositionUtil.generateAdjacentPositions(position, board); for(Position p : positions){ - if(b.getState(p) instanceof EmptySquare){ - if(b.getState(p).getAge() < b.getStepNumber()){ + if(b.getState(p).contains(Fire.class)){ + if(b.getState(p).get(b.getState(p).indexOf(Fire.class)).getAge() < b.getStepNumber()){ board.setState(new Fire(p, board), p); } } @@ -60,6 +60,7 @@ public class Fire implements Entity{ return this.age; } + @Override public void incrementAge() { this.age = age + 1 ; diff --git a/src/main/java/model/FireFighter.java b/src/main/java/model/FireFighter.java index e9f2afb2c450b85727fea9a8fba26778a4439fea..88236a8b7ab2165da064e725001f4b8538245af3 100644 --- a/src/main/java/model/FireFighter.java +++ b/src/main/java/model/FireFighter.java @@ -29,7 +29,7 @@ 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.getState(p) instanceof Fire); + .anyMatch(p -> b.getState(p).contains(Fire.class)); if (hasFire) { // Si du feu est trouvé, on éteint les feux adjacents @@ -62,7 +62,7 @@ public class FireFighter implements Entity{ private List<Position> extinguish(List<Position> adjacentPositions, Board<Entity> b) { List<Position> extinguishedPositions = new ArrayList<>(); for (Position p : adjacentPositions) { - if (b.getState(p) instanceof Fire) { + if (b.getState(p).contains(Fire.class)) { b.clearCase(p); extinguishedPositions.add(p); // Ajouter la position où le feu a été éteint } @@ -75,7 +75,7 @@ public class FireFighter implements Entity{ List<Position> possibleMoves = PositionUtil.generateAllAdjacentPositions(currentPos, b); // Filtrer les positions qui sont libres - possibleMoves.removeIf(p -> !(b.getState(p) instanceof EmptySquare)); + possibleMoves.removeIf(p -> !(b.getState(p).contains(Fire.class))); // Si aucune position libre n'est disponible, retourner null if (possibleMoves.isEmpty()) { diff --git a/src/main/java/model/FireFighterScenario.java b/src/main/java/model/FireFighterScenario.java index ff4d8d870836c8a5a5b7dfd772adf1319f22662e..4a2b2d47458043dfd692c55b341b6bd8a0b90c82 100644 --- a/src/main/java/model/FireFighterScenario.java +++ b/src/main/java/model/FireFighterScenario.java @@ -15,20 +15,24 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity> private Matrix<Entity> matrix; private int step; + private int initialCloudCount; private int initialFireCount; private int initialFireFightersCount; - public FireFighterScenario(int columns, int rows, int initialFireCount, int initialFireFightersCount) { + + public FireFighterScenario(int columns, int rows, int initialFireCount, int initialFireFightersCount, int initialCloudCount) { this.matrix = new Matrix<Entity>(columns, rows); this.initialFireCount = initialFireCount; this.initialFireFightersCount = initialFireFightersCount; + this.initialCloudCount = initialCloudCount; //ajout de l'init cloud initScenario(matrix); - placeInitialActors(initialFireCount, initialFireFightersCount); + placeInitialActors(); this.step = 0; } - private void placeInitialActors(int initialFireCount, int initialFireFightersCount) { + private void placeInitialActors() { int fireCount = 0; int fireFighterCount = 0; + int cloudCount =0; int chance = 5; // Chance initiale en pourcentage Random random = new Random(); @@ -39,15 +43,15 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity> } } - while (fireCount < initialFireCount || fireFighterCount < initialFireFightersCount) { + while (fireCount < initialFireCount || fireFighterCount < initialFireFightersCount || cloudCount < initialCloudCount) { Collections.shuffle(positions); // Mélange les positions pour un parcours aléatoire for (Position pos : positions) { - if (getState(pos) instanceof EmptySquare) { + if (getState(pos).contains(EmptySquare.class)) { if (fireCount < initialFireCount && random.nextInt(100) < chance) { setState(new Fire(pos, this, 1), pos); fireCount++; - if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount) { + if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount) { return; } continue; @@ -56,7 +60,15 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity> if (fireFighterCount < initialFireFightersCount && random.nextInt(100) < chance) { setState(new FireFighter(pos, this, 1), pos); fireFighterCount++; - if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount) { + if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount) { + return; + } + } + + if (cloudCount < initialCloudCount && random.nextInt(100) < chance) { + setState(new cloud(pos, this, 1), pos); + cloudCount++; + if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount) { return; } } @@ -68,7 +80,7 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity> } } - public Entity getState(Position position) { + public ArrayList<Entity> getState(Position position) { if (position.x() > matrix.size() || position.y() > matrix.size()) { throw new IllegalArgumentException( "The position x:" + position.x() + " y:" + position.y() + " is out of the board."); @@ -77,7 +89,7 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity> } public void setState(Entity state, Position position) { - if (!(getState(position) instanceof EmptySquare)) { + if (!(getState(position).getFirst() instanceof EmptySquare)) { return; } if (doesPositionExist(position)) { @@ -86,7 +98,7 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity> } public void setState(Entity state, Position position, boolean replaceStates) { - if (!(getState(position) instanceof EmptySquare) && !replaceStates) { + if (!(getState(position).getFirst() instanceof EmptySquare) && !replaceStates) { return; } matrix.set(position.x(), position.y(), state); @@ -108,19 +120,22 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity> ArrayList<Position> changedPositions = new ArrayList<>(); Iterator<Entity> iterator = matrix.iterator(); while (iterator.hasNext()) { - Entity e = iterator.next(); - if (e instanceof EmptySquare) - continue; - if (e.getAge() == 0) { + + ArrayList<Entity> entities = (ArrayList<Entity>) iterator.next(); + for (Entity e : entities) { + if (e instanceof EmptySquare) + continue; + if (e.getAge() == 0) { + e.incrementAge(); + continue; + } + if (e.getAge() == step + 1) { + continue; + } + List<Position> entityUpdatedPositions = e.nextTurn(this); e.incrementAge(); - continue; - } - if(e.getAge() == step+1){ - continue; + changedPositions.addAll(entityUpdatedPositions); } - List<Position> entityUpdatedPositions = e.nextTurn(this); - e.incrementAge(); - changedPositions.addAll(entityUpdatedPositions); } return changedPositions; } @@ -136,14 +151,16 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity> // Parcourir les distances croissantes à partir de 1 for (int distance = 1; distance < maxDistance; distance++) { List<Position> positionsAtDistance = PositionUtil.getPositionsAtManhattanDistance(fromPos, distance, rows, cols); - +//ligne a verifier for (Position currentPos : positionsAtDistance) { - Entity currentEntity = matrix.get(currentPos.x(), currentPos.y()); - if (entityType.isInstance(currentEntity)) { - // Dès qu'une entité est trouvée à cette distance, elle est la plus proche - // possible - return currentPos; + ArrayList<Entity> entitiesAtPos = matrix.get(currentPos.x(), currentPos.y()); + if (!entitiesAtPos.isEmpty()) { + Entity currentEntity = entitiesAtPos.get(0); // Récupérer le premier élément de la liste + if (entityType.isInstance(currentEntity)) { + return currentPos; + } } + } } @@ -155,7 +172,7 @@ public class FireFighterScenario extends EntityScenario implements Board<Entity> step = 0; matrix.clear(); initScenario(matrix); - placeInitialActors(initialFireCount, initialFireFightersCount); + placeInitialActors(); } public int stepNumber() { diff --git a/src/main/java/model/cloud.java b/src/main/java/model/cloud.java new file mode 100644 index 0000000000000000000000000000000000000000..b11b9932d430732848f1c7bf298f8b8782812c63 --- /dev/null +++ b/src/main/java/model/cloud.java @@ -0,0 +1,94 @@ +package model; + +import javafx.scene.paint.Color; +import util.Position; +import util.PositionUtil; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +public class cloud implements Entity{ + private int age; + private final Color viewColor = Color.GREY; + private Position position; + Board<Entity> b; + + public cloud (Position position, Board<Entity> b, int age){ + this.age = age; + this.position = position; + this.b = b; + } + + + + @Override + public List<Position> nextTurn(Board<Entity> b) { + List<Position> positions = new ArrayList<>(); + + // Générer les positions adjacentes valides + List<Position> possibleMoves = PositionUtil.generateAllAdjacentPositions(position, b); + + // Sélectionner une position aléatoire parmi les mouvements possibles + Position next_pos = possibleMoves.get(new Random().nextInt(possibleMoves.size())); + + // Vérifier l'état de la nouvelle position + ArrayList<Entity> nextEntities = b.getState(next_pos); + + positions.add(position); + positions.add(next_pos); + + // Si la nouvelle position contient un feu, éteindre le feu + if (nextEntities.contains(Fire.class)) { + extinguish(List.of(next_pos), b); + } + + + b.setState(this, next_pos); + + + + // Retourner la position mise à jour pour affichage ou suivi + return positions; + } + + + + + private List<Position> extinguish(List<Position> next_pos, Board<Entity> b) { + List<Position> extinguishedPositions = new ArrayList<>(); + + if (b.getState(next_pos.get(0)).contains(Fire.class)) { + b.clearCase(next_pos.get(0)); + extinguishedPositions.add(next_pos.get(0)); + } + + + return extinguishedPositions; + } + + @Override + public Position getPosition() { + return position; + } + + @Override + public void setPosition(Position p) { + this.position = p; + } + + @Override + public int getAge() { + return this.age; + } + + @Override + public void incrementAge() { + this.age += 1; + } + + @Override + public Color getViewColor() { + return viewColor; + } +} diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java index 4c36d97709b342e457203c75d081fc5cc1955c0f..1bd3e9a86156ea98b4650fee627b4411b90ff3fd 100644 --- a/src/main/java/module-info.java +++ b/src/main/java/module-info.java @@ -2,7 +2,8 @@ module firefighter { requires javafx.controls; requires javafx.fxml; requires javafx.graphics; - opens controller to javafx.fxml; + requires java.sql; + opens controller to javafx.fxml; exports app; opens app to javafx.fxml; } diff --git a/src/main/java/util/Matrix.java b/src/main/java/util/Matrix.java index 6b5000be034cb782b77e941f7114ad37ab49b38d..dcd518a02498dc82f5c16d9fe866dae0d2bf170b 100644 --- a/src/main/java/util/Matrix.java +++ b/src/main/java/util/Matrix.java @@ -5,7 +5,7 @@ import java.util.Iterator; import java.util.NoSuchElementException; public class Matrix<E> implements Iterable<E> { - private ArrayList<ArrayList<E>> matrix; + private ArrayList<ArrayList<ArrayList<E>>> matrix; private final int rows; private final int columns; @@ -16,33 +16,37 @@ public class Matrix<E> implements Iterable<E> { // Initialiser chaque ligne de la matrice for (int i = 0; i < rows; i++) { - ArrayList<E> row = new ArrayList<>(columns); + ArrayList<ArrayList<E>> row = new ArrayList<>(columns); + // Initialiser chaque colonne avec des valeurs nulles for (int j = 0; j < columns; j++) { - row.add(null); + row.add(new ArrayList<E>()); } this.matrix.add(row); } } - public E get(int x, int y) { + public ArrayList<E> get(int x, int y) { validateIndex(x, y); return matrix.get(x).get(y); } - public E set(int x, int y, E object) { + public ArrayList<E> set(int x, int y, E object) { validateIndex(x, y); - return matrix.get(x).set(y, object); + ArrayList<E> previous_Entities = matrix.get(x).get(y); + matrix.get(x).get(y).add(object); + return previous_Entities; + } public void clear() { this.matrix = new ArrayList<>(rows); // Initialiser chaque ligne de la matrice for (int i = 0; i < rows; i++) { - ArrayList<E> row = new ArrayList<>(columns); + ArrayList<ArrayList<E>> row = new ArrayList<>(columns); // Initialiser chaque colonne avec des valeurs nulles for (int j = 0; j < columns; j++) { - row.add(null); + row.add(new ArrayList<E>()); } this.matrix.add(row); } @@ -122,11 +126,23 @@ public class Matrix<E> implements Iterable<E> { } @Override - public E next() { + public E next(){ if (!hasNext()) { throw new NoSuchElementException(); } - E element = matrix.get(row).get(col); + ArrayList<E> element = matrix.get(row).get(col); + col++; + if (col >= columns) { + col = 0; + row++; + } + return element.getFirst(); + } + /* public ArrayList<E> next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + ArrayList<E> element = matrix.get(row).get(col); col++; if (col >= columns) { col = 0; @@ -134,5 +150,8 @@ public class Matrix<E> implements Iterable<E> { } return element; } + + + */ } }