Ajoute de toute la doccumentation + remarque d'un erreur impossible a empêcher... Certain (Importer.java et Creer.java) prennent involontairement des minuscule en première lettre ce qui fait qu'il faut les renames sinon ça ne marche pas

Cellules.java

@@ -2,8 +2,8 @@ import java.awt.Color;
 import javax.swing.JComponent;
 import java.awt.Graphics;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class Cellules permet de créer un objet Cellules qui est un JComponent, seulement, on lui donnne de attributs en plus, comme des couleurs
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * ou des coordonnées afin de bien la placer pour faire un Labyrinthe
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -26,10 +26,10 @@ public class Cellules extends JComponent{
     private int ceType;
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Contructeur
-     * @param unPerso On rentre 
+     * @param uneLigne On donne une la ligne dans la quelle la Cellules apparait
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param uneColone On donne une la colone dans la quelle la Cellules apparait
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param type On donne un type (entrée, sortie, couloir, mur) a cette cellules pour pourvoir modifier la grille
      */
     public Cellules(int uneLigne, int uneColone, int type){
         super();
@@ -42,40 +42,29 @@ public class Cellules extends JComponent{
     }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode qui premte d'accéder a la ligne
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public int getLigne(){
         return this.cetteLigne;
     }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode qui premte de renvoyer la colone de la cellule
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public int getColone(){
         return this.cetteColone;
     }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode qui premte de renvoyer le type de la cellule
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public int getType(){
         return this.ceType;
     }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode qui permet de changer le type d'une cellules Mur -> Couloir
-     * @param unPerso On rentre 
+     * @param newType (int) Nouveau type de la cellules
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void setType(int newType){
         if(newType==COULOIR){
@@ -90,10 +79,8 @@ public class Cellules extends JComponent{
     }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode qui permet d'attribuer une nouvelle couleur a la Cellule en fonction de son type
-     * @param unPerso On rentre 
+     * @param peinture (int) On rentre la nouvelle peinture
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void peindre(int peinture){
         if(peinture==COULOIR){
@@ -114,10 +101,9 @@ public class Cellules extends JComponent{
     }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode qui est appelé automatiquement lors d'un apelle de la classe Cellule
-     * @param unPerso On rentre 
+     * Cette méthode à pour but de repeindre notre Cellule 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param g objet graphique 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     @Override
     protected void paintComponent(Graphics g) {

ChoixAlgo.java

@@ -1,8 +1,7 @@
 import javax.swing.*;
 import java.awt.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class choix Algo hérite de Fenetre, cette classe ouvre une fenetre et invite l'utilisateur a choisir un algo et une visualisation
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -13,10 +12,11 @@ public class ChoixAlgo extends Fenetre {
     private int cetteTaille;
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur 
-     * @param unPerso On rentre 
+     * @param uneTaille Taille du lab
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param fenGrille Notre fenetre graphique pour la gérer
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param uneGrille Labyrinthe de boolean pour le parcourir 
+     * @param uneGrilleCell Labyrinthe de Cellules pour le parcourir 
      */
     public ChoixAlgo(int uneTaille, JFrame fenGrille, boolean[][] uneGrille, Cellules[][] uneGrilleCell){
         super();
@@ -34,10 +34,7 @@ public class ChoixAlgo extends Fenetre {
     }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * la méthode void setup permet de mettre la fenetre en place et d'ajouter tous les différents élément dessus
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void setUp(){
         /* ============================= TEXT PRESENTATION =========================*/

ChoixEtTaille.java

@@ -1,8 +1,8 @@
 import javax.swing.*;
 import java.awt.event.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Choix et taille est une méthode qui se repose sur un action Listener, son but est de récupérer la taille de la grille
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * que souhaite créer l'utilisateur, également, ChoixEtTaille récupère le type de grille
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -12,10 +12,10 @@ public class ChoixEtTaille extends JFrame implements ActionListener {
   private ButtonGroup ce_group;
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode constructeur
-     * @param unPerso On rentre 
+     * @param une_frame prend en argument la fenetre précédente pour la fermer
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param un_tfield un_tfield représente un champ de text dans le quel on récuperera la taille saisie 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param group on récupère un group de boutton pour en extraire les valeurs des différents boutons
      */
   public ChoixEtTaille(JFrame une_frame, JTextField un_tfield, ButtonGroup group){
     this.cette_frame = une_frame;
@@ -24,10 +24,9 @@ public class ChoixEtTaille extends JFrame implements ActionListener {
   }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode va créer et éxécuter un objet FenetreRndmGrille ou FenetreVideGrille en fonction des choix de l'utilisateur et
-     * @param unPerso On rentre 
+     * si et seulement si l'utilisateur a appuyer sur un boutons 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param e On rentre 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
   public void actionPerformed(ActionEvent e){
     this.cette_frame.dispose();

Ecriture.java

@@ -1,7 +1,6 @@
 import java.io.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class écriture a pour objectif d'écrire dans un fichier un certain nombre de bits et octets afin de sauvegarder les grilles
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -11,10 +10,10 @@ public class Ecriture {
     private String filePath;
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode constructeur qui va tout écrire dans le fichier 
-     * @param unPerso On rentre 
+     * @param tabBytes Dans ce tableau sont stockés les 5 premier octets a écrire dans le fichier 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param tabOctetsBinaires dans ce String, on a tous les autres bits que l'on écrira en octet dans le fichier 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param chemin c'est le chemin d'accès au fichier pour pouvoir ouvrir un flux d'entrée et donc d'"crire des choses"
      */
     public Ecriture(byte[] tabBytes, String[] tabOctetsBinaires, String chemin) {
         this.tabHeader = tabBytes;

Exporter.java

@@ -1,8 +1,7 @@
 import java.awt.*;
 import javax.swing.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class Exporter est un héritage de Fenetre, cette classe ouvre simplement une interface graphique invitant l'utilisateur a sauvegarder ou non sa grille
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -16,9 +15,11 @@ public class Exporter extends Fenetre{
 
     /**
      * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
-     * @param unPerso On rentre 
+     * @param uneGrille On prend tous les prochain attributs, il ne sont récupérés que pour pouvoir être transmit
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param uneGrilleCell 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param uneTaille 
+     * @param fenetreG 
+     * @param fenetreM
      */
     public Exporter(boolean[][] uneGrille, Cellules[][] uneGrilleCell, int uneTaille, JFrame fenetreG, JFrame fenetreM){
         this.cetteGrille = uneGrille;

Fenetre.java

@@ -1,7 +1,6 @@
 import javax.swing.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class fenetre est une classe qui a simplement pour but de créer une Fenetre, puis attendre que des class hérite d'elle afin d'utiliser sa JFrame
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -9,10 +8,7 @@ public class Fenetre{
     protected JFrame fenetre;
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Contructeur
-     * @param unPerso On rentre un objet de type These qui est l'objet qui va parcourir notre labyrinthe
-     * @param grille grille C'est la grille qui va être parcourue comme le labyrinthe
-     * @param coord Ce sont les coordonnées des portes d'entrées et de sortie 
      */
     public Fenetre() {
         this.fenetre = new JFrame("Creation du programme");
@@ -23,10 +19,7 @@ public class Fenetre{
     }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode a pour but de fermer la fenetre quand on le demande 
-     * @param unPerso On rentre un objet de type These qui est l'objet qui va parcourir notre labyrinthe
-     * @param grille grille C'est la grille qui va être parcourue comme le labyrinthe
-     * @param coord Ce sont les coordonnées des portes d'entrées et de sortie 
      */
     public void closeFrame() {
         this.fenetre.dispose();

FenetreDefSize.java

@@ -2,26 +2,20 @@ import javax.swing.*;
 
 import java.awt.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class FenetreDefSize ouvre une instance graphique, une JFrame qui est la pour que l'utilisateur rentre les informations sur la grille qu'il souhaite faire
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
 public class FenetreDefSize extends Fenetre{
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur qui apelle toutes différentes var de Fenetre via super();
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public FenetreDefSize(){
         super();
     } 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * La méthode MiseEnPlace ne prend pas d'argument, simplement, elle ajoute différents éléments a la fenetre puis l'affiche en true, 
-     * @param unPerso On rentre 
+     * par ailleurs, dans le bas de cette méthode, nous pouvons voir qu'un actionListener relié a ChoixEtTaille est posés sur les bourons 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void MiseEnPlace(){       
         /*============================== ---------------  Fenetre --------------- ==============================*/ 

FenetreImpGrille.java

@@ -1,7 +1,6 @@
 import java.awt.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class FenetreImpGrille a pour but de créer une grille ainsi qu'un tableau de boolean (pour les parcours) a la suite de la lecture d'un fichier 
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -9,14 +8,21 @@ public class FenetreImpGrille extends Fenetre {
     private boolean[][] grille;
     private Cellules[][] grilleCell;
     
+    /**
+     * Constructeur qui fait apelle a la class supérieur : Fenetre
+     */
     public FenetreImpGrille(){   
         super();
     }
+    
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode qui dans un premier temp remplie un tab de bool, puis affiche la grille grace aux cellules et enfin qui propose de choisir un algo de parcours de Labyrinthe
-     * @param unPerso On rentre 
+     * @param taille récupère la taille de notre grille 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param Lentre récupère la ligne de notre entré
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param Centre récupère la Colone de notre entré
+     * @param Lortie récupère la ligne de notre sortie
+     * @param Cortie récupère la Colone de notre sortie
+     * @param tabGrille tableau qui contient tous les états de toutes les cases
      */
     public void ImporterGrille(int taille, int Lentre, int Centre, int Lortie, int Cortie, int[] tabGrille){
         /* ================================================================ Déclaration des variables ============================================================================= */

FenetreInit.java

@@ -1,27 +1,22 @@
 import javax.swing.*;
 import java.awt.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * FenetreInit est la toute première class a hérité de feneètre, elle a pour objectif de récupérer l'informations si l'utilisateur
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * souhaite importer ou creer un grills 
  * @version 1.1
  * @author Matthis Fauvet 
  */
 public class FenetreInit extends Fenetre
 {
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur qui fait apelle a la class hérité : Fenetre 
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public FenetreInit(){   
         super();
     }
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * La méthode Initialisation a seulement pout but de créer une petite fenetre qui demande ce qu'il veut faire a l'utilisateur, 
-     * @param unPerso On rentre 
+     * cette décision est écouter par un ActionListener
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void Initialisation(){        
         GridLayout gestionnaire = new GridLayout(2,1);

FenetreRndmGrille.java

@@ -1,8 +1,8 @@
 import java.awt.*;
 import java.util.Random;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class FenetreRndmGrille a pour but de créer une grille aléatoirement ainsi qu'un tableau de boolean (pour les parcours) (généré aléatoirement également)
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * A la suite de cela, on invite l'utilisateur a modifier la Lab s'il ne le satisfait pas 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -19,10 +19,8 @@ public class FenetreRndmGrille extends Fenetre{
 
     private Modifications modif;
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur qui prend en paramètre la taille donné par l'utilisateur afin de créer un lab de toute piece en se basant sur le random et sa taille
-     * @param unPerso On rentre 
+     * @param taille int qui représente le nomre max de ligne et colone du tableau
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public FenetreRndmGrille(int taille){
         super();
@@ -32,10 +30,9 @@ public class FenetreRndmGrille extends Fenetre{
         this.tabCouleur = new int[] {1, 1};
     }
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * randomGrille est la méthode qui permet de lancer la création et la modifications du lab 
-     * @param unPerso On rentre 
+     * Modification : Ecoute les event
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * Panneau modification : fenetre qui permet de créer / modifier le Lab a notre guise
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void randomGrille(){
         

FenetreVideGrille.java

@@ -1,7 +1,6 @@
 import java.awt.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Class qui met en place une grille totalement vide et c'est donc a l'utilisateur de créer son la à partir de rien 
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -14,11 +13,10 @@ public class FenetreVideGrille extends Fenetre{
     private Cellules[][] grilleCellules;
 
     private Modifications modif;
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Comme pour fenetreRndmGrille, on réupère la taille 
-     * @param unPerso On rentre 
+     * @param taille = taille du lab a créer
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public FenetreVideGrille(int taille){
         super();
@@ -27,12 +25,13 @@ public class FenetreVideGrille extends Fenetre{
         this.grilleCellules = new Cellules[this.taille][this.taille];
         this.tabCouleur = new int[] {0, 0};
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode qui permet de créer un tab vide et qui ajoute les modifications
-     * @param unPerso On rentre 
+     * Modification : Ecoute les event
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * Panneau modification : fenetre qui permet de créer / modifier le Lab a notre guise
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
+    
     public void videGrille(){
         
         this.fenetre.setSize(600, 600);

FileImport.java

@@ -1,22 +1,23 @@
 import javax.swing.*;
 import java.io.File;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La classe FlieImport a pour but d'aller chercher un fichier a ouvrir sur l'ordinateur via un JFileChooser
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
 public class FileImport {
     private String ce_chemin;
 
+    /**
+     * Constructeur ou l'on établit seulement 
+     */
     public FileImport(){
         this.ce_chemin = "";
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * méthode qui va permettre d'ouvrir un explorateur de fichier afin de choisir un fichier.
-     * @param unPerso On rentre 
+     * Cette fonction renvoir le chemin d'accès de ce fichier.
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public String Parcours(){
         JFileChooser fileChooser = new JFileChooser();

GestionChoixAlgo.java

@@ -1,8 +1,7 @@
 import javax.swing.*;
 import java.awt.event.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Cette class a pour but de rediriger le programme vers l'algorithme que l'utilisateur a choisit 
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -18,9 +17,13 @@ public class GestionChoixAlgo extends JFrame implements ActionListener {
   private Cellules[][] cetteGrilleCell;
   /**
      * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
-     * @param unPerso On rentre 
+     * @param uneTaille Taille de notre lab actuel 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param uneFrame Fenetre actuelle récupéré pour la clore quand elle n'est plus utile 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param group0 Récupération de l'algo choisit 
+     * @param group1 Récupération de la visualisation choisit 
+     * @param uneGrille notreLabyrinthe sous forme de tab de boolean
+     * @param grilleCell notreLabyrinthe sous forme de tab de Cellules
+     * @param uneFenetre On récupère la grille où est affiché le lab pour voir si on la ferme ou non (tout dépend de l'algo)
      */
   public GestionChoixAlgo(int uneTaille, JFrame uneFrame, ButtonGroup group0,  ButtonGroup group1, boolean[][] uneGrille, Cellules[][] grilleCell,JFrame uneFenetre){
     this.cetteFrame = uneFrame;
@@ -33,11 +36,11 @@ public class GestionChoixAlgo extends JFrame implements ActionListener {
     this.cetteGrille = uneGrille;
     this.cetteGrilleCell=grilleCell;
   }
+
   /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode, en fonction des JRadioButton sélectionné ou non, va dirigé le programme vers un type d'algo et son parcours précis
-     * @param unPerso On rentre 
+     * important : Cette méthode ne se lance que si et seulement si le bouton a été préssé  
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param e raison de l'événement
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
   public void actionPerformed(ActionEvent e){
     this.cetteFrame.dispose();

GestionExporter.java

@@ -1,8 +1,7 @@
 import java.awt.event.*;
 import javax.swing.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Cette class inclus un ActionListener, elle a pour but de rediriger le programme si l'utilisateur veut ou non sauvegarder sa grille
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -17,11 +16,15 @@ public class GestionExporter implements ActionListener{
     private JFrame frameGrille;
     private JFrame frameModif;
     private JFrame framePopup;
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur 
-     * @param unPerso On rentre 
+     * @param uneGrille on récupère une grille de boolean  
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param uneGrilleCell on récupère une grille de cellules
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param uneTaille on récupère la taille de notre Lab
+     * @param frameG première fenetre qui est celle de la grille
+     * @param frameM Deuxième fenetre qui est celle de la Modifications
+     * @param frameP troisième fenetre qui est la Pop-Up 
      */
     public GestionExporter(boolean[][] uneGrille, Cellules[][] uneGrilleCell , int uneTaille, JFrame frameG, JFrame frameM, JFrame frameP){
         this.cetteGrille=uneGrille;
@@ -32,21 +35,18 @@ public class GestionExporter implements ActionListener{
         this.frameModif = frameM;
         this.framePopup = frameP;
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Lorsque l'on appui sur le bouton Sauvegarer, alors le programme va lancer la procédure d'écriture puis va lancer le choix des algoritme, 
-     * @param unPerso On rentre 
+     * Si l'on clique sur le bouton "passer", alors on ne sauvegarder pas la grille et on passe a la résolutions 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param e event qui permet de choisir la suite su programme
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void actionPerformed(ActionEvent e){
         this.cet_event=e.getActionCommand();
         if (cet_event.equals(this.Reponses1)){
             this.frameModif.dispose();
             this.framePopup.dispose();
-            //outils.PrintGrilleBool(this.cetteGrille, this.cetteTaille);
-
             PreEcriture precriture = new PreEcriture(this.cetteGrille, this.grilleCellules, this.cetteTaille);
-
             ChoixAlgo suite = new ChoixAlgo(this.cetteTaille, this.frameGrille ,this.cetteGrille, this.grilleCellules);
             suite.setUp();
         }

GestionModif.java

@@ -1,8 +1,8 @@
 import java.awt.event.*;
 import javax.swing.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Cette classe est utilisé pendant la modification de grille. En effet, grace a ses ActionListener, cette class a pour objectif de soit passer 
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * a l'écriture ou bien aux algorithmes. ou encore, si l'utilisateur appuie sur quitter, alors le programme entier prend fin.
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -15,11 +15,15 @@ public class GestionModif implements ActionListener{
 
     private JFrame cetteFrameGrille;
     private JFrame cetteFrameModif;
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur
-     * @param unPerso On rentre 
+     * On récupère toutes les donnés que l'on a traité ou modifié pour les utiliser plus tard 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param uneGrille importation d'une grille de boolean
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param uneGrilleCell importation d'une grille de cellules
+     * @param uneTaille on récupère la taille du Lab 
+     * @param frameGrille On récupère la fenetre ou apparaissait le Labyrinthe graphiquement
+     * @param frameModif Fenetre ou l'on choisissait les différentes options de dessin ou de suite.
      */
     public GestionModif(boolean[][] uneGrille, Cellules[][] uneGrilleCell, int uneTaille, JFrame frameGrille, JFrame frameModif){
         this.cetteGrille=uneGrille;
@@ -30,10 +34,8 @@ public class GestionModif implements ActionListener{
         this.cetteFrameModif = frameModif;
     }
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode redirige les actions du programme
-     * @param unPerso On rentre 
+     * @param e
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void actionPerformed(ActionEvent e){
         this.cet_event=e.getActionCommand();

Modifications.java

@@ -1,7 +1,6 @@
 import java.awt.event.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class relai n'est réellement qu'une transition en fonctions des cliques effectué sur la grille et le traitement de ces cliques 
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -9,13 +8,13 @@ public class Modifications implements MouseListener {
     private PanneauModification unPanel;
     private boolean[][] cetteGrille;
     private int[] ceTab;
-
     private ModificationsTab change;
+
     /**
      * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
-     * @param unPerso On rentre 
+     * @param panneauModification On récupère ce tableau pour avoir les valeurs des JButtons
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param grilleTab On récupère la grille de boolean afin de la traiter dans la prochaine class
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param unTab on récupère un tableau qui contient les valeurs Entree et sortie (si les cases sont posé ou non)
      */
     public Modifications(PanneauModification panneauModification, boolean[][] grilleTab, int[] unTab){
         this.unPanel = panneauModification;
@@ -23,22 +22,18 @@ public class Modifications implements MouseListener {
         this.ceTab = unTab;
     }
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Lorque qu'une cellule est clique, alors on lance la modification du tableau de boolean
-     * @param unPerso On rentre 
+     * @param e
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void mouseClicked(MouseEvent e) {
         this.change = new ModificationsTab(this.unPanel, this.cetteGrille, this.ceTab, e);
     }
+
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode permet de renvoyer le tableau des entré et sortie afin de le mettre continuellement a jour.
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public int[] getGateState(){
-        //System.out.println("this.ceTab vaut : [0] : "+this.ceTab[0] + " et this.ceTab vaut : [1] :"+this.ceTab[1]);
         return this.ceTab;
     }
     

ModificationsTab.java

@@ -1,6 +1,6 @@
 import java.awt.event.MouseEvent;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Le principe de cette classe est de, sous certaines conditions, modifier le tableau de boolean afin d'ensuite modifier l'affichage graphique
  * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
@@ -17,11 +17,14 @@ public class ModificationsTab {
     private PanneauModification cePanel;
 
     // -------------------------------------------------------------------------------------------------------------------------------------------------
+    
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Dans cette classe, on récupère la valeur de notre tableau en fontion de la ligne et de la colone de la cellule cliqué, ensuite, on modifie notre tableau de boolean
-     * @param unPerso On rentre 
+     * en metant a true si false et inversement dans le but de changer les mur en couloir etc.
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param panneauModification permet de transferrer cette interface afin de récupérer l'etat des radio boutons 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param grilleTab c'est la grille de true et false
+     * @param unTab tableau simple qui contient les valeurs des entrés et des sorties
+     * @param unEvent permet de récupérer la grille cliqué
      */
     public ModificationsTab(PanneauModification panneauModification, boolean[][] grilleTab, int[] unTab, MouseEvent unEvent){
         this.cetteGrille = grilleTab;
@@ -56,14 +59,4 @@ public class ModificationsTab {
 
         this.rafraichir = new Affichage(notreCellule, panneauModification, unTab, this.cetteGrille[this.cetteLigne][this.cetteColone]);
     }
-    /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
-     */
-    public int[] getGateState(){
-        this.tabEtat = this.rafraichir.getGateState();
-        return this.tabEtat;    
-    }
 }

PanneauModification.java

@@ -1,8 +1,8 @@
 import java.awt.*;
 import javax.swing.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Cette class hérité de Fenetre met en place une  fenetre qui est un panneau avec plusieur options pour modifier le tableau/ la grille
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * ainsi que pour passer a la suite du programme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -18,9 +18,10 @@ public class PanneauModification extends Fenetre {
     private JFrame frameGrille;
     /**
      * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
-     * @param unPerso On rentre 
+     * @param uneGrille Labyrinthe de boolean
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param uneTaille taille du labyrinthe 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param uneGrilleCell grille de Cellules
+     * @param uneFrame fenetre précédente
      */
     public PanneauModification(boolean[][] uneGrille, int uneTaille, Cellules[][] uneGrilleCell, JFrame uneFrame){
         super();
@@ -34,10 +35,7 @@ public class PanneauModification extends Fenetre {
         this.frameGrille = uneFrame;
     }
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode a pour objectif d'ajouté différents élément a fenetre pour tout modifier
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void SetUp(){
         GridLayout gestionnaire = new GridLayout(4,1);

Parcours.java

@@ -1,19 +1,21 @@
 import javax.swing.JOptionPane;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Cette class est une class de parcour de labyrinthe qui se base sur la récurence afin de trouve la sortie le plus vite possible 
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
+
 public class Parcours {
     private int taille;
     private int ceCompteur = 0;
     private Cellules[][] labyrinthe;
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur
-     * @param unPerso On rentre 
+     * @param tableau importation du tableau a parcourir 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param X position Actuelle en X de l'algo
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param Y  position Actuelle en Y de l'algo
+     * @param len taille max du labyrinthe 
      */
     public Parcours(Cellules[][] tableau, int X, int Y, int len){
         this.taille = len;
@@ -22,10 +24,13 @@ public class Parcours {
         this.Parcourir(X, Y);
     }
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode récursive qui fonctionne ainsi :
-     * @param unPerso On rentre 
+     * A chaque fois que l'on va sur une case , on essaie d'aller en bas, sinon a droite, sinon en haut ou alors sinon a gauche 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * si on ne oeut plus aller nulle part, alors on revient a la case précédente en essayant les chemins que l'on avait pas encore essayé
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * a chaque fois que l'on passe sur une case, on la rend non-accessible 
+     * 
+     * @param coordX position Actuelle en X de l'algo
+     * @param coordY position Actuelle en Y de l'algo
      */
     public boolean Parcourir(int coordX, int coordY){
 
@@ -49,11 +54,11 @@ public class Parcours {
         }
         return done;
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * cette méthode permet de renvoyer true si la prochaine case est valable sinon false. 
-     * @param unPerso On rentre 
+     * @param pos_x On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param pos_y c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     private boolean estValide(int pos_x, int pos_y) {
         this.ceCompteur++;

ParcoursManuel.java

@@ -1,26 +1,37 @@
 import javax.swing.JOptionPane;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Cette class est une class de parcour de labyrinthe qui se base sur la récurence afin de trouve la sortie le plus vite possible 
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
+
 public class ParcoursManuel {
     private int taille;
     private int ceCompteur = 0;
     private Cellules[][] labyrinthe;
 
+    /**
+     * Constructeur
+     * @param tableau importation du tableau a parcourir 
+     * @param X position Actuelle en X de l'algo
+     * @param Y  position Actuelle en Y de l'algo
+     * @param len taille max du labyrinthe 
+     */
     public ParcoursManuel(Cellules[][] tableau, int X, int Y, int len){
         this.taille = len;
         this.labyrinthe = tableau;
 
         this.Parcourir(X, Y);
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode récursive qui fonctionne ainsi :
-     * @param unPerso On rentre 
+     * A chaque fois que l'on va sur une case , on essaie d'aller en bas, sinon a droite, sinon en haut ou alors sinon a gauche 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * si on ne oeut plus aller nulle part, alors on revient a la case précédente en essayant les chemins que l'on avait pas encore essayé
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * a chaque fois que l'on passe sur une case, on la rend non-accessible 
+     * 
+     * @param coordX position Actuelle en X de l'algo
+     * @param coordY position Actuelle en Y de l'algo
      */
     public boolean Parcourir(int coordX, int coordY){
 
@@ -44,11 +55,11 @@ public class ParcoursManuel {
         }
         return done;
     }
+    
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * cette méthode permet de renvoyer true si la prochaine case est valable sinon false. Egalement, a chaque fois que l'on passe sur une nouvelle case, on colorie l'ancienne
-     * @param unPerso On rentre 
+     * @param pos_x On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param pos_y c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     private boolean estValide(int pos_x, int pos_y) {
         this.ceCompteur++;

PreEcriture.java

@@ -3,8 +3,8 @@ import java.io.File;
 import javax.swing.JFileChooser;
 import javax.swing.filechooser.FileNameExtensionFilter;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Cette class a pour objectif de préparer tout ce qui va être écrit dans notre fichier
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -22,9 +22,9 @@ public class PreEcriture {
 
     /**
      * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
-     * @param unPerso On rentre 
+     * @param uneGrille Grille de bollean pour les murs  
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param uneGrilleCell grille de Cellules qui contient les Cellules (pour entré et sortie seuelemtn)
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param uneTaille tailles des grilles 
      */
     public PreEcriture(boolean[][] uneGrille, Cellules[][] uneGrilleCell , int uneTaille){
         this.cetteTaille = uneTaille;

Start.java

@@ -1,16 +1,10 @@
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * Start est la class main, c'est celle ci qu'il faut lancer au départ et qui lance tout notre programme 
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
 public class Start {
-    /**
+
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
-     */
     public static void main(String[] args) {
         FenetreInit une_fenetre = new FenetreInit();
         une_fenetre.Initialisation();

These.java

@@ -1,6 +1,6 @@
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * These est une class qui est utilisé par l'algo aléatoire pour parcourir un tableau
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * il faut créer un objet Thesee et lui donner une grille dans laquelle il pourra progrésser
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -16,11 +16,13 @@ public class These {
     private int cetteTaille;
 
     private boolean[][] cetteGrille;
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur
-     * @param unPerso On rentre 
+     * @param x position initiale
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param y position initiale
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param taille taille du tableau que thesee doit parcourir 
+     * @param grille tableau que these devra parcourir
      */
     public These(int x, int y, int taille, boolean[][] grille){
         this.coordX = x;
@@ -28,11 +30,10 @@ public class These {
         this.cetteGrille = grille;
         this.cetteTaille = taille;
     }
+
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode essaie de faire bouger thesee a droite, si c'est possible, thesee bouge et renvoie true, sinon false 
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public boolean goRight(){
         if(coordY+1 < this.cetteTaille){
@@ -44,11 +45,9 @@ public class These {
         }
         return false;
     }
+    
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode essaie de faire bouger thesee en bas, si c'est possible, thesee bouge et renvoie true, sinon false 
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public boolean goDown(){
         if(coordX+1 < this.cetteTaille){
@@ -59,11 +58,9 @@ public class These {
         }
         return false;
     }
+    
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode essaie de faire bouger thesee a gauche, si c'est possible, thesee bouge et renvoie true, sinon false 
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public boolean goLeft(){
         if(coordY-1 >= 0){
@@ -75,11 +72,9 @@ public class These {
         }
         return false;
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode essaie de faire bouger thesee en haut , si c'est possible, thesee bouge et renvoie true, sinon false 
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public boolean goTop(){
         if(coordX-1 >= 0){
@@ -93,11 +88,10 @@ public class These {
     }
 
     /* ======================== regarder ======================== */
+
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode renvoie true si les thesee venait a être en dehors du tab
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public boolean debordementVerticaux(){
         //renvoie true s'il y a débordement sinon false
@@ -106,11 +100,9 @@ public class These {
         }
         return LIBRE;
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode fait regarder son bas a Thesee, thesee renvoie l'etat de la case regardé 
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public boolean lookBot(){
         if(coordY+1 < this.cetteTaille){
@@ -120,11 +112,9 @@ public class These {
         }
         return LIBRE;
     }
+
      /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode fait regarder sa gauche a Thesee, thesee renvoie l'etat de la case regardé 
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public boolean lookLeft(){
         if(coordY+1 < this.cetteTaille){
@@ -134,11 +124,9 @@ public class These {
         }
         return LIBRE;
     }
+    
      /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode fait regarder a Thesee la case au dessus de lui, thesee renvoie l'etat de la case regardé 
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public boolean lookTop(){
         if(coordY+1 < this.cetteTaille){
@@ -151,10 +139,9 @@ public class These {
 
     // Gestion Fin
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Méthode qui regarde si thésée est arrivé a la case de fin
-     * @param unPerso On rentre 
+     * @param finalX Coordonné X de la fin
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param finalY Coordonné X de la fin
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public boolean isArrived(int finalX, int finalY){
         // renvoie un boolean
@@ -166,20 +153,16 @@ public class These {
     }
 
     // Miscelaneous 
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * cette méthode print la position actuelle de These
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public void printPlacement(){
         System.out.println("La position en X vaut : "+coordX+" et en y : "+coordY);
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * cette méthode renvoie la position actuelle de These dans un tab de int[]
-     * @param unPerso On rentre 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public int[] getCoord(){
         int[] coordonnes = new int[2];

creer.java

@@ -1,29 +1,30 @@
 import javax.swing.*;
 import java.awt.event.*;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class Creer se lance si et seuelemnt si l'utilisateur décide de creéer un nouveau labyrinthe (!importer)
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * Ensuite, on doit lancer les classes suivante afin de pouvoir creér ntore Labyrinthe
+ * 
  * @version 1.1
  * @author Matthis Fauvet 
  */
+
 public class Creer implements ActionListener {
     private String cet_event, f_option = "Nouvelle Grille";
     private JFrame cette_frame;
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur 
-     * @param unPerso On rentre 
+     * @param frame_initial On récupère la fenetre précédente pour pouvoir la fermer un peu plus tard
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public Creer(JFrame frame_initial){
         super();
         this.cette_frame=frame_initial;
     }
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode d'active si et seulement si l'utilisateur a cliqué sur "nouvelle grille". Elle permet de créer un objet FenetreDefSize pourprendre en main
-     * @param unPerso On rentre 
+     * la suite du programme 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
+     * @param e on récupère la raison de l'evenement pour comparer les possibilitées
      */
     public void actionPerformed(ActionEvent e){
         this.cet_event=e.getActionCommand();

importer.java

@@ -2,8 +2,10 @@ import java.awt.event.*;
 import javax.swing.JFrame;
 import javax.swing.JOptionPane;
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class importer implémente un Action Listener pour lancer les prochaine partie du programme :
- * pour regarder le parcours qu'emprunte l'algorithme 
+ * permet das un premier temps de laisser l'utilisateur aller chercher le fichier qu'il souhaite importer (FileImport)
+ * Ensuite, le programme va lire ce fichier (Lecture)
+ * Et enfin, il va générer une grille en se basant sur le contenur du fichier
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -17,21 +19,20 @@ public class Importer implements ActionListener {
     int valeur0, valeur1, valeur2, valeur3, valeur4;
   
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Constructeur qui prend en paramètre la fenetre précédente
-     * @param unPerso On rentre 
+     * @param une_frame on récupère la premiere fenetre pour la fermer un peu plus tard 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public Importer(JFrame une_frame){
         this.cette_option="Importer Grille";
         this.cette_frame = une_frame;
     }
+
+
         /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Si l'utilisateur décide d'importer un grille, alors on choisit un fichier, on le lit, on créer un fenetre en se basant dessus.
-     * @param unPerso On rentre 
+     * @param e on prend l'évènement en param afin de le traiter
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
+
     public void actionPerformed(ActionEvent e){
         this.cet_event=e.getActionCommand();
         if(cet_event.equals(this.cette_option)){

outils.java

@@ -1,6 +1,5 @@
 /**
- * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
+ * La class outils ne propose que des méthodes Static qui ont pour but de simplifier certaine action mais aussi d'éviter d'alourdir trop notre code
- * pour regarder le parcours qu'emprunte l'algorithme 
  * @version 1.1
  * @author Matthis Fauvet 
  */
@@ -15,10 +14,8 @@ public class outils {
     }
 
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode a pour objectif de changer l'ordre des elt dans un tableau simple
-     * @param unPerso On rentre 
+     * @param un_tableau tableau de int 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public static int[] reverse(int[] un_tableau) {
         int taille = un_tableau.length;
@@ -31,11 +28,11 @@ public class outils {
         }
         return cette_copie;
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode static a pour objectif de prendre deux tab de int et de n'en faire plus qu'un, de les concaténés
-     * @param unPerso On rentre 
+     * @param first_tab voici notre premier tab 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param tab_to_add voici le code a ajouter 
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public static int[] concatenate(int[] first_tab, int[] tab_to_add){
         int taille = first_tab.length;
@@ -55,11 +52,11 @@ public class outils {
         }
         return tableau_temp;
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode permet de de print un tableau de boolea
-     * @param unPerso On rentre 
+     * @param leTableau Tableau de bollean 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param saTaille sa taille
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public static void PrintGrilleBool(boolean[][] leTableau, int saTaille){
         for(int i=0; i<saTaille; i++){
@@ -70,11 +67,11 @@ public class outils {
         }
         System.out.print("\n ------------ \n FIN \n");
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode permet de de print un tableau de Cellules
-     * @param unPerso On rentre 
+     * @param leTableau Tableau de Cellules 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param saTaille sa taille
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public static void PrintGrilleCell(Cellules[][] leTableau, int saTaille){
         for(int i=0; i<saTaille; i++){
@@ -85,11 +82,11 @@ public class outils {
         }
         System.out.print("\n ------------ \n FIN \n");
     }
+    
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode permet de parcourir un tableau de cellules et renvoie les coord de la porte d'entrée et de la sortie 
-     * @param unPerso On rentre 
+     * @param leTableau Tableau de Cellules 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param saTaille sa taille
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public static int[] ParcoursCell(Cellules[][] leTableau, int saTaille){
         int[] ceTableau = new int[4];
@@ -106,11 +103,10 @@ public class outils {
         }
         return ceTableau;
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode permet de transformer un tableau de int en un tableau de byte[]
-     * @param unPerso On rentre 
+     * @param leTableau Tableau de int 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public static byte[] ConvertToByte(int[] leTableau){
         byte[] taByte = new byte[leTableau.length];
@@ -119,11 +115,12 @@ public class outils {
         }
         return taByte;
     }
+
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode permet de print les elts d'un tableau de int simple
-     * @param unPerso On rentre 
+     * @param leTableau Tableau de int
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param saTaille sa taille
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public static void printInt(int[] leTableau, int saTaille) {
         for(int i=0; i<saTaille;i++){
@@ -131,11 +128,13 @@ public class outils {
         }
         System.out.print("\n");
     }
+
+
+        
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode permet de parcourir un tableau de boolean et affiche chaque elt parcourue 
-     * @param unPerso On rentre 
+     * @param leTableau Tableau de boolean 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param saTaille sa taille
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public static void printBool(boolean[] leTableau, int saTaille) {
         for(int i=0; i<saTaille*saTaille;i++){
@@ -143,11 +142,11 @@ public class outils {
         }
         System.out.print("\n");
     }
+
     /**
-     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
+     * Cette méthode permet de mettre la totalité des elt dans un tableau a double dimension dans un tableau simple
-     * @param unPerso On rentre 
+     * @param leTableau Grille de boolean 
-     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
+     * @param saTaille sa taille
-     * @param coord tableau double dimension qui stock les différentes Cellules.
      */
     public static boolean[] PutToVertical(boolean[][] leTableau, int saTaille){
         boolean[] resultat = new boolean[saTaille*saTaille];
@@ -161,6 +160,11 @@ public class outils {
         return resultat;
     }
 
+    /**
+     * Cette méthode permet de parcourir un tableau de int et renvoie la moyenne des différentes valeur dans le tab
+     * @param leTableau Tableau de Cellules 
+     * @param saTaille sa taille
+     */
     public static int moyenneTabint(int[] leTableau){
         int somme = 0;
         for(int valeur : leTableau){