diff --git a/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance01.pdf b/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance01.pdf new file mode 100644 index 0000000000000000000000000000000000000000..90cfdef7c5999416c34f1b0788ceb4c17046d4df Binary files /dev/null and b/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance01.pdf differ diff --git a/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance02.pdf b/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance02.pdf new file mode 100644 index 0000000000000000000000000000000000000000..5d06ba7047f3f2c98d63add3fcc4316759b8ae11 Binary files /dev/null and b/Rapports/RAPPORT_CHERCHEM_AREZKI_Seance02.pdf differ diff --git a/src/main/java/app/SimulatorMain.java b/src/main/java/app/SimulatorMain.java index f2e49f262ebec4136cf57d3b50fea3987b3b69fc..1520ca6013b265b8a0d0b872cec5f0454c311520 100644 --- a/src/main/java/app/SimulatorMain.java +++ b/src/main/java/app/SimulatorMain.java @@ -4,4 +4,5 @@ public class SimulatorMain { public static void main(String[] args){ SimulatorApplication.main(args); } + } diff --git a/src/main/java/controller/CloudController.java b/src/main/java/controller/CloudController.java new file mode 100644 index 0000000000000000000000000000000000000000..c7604b19bedc9c11c69d5985cc91ff6af678f6c5 --- /dev/null +++ b/src/main/java/controller/CloudController.java @@ -0,0 +1,52 @@ +package controller; + +import util.Position; +import view.ViewElement; + +import java.util.*; + +public class CloudController { + private final int rowCount; + private final int columnCount; + private final Set<Position> clouds = new HashSet<>(); + + public CloudController(int rowCount, int columnCount) { + this.rowCount = rowCount; + this.columnCount = columnCount; + } + + public void addCloud(Position position) { + clouds.add(position); + } + + public Set<Position> getCloudPositions() { + return clouds; + } + + public void moveClouds() { + Set<Position> newCloudPositions = new HashSet<>(); + Random random = new Random(); + + for (Position cloud : clouds) { + int newRow = cloud.row() + random.nextInt(3) - 1; // Mouvement aléatoire (-1, 0, 1) + int newCol = cloud.column() + random.nextInt(3) - 1; + + // S'assurer que les nuages restent dans les limites de la grille + newRow = Math.max(0, Math.min(rowCount - 1, newRow)); + newCol = Math.max(0, Math.min(columnCount - 1, newCol)); + + newCloudPositions.add(new Position(newRow, newCol)); + } + + clouds.clear(); + clouds.addAll(newCloudPositions); + } + + public void extinguishFires(ViewElement[][] grid) { + for (Position cloud : clouds) { + if (grid[cloud.row()][cloud.column()] == ViewElement.FIRE) { + grid[cloud.row()][cloud.column()] = ViewElement.EMPTY; // Éteindre le feu + } + } + } +} diff --git a/src/main/java/controller/Controller.java b/src/main/java/controller/Controller.java index 2a60897c6eb8ba847cb8589840c16a0f175ce0a3..55cd3293e690c550ee2c28451dd942ecd81694dc 100644 --- a/src/main/java/controller/Controller.java +++ b/src/main/java/controller/Controller.java @@ -40,7 +40,7 @@ public class Controller { @FXML private Grid<ViewElement> grid; private Timeline timeline; - private Board<List<ModelElement>> board; + private FirefighterBoard board; @FXML private void initialize() { diff --git a/src/main/java/model/Board.java b/src/main/java/model/Board.java index bb089a41406d57b0b2fe3d43b3c040cbd640b6b9..e671eb09e2dcb2b788d40b7fe87cefcaf19d4fd3 100644 --- a/src/main/java/model/Board.java +++ b/src/main/java/model/Board.java @@ -4,62 +4,9 @@ import util.Position; import java.util.List; -/** - * This interface represents a generic board for modeling various state-based systems. - * - * @param <S> The type of state represented on the board. - */ -public interface Board<S> { - - /** - * Get the state of the board at a specific position. - * - * @param position The position on the board for which to retrieve the state. - * @return The state at the specified position. - */ - S getState(Position position); - - /** - * Set the state of a specific position on the board to the specified state. - * - * @param state The state to set for the given position. - * @param position The position on the board for which to set the state. - */ - void setState(S state, Position position); - /** - * Get the number of rows in the board. - * - * @return The number of rows in the board. - */ - int rowCount(); - - /** - * Get the number of columns in the board. - * - * @return The number of columns in the board. - */ - int columnCount(); - - /** - * Update the board to its next generation or state. This method may modify the - * internal state of the board and return a list of positions that have changed - * during the update. - * - * @return A list of positions that have changed during the update. - */ - List<Position> updateToNextGeneration(); +public interface Board<S> { - /** - * Reset the board to its initial state. - */ - void reset(); - /** - * Get the current step number or generation of the board. - * - * @return The current step number or generation. - */ - int stepNumber(); } diff --git a/src/main/java/model/BoardBehavior.java b/src/main/java/model/BoardBehavior.java index cf02e8d51b15f2ab1a27c662fea95c457756a2fb..0ce2952092106532eccd12b91fdede4fe30085a4 100644 --- a/src/main/java/model/BoardBehavior.java +++ b/src/main/java/model/BoardBehavior.java @@ -1,11 +1,27 @@ package model; import util.Position; - import java.util.List; -public interface BoardBehavior { - public int stepNumber(); // Numéro de l'étape actuelle. - public List<Position> updateToNextGeneration(); - public void reset(); +public interface BoardBehavior<S> extends Board<S>{ + /** + * Get the current step number or generation of the board. + * + * @return The current step number or generation. + */ + int stepNumber(); + + /** + * Update the board to its next generation or state. This method may modify the + * internal state of the board and return a list of positions that have changed + * during the update. + * + * @return A list of positions that have changed during the update. + */ + List<Position> updateToNextGeneration(); + + /** + * Reset the board to its initial state. + */ + void reset(); } diff --git a/src/main/java/model/BoardProperties.java b/src/main/java/model/BoardProperties.java index 901b1164479373cd9bb9484a63caaab650f31c50..ec37435d035edda6babe33cc2d05f41f28e2cea9 100644 --- a/src/main/java/model/BoardProperties.java +++ b/src/main/java/model/BoardProperties.java @@ -4,9 +4,39 @@ import util.Position; import java.util.List; -public interface BoardProperties { +/** + * Interface représentant les propriétés d'un tableau générique pour la gestion de l'état. + * + * @param <S> Le type d'état utilisé pour les éléments du tableau. + */ +public interface BoardProperties<S> extends Board<S> { + /** + * Retourne le nombre de lignes du tableau. + * + * @return Le nombre de lignes. + */ int rowCount(); // Nombre de lignes. + + /** + * Retourne le nombre de colonnes du tableau. + * + * @return Le nombre de colonnes. + */ int columnCount(); // Nombre de colonnes. - List<ModelElement> getState(Position position); // État des éléments sur une position donnée. - void setState(List<ModelElement> state, Position position); + + /** + * Retourne l'état des éléments situés à une position spécifique du tableau. + * + * @param position La position sur le tableau pour laquelle récupérer l'état. + * @return L'état des éléments à la position donnée. + */ + S getState(Position position); // État des éléments sur une position donnée. + + /** + * Définit l'état des éléments à une position spécifique du tableau. + * + * @param state L'état à définir pour la position donnée. + * @param position La position sur le tableau pour laquelle définir l'état. + */ + void setState(S state, Position position); } diff --git a/src/main/java/model/ClassicFireFighter.java b/src/main/java/model/ClassicFireFighter.java new file mode 100644 index 0000000000000000000000000000000000000000..13fefbecb116637cb28375a542138efd742ebf6f --- /dev/null +++ b/src/main/java/model/ClassicFireFighter.java @@ -0,0 +1,29 @@ +package model; + +import util.Position; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +public class ClassicFireFighter extends FirefighterManager{ + public ClassicFireFighter(List<Position> firefighterPositions) { + super(firefighterPositions); + } + @Override + public List<Position> updateFirefighters(int step, Map<Position, List<Position>> neighbors) { + List<Position> modifiedPositions = new ArrayList<>(); + for (Position firefighterPosition : firefighterPositions) { + Position newFirefighterPosition = moveToTarget(firefighterPosition, fireManager.getFirePosition(), neighbors); + setFirefighterPosition(firefighterPosition, newFirefighterPosition); + + if (fireManager.isOnFire(newFirefighterPosition)) { + extinguishFire(newFirefighterPosition); + } + + modifiedPositions.add(firefighterPosition); + modifiedPositions.add(newFirefighterPosition); + } + return modifiedPositions; + } +} diff --git a/src/main/java/model/FireBehavior.java b/src/main/java/model/FireBehavior.java new file mode 100644 index 0000000000000000000000000000000000000000..bfa1aca7a681982c92fc20b9106ce0b83ffd7f9b --- /dev/null +++ b/src/main/java/model/FireBehavior.java @@ -0,0 +1,11 @@ +package model; + +import util.Position; + +import java.util.List; +import java.util.Map; + +public interface FireBehavior { + public List<Position> updateFires(int step, Map<Position, List<Position>> neighbors); + void extinguishFire(Position position); +} diff --git a/src/main/java/model/FireManager.java b/src/main/java/model/FireManager.java new file mode 100644 index 0000000000000000000000000000000000000000..93b0299eb840fa28a3fa4d9e7c6b777917f93b33 --- /dev/null +++ b/src/main/java/model/FireManager.java @@ -0,0 +1,127 @@ +package model; + +import util.Position; +import view.ViewElement; + +import java.util.*; + +public class FireManager implements FireBehavior, FireProperties{ + private Set<Position> firePositions; + private FirefighterManager firefighterManager; + + public FireManager(Set<Position> firePositions,FirefighterManager firefighterManager) { + this.firePositions = firePositions; + this.firefighterManager=firefighterManager; + + } + + // Initialize fire positions randomly + public void initializeFires(int fireCount, int rowCount, int columnCount, Random random) { + firePositions.clear(); + for (int i = 0; i < fireCount; i++) { + firePositions.add(new Position(random.nextInt(rowCount), random.nextInt(columnCount))); + } + } + @Override + public List<Position> updateFires(int step, Map<Position, List<Position>> neighbors) { + List<Position> newFirePositions = new ArrayList<>(); + if (step % 2 == 0) { // Le feu se propage tous les deux pas + for (Position fire : firePositions) { + for (Position neighbor : neighbors.get(fire)) { + // Vérifier si le voisin est déjà en feu ou s'il y a un pompier + if (!firePositions.contains(neighbor) && !firefighterManager.getFirefighterPositions().contains(neighbor)) { + newFirePositions.add(neighbor); + } + } + } + firePositions.addAll(newFirePositions); + } + return newFirePositions; + } + public void spreadFire(ViewElement[][] grid) { + int rows = grid.length; + int columns = grid[0].length; + + // Créez un tableau pour suivre les tours avant que le feu se propage sur les rocailles + int[][] fireCooldown = new int[rows][columns]; + + // Initialisation du tableau de cooldown des rocailles à 0 + for (int i = 0; i < rows; i++) { + for (int j = 0; j < columns; j++) { + if (grid[i][j] == ViewElement.ROCKY) { + fireCooldown[i][j] = 4; // Le feu prend 4 tours pour se propager sur les rocailles + } else { + fireCooldown[i][j] = 0; // Aucune attente pour les autres cases + } + } + } + + ViewElement[][] newGrid = new ViewElement[rows][columns]; + for (int i = 0; i < rows; i++) { + System.arraycopy(grid[i], 0, newGrid[i], 0, columns); + } + + // Propagation du feu + for (int i = 0; i < rows; i++) { + for (int j = 0; j < columns; j++) { + if (grid[i][j] == ViewElement.FIRE) { + // Propager le feu sur les voisins si possible + for (Position neighbor : getNeighbors(i, j, rows, columns)) { + if (grid[neighbor.row()][neighbor.column()] == ViewElement.EMPTY) { + newGrid[neighbor.row()][neighbor.column()] = ViewElement.FIRE; + } + // Empêcher la propagation sur les montagnes + if (grid[neighbor.row()][neighbor.column()] == ViewElement.MOUNTAIN) { + newGrid[neighbor.row()][neighbor.column()] = ViewElement.MOUNTAIN; + } + // Propagation du feu sur les rocailles après 4 tours + if (grid[neighbor.row()][neighbor.column()] == ViewElement.ROCKY && fireCooldown[neighbor.row()][neighbor.column()] == 0) { + newGrid[neighbor.row()][neighbor.column()] = ViewElement.FIRE; + } + } + } + } + } + + // Mise à jour de la grille après propagation + for (int i = 0; i < rows; i++) { + System.arraycopy(newGrid[i], 0, grid[i], 0, columns); + } + + // Décrémenter le cooldown des rocailles chaque tour + for (int i = 0; i < rows; i++) { + for (int j = 0; j < columns; j++) { + if (fireCooldown[i][j] > 0) { + fireCooldown[i][j]--; // Décrémenter le compteur de cooldown + } + } + } + } + + + private List<Position> getNeighbors(int row, int column, int rows, int columns) { + List<Position> neighbors = new ArrayList<>(); + if (row > 0) neighbors.add(new Position(row - 1, column)); + if (row < rows - 1) neighbors.add(new Position(row + 1, column)); + if (column > 0) neighbors.add(new Position(row, column - 1)); + if (column < columns - 1) neighbors.add(new Position(row, column + 1)); + return neighbors; + } + + + + // Extinguish a fire at a specific position + @Override + public void extinguishFire(Position position) { + firePositions.remove(position); + } + // Query if a position is on fire + @Override + public boolean isOnFire(Position position) { + return firePositions.contains(position); + } + @Override + public Set<Position> getFirePosition() + { return new HashSet<>(firePositions);} + +} diff --git a/src/main/java/model/FireProperties.java b/src/main/java/model/FireProperties.java new file mode 100644 index 0000000000000000000000000000000000000000..906756108d3c70143a50f6bc9aba89d37e8c658b --- /dev/null +++ b/src/main/java/model/FireProperties.java @@ -0,0 +1,10 @@ +package model; + +import util.Position; + +import java.util.Set; + +public interface FireProperties { + public boolean isOnFire(Position position); + Set<Position> getFirePosition(); +} diff --git a/src/main/java/model/FirefighterBehavior.java b/src/main/java/model/FirefighterBehavior.java new file mode 100644 index 0000000000000000000000000000000000000000..89773dcfad96ff72878698e316b9b92c4b3fa22b --- /dev/null +++ b/src/main/java/model/FirefighterBehavior.java @@ -0,0 +1,14 @@ +package model; + +import util.Position; + +import java.util.Collection; +import java.util.List; +import java.util.Map; + +public interface FirefighterBehavior { + Position moveToTarget(Position currentPosition, Collection<Position> firePositions, + Map<Position, List<Position>> neighbors); // Déplacer un pompier vers une cible. + void extinguishFire(Position firePosition); // Éteindre un feu à une position donnée. + // public List<Position> updateFirefighters(int step, Map<Position, List<Position>> neighbors); +} diff --git a/src/main/java/model/FirefighterManager.java b/src/main/java/model/FirefighterManager.java new file mode 100644 index 0000000000000000000000000000000000000000..1317bb1cbd7b025e0a223383dec11810c718968f --- /dev/null +++ b/src/main/java/model/FirefighterManager.java @@ -0,0 +1,47 @@ +package model; + +import util.Position; +import util.TargetStrategy; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map; + +public abstract class FirefighterManager implements FirefighterBehavior, FirefighterProperties { + protected List<Position> firefighterPositions; + FireManager fireManager; + + public void setFireManager(FireManager fireManager) { + this.fireManager = fireManager; + } + + public FirefighterManager(List<Position> firefighterPositions) { + this.firefighterPositions = firefighterPositions; + } + + @Override + public Position moveToTarget(Position currentPosition, Collection<Position> firePositions, Map<Position, List<Position>> neighbors) { + TargetStrategy targetStrategy = new TargetStrategy(); + return targetStrategy.neighborClosestToFire(currentPosition, firePositions, neighbors); + } + + @Override + public void extinguishFire(Position firePosition) { + fireManager.extinguishFire(firePosition); + } + + @Override + public List<Position> getFirefighterPositions() { + return firefighterPositions; + } + + @Override + public void setFirefighterPosition(Position oldPosition, Position newPosition) { + firefighterPositions.remove(oldPosition); + firefighterPositions.add(newPosition); + } + + public abstract List<Position> updateFirefighters(int step, Map<Position, List<Position>> neighbors) ; + +} diff --git a/src/main/java/model/FirefighterProperties.java b/src/main/java/model/FirefighterProperties.java new file mode 100644 index 0000000000000000000000000000000000000000..b8cac29a8cb31901654f45af4f911b94d4c7d8cb --- /dev/null +++ b/src/main/java/model/FirefighterProperties.java @@ -0,0 +1,10 @@ +package model; + +import util.Position; + +import java.util.List; + +public interface FirefighterProperties { + List<Position> getFirefighterPositions(); + void setFirefighterPosition(Position oldPosition, Position newPosition); +} diff --git a/src/main/java/model/MotorizedFirefighter.java b/src/main/java/model/MotorizedFirefighter.java new file mode 100644 index 0000000000000000000000000000000000000000..71edb72c600981ef91a2b1d524f7e2f87dadbe1f --- /dev/null +++ b/src/main/java/model/MotorizedFirefighter.java @@ -0,0 +1,49 @@ +package model; + +import util.Position; + +import java.util.*; + +public class MotorizedFirefighter extends FirefighterManager { + private Random random =new Random(); + public MotorizedFirefighter(List<Position> firefighterPositions) { + super(firefighterPositions); + } + + @Override + public List<Position> updateFirefighters(int step, Map<Position, List<Position>> neighbors) { + List<Position> modifiedPositions = new ArrayList<>(); + for (Position firefighterPosition : firefighterPositions) { + // Déplacement motorisé, on se déplace de deux cases + Position newFirefighterPosition = moveToTarget(firefighterPosition, fireManager.getFirePosition(), neighbors); + setFirefighterPosition(firefighterPosition, newFirefighterPosition); + + // Vérifier si un feu est à la nouvelle position et l'éteindre + if (fireManager.isOnFire(newFirefighterPosition)) { + extinguishFire(newFirefighterPosition); + } + + modifiedPositions.add(firefighterPosition); + modifiedPositions.add(newFirefighterPosition); + } + return modifiedPositions; + } + @Override + public Position moveToTarget(Position currentPosition, Collection<Position> firePositions, Map<Position, List<Position>> neighbors) { + // Logique spécifique pour le déplacement motorisé (deux cases) + List<Position> possibleMoves = new ArrayList<>(); + for (Position neighbor : neighbors.get(currentPosition)) { + for (Position secondNeighbor : neighbors.get(neighbor)) { + if (!secondNeighbor.equals(currentPosition)) { + possibleMoves.add(secondNeighbor); + } + } + } + + if (!possibleMoves.isEmpty()) { + return possibleMoves.get(random.nextInt(possibleMoves.size())); + } else { + return currentPosition; + } + } +} diff --git a/src/main/java/util/MotorizedStrategy.java b/src/main/java/util/MotorizedStrategy.java new file mode 100644 index 0000000000000000000000000000000000000000..6f5b092c3764a2b2070a1ee8ab2c3c9b26d3eb10 --- /dev/null +++ b/src/main/java/util/MotorizedStrategy.java @@ -0,0 +1,22 @@ +package util; + +import java.util.Collection; +import java.util.List; +import java.util.Map; + +public class MotorizedStrategy implements Strategy{ + @Override + public Position neighborClosestToTarget(Position position, Collection<Position> targets, Map<Position, List<Position>> neighbors) { + TargetStrategy normalStrategy = new TargetStrategy(); + Position firstMove = normalStrategy.neighborClosestToTarget(position, targets, neighbors); + + // Si un premier mouvement est trouvé, on simule un second déplacement + if (firstMove != null && neighbors.containsKey(firstMove)) { + return normalStrategy.neighborClosestToTarget(firstMove, targets, neighbors); + } + + return position; + } + + +} diff --git a/src/main/java/util/Strategy.java b/src/main/java/util/Strategy.java new file mode 100644 index 0000000000000000000000000000000000000000..4ca44e7aa30160c942c83f6abe8a44e1b44c509e --- /dev/null +++ b/src/main/java/util/Strategy.java @@ -0,0 +1,11 @@ +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, ViewElement[][] grid); +} diff --git a/src/main/java/util/TargetStrategy.java b/src/main/java/util/TargetStrategy.java index 5e2e743affb2795efbf641942452fe0339d5bce9..7a2b0519452f37629da82619457c4c1739596eba 100644 --- a/src/main/java/util/TargetStrategy.java +++ b/src/main/java/util/TargetStrategy.java @@ -1,10 +1,11 @@ package util; import util.Position; +import view.ViewElement; import java.util.*; -public class TargetStrategy { +public class TargetStrategy implements Strategy{ /** @@ -12,8 +13,8 @@ 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. */ - public Position neighborClosestToFire(Position position, Collection<Position> targets, - Map<Position, List<Position>> neighbors) { + public Position neighborClosestToTarget(Position position, Collection<Position> targets, + Map<Position, List<Position>> neighbors, ViewElement[][] grid) { Set<Position> seen = new HashSet<Position>(); HashMap<Position, Position> firstMove = new HashMap<Position, Position>(); Queue<Position> toVisit = new LinkedList<Position>(neighbors.get(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)) { diff --git a/src/main/java/view/FirefighterGrid.java b/src/main/java/view/FirefighterGrid.java index 4c9041f034ec9a4eb07ce4334de237f1e99ccdc9..59aa2f0cdfad13835a96cfa344ae8be66f1c89f0 100644 --- a/src/main/java/view/FirefighterGrid.java +++ b/src/main/java/view/FirefighterGrid.java @@ -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 diff --git a/src/main/java/view/ViewElement.java b/src/main/java/view/ViewElement.java index ffb76112e1af543df5af41fa906082ef11be9967..ed16ed1465ca78a590cd05a9e438baaf950101ba 100644 --- a/src/main/java/view/ViewElement.java +++ b/src/main/java/view/ViewElement.java @@ -3,7 +3,7 @@ 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), MOUNTAIN(Color.GRAY), ROCKY(Color.GRAY); final Color color; ViewElement(Color color) { this.color = color; diff --git a/src/test/java/model/FirefighterBoardTest.java b/src/test/java/model/FirefighterBoardTest.java index 25cc8dbca8acea698879df68a5006a179f281ecc..b9db2fd319c61d7369c42c16231163ec683b2e5a 100644 --- a/src/test/java/model/FirefighterBoardTest.java +++ b/src/test/java/model/FirefighterBoardTest.java @@ -10,17 +10,17 @@ import static org.assertj.core.api.Assertions.*; public class FirefighterBoardTest { @Test void testColumnCount(){ - Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3); + FirefighterBoard board = new FirefighterBoard(20, 10, 1, 3); assertThat(board.columnCount()).isEqualTo(20); } @Test void testRowCount(){ - Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3); + FirefighterBoard board = new FirefighterBoard(20, 10, 1, 3); assertThat(board.rowCount()).isEqualTo(10); } @Test void testStepNumber(){ - Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3); + FirefighterBoard board = new FirefighterBoard(20, 10, 1, 3); for(int index = 0; index < 10; index++){ assertThat(board.stepNumber()).isEqualTo(index); board.updateToNextGeneration(); @@ -29,7 +29,7 @@ public class FirefighterBoardTest { } @Test void testGetState_afterSet(){ - Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 0, 0); + FirefighterBoard board = new FirefighterBoard(20, 10, 0, 0); Position position = new Position(1,2); assertThat(board.getState(position)).isEmpty(); board.setState(List.of(ModelElement.FIRE), position);