Merge remote-tracking branch 'origin/main'

Project Repports/Diagram

+@startuml
+
+' Enum: ModelElement
+enum ModelElement {
+    FIREFIGHTER
+    FIRE
+    CLOUD
+    ROAD
+    EMPTY
+    MOUNTAIN
+    FIRETRUCK
+    ROCKS
+}
+
+' Class: Position
+class Position {
+    - row: int
+    - column: int
+    + Position(row: int, column: int)
+    + getRow(): int
+    + getColumn(): int
+}
+
+' Interface: Strategy
+interface Strategy {
+    + update(): List<Position>
+    + getModelPositions(): List<Position>
+    + getFirePositions(): Set<Position>
+}
+
+' Class: FireTruckMovementStrategy
+class FireTruckMovementStrategy {
+    - targetStrategy: TargetStrategy
+    - fireTruckPositions: List<Position>
+    - firePositions: Set<Position>
+    - neighbors: Map<Position, List<Position>>
+    + FireTruckMovementStrategy(firefighterPositions: List<Position>, firePositions: Set<Position>, neighbors: Map<Position, List<Position>>)
+    + update(): List<Position>
+    + nextValidPosition(currentPosition: Position): Position
+    + extinguishNearbyFires(position: Position, modifiedPositions: List<Position>)
+    + extinguishAll(positions: List<Position>)
+}
+
+' Class: SimpleFireSpreadStrategy
+class SimpleFireSpreadStrategy {
+    - firePositions: Set<Position>
+    - neighbors: Map<Position, List<Position>>
+    - mountainPositions: Set<Position>
+    - roadPositions: Set<Position>
+    - rocksPositions: Set<Position>
+    - step: int
+    + SimpleFireSpreadStrategy(firePositions: Set<Position>, neighbors: Map<Position, List<Position>>, mountainPositions: Set<Position>, roadPositions: Set<Position>, rocksPositions: Set<Position>, step: int)
+    + update(): List<Position>
+    + spreadFire(firePosition: Position, newFirePositions: Set<Position>)
+    + canPropagateTo(newPosition: Position): boolean
+}
+
+' Class: Initializer
+class Initializer {
+    - columnCount: int
+    - rowCount: int
+    - initialFireCount: int
+    - initialFirefighterCount: int
+    - initialRoadCount: int
+    - initialCloudCount: int
+    - initialMountainCount: int
+    - initialFireTruckCount: int
+    - initialRocksCount: int
+    - positions: Position[][]
+    - neighbors: Map<Position, List<Position>>
+    - firePositions: Set<Position>
+    - firefighterPositions: List<Position>
+    - RoadPositions: List<Position>
+    - cloudPositions: List<Position>
+    - mountainsPositions: Set<Position>
+    - FireTruckPositions: List<Position>
+    - rocksPositions: Set<Position>
+    - randomGenerator: Random
+    + Initializer(columnCount: int, rowCount: int, initialFireCount: int, initialFirefighterCount: int, initialRoadCount: int, initialCloudCount: int, initialMountainCount: int, initialRocksCount: int, initialFireTruckCount: int)
+    + initializePositions(): void
+    + initializeNeighbors(): void
+    + initializeElements(): void
+    + addRandomPositions(targetCollection: Collection<Position>, count: int)
+}
+
+' Class: NeighborManager
+class NeighborManager {
+    - neighbors: Map<Position, List<Position>>
+    + NeighborManager(rowCount: int, columnCount: int)
+    + getNeighbors(): Map<Position, List<Position>>
+    + getAdjacentPositions(position: Position): List<Position>
+}
+
+' Class: TargetStrategy
+class TargetStrategy {
+    + calculateTarget(fireTruckPosition: Position, firePositions: Set<Position>): Position
+}
+
+' Class: Board
+class Board {
+    - positions: Position[][]
+    - modelElements: Map<Position, ModelElement>
+    + Board(rowCount: int, columnCount: int)
+    + setModelElement(position: Position, element: ModelElement): void
+    + getModelElement(position: Position): ModelElement
+}
+
+' Class: BoardManager
+class BoardManager {
+    - board: Board
+    - initializer: Initializer
+    + BoardManager(board: Board, initializer: Initializer)
+    + initializeBoard(): void
+    + updateBoard(): void
+}
+
+' Class: CloudStrategy
+class CloudStrategy {
+    - cloudPositions: Set<Position>
+    + CloudStrategy(cloudPositions: Set<Position>)
+    + updateCloud(): Set<Position>
+    + addCloudPosition(position: Position): void
+}
+
+' Class: FirefighterBoard
+class FirefighterBoard {
+    - firefighterPositions: List<Position>
+    + FirefighterBoard(firefighterPositions: List<Position>)
+    + updateFirefighterPositions(): void
+    + addFirefighter(position: Position): void
+}
+
+' Class: FirefighterMovementStrategy
+class FirefighterMovementStrategy {
+    - firefighterPositions: List<Position>
+    - neighbors: Map<Position, List<Position>>
+    + FirefighterMovementStrategy(firefighterPositions: List<Position>, neighbors: Map<Position, List<Position>>)
+    + update(): List<Position>
+    + nextValidPosition(currentPosition: Position): Position
+    + moveToNextPosition(): Position
+}
+
+' Relationship: FireTruckMovementStrategy implements Strategy
+FireTruckMovementStrategy -|> Strategy : implements
+
+' Relationship: SimpleFireSpreadStrategy implements Strategy
+SimpleFireSpreadStrategy -|> Strategy : implements
+
+' Relationship: Initializer uses NeighborManager
+Initializer --> NeighborManager : uses
+
+' Relationship: FireTruckMovementStrategy and SimpleFireSpreadStrategy depend on Position
+FireTruckMovementStrategy --> Position : depends on
+SimpleFireSpreadStrategy --> Position : depends on
+
+' Relationship: FireTruckMovementStrategy and SimpleFireSpreadStrategy depend on neighbors
+FireTruckMovementStrategy --> Map : depends on
+SimpleFireSpreadStrategy --> Map : depends on
+
+' Relationship: FireTruckMovementStrategy uses TargetStrategy
+FireTruckMovementStrategy --> TargetStrategy : uses
+
+' Relationship: ModelElement is an enum
+ModelElement ..> FireTruckMovementStrategy : used by
+ModelElement ..> SimpleFireSpreadStrategy : used by
+
+' Relationship: Position used by Initializer for grid setup
+Position --> Initializer : used by
+
+' Relationship: Position used by FireTruckMovementStrategy and SimpleFireSpreadStrategy
+Position --> FireTruckMovementStrategy : used by
+Position --> SimpleFireSpreadStrategy : used by
+
+' Relationship: Board is used by BoardManager
+Board --> BoardManager : used by
+
+' Relationship: CloudStrategy uses Position
+CloudStrategy --> Position : uses
+
+' Relationship: BoardManager uses Board and Initializer
+BoardManager --> Board : uses
+BoardManager --> Initializer : uses
+
+' Relationship: FirefighterMovementStrategy uses Position
+FirefighterMovementStrategy --> Position : uses
+
+' Relationship: FirefighterMovementStrategy and FirefighterBoard use Board
+FirefighterBoard --> Board : uses
+FirefighterMovementStrategy --> Board : uses
+
+@enduml

Project Repports/Rapport2.md

@@ -3,4 +3,4 @@ et SimpleFireSpreadStrategy qui implementent leurs Strategy respectivent
 De plus nous avons essayé de faire le FirefighterBoard qui soit compatible avec Controller 
 nous avons ajouté de plus des getters dans util.Position
  
-on va finir le FirefighterBoard la semaine prochaine ainsi que implementer util.TargetStrategy dans notre code 
\ No newline at end of file
+Nous allons finir le FirefighterBoard la semaine prochaine ainsi que implementer util.TargetStrategy dans notre code 
\ No newline at end of file

Project Repports/Rapport3.md

@@ -8,6 +8,10 @@ pas ce passer.
 Avant la prochaine seance nous allons corriger le code en sorte que ça fonctionne correctement
 
 refactorisation totale du code
-j'ai enlever les classes Manager et je les ai implementer dans les startegy de plus 
-j'ai ajouter une interface globale nomme Strategy et une classe Initializer 
+nous avions enlevé les classes Manager et je les ai implementer dans les startegy de plus 
+nous avions ajouté une interface globale nomme Strategy et une classe Initializer 
 afin de reduire le code dans les autre classe et faciliter l'implementation de codes additionelle
+
+Rami à ajouter les Roads et les firetrucks dans le code et il c'est assurer de leurs bon fonctionnement
+Chadi a ajouter la trategy des nuages ainsi que les montagnes et les rocks
+nous somme entrain de verifier que tout fonctionne comme il le faut
\ No newline at end of file

README.md

@@ -3,3 +3,68 @@ Project members :
 member 1 : Mansour Chadi
 
 member 2 : Chahine Rami
+
+
+Objectif du Projet
+
+Ce projet a pour objectif de refactoriser un code initial qui ne respectait pas les principes SOLID, afin de le rendre plus lisible, modulaire, et extensible. La refactorisation vise à diviser le code en plusieurs sous-parties bien définies, en respectant des concepts de conception logicielle modernes, notamment les principes SOLID.
+
+Par ailleurs, de nouvelles fonctionnalités ont été ajoutées au jeu, notamment :
+
+    L'introduction d'éléments tels que des nuages, des rocailles, des routes et des montagnes.
+    L'ajout de pompiers équipés de motos pour une mobilité accrue.
+
+Approche Initiale et Révision du Plan
+
+    Approche Initiale :
+        Lors de la première phase, nous avons introduit des classes Manager pour gérer les pompiers et les incendies.
+        Ces classes étaient accompagnées d'interfaces Strategy permettant d'implémenter différents types de mouvements et comportements.
+        Cependant, cette approche s'est révélée complexe et peu fonctionnelle,
+        en raison d'une mauvaise séparation des responsabilités et d'une gestion inefficace des dépendances.
+
+    Nouvelle Approche :
+        Face à ces difficultés, nous avons opté pour une refonte complète du système.
+        Nous avons simplifié l'architecture en nous concentrant uniquement sur les stratégies de mouvements. 
+        Cette approche, plus simple, s'est avérée non seulement fonctionnelle, mais aussi plus facile à modifier et à étendre.
+
+Avantages de la Nouvelle Architecture
+
+La nouvelle architecture a démontré son efficacité lors de l'ajout des nouvelles fonctionnalités :
+
+    Modularité accrue : Chaque fonctionnalité est encapsulée dans des classes ou stratégies indépendantes.
+    Facilité de modification : L'ajout de nouveaux éléments comme les nuages, les rocailles, 
+        ou les motos n'a pas nécessité de réécriture majeure du code existant.
+    Respect des principes SOLID :
+        Single Responsibility Principle : Chaque classe ou stratégie a une responsabilité unique et clairement définie.
+        Open/Closed Principle : Le système est ouvert à l'extension mais fermé à la modification.
+        Liskov Substitution Principle : Les stratégies implémentent des interfaces communes et peuvent être utilisées de manière interchangeable.
+        Interface Segregation Principle : Les interfaces sont petites et spécifiques aux besoins de chaque composant.
+        Dependency Inversion Principle : Les dépendances sont abstraites et injectées, ce qui réduit le couplage.
+
+Fonctionnalités Clés
+
+Voici un aperçu des fonctionnalités intégrées grâce à cette refactorisation :
+
+    Stratégies de Propagation du Feu :
+        Différents types de terrains influencent la propagation des flammes :
+            Les montagnes bloquent complètement le feu.
+            Les rocailles ralentissent sa propagation, ne brûlant qu'à des intervalles précis.
+            Les routes empêchent la propagation.
+
+    Gestion des Pompiers :
+        Les pompiers peuvent se déplacer rapidement grâce à des motos, permettant une intervention plus efficace.
+        Les stratégies de mouvement tiennent compte des obstacles comme les montagnes et les rocailles.
+
+    Ajout d’éléments naturels :
+        Les nuages peuvent interagir avec le terrain et affecter les conditions du feu.
+        Les différents types de terrains apportent une dimension stratégique au jeu.
+
+    Visualisation Améliorée :
+        Le système de rendu utilise une grille pour afficher clairement chaque élément (feu, pompiers, routes, etc.),
+        avec des couleurs spécifiques pour une meilleure lisibilité.
+
+Conclusion
+
+Cette refactorisation a permis de transformer un code monolithique et difficile à maintenir en un système modulaire et extensible.
+Les bénéfices se sont manifestés lors de l'ajout rapide et efficace de nouvelles fonctionnalités.
+En adoptant une architecture basée sur les stratégies et les principes SOLID, le projet est désormais mieux structuré, plus facile à comprendre et prêt pour des extensions futures.
\ No newline at end of file