diff --git a/Cellules.java b/Cellules.java index 6046417..2392cb3 100644 --- a/Cellules.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 + * 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 - * @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. + * Contructeur + * @param uneLigne On donne une la ligne dans la quelle la Cellules apparait + * @param uneColone On donne une la colone dans la quelle la Cellules apparait + * @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 - * @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. + * Méthode qui premte d'accéder a la ligne */ public int getLigne(){ return this.cetteLigne; } /** - * 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. + * Méthode qui premte de renvoyer la colone de la cellule */ public int getColone(){ return 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. + * Méthode qui premte de renvoyer le type de la cellule */ public int getType(){ return this.ceType; } /** - * 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. + * Méthode qui permet de changer le type d'une cellules Mur -> Couloir + * @param newType (int) Nouveau type de la 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 - * @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. + * Méthode qui permet d'attribuer une nouvelle couleur a la Cellule en fonction de son type + * @param peinture (int) On rentre la nouvelle peinture */ 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 - * @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. + * Méthode qui est appelé automatiquement lors d'un apelle de la classe Cellule + * Cette méthode à pour but de repeindre notre Cellule + * @param g objet graphique */ @Override protected void paintComponent(Graphics g) { diff --git a/ChoixAlgo.java b/ChoixAlgo.java index c32772a..db56d6d 100644 --- a/ChoixAlgo.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * La class choix Algo hérite de Fenetre, cette classe ouvre une fenetre et invite l'utilisateur a choisir un algo et une visualisation * @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 - * @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. + * Constructeur + * @param uneTaille Taille du lab + * @param fenGrille Notre fenetre graphique pour la gérer + * @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 - * @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. + * la méthode void setup permet de mettre la fenetre en place et d'ajouter tous les différents élément dessus */ public void setUp(){ /* ============================= TEXT PRESENTATION =========================*/ diff --git a/ChoixEtTaille.java b/ChoixEtTaille.java index 94a67cb..730d7d5 100644 --- a/ChoixEtTaille.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 + * 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 - * @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. + * Méthode constructeur + * @param une_frame prend en argument la fenetre précédente pour la fermer + * @param un_tfield un_tfield représente un champ de text dans le quel on récuperera la taille saisie + * @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 - * @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. + * Cette méthode va créer et éxécuter un objet FenetreRndmGrille ou FenetreVideGrille en fonction des choix de l'utilisateur et + * si et seulement si l'utilisateur a appuyer sur un boutons + * @param e On rentre */ public void actionPerformed(ActionEvent e){ this.cette_frame.dispose(); diff --git a/Ecriture.java b/Ecriture.java index dd1493f..27a5471 100644 --- a/Ecriture.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * La class écriture a pour objectif d'écrire dans un fichier un certain nombre de bits et octets afin de sauvegarder les grilles * @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 - * @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. + * Méthode constructeur qui va tout écrire dans le fichier + * @param tabBytes Dans ce tableau sont stockés les 5 premier octets a écrire dans le fichier + * @param tabOctetsBinaires dans ce String, on a tous les autres bits que l'on écrira en octet dans le fichier + * @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; diff --git a/Exporter.java b/Exporter.java index 786323f..3a40496 100644 --- a/Exporter.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 * @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 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 uneGrille On prend tous les prochain attributs, il ne sont récupérés que pour pouvoir être transmit + * @param uneGrilleCell + * @param uneTaille + * @param fenetreG + * @param fenetreM */ public Exporter(boolean[][] uneGrille, Cellules[][] uneGrilleCell, int uneTaille, JFrame fenetreG, JFrame fenetreM){ this.cetteGrille = uneGrille; diff --git a/Fenetre.java b/Fenetre.java index fccdb4d..e3352da 100644 --- a/Fenetre.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 * @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 - * @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 + * Contructeur */ 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 - * @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 + * Cette méthode a pour but de fermer la fenetre quand on le demande */ public void closeFrame() { this.fenetre.dispose(); diff --git a/FenetreDefSize.java b/FenetreDefSize.java index 503ab24..144da63 100644 --- a/FenetreDefSize.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 * @version 1.1 * @author Matthis Fauvet */ public class FenetreDefSize extends Fenetre{ /** - * 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. + * Constructeur qui apelle toutes différentes var de Fenetre via super(); */ public FenetreDefSize(){ super(); } /** - * 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. + * La méthode MiseEnPlace ne prend pas d'argument, simplement, elle ajoute différents éléments a la fenetre puis l'affiche en true, + * par ailleurs, dans le bas de cette méthode, nous pouvons voir qu'un actionListener relié a ChoixEtTaille est posés sur les bourons */ public void MiseEnPlace(){ /*============================== --------------- Fenetre --------------- ==============================*/ diff --git a/FenetreImpGrille.java b/FenetreImpGrille.java index 038ed8d..d543529 100644 --- a/FenetreImpGrille.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 * @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 - * @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. + * 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 taille récupère la taille de notre grille + * @param Lentre récupère la ligne de notre entré + * @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 ============================================================================= */ diff --git a/FenetreInit.java b/FenetreInit.java index b2193c7..0fa436f 100644 --- a/FenetreInit.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 + * 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 - * @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. + * Constructeur qui fait apelle a la class hérité : Fenetre */ public FenetreInit(){ super(); } /** - * 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. + * La méthode Initialisation a seulement pout but de créer une petite fenetre qui demande ce qu'il veut faire a l'utilisateur, + * cette décision est écouter par un ActionListener */ public void Initialisation(){ GridLayout gestionnaire = new GridLayout(2,1); diff --git a/FenetreRndmGrille.java b/FenetreRndmGrille.java index be7eec0..069b11d 100644 --- a/FenetreRndmGrille.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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) + * 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 - * @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. + * 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 taille int qui représente le nomre max de ligne et colone du tableau */ 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 - * @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. + * randomGrille est la méthode qui permet de lancer la création et la modifications du lab + * Modification : Ecoute les event + * Panneau modification : fenetre qui permet de créer / modifier le Lab a notre guise */ public void randomGrille(){ diff --git a/FenetreVideGrille.java b/FenetreVideGrille.java index 6dcca72..4f9142d 100644 --- a/FenetreVideGrille.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * Class qui met en place une grille totalement vide et c'est donc a l'utilisateur de créer son la à partir de rien * @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 - * @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. + * Comme pour fenetreRndmGrille, on réupère la taille + * @param taille = taille du lab a créer */ 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 - * @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. + * Méthode qui permet de créer un tab vide et qui ajoute les modifications + * Modification : Ecoute les event + * Panneau modification : fenetre qui permet de créer / modifier le Lab a notre guise */ + public void videGrille(){ this.fenetre.setSize(600, 600); diff --git a/FileImport.java b/FileImport.java index 965f999..10592a9 100644 --- a/FileImport.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * La classe FlieImport a pour but d'aller chercher un fichier a ouvrir sur l'ordinateur via un JFileChooser * @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 - * @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. + * méthode qui va permettre d'ouvrir un explorateur de fichier afin de choisir un fichier. + * Cette fonction renvoir le chemin d'accès de ce fichier. */ public String Parcours(){ JFileChooser fileChooser = new JFileChooser(); diff --git a/GestionChoixAlgo.java b/GestionChoixAlgo.java index 03c1de2..df544bc 100644 --- a/GestionChoixAlgo.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * Cette class a pour but de rediriger le programme vers l'algorithme que l'utilisateur a choisit * @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 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 uneTaille Taille de notre lab actuel + * @param uneFrame Fenetre actuelle récupéré pour la clore quand elle n'est plus utile + * @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; @@ -32,12 +35,12 @@ public class GestionChoixAlgo extends JFrame implements ActionListener { this.frameGrille=uneFenetre; this.cetteGrille = uneGrille; this.cetteGrilleCell=grilleCell; - } + } + /** - * 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. + * 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 + * important : Cette méthode ne se lance que si et seulement si le bouton a été préssé + * @param e raison de l'événement */ public void actionPerformed(ActionEvent e){ this.cetteFrame.dispose(); diff --git a/GestionExporter.java b/GestionExporter.java index 80b4600..dcd3678 100644 --- a/GestionExporter.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * Cette class inclus un ActionListener, elle a pour but de rediriger le programme si l'utilisateur veut ou non sauvegarder sa grille * @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 - * @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. + * Constructeur + * @param uneGrille on récupère une grille de boolean + * @param uneGrilleCell on récupère une grille de 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 - * @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. + * 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, + * Si l'on clique sur le bouton "passer", alors on ne sauvegarder pas la grille et on passe a la résolutions + * @param e event qui permet de choisir la suite su programme */ 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(); } diff --git a/GestionModif.java b/GestionModif.java index 360451c..00e8c5c 100644 --- a/GestionModif.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * Cette classe est utilisé pendant la modification de grille. En effet, grace a ses ActionListener, cette class a pour objectif de soit passer + * 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 - * @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. + * Constructeur + * On récupère toutes les donnés que l'on a traité ou modifié pour les utiliser plus tard + * @param uneGrille importation d'une grille de boolean + * @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 - * @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. + * Cette méthode redirige les actions du programme + * @param e */ public void actionPerformed(ActionEvent e){ this.cet_event=e.getActionCommand(); diff --git a/Modifications.java b/Modifications.java index 27e86ec..015e784 100644 --- a/Modifications.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * La class relai n'est réellement qu'une transition en fonctions des cliques effectué sur la grille et le traitement de ces cliques * @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 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 panneauModification On récupère ce tableau pour avoir les valeurs des JButtons + * @param grilleTab On récupère la grille de boolean afin de la traiter dans la prochaine class + * @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 - * @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. + * Lorque qu'une cellule est clique, alors on lance la modification du tableau de boolean + * @param e */ 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 - * @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. + * Cette méthode permet de renvoyer le tableau des entré et sortie afin de le mettre continuellement a jour. */ public int[] getGateState(){ - //System.out.println("this.ceTab vaut : [0] : "+this.ceTab[0] + " et this.ceTab vaut : [1] :"+this.ceTab[1]); return this.ceTab; } diff --git a/ModificationsTab.java b/ModificationsTab.java index c5a9c7a..aa0b603 100644 --- a/ModificationsTab.java +++ b/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 - * @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. + * 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 + * en metant a true si false et inversement dans le but de changer les mur en couloir etc. + * @param panneauModification permet de transferrer cette interface afin de récupérer l'etat des radio boutons + * @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; - } } diff --git a/PanneauModification.java b/PanneauModification.java index 5b6bab4..d5cb1c1 100644 --- a/PanneauModification.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * Cette class hérité de Fenetre met en place une fenetre qui est un panneau avec plusieur options pour modifier le tableau/ la grille + * 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 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 uneGrille Labyrinthe de boolean + * @param uneTaille taille du labyrinthe + * @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 - * @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. + * Cette méthode a pour objectif d'ajouté différents élément a fenetre pour tout modifier */ public void SetUp(){ GridLayout gestionnaire = new GridLayout(4,1); diff --git a/Parcours.java b/Parcours.java index bf07dea..ed04578 100644 --- a/Parcours.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 * @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 - * @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. + * 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 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 - * @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. + * Méthode récursive qui fonctionne ainsi : + * 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 + * 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é + * 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 - * @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. + * cette méthode permet de renvoyer true si la prochaine case est valable sinon false. + * @param pos_x On rentre + * @param pos_y c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir */ private boolean estValide(int pos_x, int pos_y) { this.ceCompteur++; diff --git a/ParcoursManuel.java b/ParcoursManuel.java index bb62db8..655cde0 100644 --- a/ParcoursManuel.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 * @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 - * @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. + * Méthode récursive qui fonctionne ainsi : + * 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 + * 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é + * 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 - * @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. + * 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 pos_x On rentre + * @param pos_y c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir */ private boolean estValide(int pos_x, int pos_y) { this.ceCompteur++; diff --git a/PreEcriture.java b/PreEcriture.java index e2fad36..70de62c 100644 --- a/PreEcriture.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * Cette class a pour objectif de préparer tout ce qui va être écrit dans notre fichier + * * @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 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 uneGrille Grille de bollean pour les murs + * @param uneGrilleCell grille de Cellules qui contient les Cellules (pour entré et sortie seuelemtn) + * @param uneTaille tailles des grilles */ public PreEcriture(boolean[][] uneGrille, Cellules[][] uneGrilleCell , int uneTaille){ this.cetteTaille = uneTaille; diff --git a/Start.java b/Start.java index baf9262..3d06fed 100644 --- a/Start.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * Start est la class main, c'est celle ci qu'il faut lancer au départ et qui lance tout notre programme * @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(); diff --git a/These.java b/These.java index e65ef70..c729a94 100644 --- a/These.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * These est une class qui est utilisé par l'algo aléatoire pour parcourir un tableau + * 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 - * @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. + * Constructeur + * @param x position initiale + * @param y position initiale + * @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 - * @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. + * Cette méthode essaie de faire bouger thesee a droite, si c'est possible, thesee bouge et renvoie true, sinon false */ 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 - * @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. + * Cette méthode essaie de faire bouger thesee en bas, si c'est possible, thesee bouge et renvoie true, sinon false */ 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 - * @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. + * Cette méthode essaie de faire bouger thesee a gauche, si c'est possible, thesee bouge et renvoie true, sinon false */ 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 - * @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. + * Cette méthode essaie de faire bouger thesee en haut , si c'est possible, thesee bouge et renvoie true, sinon false */ 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 - * @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. + * Cette méthode renvoie true si les thesee venait a être en dehors du tab */ 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 - * @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. + * Cette méthode fait regarder son bas a Thesee, thesee renvoie l'etat de la case regardé */ 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 - * @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. + + /** + * Cette méthode fait regarder sa gauche a Thesee, thesee renvoie l'etat de la case regardé */ 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 - * @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. + + /** + * Cette méthode fait regarder a Thesee la case au dessus de lui, thesee renvoie l'etat de la case regardé */ 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 - * @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. + * Méthode qui regarde si thésée est arrivé a la case de fin + * @param finalX Coordonné X de la fin + * @param finalY Coordonné X de la fin */ 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 - * @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. + * cette méthode print la position actuelle de These */ 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 - * @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. + * cette méthode renvoie la position actuelle de These dans un tab de int[] */ public int[] getCoord(){ int[] coordonnes = new int[2]; diff --git a/creer.java b/creer.java index a63f9da..717d4cb 100644 --- a/creer.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * La class Creer se lance si et seuelemnt si l'utilisateur décide de creéer un nouveau labyrinthe (!importer) + * 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 - * @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. + * Constructeur + * @param frame_initial On récupère la fenetre précédente pour pouvoir la fermer un peu plus tard */ public Creer(JFrame frame_initial){ super(); this.cette_frame=frame_initial; } /** - * 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. + * 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 + * la suite du programme + * + * @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(); diff --git a/importer.java b/importer.java index 50c0310..37ac677 100644 --- a/importer.java +++ b/importer.java @@ -2,67 +2,68 @@ 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 - * pour regarder le parcours qu'emprunte l'algorithme + * La class importer implémente un Action Listener pour lancer les prochaine partie du programme : + * 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 */ public class Importer implements ActionListener { - String cette_option; - String cet_event; - String ce_chemin; - JFrame cette_frame; - Lecture cette_lecture; - FenetreImpGrille cette_fenetre; - int valeur0, valeur1, valeur2, valeur3, valeur4; + String cette_option; + String cet_event; + String ce_chemin; + JFrame cette_frame; + Lecture cette_lecture; + FenetreImpGrille cette_fenetre; + int valeur0, valeur1, valeur2, valeur3, valeur4; - /** - * 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. + /** + * Constructeur qui prend en paramètre la fenetre précédente + * @param une_frame on récupère la premiere fenetre pour la fermer un peu plus tard */ - 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 - * @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 actionPerformed(ActionEvent e){ - this.cet_event=e.getActionCommand(); - if(cet_event.equals(this.cette_option)){ - //System.out.println("Importation de la grille"); - - /*cherche le chemin du fichier */ - FileImport un_test = new FileImport(); - this.ce_chemin = un_test.Parcours(); - - if(this.ce_chemin == ""){ - JOptionPane.showMessageDialog(null, "Aucun fichier n'a été importé, le programme va se clore a la suite de cette fenetre", "Erreur d'importation", JOptionPane.ERROR_MESSAGE); - System.exit(1); - } - - /*lecture du fichier */ - this.cette_lecture = new Lecture(this.ce_chemin); - - this.valeur0=this.cette_lecture.GetHeader(0); - this.valeur1=this.cette_lecture.GetHeader(1); - this.valeur2=this.cette_lecture.GetHeader(2); - this.valeur3=this.cette_lecture.GetHeader(3); - this.valeur4=this.cette_lecture.GetHeader(4); - - /*Fermeture de la première fenètre */ - cette_frame.dispose(); - - /* Ouverture de la nouvelle */ - - this.cette_fenetre = new FenetreImpGrille(); - - cette_fenetre.ImporterGrille(this.valeur0, this.valeur1, this.valeur2, this.valeur3, this.valeur4, this.cette_lecture.GetOffset()); + public Importer(JFrame une_frame){ + this.cette_option="Importer Grille"; + this.cette_frame = une_frame; + } + + + /** + * 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 e on prend l'évènement en param afin de le traiter + */ + + public void actionPerformed(ActionEvent e){ + this.cet_event=e.getActionCommand(); + if(cet_event.equals(this.cette_option)){ + //System.out.println("Importation de la grille"); + + /*cherche le chemin du fichier */ + FileImport un_test = new FileImport(); + this.ce_chemin = un_test.Parcours(); + + if(this.ce_chemin == ""){ + JOptionPane.showMessageDialog(null, "Aucun fichier n'a été importé, le programme va se clore a la suite de cette fenetre", "Erreur d'importation", JOptionPane.ERROR_MESSAGE); + System.exit(1); + } + + /*lecture du fichier */ + this.cette_lecture = new Lecture(this.ce_chemin); + + this.valeur0=this.cette_lecture.GetHeader(0); + this.valeur1=this.cette_lecture.GetHeader(1); + this.valeur2=this.cette_lecture.GetHeader(2); + this.valeur3=this.cette_lecture.GetHeader(3); + this.valeur4=this.cette_lecture.GetHeader(4); + + /*Fermeture de la première fenètre */ + cette_frame.dispose(); + + /* Ouverture de la nouvelle */ + + this.cette_fenetre = new FenetreImpGrille(); + + cette_fenetre.ImporterGrille(this.valeur0, this.valeur1, this.valeur2, this.valeur3, this.valeur4, this.cette_lecture.GetOffset()); + } } - } } \ No newline at end of file diff --git a/outils.java b/outils.java index 3fe274e..93f9c76 100644 --- a/outils.java +++ b/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 - * pour regarder le parcours qu'emprunte l'algorithme + * 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 * @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 - * @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. + * Cette méthode a pour objectif de changer l'ordre des elt dans un tableau simple + * @param un_tableau tableau de int */ 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 - * @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. + * 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 first_tab voici notre premier tab + * @param tab_to_add voici le code a ajouter */ 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 - * @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. + * Cette méthode permet de de print un tableau de boolea + * @param leTableau Tableau de bollean + * @param saTaille sa taille */ public static void PrintGrilleBool(boolean[][] leTableau, int saTaille){ for(int i=0; i