Skip to content
Snippets Groups Projects

Compare revisions

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

Source

Select target project
No results found
Select Git revision
  • main
  • melissa
  • variant
  • yanis
4 results

Target

Select target project
  • l22015417/firefighterstarter
  • m19023837/firefighter-starter-mansour-chadi-chahine-rami
  • r24025701/firefighterstarter
  • n24026202/firefighterstarter
  • couetoux.b/firefighterstarter
  • b23027938/firefighterstarter
  • z20039716/fire-fighter
  • a18023913/firefighterstarter
  • o22010261/firefighterstarter
  • b22015516/firefighterstarter
  • alaboure/firefighter-template
  • p21211679/firefighter-luis-parra-yanis-lounadi
  • v23014723/firefighter-project
  • k20014011/firefighter-template
  • m23022217/firefighter-template
  • p20006624/firefighter-template
  • l21221596/firefighter-template
  • s21232465/firefighter-template
  • y21224754/firefighter-template
  • w21225935/firefighter-template
  • h22023886/firefighter-template
  • b21221604/firefighter-template-boucenna-yacine-zeghar-mohamed-lamine
  • c23025119/firefighterstarter
  • b20031964/firefighterstarter
24 results
Select Git revision
  • main
  • variant
2 results
Show changes
package model;
import util.Matrix;
public interface Scenario {
public void initScenario(Matrix<Square> matrix);
}
\ No newline at end of file
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;
}
}
}
......@@ -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;
......
package util;
public enum Direction {
NORTH, EAST, WEST, SOUTH
}
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;
}
}
}
package util;
public record Position(int row, int column) {
public record Position(int x, int y) {
}
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
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>();
......
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());
}
}
......
......@@ -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;
}
}
<?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"
......
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);
}
}
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);
}
}