main to f46e527fbd107e08f690e6f3ad8924edfe64d001 · OUALAN Yanis / FirefighterStarter

.gitignore

+8 −0

Original line number	Diff line number	Diff line
		@@ -32,3 +32,11 @@ fabric.properties
		.idea/caches/build_file_checksums.ser


		.gradle/
		*.class
		bin/
		.gradle
		*.bin
		*.lock
		.gradle/8.10.2/executionHistory/executionHistory.bin
		build/
		No newline at end of file

build/resources/main/view/DarkTheme.css

0 → 100644

+142 −0

Original line number	Diff line number	Diff line
		.background {
		-fx-background-color: #1d1d1d;
		}

		.label {
		-fx-font-size: 11pt;
		-fx-font-family: "Segoe UI Semibold";
		-fx-text-fill: white;
		-fx-opacity: 0.6;
		}

		.label-bright {
		-fx-font-size: 11pt;
		-fx-font-family: "Segoe UI Semibold";
		-fx-text-fill: white;
		-fx-opacity: 1;
		}

		.label-header {
		-fx-font-size: 32pt;
		-fx-font-family: "Segoe UI Light";
		-fx-text-fill: white;
		-fx-opacity: 1;
		}

		.table-view {
		-fx-base: #1d1d1d;
		-fx-control-inner-background: #1d1d1d;
		-fx-background-color: #1d1d1d;
		-fx-table-cell-border-color: transparent;
		-fx-table-header-border-color: transparent;
		-fx-padding: 5;
		}

		.table-view .column-header-background {
		-fx-background-color: transparent;
		}

		.table-view .column-header, .table-view .filler {
		-fx-border-width: 0 0 1 0;
		-fx-background-color: transparent;
		-fx-border-color:
		transparent
		transparent
		derive(-fx-base, 80%)
		transparent;
		-fx-border-insets: 0 10 1 0;
		}

		.table-view .column-header .label {
		-fx-font-size: 20pt;
		-fx-font-family: "Segoe UI Light";
		-fx-text-fill: white;
		-fx-alignment: center-left;
		-fx-opacity: 1;
		}

		.table-view:focused .table-row-cell:filled:focused:selected {
		-fx-background-color: -fx-focus-color;
		}

		.split-pane:horizontal > .split-pane-divider {
		-fx-border-color: transparent #1d1d1d transparent #1d1d1d;
		-fx-background-color: transparent, derive(#1d1d1d,20%);
		}

		.split-pane {
		-fx-padding: 1 0 0 0;
		}

		.menu-bar {
		-fx-background-color: derive(#1d1d1d,20%);
		}

		.context-menu {
		-fx-background-color: derive(#1d1d1d,50%);
		}

		.menu-bar .label {
		-fx-font-size: 14pt;
		-fx-font-family: "Segoe UI Light";
		-fx-text-fill: white;
		-fx-opacity: 0.9;
		}

		.menu .left-container {
		-fx-background-color: black;
		}

		.text-field {
		-fx-font-size: 12pt;
		-fx-font-family: "Segoe UI Semibold";
		}

		/*
		* Metro style Push Button
		* Author: Pedro Duque Vieira
		* http://pixelduke.wordpress.com/2012/10/23/jmetro-windows-8-controls-on-java/
		*/
		.button {
		-fx-padding: 5 22 5 22;
		-fx-border-color: #e2e2e2;
		-fx-border-width: 2;
		-fx-background-radius: 0;
		-fx-background-color: #1d1d1d;
		-fx-font-family: "Segoe UI", Helvetica, Arial, sans-serif;
		-fx-font-size: 11pt;
		-fx-text-fill: #d8d8d8;
		-fx-background-insets: 0 0 0 0, 0, 1, 2;
		}

		.button:hover {
		-fx-background-color: #3a3a3a;
		}

		.button:pressed, .button:default:hover:pressed {
		-fx-background-color: white;
		-fx-text-fill: #1d1d1d;
		}

		.button:focused {
		-fx-border-color: white, white;
		-fx-border-width: 1, 1;
		-fx-border-style: solid;
		-fx-border-radius: 0, 0;
		-fx-border-insets: 1 1 1 1, 0;
		}

		.button:disabled, .button:default:disabled {
		-fx-opacity: 0.4;
		-fx-background-color: #1d1d1d;
		-fx-text-fill: white;
		}

		.button:default {
		-fx-background-color: -fx-focus-color;
		-fx-text-fill: #ffffff;
		}

		.button:default:hover {
		-fx-background-color: derive(-fx-focus-color,30%);
		}
		No newline at end of file

build/resources/main/view/view.fxml

0 → 100644

+46 −0

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="UTF-8"?>

		<?import javafx.scene.control.Button?>
		<?import javafx.scene.control.Label?>
		<?import javafx.scene.control.Separator?>
		<?import javafx.scene.control.ToggleButton?>
		<?import javafx.scene.layout.HBox?>
		<?import javafx.scene.layout.VBox?>
		<?import view.FirefighterGrid?>

		<HBox styleClass="background" stylesheets="@DarkTheme.css"
		xmlns="http://javafx.com/javafx"
		xmlns:fx="http://javafx.com/fxml"
		fx:controller="controller.Controller">
		<VBox>
		<Separator maxHeight="-Infinity" maxWidth="-Infinity"
		prefHeight="24.0" prefWidth="200.0" />
		<Label maxHeight="-Infinity" maxWidth="-Infinity"
		alignment="CENTER" prefHeight="24.0" prefWidth="200.0"
		text="Generation number" />
		<Label fx:id="generationNumberLabel"
		alignment="CENTER" contentDisplay="TEXT_ONLY"
		maxHeight="-Infinity" maxWidth="-Infinity"
		prefHeight="24.0" prefWidth="200.0" />
		<Separator maxHeight="-Infinity" maxWidth="-Infinity"
		prefHeight="24.0" prefWidth="200.0" />
		<Button fx:id="restartButton" maxHeight="-Infinity" maxWidth="-Infinity"
		mnemonicParsing="false" onAction="#restartButtonAction"
		prefHeight="24.0" prefWidth="200.0" text="Restart" />
		<Button fx:id="oneStepButton" maxHeight="-Infinity" maxWidth="-Infinity"
		mnemonicParsing="false" onAction="#oneStepButtonAction"
		prefHeight="24.0" prefWidth="200.0" text="One step" />
		<ToggleButton fx:id="playToggleButton" maxHeight="-Infinity" maxWidth="-Infinity"
		mnemonicParsing="false" onAction="#playToggleButtonAction"
		prefHeight="24.0" prefWidth="200.0"
		styleClass="button" text="Play" />
		<ToggleButton fx:id="pauseToggleButton" maxHeight="-Infinity" maxWidth="-Infinity"
		mnemonicParsing="false" onAction="#pauseToggleButtonAction"
		prefHeight="24.0" prefWidth="200.0"
		styleClass="button" text="Pause" />
		</VBox>
		<FirefighterGrid fx:id="grid"
		xmlns="http://javafx.com/javafx"
		xmlns:fx="http://javafx.com/fxml">
		</FirefighterGrid>
		</HBox>

diagrams/model.png

0 → 100644

+77.1 KiB

77.14 KiB

gradlew.bat

+89 −89

File changed.

Contains only whitespace changes.

src/main/java/app/SimulatorApplication.java

+10 −7

Original line number	Diff line number	Diff line
		package app;

		import java.io.IOException;
		import java.net.URL;

		import controller.Controller;
		import javafx.application.Platform;
		import javafx.fxml.FXMLLoader;
		@@ -7,21 +10,21 @@ import javafx.scene.Parent;
		import javafx.scene.Scene;
		import javafx.stage.Stage;

		import java.io.IOException;
		import java.net.URL;

		public class SimulatorApplication extends javafx.application.Application {
		private static final String VIEW_RESOURCE_PATH = "/view/view.fxml";
		private static final String APP_NAME = "Firefighter simulator";
		private static final int ROW_COUNT = 20;
		private static final int COLUMN_COUNT = 20;
		private static final int BOX_WIDTH = 50;
		private static final int BOX_HEIGHT = 50;
		private static final int BOX_WIDTH = 25;
		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;
		public static final int INITIAL_MOUNTAIN_COUNT= 30;

		private Stage primaryStage;
		private Parent view;

		private void initializePrimaryStage(Stage primaryStage) {
		this.primaryStage = primaryStage;
		this.primaryStage.setTitle(APP_NAME);
		@@ -31,7 +34,7 @@ public class SimulatorApplication extends javafx.application.Application {
		}

		@Override
		public void start(Stage primaryStage) throws IOException {
		public void start(@SuppressWarnings("exports") Stage primaryStage) throws IOException {
		initializePrimaryStage(primaryStage);
		initializeView();
		showScene();
		@@ -44,7 +47,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, INITIAL_MOUNTAIN_COUNT);
		}

		private void showScene() {

src/main/java/controller/Controller.java

+25 −30

Original line number	Diff line number	Diff line
		package controller;

		import static java.util.Objects.*;

		import java.util.ArrayList;
		import java.util.List;



		import javafx.animation.Animation;
		import javafx.animation.KeyFrame;
		import javafx.animation.Timeline;
		@@ -13,17 +20,12 @@ import javafx.scene.control.ToggleGroup;
		import javafx.util.Duration;
		import javafx.util.Pair;
		import model.Board;
		import model.ModelElement;
		import model.FirefighterBoard;
		import model.FireFighterScenario;
		import model.Square;
		import util.Position;
		import view.Grid;
		import view.ViewElement;

		import java.util.ArrayList;
		import java.util.List;

		import static java.util.Objects.requireNonNull;

		public class Controller {

		public static final int PERIOD_IN_MILLISECONDS = 50;
		@@ -40,7 +42,7 @@ public class Controller {
		@FXML
		private Grid<ViewElement> grid;
		private Timeline timeline;
		private Board<List<ModelElement>> board;
		private Board<Square> board;

		@FXML
		private void initialize() {
		@@ -54,15 +56,15 @@ public class Controller {
		pauseToggleButton.setSelected(true);
		}

		private void setModel(FirefighterBoard firefighterBoard) {
		this.board = requireNonNull(firefighterBoard, "firefighter.model is null");
		private void setModel(Board<Square> board) {
		this.board = requireNonNull(board, "board is null");
		}

		private void updateBoard() {
		List<Position> updatedPositions = board.updateToNextGeneration();
		List<Pair<Position, ViewElement>> updatedSquares = new ArrayList<>();
		for (Position updatedPosition : updatedPositions) {
		List<ModelElement> squareState = board.getState(updatedPosition);
		Square squareState = board.getStates(updatedPosition);
		ViewElement viewElement = getViewElement(squareState);
		updatedSquares.add(new Pair<>(updatedPosition, viewElement));
		}
		@@ -76,25 +78,18 @@ 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)));
		viewElements[row][column] = getViewElement(board.getStates(new Position(row, column)));
		grid.repaint(viewElements);
		updateGenerationLabel(board.stepNumber());
		}

		private ViewElement getViewElement(List<ModelElement> squareState) {
		if(squareState.contains(ModelElement.FIREFIGHTER)){
		return ViewElement.FIREFIGHTER;
		}
		if (squareState.contains(ModelElement.FIRE)){
		return ViewElement.FIRE;
		}
		return ViewElement.EMPTY;
		private ViewElement getViewElement(Square square) {
		return new ViewElement(square.getViewColor());
		}

		private void initializeTimeline() {
		Duration duration = new Duration(Controller.PERIOD_IN_MILLISECONDS);
		EventHandler<ActionEvent> eventHandler =
		event -> updateBoard();
		EventHandler<ActionEvent> eventHandler = event -> updateBoard();
		KeyFrame keyFrame = new KeyFrame(duration, eventHandler);
		timeline = new Timeline(keyFrame);
		timeline.setCycleCount(Animation.INDEFINITE);
		@@ -124,9 +119,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, int initialmountaincount) {
		grid.setDimensions(columnCount, rowCount, squareWidth, squareHeight);
		this.setModel(new FirefighterBoard(columnCount, rowCount, initialFireCount, initialFirefighterCount));
		this.setModel(new FireFighterScenario(columnCount, rowCount, initialFireCount, initialFirefighterCount, initialcloudCount, initialmountaincount));
		repaintGrid();
		}

src/main/java/model/AirTanker.java

0 → 100644

+172 −0

Original line number	Diff line number	Diff line
		package model;

		import java.util.ArrayList;
		import java.util.List;
		import java.util.Objects;

		import javafx.scene.paint.Color;
		import util.Direction;
		import util.Position;
		import util.PositionUtil;

		public class AirTanker implements Entity{
		private final Color viewColor = Color.GOLD;
		private Direction direction; // Direction in which the AirTanker moves
		private int age;
		private Position position;
		private int priority = 3;

		public AirTanker(Position position, Board<Square> b) {
		this.age = 0;
		this.position = position;
		determineDirection(b);
		extinguish(position,b);
		}

		@Override
		public int getPriority() {
		return this.priority;
		}

		private void determineDirection(Board<Square> b) {
		int rowCount = b.rowCount();
		int columnCount = b.columnCount();

		if (position.x() == 0) {
		direction = Direction.EAST; // Move east if on left edge
		} else if (position.x() == columnCount - 1) {
		direction = Direction.WEST; // Move west if on right edge
		} else if (position.y() == 0) {
		direction = Direction.SOUTH; // Move south if on top edge
		} else if (position.y() == rowCount - 1) {
		direction = Direction.NORTH; // Move north if on bottom edge
		} else {
		System.out.println("not on a edge");
		// Not on an edge; default to moving east or choose a random direction
		direction = Direction.EAST;
		}
		}

		@Override
		public List<Position> nextTurn(Board<Square> b) {

		List<Position> positions = new ArrayList<>();
		// Move in the determined direction
		Position nextPos = getNextPosition(position, direction, b);

		if (nextPos == null \|\| !b.doesPositionExist(nextPos)) {
		// Reached the edge; remove AirTanker from the board
		System.out.println("end of airtanker mission");
		b.clearCaseFrom(this, position);
		positions.add(position);
		return positions;
		} else {
		// Extinguish fires within a 3-square radius

		positions.addAll(extinguish(position, b));
		// Move to the next position
		b.clearCaseFrom(this, position);
		positions.add(new Position(position.x(), position.y())); // Old position
		this.position = nextPos;
		b.addEntityAtSquare(this, nextPos);
		positions.add(nextPos); // New position


		// Increment age if needed
		this.age++;

		return positions;
		}
		}
		protected List<Position> extinguish(Position position, Board<Square> b){
		List<Position> positions = new ArrayList<Position>();
		List<Position> positionsInRange = PositionUtil.getPositionsInRadius(position, 3, b);
		for (Position p : positionsInRange) {
		if (b.doesSquareContainEntity(p, Fire.class)) {
		b.getStates(p).getEntities().removeIf(e -> e instanceof Fire);
		positions.add(p); // Add position where fire was extinguished
		}
		}
		return positions;
		}
		private Position getNextPosition(Position currentPosition, Direction direction, Board<Square> b) {
		int x = currentPosition.x();
		int y = currentPosition.y();

		switch (direction) {
		case NORTH:
		y -= 1;
		break;
		case SOUTH:
		y += 1;
		break;
		case EAST:
		x += 1;
		break;
		case WEST:
		x -= 1;
		break;
		default:
		break; // Only handling cardinal directions
		}
		Position newPos = new Position(x, y);
		System.out.println("trying to move to : " + newPos.toString());
		if (b.doesPositionExist(newPos)) {
		return newPos;
		} else {
		return null; // Reached the edge
		}
		}

		public Direction getDirection(){
		return this.direction;
		}

		@Override
		public void setPosition(Position p) {
		this.position = p;
		}

		@Override
		public Position getPosition() {
		return this.position;
		}

		@Override
		public Color getViewColor() {
		return this.viewColor;
		}

		@Override
		public int getAge() {
		return this.age;
		}

		@Override
		public void incrementAge() {
		this.age++;
		}

		@Override
		public void setAge(int age) {
		this.age = age;
		}



		@Override
		public boolean equals(Object obj) {
		if (this == obj) return true; // Check if same object
		if (obj == null \|\| getClass() != obj.getClass()) return false; // Check for null and class match
		AirTanker airTanker = (AirTanker) obj; // Cast to Fire
		return age == airTanker.age && position.equals(airTanker.position); // Compare age and position
		}


		@Override
		public int hashCode() {
		return Objects.hash(position, age);
		}


		}

src/main/java/model/Board.java

+30 −7

Original line number	Diff line number	Diff line
		package model;

		import util.Position;

		import java.util.List;

		import util.Position;

		/**
		* This interface represents a generic board for modeling various state-based systems.
		* This interface represents a generic board for modeling various state-based
		* systems.
		*
		* @param <S> The type of state represented on the board.
		*/
		@@ -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);
		S getStates(Position position);

		/**
		* Set the state of a specific position on the board to the specified state.
		@@ -25,7 +26,7 @@ public interface Board<S> {
		* @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);
		void setSquare(S square);

		/**
		* Get the number of rows in the board.
		@@ -61,5 +62,27 @@ public interface Board<S> {
		* @return The current step number or generation.
		*/
		int stepNumber();
		}

		public int getStepNumber();

		// Le booléen replaceState permet de forcer le remplacement des cases vides
		public void setSquare(S square, boolean replaceStates);

		public boolean doesPositionExist(Position position);

		public void clearCaseFrom(Entity entity, Position position);

		public Position getNearestEntity(Position fromPos, Class<?> entityType);

		public boolean doesSquareContainEntity(Position squarePos, Class<?> entityType);

		public void addEntityAtSquare(Entity entity, Position position);

		//Return if the position is completely free
		public boolean isPositionEmpty(Position position);

		//Return if the position is available for the specified priority
		public boolean isPositionFree(Position position, int priority);


		}

src/main/java/model/Cloud.java

0 → 100644

+105 −0

Original line number	Diff line number	Diff line
		package model;

		import java.util.List;
		import java.util.Random;

		import javafx.scene.paint.Color;
		import util.Position;
		import util.PositionUtil;

		public class Cloud implements Entity{
		private int age;
		private Position position;
		private final Color viewColor = Color.GRAY;
		private final int priority = 2;



		public Cloud(Position position, Board<Square> b){
		this.age = 0;
		this.position = position;

		}

		public Cloud(Position position, Board<Square> b, int age){
		this.age = age;
		this.position = position;

		}

		@Override
		public List<Position> nextTurn(Board<Square> b) {
		List<Position> adjacentPositions = PositionUtil.generateAdjacentPositions(position, b);
		adjacentPositions.removeIf( p -> b.doesSquareContainEntity(p, Cloud.class));
		adjacentPositions.removeIf( p -> b.doesSquareContainEntity(p, Mountain.class));

		// Filtrer pour obtenir uniquement les positions qui ne contiennent pas de pompier
		adjacentPositions.removeIf(p -> b.doesSquareContainEntity(p, FireFighter.class));

		// Choisir une position aléatoire parmi les mouvements possibles
		Position next_position = adjacentPositions.get(new Random().nextInt(adjacentPositions.size()));

		// Si la nouvelle position contient un feu, éteindre le feu
		if (b.getStates(next_position).getEntities().stream().anyMatch(element -> element instanceof Fire) ){
		extinguish(next_position, b);
		}

		Position old_position = this.position;
		this.position = next_position;
		b.addEntityAtSquare(this, next_position);
		b.clearCaseFrom(this, old_position);

		return List.of(old_position, this.position);
		}


		private Position extinguish(Position p, Board<Square> b) {
		b.getStates(p).getEntities().removeIf(element -> element instanceof Fire);
		List<Entity> entities = b.getStates(p).getEntities();
		for (Entity e : entities) {
		if (e instanceof EmptySquare) {
		e.setAge(b.stepNumber() + 1);
		}
		}

		return p;
		}

		@Override
		public Position getPosition() {
		return this.position;
		}

		@Override
		public void setPosition(Position p) {
		this.position = p;
		}

		@Override
		public int getAge() {
		return age;
		}

		@Override
		public void setAge(int age) {
		this.age =age;
		}

		@Override
		public void incrementAge() {
		this.age += 1;

		}

		@Override
		public Color getViewColor() {
		return this.viewColor;
		}

		@Override
		public int getPriority(){
		return this.priority;
		}


		}

src/main/java/model/EmptySquare.java

0 → 100644

+64 −0

Original line number	Diff line number	Diff line
		package model;

		import java.util.ArrayList;
		import java.util.List;

		import javafx.scene.paint.Color;
		import util.Position;

		public class EmptySquare implements Entity {

		private Position position;
		private final Color viewColor = Color.WHITE;
		private int age;
		private final int priotity = -1;

		public EmptySquare(Position p) {
		this.position = p;
		this.age = -999;
		}

		public EmptySquare(Position p, int age) {
		this.position = p;
		this.age = age;
		}

		@Override
		public List<Position> nextTurn(Board<Square> board) {
		return new ArrayList<Position>();
		}

		@Override
		public Position getPosition() {
		return position;
		}

		@Override
		public void setPosition(Position p) {
		this.position = p;
		}

		public Color getViewColor() {
		return this.viewColor;
		}

		@Override
		public int getAge() {
		return this.age;
		}

		@Override
		public void incrementAge() {
		age = age + 1;
		}

		@Override
		public void setAge(int age) {
		this.age = age;
		}

		@Override
		public int getPriority(){
		return this.priotity;
		}
		}

src/main/java/model/Entity.java

0 → 100644

+24 −0

Original line number	Diff line number	Diff line
		package model;

		import java.util.List;

		import javafx.scene.paint.Color;
		import util.Position;


		public interface Entity {
		/**
		* Exécute un tour de jeu, en vérifiant les cases adjacentes pour des instances de Fire.
		*
		* @param b Le plateau de jeu contenant des entités.
		* @return Une liste de positions affectées durant le tour (que la vue doit mettre à jour).
		*/
		public List<Position> nextTurn(Board<Square> board);
		public Position getPosition();
		public void setPosition(Position p);
		public int getAge();
		public void setAge(int age);
		public void incrementAge();
		public Color getViewColor();
		public int getPriority();
		}

src/main/java/model/EntityScenario.java

0 → 100644

+15 −0

Original line number	Diff line number	Diff line
		package model;

		import util.Matrix;
		import util.Position;

		public abstract class EntityScenario implements Scenario{
		public void initScenario(Matrix<Square> matrix){
		for(int x = 0; x < matrix.getRows(); x++){
		for(int y = 0; y < matrix.getColumns(); y++){
		Square s = new Square(new Position(x, y), new EmptySquare(new Position(x,y)));
		matrix.set(x,y, s);
		}
		}
		}
		}

src/main/java/model/Fire.java

0 → 100644

+120 −0

Original line number	Diff line number	Diff line
		package model;

		import java.util.ArrayList;
		import java.util.List;
		import java.util.Objects;

		import javafx.scene.paint.Color;
		import util.Position;
		import util.PositionUtil;


		public class Fire implements Entity {
		private Position position;
		private final Color viewColor = Color.RED;
		private int age;
		private final int priority = 1;

		public Fire(Position position) {
		this.position = position;
		this.age = 0;
		}

		public Fire(Position position, int age) {
		this.position = position;
		this.age = age;
		}

		@Override
		public List<Position> nextTurn(Board<Square> board) {
		List<Position> newFirePositions = new ArrayList<>();
		if(board.getStepNumber() <= 1){
		return newFirePositions;
		}
		// Fire propagates every 2 turns
		if (age % 2 != 0) {
		return newFirePositions; // No propagation this turn
		}

		// Generate adjacent positions
		List<Position> adjacentPositions = PositionUtil.generateAdjacentPositions(position, board);

		for (Position p : adjacentPositions) {
		// Skip if position does not exist
		if (!board.doesPositionExist(p)) {
		continue;
		}

		// Skip if the position contains a Mountain
		if (board.doesSquareContainEntity(p, Mountain.class)) {
		continue;
		}

		// Skip if the position already contains a Fire
		if (board.doesSquareContainEntity(p, Fire.class)) {
		continue;
		}

		// Skip if the position contains a Cloud (if clouds prevent fire spread)
		if (board.doesSquareContainEntity(p, Cloud.class)) {
		continue;
		}

		// Add new Fire to the board
		board.addEntityAtSquare(new Fire(p), p);
		newFirePositions.add(p); // Keep track of new fires for updates
		}

		return newFirePositions;
		}

		@Override
		public void setPosition(Position p) {
		this.position = p;
		}

		@Override
		public Position getPosition() {
		return this.position;
		}

		@Override
		public Color getViewColor() {
		return this.viewColor;
		}

		@Override
		public int getAge() {
		return this.age;
		}

		@Override
		public void incrementAge() {
		this.age++;
		}

		@Override
		public void setAge(int age) {
		this.age = age;
		}

		@Override
		public int getPriority() {
		return this.priority;
		}

		@Override
		public boolean equals(Object obj) {
		if (this == obj) return true; // Check if same object
		if (obj == null \|\| getClass() != obj.getClass()) return false; // Check for null and class match
		Fire fire = (Fire) obj; // Cast to Fire
		return age == fire.age && position.equals(fire.position); // Compare age and position
		}


		@Override
		public int hashCode() {
		return Objects.hash(position, age);
		}

		}

src/main/java/model/FireFighter.java

0 → 100644

+213 −0

Original line number	Diff line number	Diff line
		package model;
		import java.util.ArrayList;
		import java.util.List;
		import java.util.Random;

		import javafx.scene.paint.Color;
		import util.Position;
		import util.PositionUtil;



		public class FireFighter implements Entity {
		private int age;
		private Position position;
		private final Color viewColor = Color.BLUE;
		private final int priority = 1;
		protected List<Position> lastThreePosition;

		public FireFighter(Position position, Board<Square> b) {
		this.position = position;
		this.age = 0;
		this.lastThreePosition = new ArrayList<Position>();
		}

		public FireFighter(Position position, Board<Square> b, int age) {
		this.position = position;
		this.age = age;
		this.lastThreePosition = new ArrayList<Position>();
		}

		public List<Position> nextTurn(Board<Square> b) {
		List<Position> positions = new ArrayList<>();

		// Generate adjacent positions, excluding mountains
		List<Position> adjacentPositions = PositionUtil.generateAdjacentPositions(position, b);
		adjacentPositions.removeIf(p -> b.doesSquareContainEntity(p, Mountain.class));

		// Check if there is fire in any adjacent positions
		boolean hasFire = adjacentPositions.stream()
		.anyMatch(p -> b.doesSquareContainEntity(p, Fire.class));

		boolean isStuck = isStuck();

		if (hasFire) {
		// Extinguish fires in adjacent positions
		positions.addAll(extinguish(adjacentPositions, b));
		if (isStuck) {
		// If stuck, attempt to move and then extinguish fires
		positions.addAll(moveAndExtinguish(b));
		}
		} else {
		// No fire adjacent; move and attempt to extinguish fires
		positions.addAll(moveAndExtinguish(b));
		}

		// Update last three positions
		updateLastPositions();

		return positions;
		}

		protected boolean isStuck() {
		if (lastThreePosition.size() < 3) {
		return false;
		}
		Position first = lastThreePosition.get(lastThreePosition.size() - 1);
		return lastThreePosition.stream().allMatch(pos -> pos.equals(first));
		}

		private void updateLastPositions() {
		if (lastThreePosition.size() >= 3) {
		lastThreePosition.remove(0);
		}
		lastThreePosition.add(this.position);
		}


		protected List<Position> extinguish(List<Position> adjacentPositions, Board<Square> b) {
		List<Position> extinguishedPositions = new ArrayList<>();
		for (Position p : adjacentPositions) {
		if (b.doesSquareContainEntity(p, Fire.class)) {
		b.getStates(p).getEntities().removeIf(element -> element instanceof Fire);
		// Update age for EmptyEntity if needed
		b.getStates(p).getEntities().forEach(e -> {
		if (e instanceof EmptySquare) {
		e.setAge(b.stepNumber() + 1);
		}
		});
		extinguishedPositions.add(p); // Add position where fire was extinguished
		}
		}
		return extinguishedPositions;
		}


		protected List<Position> moveAndExtinguish(Board<Square> b) {
		List<Position> positions = new ArrayList<>();

		// Find the nearest fire
		Position nearestFirePos = b.getNearestEntity(position, Fire.class);
		if (nearestFirePos != null) {
		// Get the next position towards the fire
		Position nextPos = getNextPositionTowards(position, nearestFirePos, b);
		if (nextPos != null && !nextPos.equals(position)) {
		// Move the firefighter
		b.clearCaseFrom(this, position); // Clear old position
		positions.add(new Position(position.x(), position.y())); // Add old position
		this.position = nextPos;
		b.addEntityAtSquare(this, nextPos); // Add to new position
		positions.add(nextPos); // Add new position

		// After moving, attempt to extinguish fires adjacent to new position
		List<Position> newAdjacentPositions = PositionUtil.generateAdjacentPositions(nextPos, b);
		newAdjacentPositions.removeIf(p -> b.doesSquareContainEntity(p, Mountain.class));
		positions.addAll(extinguish(newAdjacentPositions, b));
		}
		}
		return positions;
		}

		protected Position getNextPositionTowards(Position currentPos, Position targetPos, Board<Square> b) {
		// Generate adjacent positions
		List<Position> possibleMoves = PositionUtil.generateAllAdjacentPositions(currentPos, b);

		// Filter out positions that are not empty or contain obstacles
		possibleMoves.removeIf(p -> !b.isPositionEmpty(p) \|\| b.doesSquareContainEntity(p, Mountain.class));

		// If no possible moves, return null
		if (possibleMoves.isEmpty()) {
		return null;
		}

		// Calculate the current distance to the target
		int currentDistance = PositionUtil.getManhattanDistance(currentPos, targetPos);

		// Initialize variables to find the best moves
		int minDistance = Integer.MAX_VALUE;
		List<Position> bestMoves = new ArrayList<>();

		for (Position move : possibleMoves) {
		int distance = PositionUtil.getManhattanDistance(move, targetPos);

		// Skip positions occupied by other firefighters
		if (b.doesSquareContainEntity(move, FireFighter.class)) {
		continue;
		}

		// Find positions that minimize the distance
		if (distance < minDistance) {
		minDistance = distance;
		bestMoves.clear();
		bestMoves.add(move);
		} else if (distance == minDistance) {
		bestMoves.add(move);
		}
		}

		// If no better move is found, consider moves that maintain the same distance
		if (bestMoves.isEmpty()) {
		minDistance = currentDistance;
		for (Position move : possibleMoves) {
		int distance = PositionUtil.getManhattanDistance(move, targetPos);
		if (distance == minDistance) {
		bestMoves.add(move);
		}
		}
		}

		// If still no move is found, stay in the current position
		if (bestMoves.isEmpty()) {
		return currentPos;
		}

		// Select a move from the best moves (e.g., randomly or based on additional criteria)
		Random r = new Random();

		Position nextMove = bestMoves.get(r.nextInt(bestMoves.size()));

		return nextMove;
		}


		@Override
		public void setPosition(Position p) {
		this.position = p;
		}

		@Override
		public Position getPosition() {
		return this.position;
		}

		public Color getViewColor() {
		return this.viewColor;
		}

		@Override
		public int getAge() {
		return this.age;
		}

		@Override
		public void incrementAge() {
		this.age = age + 1;
		}

		@Override
		public void setAge(int age) {
		this.age = age;
		}
		public int getPriority(){ return this.priority;}

		}

src/main/java/model/FireFighterScenario.java

0 → 100644

+280 −0

Original line number	Diff line number	Diff line
		package model;

		import java.util.ArrayList;
		import java.util.Collections;
		import java.util.Iterator;
		import java.util.List;
		import java.util.Random;

		import util.Matrix;
		import util.Position;
		import util.PositionUtil;

		public class FireFighterScenario extends EntityScenario implements Board<Square> {

		private Matrix<Square> matrix;
		private int step;

		private int initialFireCount;
		private int initialFireFightersCount;
		private int intialCloudCount;
		private int initialMoutainCount;

		public FireFighterScenario(int columns, int rows, int initialFireCount, int initialFireFightersCount, int initialCloudCount, int initialMoutainCount) {
		this.matrix = new Matrix<Square>(columns, rows);
		this.initialFireCount = initialFireCount;
		this.initialFireFightersCount = initialFireFightersCount;
		this.intialCloudCount = initialCloudCount;
		this.initialMoutainCount = initialMoutainCount;
		initScenario(matrix);
		placeInitialActors(initialFireCount, initialFireFightersCount, initialCloudCount, initialMoutainCount);
		this.step = 0;
		}

		private void placeInitialActors(int initialFireCount, int initialFireFightersCount, int initialCloudCount, int initialMoutainCount) {
		int fireCount = 0;
		int fireFighterCount = 0;
		int cloudCount = 0;
		int moutainCount = 0;
		int chance = 5; // Chance initiale en pourcentage
		Random random = new Random();
		List<Position> positions = new ArrayList<>();
		for (int x = 0; x < matrix.getRows(); x++) {
		for (int y = 0; y < matrix.getColumns(); y++) {
		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

		for (Position pos : positions) {
		if (getStates(pos).isEmpty()) {
		if (fireCount < initialFireCount && random.nextInt(100) < chance) {
		setSquare(new Square(pos, new Fire(pos, 0)));
		fireCount++;
		if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount && moutainCount == initialMoutainCount) {
		return;
		}
		continue;
		}

		if (fireFighterCount < initialFireFightersCount && random.nextInt(100) < chance) {
		setSquare(new Square(pos, new FireFighter(pos, this, 1)));
		fireFighterCount++;
		if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount && moutainCount == initialMoutainCount) {
		return;
		}
		}

		if (cloudCount < intialCloudCount && random.nextInt(100) < chance) {
		setSquare(new Square(pos, new Cloud(pos, this, 1)));
		cloudCount++;
		if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount && moutainCount == initialMoutainCount) {
		return;
		}
		}

		if (moutainCount < initialMoutainCount && random.nextInt(100) < chance) {
		setSquare(new Square(pos, new Mountain(pos, 1)));
		moutainCount++;
		if (fireCount == initialFireCount && fireFighterCount == initialFireFightersCount && cloudCount == initialCloudCount && moutainCount == initialMoutainCount) {
		return;
		}
		}
		}
		}

		// Augmente la chance de placement après chaque parcours complet
		chance = Math.min(chance + 5, 100); // Ne dépasse pas 100%
		}
		}

		public Square getStates(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.");
		}
		return matrix.get(position.x(), position.y());
		}

		public void setSquare(Square square) {
		Position position = square.getPosition();
		if (!(getStates(position).isEmpty())) {
		return;
		}
		if (doesPositionExist(position)) {
		matrix.set(position.x(), position.y(), square);
		}
		}

		public void setSquare(Square square, boolean replaceStates) {
		Position position = square.getPosition();
		if (!(getStates(position).isEmpty()) && !replaceStates) {
		return;
		}
		matrix.set(position.x(), position.y(), square);
		}

		public void addEntityAtSquare(Entity entity, Position position) {
		if (doesPositionExist(position)) {
		matrix.get(position.x(), position.y()).addEntity(entity);
		}
		}


		public int rowCount() {
		return matrix.getRows();
		}

		public int columnCount() {
		return matrix.getColumns();
		}

		@Override
		public void clearCaseFrom(Entity entity, Position position) {
		matrix.get(position.x(), position.y()).getEntities().removeIf(element -> element.equals(entity));
		}

		public List<Position> updateToNextGeneration() {
		ArrayList<Position> changedPositions = new ArrayList<>();
		Iterator<Square> iterator = matrix.iterator();

		while (iterator.hasNext()) {
		Square s = iterator.next();
		if (s.isEmpty())
		continue;
		if (s.getMaxAge() == 0) {
		s.incrementAllAges();
		continue;
		}
		if (s.getMaxAge() == step + 1) {
		continue;
		}
		List<Entity> entities = new ArrayList<>(s.getEntities());
		for (Entity e : entities) {
		if(e.getAge() >= stepNumber()-1){
		continue;
		}
		e.incrementAge();
		changedPositions.addAll(e.nextTurn(this));
		}
		}

		// Increment the step counter
		this.step = this.step + 1;

		// Check if it's time to spawn an AirTanker
		if (this.step % 8 == 0) {
		// Spawn an AirTanker at a random edge position
		spawnAirTanker(changedPositions);
		}

		return changedPositions;
		}

		// Helper method to spawn an AirTanker
		private void spawnAirTanker(List<Position> changedPositions) {
		System.out.println("Spawning AirTanker");
		Random rand = new Random();
		int edge = rand.nextInt(4); // 0: top, 1: bottom, 2: left, 3: right
		Position position = null;

		if (edge == 0) { // Top edge (x == 0)
		int y = rand.nextInt(columnCount()-1);
		position = new Position(0, y);
		} else if (edge == 1) { // Bottom edge (x == rowCount() - 1)
		int y = rand.nextInt(columnCount());
		position = new Position(rowCount() - 1, y);
		} else if (edge == 2) { // Left edge (y == 0)
		int x = rand.nextInt(rowCount()-1);
		position = new Position(x, 0);
		} else if (edge == 3) { // Right edge (y == columnCount() - 1)
		int x = rand.nextInt(rowCount()-1);
		position = new Position(x, columnCount() -1);
		} else {
		// This else block is technically not necessary because edge will always be between 0 and 3
		throw new IllegalStateException("Unexpected edge value: " + edge);
		}

		System.out.println("Position: " + position.toString());
		// Create a new AirTanker
		AirTanker airTanker = new AirTanker(position, this);
		System.out.println(" direction : " + airTanker.getDirection());
		// Add the AirTanker to the board
		addEntityAtSquare(airTanker, position);

		// Record the changed position
		changedPositions.add(position);
		}



		public Position getNearestEntity(Position fromPos, Class<?> entityType) {
		int rows = matrix.getRows();
		int cols = matrix.getColumns();
		Position nearestPosition = fromPos;

		// 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);

		for (Position currentPos : positionsAtDistance) {
		Square currentSquare = matrix.get(currentPos.x(), currentPos.y());
		for (Entity currentEntity : currentSquare.getEntities()) {
		if (entityType.isInstance(currentEntity)) {
		// Dès qu'une entité est trouvée à cette distance, elle est la plus proche
		// possible
		return currentPos;
		}
		}
		}
		}

		return nearestPosition; // Retourne null si aucune entité n'est trouvée
		}

		public void reset() {
		step = 0;
		matrix.clear();
		initScenario(matrix);
		placeInitialActors(initialFireCount, initialFireFightersCount, intialCloudCount, initialMoutainCount);
		}

		public int stepNumber() {
		return this.step;
		}

		@Override
		public boolean doesPositionExist(Position position) {
		return matrix.validateIndex(position);
		}

		@Override
		public int getStepNumber() {
		return step;
		}

		@Override
		public boolean doesSquareContainEntity(Position squarePos, Class<?> entityType) {
		return getStates(squarePos).getEntities().stream().anyMatch(entityType::isInstance);
		}

		@Override
		public boolean isPositionEmpty(Position position) {
		return getStates(position).isEmpty();
		}

		@Override
		public boolean isPositionFree(Position position, int priority) {
		List<Entity> entities = matrix.get(position.x(), position.y()).getEntities();
		for(Entity e : entities){
		if(e.getPriority() == priority){
		return false;
		}
		}
		return true;
		}
		}

src/main/java/model/FirefighterBoard.java

deleted100644 → 0

+0 −147

Original line number	Diff line number	Diff line
		package model;

		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 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++)
		positions[row][column] = new Position(row, column);
		for (int column = 0; column < columnCount; column++)
		for (int row = 0; row < rowCount; row++) {
		List<Position> list = new ArrayList<>();
		if (row > 0) list.add(positions[row - 1][column]);
		if (column > 0) list.add(positions[row][column - 1]);
		if (row < rowCount - 1) list.add(positions[row + 1][column]);
		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());
		}

		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;
		}

		@Override
		public int columnCount() {
		return columnCount;
		}

		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));
		}
		firePositions.addAll(newFirePositions);
		modifiedPositions.addAll(newFirePositions);
		}
		return modifiedPositions;

		}

		@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;
		}

		@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);
		}
		}
		}
		}
		No newline at end of file

src/main/java/model/ModelElement.java

deleted100644 → 0

+0 −5

Original line number	Diff line number	Diff line
		package model;

		public enum ModelElement {
		FIREFIGHTER, FIRE
		}

src/main/java/model/MotorizedFireFighter.java

0 → 100644

+110 −0

Original line number	Diff line number	Diff line
		package model;

		import java.util.ArrayList;
		import java.util.List;

		import javafx.scene.paint.Color;
		import util.Position;
		import util.PositionUtil;

		public class MotorizedFireFighter extends FireFighter {
		private final Color viewColor = Color.CYAN;

		public MotorizedFireFighter(Position position, Board<Square> b) {
		super(position, b);
		}

		@Override
		public List<Position> nextTurn(Board<Square> b) {
		List<Position> positions = new ArrayList<>();

		// Generate adjacent positions excluding mountains
		List<Position> adjacentPositions = PositionUtil.generateAdjacentPositions(getPosition(), b);
		adjacentPositions.removeIf(p -> b.doesSquareContainEntity(p, Mountain.class));

		// Check if there is fire in any adjacent positions
		boolean hasFire = adjacentPositions.stream()
		.anyMatch(p -> b.doesSquareContainEntity(p, Fire.class));

		boolean isStuck = isStuck();

		if (hasFire) {
		// Extinguish fires in adjacent positions
		positions.addAll(extinguish(adjacentPositions, b));

		if (isStuck) {
		// If stuck, attempt to move and extinguish after moving
		positions.addAll(moveAndExtinguish(b));
		}
		} else {
		// No fire adjacent; move and attempt to extinguish fires
		positions.addAll(moveAndExtinguish(b));
		}

		// Update last positions for stuck detection
		updateLastPositions();

		return positions;
		}

		@Override
		protected List<Position> moveAndExtinguish(Board<Square> b) {
		List<Position> positions = new ArrayList<>();

		// Find the nearest fire
		Position nearestFirePos = b.getNearestEntity(getPosition(), Fire.class);
		if (nearestFirePos != null) {
		// Get the next position after moving up to two steps towards the fire
		Position nextPos = getNextPositionTowards(getPosition(), nearestFirePos, b, 2);

		if (nextPos != null && !nextPos.equals(getPosition())) {
		// Move the firefighter
		b.clearCaseFrom(this, getPosition()); // Clear old position
		positions.add(new Position(getPosition().x(), getPosition().y())); // Add old position
		setPosition(nextPos);
		b.addEntityAtSquare(this, nextPos); // Add to new position
		positions.add(nextPos); // Add new position

		// After moving, attempt to extinguish fires adjacent to new position
		List<Position> newAdjacentPositions = PositionUtil.generateAdjacentPositions(nextPos, b);
		newAdjacentPositions.removeIf(p -> b.doesSquareContainEntity(p, Mountain.class));
		positions.addAll(extinguish(newAdjacentPositions, b));
		}
		}

		return positions;
		}

		// Overloaded method to handle multiple steps
		protected Position getNextPositionTowards(Position currentPos, Position targetPos, Board<Square> b, int steps) {
		Position nextPos = currentPos;

		for (int i = 0; i < steps; i++) {
		Position stepPos = super.getNextPositionTowards(nextPos, targetPos, b);

		if (stepPos == null \|\| stepPos.equals(nextPos)) {
		// Can't move further
		break;
		}

		nextPos = stepPos;
		}

		return nextPos;
		}

		// Override to ensure correct color
		@Override
		public Color getViewColor() {
		return this.viewColor;
		}

		// Ensure the last positions are updated correctly
		protected void updateLastPositions() {
		if (lastThreePosition.size() >= 3) {
		lastThreePosition.remove(0);
		}
		lastThreePosition.add(this.getPosition());
		}

		}
		No newline at end of file

src/main/java/model/Mountain.java

0 → 100644

+65 −0

Original line number	Diff line number	Diff line
		package model;

		import java.util.List;

		import javafx.scene.paint.Color;
		import util.Position;

		public class Mountain implements Entity{
		private final int priority = 0;
		Position position;
		private int age;
		private final Color viewColor = Color.CHOCOLATE;

		public Mountain(Position p ){
		this.position = p;
		}


		public Mountain(Position p , int age){
		this.position = p;
		this.age = age;
		}

		@Override
		public List<Position> nextTurn(Board<Square> board) {
		List<Entity> states = board.getStates(position).getEntities();
		return List.of();
		}

		@Override
		public Position getPosition() {
		return this.position;
		}

		@Override
		public void setPosition(Position p) {
		this.position = p;

		}

		@Override
		public int getAge() {
		return this.age;
		}

		@Override
		public void setAge(int age) {
		this.age = age;
		}

		@Override
		public void incrementAge() {
		this.age += 1;
		}

		@Override
		public Color getViewColor() {
		return this.viewColor;
		}

		@Override
		public int getPriority() {
		return this.priority;
		}
		}

src/main/java/model/Scenario.java

0 → 100644

+8 −0

Original line number	Diff line number	Diff line
		package model;

		import util.Matrix;

		public interface Scenario {
		public void initScenario(Matrix<Square> matrix);

		}
		No newline at end of file

src/main/java/model/Square.java

0 → 100644

+93 −0

Original line number	Diff line number	Diff line
		package model;

		import java.util.ArrayList;
		import java.util.List;

		import javafx.scene.paint.Color;
		import util.Position;

		public class Square {
		private List<Entity> entities;
		private Position position;
		public Square(Position position){
		this.entities = new ArrayList<Entity>();
		this.position = position;
		}
		public Square(Position position, Entity entity){
		this.entities = new ArrayList<Entity>();
		this.entities.add(entity);
		this.position = position;
		}

		public List<Entity> getEntities(){
		return this.entities;
		}

		public Position getPosition(){
		return this.position;
		}

		public void addEntity(Entity entity){
		entities.add(entity);
		}

		public void removeEntity(Entity entity){
		entities.remove(entity);
		}

		public void setEntities(List<Entity> entities){
		this.entities = entities;
		}

		public boolean isEmpty(){
		return entities.isEmpty() \|\|(entities.size() == 1 && entities.get(0) instanceof EmptySquare);
		}

		public int getMinimalAge(){
		int minimalAge = 0;
		for(Entity e : entities){
		if(e.getAge() < minimalAge){
		minimalAge = e.getAge();
		}
		}
		return minimalAge;
		}

		public int getMaxAge(){
		int maxAge = 0;
		for(Entity e : entities){
		if(e.getAge() > maxAge){
		maxAge = e.getAge();
		}
		}
		return maxAge;
		}

		public void incrementAllAges(){
		for(Entity e : entities){
		e.incrementAge();
		}
		}

		public Color getViewColor() {
		if (entities.isEmpty()) {
		return Color.WHITE;
		} else {
		int maxPriority = -1; // Assuming priorities are non-negative
		Color c = Color.WHITE;

		// Iterate over entities to find the one with the highest priority
		for (Entity e : entities) {
		// Check for null entities if necessary
		if (e != null && e.getPriority() > maxPriority) {
		maxPriority = e.getPriority();
		c = e.getViewColor();
		}
		}
		return c;
		}
		}



		}

src/main/java/module-info.java

+2 −1

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@ module firefighter {
		requires javafx.controls;
		requires javafx.fxml;
		requires javafx.graphics;
		requires java.sql;
		opens controller to javafx.fxml;
		exports app;
		opens app to javafx.fxml;

src/main/java/util/Direction.java

0 → 100644

+5 −0

Original line number	Diff line number	Diff line
		package util;

		public enum Direction {
		NORTH, EAST, WEST, SOUTH
		}

src/main/java/util/Matrix.java

0 → 100644

+147 −0

Original line number	Diff line number	Diff line
		package util;


		import java.util.ArrayList;
		import java.util.Iterator;
		import java.util.NoSuchElementException;

		import model.Fire;
		import model.FireFighter;
		import model.Square;

		public class Matrix<E> implements Iterable<E> {
		private ArrayList<ArrayList<E>> matrix;
		private final int rows;
		private final int columns;

		public Matrix(int rows, int columns) {
		this.rows = rows;
		this.columns = columns;
		this.matrix = new ArrayList<>(rows);

		// Initialiser chaque ligne de la matrice
		for (int i = 0; i < rows; i++) {
		ArrayList<E> row = new ArrayList<>(columns);
		// Initialiser chaque colonne avec des valeurs nulles
		for (int j = 0; j < columns; j++) {
		row.add(null);
		}
		this.matrix.add(row);
		}
		}

		public E get(int x, int y) {
		validateIndex(x, y);
		return matrix.get(x).get(y);
		}

		public E set(int x, int y, E object) {
		validateIndex(x, y);
		return matrix.get(x).set(y, object);
		}

		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);
		// Initialiser chaque colonne avec des valeurs nulles
		for (int j = 0; j < columns; j++) {
		row.add(null);
		}
		this.matrix.add(row);
		}
		}

		public int size() {
		return rows * columns;
		}

		public int getColumns(){
		return this.columns;
		}
		public int getRows(){
		return this.rows;
		}


		public void displayMatrix() {
		System.out.print(" ");
		for (int j = 0; j < columns; j++) {
		System.out.print("___ ");
		}
		System.out.println();

		for (int i = 0; i < rows; i++) {
		System.out.print("\| ");
		for (int j = 0; j < columns; j++) {
		if (matrix.get(i).get(j) != null) {
		Square s = (Square) matrix.get(i).get(j);
		if(s.getEntities().stream().anyMatch(p -> p instanceof Fire)){
		System.out.print(" F \| ");
		}
		else if(s.getEntities().stream().anyMatch(p -> p instanceof FireFighter)){
		System.out.print(" ff \| ");
		}
		else if(s.getEntities().stream().anyMatch(p -> p instanceof FireFighter)){
		System.out.print(" A \| ");
		}else{
		System.out.print(" \| ");
		}

		} else {
		System.out.print(" \| ");
		}
		}
		System.out.println();
		System.out.print(" ");
		for (int j = 0; j < columns; j++) {
		System.out.print("___ ");
		}
		System.out.println();
		}
		}


		private void validateIndex(int x, int y) {
		if (x < 0 \|\| x >= rows \|\| y < 0 \|\| y >= columns) {
		throw new IndexOutOfBoundsException("Indices x: "+ x + " y: " + y + " hors limites pour la matrice.");
		}
		}

		public boolean validateIndex(Position position){
		return position.x() >= 0 && position.x() < rows && position.y() >= 0 && position.y() < columns;
		}




		@Override
		public Iterator<E> iterator() {
		return new MatrixIterator();
		}

		private class MatrixIterator implements Iterator<E> {
		private int row = 0;
		private int col = 0;

		@Override
		public boolean hasNext() {
		return row < rows && col < columns;
		}

		@Override
		public E next() {
		if (!hasNext()) {
		throw new NoSuchElementException();
		}
		E element = matrix.get(row).get(col);
		col++;
		if (col >= columns) {
		col = 0;
		row++;
		}
		return element;
		}
		}
		}

src/main/java/util/Position.java

+1 −1

Original line number	Diff line number	Diff line
		package util;

		public record Position(int row, int column) {
		public record Position(int x, int y) {

		}

src/main/java/util/PositionUtil.java

0 → 100644

+158 −0

Original line number	Diff line number	Diff line
		package util;

		import java.util.ArrayList;
		import java.util.List;
		import java.util.stream.Collectors;
		import java.util.stream.Stream;

		import model.Board;
		import model.Square;

		public class PositionUtil {
		/**
		* Calcule et retourne une liste de positions situées à une distance de
		* Manhattan spécifique à partir d'une position donnée.
		* La distance de Manhattan entre deux points (x1, y1) et (x2, y2) est donnée
		* par \|x1 - x2\| + \|y1 - y2\|.
		* Cette méthode génère toutes les positions possibles à cette distance dans une
		* grille de taille spécifiée.
		*
		* @param fromPos la position de départ à partir de laquelle la distance est
		* calculée.
		* @param distance la distance de Manhattan à utiliser pour trouver les
		* positions.
		* @param rows le nombre de lignes dans la grille.
		* @param cols le nombre de colonnes dans la grille.
		* @return une liste de positions à la distance de Manhattan spécifiée de la
		* position initiale, qui se trouvent également dans les limites de la
		* grille.
		*/
		public static List<Position> getPositionsAtManhattanDistance(Position fromPos, int distance, int rows, int cols) {
		List<Position> positions = new ArrayList<>();
		int x0 = fromPos.x();
		int y0 = fromPos.y();

		// Générer toutes les positions à une distance de Manhattan donnée
		for (int dx = -distance; dx <= distance; dx++) {
		int dy = distance - Math.abs(dx);

		int[] dyOptions = { dy, -dy };
		for (int deltaY : dyOptions) {
		int x = x0 + dx;
		int y = y0 + deltaY;

		// Vérifier si la position est dans les limites de la matrice
		if (x >= 0 && x < rows && y >= 0 && y < cols) {
		positions.add(new Position(x, y));
		}
		}
		}

		return positions;
		}

		/**
		* Génère une liste de positions adjacentes à une position donnée, en vérifiant
		* si chaque position est valide dans le contexte du jeu.
		*
		* @param position la position de départ pour laquelle générer les positions
		* adjacentes.
		* @param board l'objet représentant le plateau de jeu qui permet de vérifier
		* si une position existe.
		* @return une liste des positions adjacentes valides.
		*/
		public static List<Position> generateAdjacentPositions(Position position, Board<Square> board) {
		int x = position.x();
		int y = position.y();

		return Stream.of(
		new Position(x, y + 1),
		new Position(x + 1, y),
		new Position(x, y - 1),
		new Position(x - 1, y))
		.filter(p -> board.doesPositionExist(p))
		.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) {
		int x = position.x();
		int y = position.y();

		List<Position> positions = new ArrayList<>();

		// Liste des 8 déplacements possibles
		int[][] deltas = {
		{ 1, 0 }, // x+1, y
		{ -1, 0 }, // x-1, y
		{ 0, 1 }, // x, y+1
		{ 0, -1 }, // x, y-1
		{ 1, 1 }, // x+1, y+1
		{ -1, -1 }, // x-1, y-1
		{ 1, -1 }, // x+1, y-1
		{ -1, 1 } // x-1, y+1
		};

		for (int[] delta : deltas) {
		int newX = x + delta[0];
		int newY = y + delta[1];
		Position p = new Position(newX, newY);
		if (board.doesPositionExist(p)) {
		positions.add(p);
		}
		}

		return positions;
		}

		public static int getManhattanDistance(Position p1, Position p2) {
		return Math.abs(p1.x() - p2.x()) + Math.abs(p1.y() - p2.y());
		}

		/**
		* Generates all positions within a specified radius from a center position.
		* It uses Manhattan distance by default.
		*
		* @param center The center position.
		* @param radius The radius (distance) from the center position.
		* @param board The board to consider boundaries.
		* @return A list of positions within the radius.
		*/
		public static List<Position> getPositionsInRadius(Position center, int radius, Board<Square> board) {
		List<Position> positions = new ArrayList<>();

		int startX = center.x() - radius;
		int endX = center.x() + radius;
		int startY = center.y() - radius;
		int endY = center.y() + radius;

		for (int x = startX; x <= endX; x++) {
		for (int y = startY; y <= endY; y++) {
		Position pos = new Position(x, y);
		if (board.doesPositionExist(pos)) {
		// Calculate Manhattan distance from the center
		int distance = Math.abs(center.x() - x) + Math.abs(center.y() - y);
		if (distance <= radius) {
		positions.add(pos);
		}
		}
		}
		}

		return positions;
		}

		}
		No newline at end of file

src/main/java/util/TargetStrategy.java

+10 −5

Original line number	Diff line number	Diff line
		package model;
		package util;

		import util.Position;

		import java.util.*;
		import java.util.Collection;
		import java.util.HashMap;
		import java.util.HashSet;
		import java.util.LinkedList;
		import java.util.List;
		import java.util.Map;
		import java.util.Queue;
		import java.util.Set;

		public class TargetStrategy {

		@@ -12,7 +17,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 neighborClosestToFire(Position position, Collection<Position> targets,
		Map<Position,List<Position>>neighbors) {
		Set<Position> seen = new HashSet<Position>();
		HashMap<Position, Position> firstMove = new HashMap<Position, Position>();

src/main/java/view/FirefighterGrid.java

+4 −4

Original line number	Diff line number	Diff line
		package view;

		import java.util.List;

		import javafx.scene.canvas.Canvas;
		import javafx.scene.paint.Color;
		import javafx.util.Pair;
		import util.Position;

		import java.util.List;

		public class FirefighterGrid extends Canvas implements Grid<ViewElement>{

		private void paintElementAtPosition(ViewElement element, Position position) {
		paintBox(position.row(), position.column(), element.color);
		paintBox(position.x(), position.y(), element.getColor());
		}
		private int boxWidth;
		private int boxHeight;
		@@ -27,7 +27,7 @@ public class FirefighterGrid extends Canvas implements Grid<ViewElement>{
		private void clear(List<Pair<Position, ViewElement>> positionedElements) {
		for (Pair<Position, ViewElement> positionElement : positionedElements) {
		Position position = positionElement.getKey();
		clearBox(position.row(), position.column());
		clearBox(position.x(), position.y());
		}
		}

src/main/java/view/ViewElement.java

+10 −6

Original line number	Diff line number	Diff line
		@@ -2,10 +2,14 @@ package view;

		import javafx.scene.paint.Color;

		public enum ViewElement {
		FIREFIGHTER(Color.BLUE), FIRE(Color.RED), EMPTY(Color.WHITE);
		final Color color;
		ViewElement(Color color) {
		public class ViewElement {
		private final Color color;

		public ViewElement(Color color) {
		this.color = color;
		}

		public Color getColor() {
		return color;
		}
		}

src/main/resources/view/view.fxml

+24 −18

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="UTF-8"?>

		<?import javafx.scene.control.Button?>
		<?import javafx.scene.control.Label?>
		<?import javafx.scene.control.Separator?>
		<?import javafx.scene.control.ToggleButton?>
		<?import javafx.scene.layout.HBox?>
		<?import javafx.scene.layout.VBox?>
		<?import view.FirefighterGrid?>

		<?import javafx.scene.control.ToggleButton?>
		<?import javafx.scene.control.Separator?>
		<?import javafx.scene.control.Label?>
		<HBox styleClass="background" stylesheets="@DarkTheme.css"
		xmlns="http://javafx.com/javafx" xmlns:fx="http://javafx.com/fxml"
		xmlns="http://javafx.com/javafx"
		xmlns:fx="http://javafx.com/fxml"
		fx:controller="controller.Controller">
		<VBox>
		<Separator maxHeight="-Infinity" maxWidth="-Infinity"
		prefHeight="24.0" prefWidth="200.0" />
		<Label maxHeight="-Infinity" maxWidth="-Infinity" alignment="CENTER" prefHeight="24.0" prefWidth="200.0"
		<Label maxHeight="-Infinity" maxWidth="-Infinity"
		alignment="CENTER" prefHeight="24.0" prefWidth="200.0"
		text="Generation number" />
		<Label fx:id="generationNumberLabel" alignment="CENTER" contentDisplay="TEXT_ONLY"
		maxHeight="-Infinity" maxWidth="-Infinity" prefHeight="24.0" prefWidth="200.0"/>
		<Label fx:id="generationNumberLabel"
		alignment="CENTER" contentDisplay="TEXT_ONLY"
		maxHeight="-Infinity" maxWidth="-Infinity"
		prefHeight="24.0" prefWidth="200.0" />
		<Separator maxHeight="-Infinity" maxWidth="-Infinity"
		prefHeight="24.0" prefWidth="200.0" />
		<Button fx:id="restartButton" maxHeight="-Infinity" maxWidth="-Infinity"
		mnemonicParsing="false" onAction="#restartButtonAction" prefHeight="24.0" prefWidth="200.0"
		text="Restart"/>
		mnemonicParsing="false" onAction="#restartButtonAction"
		prefHeight="24.0" prefWidth="200.0" text="Restart" />
		<Button fx:id="oneStepButton" maxHeight="-Infinity" maxWidth="-Infinity"
		mnemonicParsing="false" onAction="#oneStepButtonAction" prefHeight="24.0" prefWidth="200.0"
		text="One step"/>
		mnemonicParsing="false" onAction="#oneStepButtonAction"
		prefHeight="24.0" prefWidth="200.0" text="One step" />
		<ToggleButton fx:id="playToggleButton" maxHeight="-Infinity" maxWidth="-Infinity"
		mnemonicParsing="false" onAction="#playToggleButtonAction" prefHeight="24.0"
		prefWidth="200.0" styleClass="button" text="Play"/>
		mnemonicParsing="false" onAction="#playToggleButtonAction"
		prefHeight="24.0" prefWidth="200.0"
		styleClass="button" text="Play" />
		<ToggleButton fx:id="pauseToggleButton" maxHeight="-Infinity" maxWidth="-Infinity"
		mnemonicParsing="false" onAction="#pauseToggleButtonAction" prefHeight="24.0"
		prefWidth="200.0" styleClass="button" text="Pause"/>
		mnemonicParsing="false" onAction="#pauseToggleButtonAction"
		prefHeight="24.0" prefWidth="200.0"
		styleClass="button" text="Pause" />
		</VBox>
		<FirefighterGrid fx:id="grid"
		xmlns="http://javafx.com/javafx"

src/test/java/model/FirefighterBoardTest.java

deleted100644 → 0

+0 −39

Original line number	Diff line number	Diff line
		package model;

		import org.junit.jupiter.api.Test;
		import util.Position;

		import java.util.List;

		import static org.assertj.core.api.Assertions.*;

		public class FirefighterBoardTest {
		@Test
		void testColumnCount(){
		Board<List<ModelElement>> 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);
		assertThat(board.rowCount()).isEqualTo(10);
		}
		@Test
		void testStepNumber(){
		Board<List<ModelElement>> board = new FirefighterBoard(20, 10, 1, 3);
		for(int index = 0; index < 10; index++){
		assertThat(board.stepNumber()).isEqualTo(index);
		board.updateToNextGeneration();
		}
		assertThat(board.stepNumber()).isEqualTo(10);
		}
		@Test
		void testGetState_afterSet(){
		Board<List<ModelElement>> 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);
		assertThat(board.getState(position)).containsExactly(ModelElement.FIRE);
		}

		}

src/test/java/view/FirefighterGridTest.java

+4 −4

Original line number	Diff line number	Diff line
		package view;

		import org.junit.jupiter.api.Test;
		import static org.assertj.core.api.Assertions.*;

		import static org.assertj.core.api.Assertions.assertThat;
		import org.junit.jupiter.api.Test;

		public class FirefighterGridTest {
		@Test
		void testColumnCount(){
		Grid<ViewElement> grid = new FirefighterGrid();
		grid.setDimensions(20,10,10,10);
		grid.setDimensions(20,10,5,5);
		assertThat(grid.columnCount()).isEqualTo(20);
		}
		@Test
		void testRowCount(){
		Grid<ViewElement> grid = new FirefighterGrid();
		grid.setDimensions(20,10,10,10);
		grid.setDimensions(20,10,5,5);
		assertThat(grid.rowCount()).isEqualTo(10);
		}
		}

Compare revisions

Source

Target

Files

.gitignore

build/resources/main/view/DarkTheme.css

build/resources/main/view/view.fxml

diagrams/model.png

gradlew.bat

src/main/java/app/SimulatorApplication.java

src/main/java/controller/Controller.java

src/main/java/model/AirTanker.java

src/main/java/model/Board.java

src/main/java/model/Cloud.java

src/main/java/model/EmptySquare.java

src/main/java/model/Entity.java

src/main/java/model/EntityScenario.java

src/main/java/model/Fire.java

src/main/java/model/FireFighter.java

src/main/java/model/FireFighterScenario.java

src/main/java/model/FirefighterBoard.java

src/main/java/model/ModelElement.java

src/main/java/model/MotorizedFireFighter.java

src/main/java/model/Mountain.java

src/main/java/model/Scenario.java

src/main/java/model/Square.java

src/main/java/module-info.java

src/main/java/util/Direction.java

src/main/java/util/Matrix.java

src/main/java/util/Position.java

src/main/java/util/PositionUtil.java

src/main/java/util/TargetStrategy.java

src/main/java/view/FirefighterGrid.java

src/main/java/view/ViewElement.java

src/main/resources/view/view.fxml

src/test/java/model/FirefighterBoardTest.java

src/test/java/view/FirefighterGridTest.java