Ajout de commentaires

code/jeu de la vie/src/model/arbitre/Arbitre.java

@@ -5,21 +5,51 @@ import model.CompteurDeCellule;
 import model.plateau.Plateau;
 import model.cellule.CellState;
 
+/**
+ * @author Yohann Breuil
+ * @author Allan Point
+ */
 public abstract class Arbitre {
 
 	private Plateau plateau;
 	private CompteurDeCellule compteurCell;
 
-	public Arbitre(Plateau plateau) {
+	/**
+	 * @param plateau Plateau à arbitrer
+	 * @throws IllegalArgumentException Lève une exception si le plateau est null
+	 */
+	public Arbitre(Plateau plateau) throws IllegalArgumentException {
+		if(plateau == null){
+			throw new IllegalArgumentException("Le plateau ne doit pat être null");
+		}
 		this.plateau = plateau;
 		compteurCell = new CompteurDeCellule();
 	}
+
+	/**
+	 *
+	 * @return Le plateau en cours d'arbitrage
+	 */
 	public Plateau getPlateau(){
 		return plateau;
 	}
 
+	/**
+	 *
+	 * @return Le compteur de cellule du jeu
+	 * @see CompteurDeCellule
+	 */
 	protected CompteurDeCellule getCompteurCell(){
 		return compteurCell;
 	}
+
+	/**
+	 *
+	 * @param x Coordonée x de la cellule à checker
+	 * @param y Coordonée y de la cellule à checker
+	 * @param reference Toutes les cellules qui était vivantes au début du tour et qui servent donc de references
+	 * @return L'état de la cellule au prochain tours
+	 * @see CellState
+	 */
 	public abstract CellState verifierChangementCellules(int x, int y, CellulesVivantes reference);
 }

code/jeu de la vie/src/model/arbitre/ArbitreConwayStyle.java

@@ -5,12 +5,28 @@ import model.CellulesVivantes;
 import model.plateau.Plateau;
 import model.cellule.CellState;
 
+/**
+ * @author Yohann Breuil
+ * @author Allan Point
+ */
 public class ArbitreConwayStyle extends Arbitre{
 
+	/**
+	 *
+	 * @param plateau Plateau à arbitrer
+	 * @see Arbitre
+	 */
 	public ArbitreConwayStyle(Plateau plateau) {
 		super(plateau);
 	}
 
+	/**
+	 *
+	 * @param x Coordonée x de la cellule à checker
+	 * @param y Coordonée y de la cellule à checker
+	 * @param reference Toutes les cellules qui était vivantes au début du tour et qui servent donc de references
+	 * @return L'état de la cellule au prohain tour
+	 */
 	@Override
 	public CellState verifierChangementCellules(int x, int y, CellulesVivantes reference) {
 		if(verifierNaissance(x, y, reference)) {
@@ -22,6 +38,13 @@ public class ArbitreConwayStyle extends Arbitre{
 		return reference.getAt(x, y) != null ? CellState.LIVE : CellState.DIE;
 	}
 
+	/**
+	 *
+	 * @param x Coordonée x de la cellule à checker
+	 * @param y Coordonée y de la cellule à checker
+	 * @param reference Toutes les cellules qui était vivantes au début du tour et qui servent donc de references
+	 * @return True si la cellule doit naître. Sinon false
+	 */
 	private boolean verifierNaissance(int x, int y, CellulesVivantes reference) {
 		int cpt = getCompteurCell().compteNombreCellulesAutour(x, y, reference);
 		if(cpt == 3 && !getPlateau().getCell(x, y).isAlive()) {
@@ -29,7 +52,13 @@ public class ArbitreConwayStyle extends Arbitre{
 		}
 		return false;
 	}
-
+	/**
+	 *
+	 * @param x Coordonée x de la cellule à checker
+	 * @param y Coordonée y de la cellule à checker
+	 * @param reference Toutes les cellules qui était vivantes au début du tour et qui servent donc de references
+	 * @return True si la cellule doit mourir. Sinon false
+	 */
 	private boolean verifierMort(int x, int y, CellulesVivantes reference) {
 		int cpt = getCompteurCell().compteNombreCellulesAutour(x, y, reference);
 		if(!(cpt == 2 || cpt == 3) && getPlateau().getCell(x, y).isAlive()) {

code/jeu de la vie/src/model/boucleDeJeu/BoucleDeJeu30FPS.java

@@ -4,11 +4,19 @@ package model.boucleDeJeu;
 import model.boucleDeJeu.observer.ObservableBDJ;
 
 import java.util.LinkedList;
-
+/**
+ * Boucle de jeu qui notifit tout les 33ms pour avoir 60 Image Par Seconde dans un thread (fils d'execution) séparé.
+ * @author Yohann Breui
+ * @author Allan Point
+ */
 public class BoucleDeJeu30FPS extends ObservableBDJ implements IBoucleDeJeu {
 	public BoucleDeJeu30FPS(){
 		setObserveurs(new LinkedList<>());
 	}
+
+	/**
+	 * Déffinition du comportement de la boucle de jeu pour le thread
+	 */
 	@Override
 	public void run()
 	{
@@ -18,14 +26,17 @@ public class BoucleDeJeu30FPS extends ObservableBDJ implements IBoucleDeJeu {
 				beep();
 			}
 
-			// Gestion des exceptions : si le processus à été intérompu pendant le sleep, on le log.
+			// Gestion des exceptions : si le processus à été intérompu pendant le sleep, on arrete la boucle.
 			catch (InterruptedException e)
 			{
-				return;
+				break;
 			}
 		}
 	}
 
+	/**
+	 * Notifier les abonnés
+	 */
 	public void beep() {
 		notifier();
 	}

code/jeu de la vie/src/model/boucleDeJeu/BoucleDeJeu5FPS.java

@@ -4,10 +4,19 @@ import model.boucleDeJeu.observer.ObservableBDJ;
 
 import java.util.LinkedList;
 
+/**
+ * Boucle de jeu qui notifit tout les 200ms pour avoir 5 Image Par Seconde dans un thread (fils d'execution) séparé.
+ * @author Yohann Breui
+ * @author Allan Point
+ */
 public class BoucleDeJeu5FPS extends ObservableBDJ implements IBoucleDeJeu {
 		public BoucleDeJeu5FPS(){
 			setObserveurs(new LinkedList<>());
 		}
+
+	/**
+	 * Déffinition du comportement de la boucle de jeu pour le thread
+	 */
 	@Override
 		public void run()
 		{
@@ -17,14 +26,17 @@ public class BoucleDeJeu5FPS extends ObservableBDJ implements IBoucleDeJeu {
 					beep();
 				}
 
-				// Gestion des exceptions : si le processus à été intérompu pendant le sleep, on le log.
+				// Gestion des exceptions : si le processus à été intérompu pendant le sleep, on arrete la boucle.
 				catch (InterruptedException e)
 				{
-					return;
+					break;
 				}
 			}
 		}
 
+	/**
+	 * Notifier les abonnés
+	 */
 	public void beep() {
 			notifier();
 		}

code/jeu de la vie/src/model/boucleDeJeu/IBoucleDeJeu.java

@@ -1,3 +1,8 @@
 package model.boucleDeJeu;
 
+/**
+ * Perrmet d'avoir une boucle de jeu Runnable dans un thread
+ * @author Yohann Breuil
+ * @author Allan Point
+ */
 public interface IBoucleDeJeu extends Runnable {}

code/jeu de la vie/src/model/boucleDeJeu/observer/ObservableBDJ.java

@@ -4,8 +4,20 @@ import javafx.application.Platform;
 
 import java.util.List;
 
+/**
+ * @author Yohann Breuil
+ * @author Allan Point
+ */
 public abstract class ObservableBDJ {
+	/**
+	 * Liste des observeurs de la boucle de jeu. Cette liste servira à notifier les abonnés de la boucle de jeu
+	 */
 	private List<ObserverBDJ> observeurs;
+
+	/**
+	 *
+	 * @return Les observeur de la boucle observée
+	 */
 	protected List<ObserverBDJ> getObserveurs(){
 		return observeurs;
 	}
@@ -13,18 +25,27 @@ public abstract class ObservableBDJ {
 	protected void setObserveurs(List<ObserverBDJ> valeur){
 		observeurs = valeur;
 	}
+
+	/**
+	 * Permet de s'abonner  l'observable
+	 * @param o Observateur qui veut s'abboner
+	 */
 	public void attacher(ObserverBDJ o) {
 		observeurs.add(o);
 	}
 
-	public void detacher(Object o) throws IllegalArgumentException{
+	/**
-		if(o.getClass() != ObserverBDJ.class) {
+	 * Permet de se déabonner de la liste de notification de la boucle.
-			throw new IllegalArgumentException("Imposible de détacher autre chose qu'un observer");
+	 * @param o Observateur qui veut s'abbonner
-		}
+	 */
+	public void detacher(ObserverBDJ o){
 		observeurs.remove(o);
 	}
 
-	public void notifier() {
+	/**
+	 * Permet de notifier les abonnés de la boucle de jeu
+	 */
+	protected void notifier() {
 		for (ObserverBDJ observeur : observeurs) {
 			Platform.runLater(()->observeur.update());
 		}

code/jeu de la vie/src/model/boucleDeJeu/observer/ObserverBDJ.java

@@ -1,5 +1,13 @@
 package model.boucleDeJeu.observer;
 
+/**
+ * Permet d'obbserver une boucle de jeu
+ * @author Yohann Breuil
+ * @author Allan Point
+ */
 public interface ObserverBDJ {
+	/**
+	 * Réaction en cas de notification
+	 */
 	void update();
 }

code/jeu de la vie/src/model/cellule/CellState.java

@@ -1,7 +1,21 @@
 package model.cellule;
 
+/**
+ * Tout les etats possible pour la manipulation de cellules
+ */
 public enum CellState {
+	/**
+	 * La cellule est vivante
+	 */
 	LIVE,
+
+	/**
+	 * La cellule est morte ou meur
+	 */
 	DIE,
+
+	/**
+	 * La cellule née
+	 */
 	BIRTH
 }

code/jeu de la vie/src/model/cellule/Cellule.java

@@ -6,22 +6,40 @@ import javafx.scene.paint.Paint;
 import model.cellule.observer.ObservableCellule;
 
 /**
- *
+ * Classe métier représentant une cellule
  */
 public class Cellule extends ObservableCellule {
+    /**
+     * Position de la cellule
+     * @see Position
+     */
     private Position position;
-    private BooleanProperty alive;
 
+    /**
+     * État de la cellule
+     */
+    private boolean alive;
+
+    /**
+     * TODO: Faire un poid mouche pour séparé les partis commune des cellules (livingColor)
+     * Permet d'avoir une propriété qui représente la coulleur de toutes les cellules vivantes
+     */
     private static ObjectProperty<Color> livingColor = new SimpleObjectProperty<>();
         public Color getLivingColor() { return livingColor.get(); }
         public void setLivingColor(Color color) { livingColor.set(color); }
         public static ObjectProperty<Color> livingColorProperty() { return livingColor; }
 
+    /**
+     * Permet d'avoir une propriété qui représente la coulleur actuel d'une cellule en fonction de son etat
+     */
     private ObjectProperty<Paint> activeColor = new SimpleObjectProperty<>();
         public Paint getActiveColor() { return activeColor.get(); }
         public void setActiveColor(Color color) { activeColor.set(color); }
         public Property<Paint> activeColorProperty() { return activeColor; }
 
+    /**
+     * Couleur des cellules mortes
+     */
     private Color deathColor;
 
     /**
@@ -34,20 +52,14 @@ public class Cellule extends ObservableCellule {
         deathColor = Color.BLACK;
         activeColorProperty().setValue(deathColor);
         position = new Position(x,y);
-        alive = new SimpleBooleanProperty(false);
+        alive = false;
     }
 
     /**
      *
      * @return état de la cellule (vivante ou morte)
      */
-    public Boolean isAlive() { return alive.get(); }
+    public Boolean isAlive() { return alive; }
-
-    /**
-     *
-     * @return
-     */
-    public ReadOnlyBooleanProperty aliveProperty() { return alive; }
 
     /**
      *
@@ -55,7 +67,7 @@ public class Cellule extends ObservableCellule {
      */
     public void setAlive(Boolean alive) {
         setActiveColor(alive ? (Color) getLivingColor() : deathColor);
-        this.alive.set(alive);
+        this.alive = alive;
         notifier(this);
     }
 
@@ -80,6 +92,6 @@ public class Cellule extends ObservableCellule {
         return false;
     }
     public void inverseAlive(){
-        setAlive(!alive.get());
+        setAlive(!alive);
     }
 }

code/jeu de la vie/src/model/cellule/créateur/CreateurCellule.java

@@ -10,10 +10,28 @@ import model.cellule.Cellule;
 import java.util.LinkedList;
 import java.util.List;
 
+/**
+ * Permet de créer des cellules de manières sécurisé et standardiser
+ * @author Yohann Breuil
+ * @author Allan Point
+ */
 public class CreateurCellule implements ICreateurCellule {
+	/**
+	 * Nombre de colones à créer
+	 */
 	private int w;
+
+	/**
+	 * Nombre de ligne à créer
+	 */
 	private int h;
 
+	/**
+	 *
+	 * @param w Nombre de colones. Doit être supperieur ou égal à 0.
+	 * @param h Nombre de lignes. Doit être supperieur ou égal à 0.
+	 * @throws IllegalArgumentException Si w ou h sont strictement inferieur à 0.
+	 */
 	public CreateurCellule(int w, int h) throws IllegalArgumentException{
 		if(w<0 || h<0){
 			throw new IllegalArgumentException("La longueur et la largeur doivent être supperieur à 0");
@@ -21,10 +39,23 @@ public class CreateurCellule implements ICreateurCellule {
 		this.w = w;
 		this.h = h;
 	}
+
+	/**
+	 * Créer des cellules selon les dimentions précisé dans le constructeur.
+	 * @param observer Permet d'abonner un objet CellulesVivantes à toute les cellules.
+	 * @return Une liste observable pour fxml avec toutes les cellules standardisées  .
+	 */
 	public ListProperty<List<Cellule>> creerCellules(CellulesVivantes observer){
 		return creerCellules(w, h, observer);
 	}
 
+	/**
+	 * Créer des cellules.
+	 * @param colone Nombre de colones à créer.
+	 * @param ligne Nombre de lignes à créer.
+	 * @param observer Permet d'abonner un objet CellulesVivantes à toute les cellules.
+	 * @return Une liste observable pour fxml avec toutes les cellules standardisées.
+	 */
 	public ListProperty<List<Cellule>> creerCellules(int colone, int ligne, CellulesVivantes observer){
 		ObservableList<List<Cellule>> cellsInit = FXCollections.observableArrayList();
 		ListProperty<List<Cellule>> cells = new SimpleListProperty<>(cellsInit);
@@ -41,12 +72,17 @@ public class CreateurCellule implements ICreateurCellule {
 		}
 		return cells;
 	}
+
+	/**
+	 * Créer une ligne de cellule
+	 * @param ligne nombre de ligne à créer
+	 * @return Les lignes avec les cellules.
+	 */
 	public List<Cellule> creerLigneCellule(int ligne){
 		List<Cellule> cells = new LinkedList<>();
 		for(int i=0; i<ligne; ++i){
 			cells.add(new Cellule(i, ligne));
 		}
-		++h;
 		return cells;
 	}
 }

code/jeu de la vie/src/model/cellule/créateur/ICreateurCellule.java

@@ -5,6 +5,17 @@ import model.cellule.Cellule;
 
 import java.util.List;
 
+/**
+ * Couche d'abstraction de la création des cellules
+ * @author Yohann Breil
+ * @author Allan Point
+ */
 public interface ICreateurCellule {
+
+	/**
+	 * Créer des cellules selon les dimentions précisé dans le constructeur.
+	 * @param observer Permet d'abonner un objet CellulesVivantes à toute les cellules.
+	 * @return Une liste observable pour fxml avec toutes les cellules standardisées  .
+	 */
 	List<List<Cellule>> creerCellules(CellulesVivantes observer);
 }

code/jeu de la vie/src/model/cellule/observer/ObservableCellule.java

@@ -4,7 +4,15 @@ import model.cellule.Cellule;
 
 import java.util.*;
 
+/**
+ * Permet à une cellule d'être observée
+ * @author Yohann Breil
+ * @author Allan Point
+ */
 public abstract class ObservableCellule {
+	/**
+	 * Liste des observeurs de la boucle de jeu. Cette liste servira à notifier les abonnés de la boucle de jeu
+	 */
 	List<ObserverCellule> observeurs;
 
 	public ObservableCellule(){
@@ -14,7 +22,7 @@ public abstract class ObservableCellule {
 	/**
 	 *
 	 * @param o observeur à attacher
-	 * @throws IllegalArgumentException
+	 * @throws IllegalArgumentException L'observeur ne peut pas être null
 	 */
 	public void attacher(ObserverCellule o) throws  IllegalArgumentException{
 		if(o == null){
@@ -26,7 +34,7 @@ public abstract class ObservableCellule {
 	/**
 	 *
 	 * @param o observeur à détacher
-	 * @throws IllegalArgumentException
+	 * @throws IllegalArgumentException L'observer ne peut pas être null
 	 */
 	public void detacher(ObserverCellule o) throws IllegalArgumentException{
 		if(o == null){
@@ -36,7 +44,7 @@ public abstract class ObservableCellule {
 	}
 
 	/**
-	 *
+	 * Permet de notifier les abonnés de la boucle de jeu
 	 */
 	public void notifier(Cellule cellule) {
 		for (ObserverCellule observeur : observeurs) {

code/jeu de la vie/src/model/cellule/observer/ObserverCellule.java

@@ -2,6 +2,14 @@ package model.cellule.observer;
 
 import model.cellule.Cellule;
 
+/**
+ * Permet d'obbserver une boucle de jeu
+ * @author Yohann Breuil
+ * @author Allan Point
+ */
 public interface ObserverCellule {
+	/**
+	 * Réaction en cas de notification
+	 */
 	void update(Cellule cellule);
 }