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

This commit is contained in:
fauvet 2023-04-28 23:16:23 +02:00
parent 02891f03fd
commit 0f2b78e1dd
26 changed files with 345 additions and 388 deletions

View File

@ -2,8 +2,8 @@ import java.awt.Color;
import javax.swing.JComponent; import javax.swing.JComponent;
import java.awt.Graphics; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -26,10 +26,10 @@ public class Cellules extends JComponent{
private int ceType; 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){ public Cellules(int uneLigne, int uneColone, int type){
super(); 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(){ public int getLigne(){
return this.cetteLigne; 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(){ public int getColone(){
return this.cetteColone; 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(){ public int getType(){
return this.ceType; 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){ public void setType(int newType){
if(newType==COULOIR){ 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){ public void peindre(int peinture){
if(peinture==COULOIR){ 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 @Override
protected void paintComponent(Graphics g) { protected void paintComponent(Graphics g) {

View File

@ -1,8 +1,7 @@
import javax.swing.*; import javax.swing.*;
import java.awt.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -13,10 +12,11 @@ public class ChoixAlgo extends Fenetre {
private int cetteTaille; 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){ public ChoixAlgo(int uneTaille, JFrame fenGrille, boolean[][] uneGrille, Cellules[][] uneGrilleCell){
super(); 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(){ public void setUp(){
/* ============================= TEXT PRESENTATION =========================*/ /* ============================= TEXT PRESENTATION =========================*/

View File

@ -1,8 +1,8 @@
import javax.swing.*; import javax.swing.*;
import java.awt.event.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -12,10 +12,10 @@ public class ChoixEtTaille extends JFrame implements ActionListener {
private ButtonGroup ce_group; 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){ public ChoixEtTaille(JFrame une_frame, JTextField un_tfield, ButtonGroup group){
this.cette_frame = une_frame; 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){ public void actionPerformed(ActionEvent e){
this.cette_frame.dispose(); this.cette_frame.dispose();

View File

@ -1,7 +1,6 @@
import java.io.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -11,10 +10,10 @@ public class Ecriture {
private String filePath; 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) { public Ecriture(byte[] tabBytes, String[] tabOctetsBinaires, String chemin) {
this.tabHeader = tabBytes; this.tabHeader = tabBytes;

View File

@ -1,8 +1,7 @@
import java.awt.*; import java.awt.*;
import javax.swing.*; 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 * @version 1.1
* @author Matthis Fauvet * @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 * 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){ public Exporter(boolean[][] uneGrille, Cellules[][] uneGrilleCell, int uneTaille, JFrame fenetreG, JFrame fenetreM){
this.cetteGrille = uneGrille; this.cetteGrille = uneGrille;

View File

@ -1,7 +1,6 @@
import javax.swing.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -9,10 +8,7 @@ public class Fenetre{
protected JFrame 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() { public Fenetre() {
this.fenetre = new JFrame("Creation du programme"); 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() { public void closeFrame() {
this.fenetre.dispose(); this.fenetre.dispose();

View File

@ -2,26 +2,20 @@ import javax.swing.*;
import java.awt.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
public class FenetreDefSize extends Fenetre{ 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(){ public FenetreDefSize(){
super(); 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(){ public void MiseEnPlace(){
/*============================== --------------- Fenetre --------------- ==============================*/ /*============================== --------------- Fenetre --------------- ==============================*/

View File

@ -1,7 +1,6 @@
import java.awt.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -9,14 +8,21 @@ public class FenetreImpGrille extends Fenetre {
private boolean[][] grille; private boolean[][] grille;
private Cellules[][] grilleCell; private Cellules[][] grilleCell;
/**
* Constructeur qui fait apelle a la class supérieur : Fenetre
*/
public FenetreImpGrille(){ public FenetreImpGrille(){
super(); 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){ public void ImporterGrille(int taille, int Lentre, int Centre, int Lortie, int Cortie, int[] tabGrille){
/* ================================================================ Déclaration des variables ============================================================================= */ /* ================================================================ Déclaration des variables ============================================================================= */

View File

@ -1,27 +1,22 @@
import javax.swing.*; import javax.swing.*;
import java.awt.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
public class FenetreInit extends Fenetre 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(){ public FenetreInit(){
super(); 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(){ public void Initialisation(){
GridLayout gestionnaire = new GridLayout(2,1); GridLayout gestionnaire = new GridLayout(2,1);

View File

@ -1,8 +1,8 @@
import java.awt.*; import java.awt.*;
import java.util.Random; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -19,10 +19,8 @@ public class FenetreRndmGrille extends Fenetre{
private Modifications modif; 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){ public FenetreRndmGrille(int taille){
super(); super();
@ -32,10 +30,9 @@ public class FenetreRndmGrille extends Fenetre{
this.tabCouleur = new int[] {1, 1}; 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(){ public void randomGrille(){

View File

@ -1,7 +1,6 @@
import java.awt.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -14,11 +13,10 @@ public class FenetreVideGrille extends Fenetre{
private Cellules[][] grilleCellules; private Cellules[][] grilleCellules;
private Modifications modif; 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){ public FenetreVideGrille(int taille){
super(); super();
@ -27,12 +25,13 @@ public class FenetreVideGrille extends Fenetre{
this.grilleCellules = new Cellules[this.taille][this.taille]; this.grilleCellules = new Cellules[this.taille][this.taille];
this.tabCouleur = new int[] {0, 0}; 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(){ public void videGrille(){
this.fenetre.setSize(600, 600); this.fenetre.setSize(600, 600);

View File

@ -1,22 +1,23 @@
import javax.swing.*; import javax.swing.*;
import java.io.File; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
public class FileImport { public class FileImport {
private String ce_chemin; private String ce_chemin;
/**
* Constructeur ou l'on établit seulement
*/
public FileImport(){ public FileImport(){
this.ce_chemin = ""; 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(){ public String Parcours(){
JFileChooser fileChooser = new JFileChooser(); JFileChooser fileChooser = new JFileChooser();

View File

@ -1,8 +1,7 @@
import javax.swing.*; import javax.swing.*;
import java.awt.event.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -18,9 +17,13 @@ public class GestionChoixAlgo extends JFrame implements ActionListener {
private Cellules[][] cetteGrilleCell; private Cellules[][] cetteGrilleCell;
/** /**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe * 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 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){ public GestionChoixAlgo(int uneTaille, JFrame uneFrame, ButtonGroup group0, ButtonGroup group1, boolean[][] uneGrille, Cellules[][] grilleCell,JFrame uneFenetre){
this.cetteFrame = uneFrame; this.cetteFrame = uneFrame;
@ -33,11 +36,11 @@ public class GestionChoixAlgo extends JFrame implements ActionListener {
this.cetteGrille = uneGrille; this.cetteGrille = uneGrille;
this.cetteGrilleCell=grilleCell; 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){ public void actionPerformed(ActionEvent e){
this.cetteFrame.dispose(); this.cetteFrame.dispose();

View File

@ -1,8 +1,7 @@
import java.awt.event.*; import java.awt.event.*;
import javax.swing.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -17,11 +16,15 @@ public class GestionExporter implements ActionListener{
private JFrame frameGrille; private JFrame frameGrille;
private JFrame frameModif; private JFrame frameModif;
private JFrame framePopup; 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){ public GestionExporter(boolean[][] uneGrille, Cellules[][] uneGrilleCell , int uneTaille, JFrame frameG, JFrame frameM, JFrame frameP){
this.cetteGrille=uneGrille; this.cetteGrille=uneGrille;
@ -32,21 +35,18 @@ public class GestionExporter implements ActionListener{
this.frameModif = frameM; this.frameModif = frameM;
this.framePopup = frameP; 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){ public void actionPerformed(ActionEvent e){
this.cet_event=e.getActionCommand(); this.cet_event=e.getActionCommand();
if (cet_event.equals(this.Reponses1)){ if (cet_event.equals(this.Reponses1)){
this.frameModif.dispose(); this.frameModif.dispose();
this.framePopup.dispose(); this.framePopup.dispose();
//outils.PrintGrilleBool(this.cetteGrille, this.cetteTaille);
PreEcriture precriture = new PreEcriture(this.cetteGrille, this.grilleCellules, this.cetteTaille); PreEcriture precriture = new PreEcriture(this.cetteGrille, this.grilleCellules, this.cetteTaille);
ChoixAlgo suite = new ChoixAlgo(this.cetteTaille, this.frameGrille ,this.cetteGrille, this.grilleCellules); ChoixAlgo suite = new ChoixAlgo(this.cetteTaille, this.frameGrille ,this.cetteGrille, this.grilleCellules);
suite.setUp(); suite.setUp();
} }

View File

@ -1,8 +1,8 @@
import java.awt.event.*; import java.awt.event.*;
import javax.swing.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -15,11 +15,15 @@ public class GestionModif implements ActionListener{
private JFrame cetteFrameGrille; private JFrame cetteFrameGrille;
private JFrame cetteFrameModif; 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){ public GestionModif(boolean[][] uneGrille, Cellules[][] uneGrilleCell, int uneTaille, JFrame frameGrille, JFrame frameModif){
this.cetteGrille=uneGrille; this.cetteGrille=uneGrille;
@ -30,10 +34,8 @@ public class GestionModif implements ActionListener{
this.cetteFrameModif = frameModif; 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){ public void actionPerformed(ActionEvent e){
this.cet_event=e.getActionCommand(); this.cet_event=e.getActionCommand();

View File

@ -1,7 +1,6 @@
import java.awt.event.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -9,13 +8,13 @@ public class Modifications implements MouseListener {
private PanneauModification unPanel; private PanneauModification unPanel;
private boolean[][] cetteGrille; private boolean[][] cetteGrille;
private int[] ceTab; private int[] ceTab;
private ModificationsTab change; private ModificationsTab change;
/** /**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe * 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){ public Modifications(PanneauModification panneauModification, boolean[][] grilleTab, int[] unTab){
this.unPanel = panneauModification; this.unPanel = panneauModification;
@ -23,22 +22,18 @@ public class Modifications implements MouseListener {
this.ceTab = unTab; 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) { public void mouseClicked(MouseEvent e) {
this.change = new ModificationsTab(this.unPanel, this.cetteGrille, this.ceTab, 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(){ public int[] getGateState(){
//System.out.println("this.ceTab vaut : [0] : "+this.ceTab[0] + " et this.ceTab vaut : [1] :"+this.ceTab[1]);
return this.ceTab; return this.ceTab;
} }

View File

@ -1,6 +1,6 @@
import java.awt.event.MouseEvent; 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 * pour regarder le parcours qu'emprunte l'algorithme
* @version 1.1 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
@ -17,11 +17,14 @@ public class ModificationsTab {
private PanneauModification cePanel; 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){ public ModificationsTab(PanneauModification panneauModification, boolean[][] grilleTab, int[] unTab, MouseEvent unEvent){
this.cetteGrille = grilleTab; this.cetteGrille = grilleTab;
@ -56,14 +59,4 @@ public class ModificationsTab {
this.rafraichir = new Affichage(notreCellule, panneauModification, unTab, this.cetteGrille[this.cetteLigne][this.cetteColone]); 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;
}
} }

View File

@ -1,8 +1,8 @@
import java.awt.*; import java.awt.*;
import javax.swing.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -18,9 +18,10 @@ public class PanneauModification extends Fenetre {
private JFrame frameGrille; private JFrame frameGrille;
/** /**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe * 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){ public PanneauModification(boolean[][] uneGrille, int uneTaille, Cellules[][] uneGrilleCell, JFrame uneFrame){
super(); super();
@ -34,10 +35,7 @@ public class PanneauModification extends Fenetre {
this.frameGrille = uneFrame; 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(){ public void SetUp(){
GridLayout gestionnaire = new GridLayout(4,1); GridLayout gestionnaire = new GridLayout(4,1);

View File

@ -1,19 +1,21 @@
import javax.swing.JOptionPane; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
public class Parcours { public class Parcours {
private int taille; private int taille;
private int ceCompteur = 0; private int ceCompteur = 0;
private Cellules[][] labyrinthe; 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){ public Parcours(Cellules[][] tableau, int X, int Y, int len){
this.taille = len; this.taille = len;
@ -22,10 +24,13 @@ public class Parcours {
this.Parcourir(X, Y); 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){ public boolean Parcourir(int coordX, int coordY){
@ -49,11 +54,11 @@ public class Parcours {
} }
return done; 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) { private boolean estValide(int pos_x, int pos_y) {
this.ceCompteur++; this.ceCompteur++;

View File

@ -1,26 +1,37 @@
import javax.swing.JOptionPane; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
public class ParcoursManuel { public class ParcoursManuel {
private int taille; private int taille;
private int ceCompteur = 0; private int ceCompteur = 0;
private Cellules[][] labyrinthe; 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){ public ParcoursManuel(Cellules[][] tableau, int X, int Y, int len){
this.taille = len; this.taille = len;
this.labyrinthe = tableau; this.labyrinthe = tableau;
this.Parcourir(X, Y); 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){ public boolean Parcourir(int coordX, int coordY){
@ -44,11 +55,11 @@ public class ParcoursManuel {
} }
return done; 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) { private boolean estValide(int pos_x, int pos_y) {
this.ceCompteur++; this.ceCompteur++;

View File

@ -3,8 +3,8 @@ import java.io.File;
import javax.swing.JFileChooser; import javax.swing.JFileChooser;
import javax.swing.filechooser.FileNameExtensionFilter; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -22,9 +22,9 @@ public class PreEcriture {
/** /**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe * 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){ public PreEcriture(boolean[][] uneGrille, Cellules[][] uneGrilleCell , int uneTaille){
this.cetteTaille = uneTaille; this.cetteTaille = uneTaille;

View File

@ -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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
public class Start { 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) { public static void main(String[] args) {
FenetreInit une_fenetre = new FenetreInit(); FenetreInit une_fenetre = new FenetreInit();
une_fenetre.Initialisation(); une_fenetre.Initialisation();

View File

@ -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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -16,11 +16,13 @@ public class These {
private int cetteTaille; private int cetteTaille;
private boolean[][] cetteGrille; 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){ public These(int x, int y, int taille, boolean[][] grille){
this.coordX = x; this.coordX = x;
@ -28,11 +30,10 @@ public class These {
this.cetteGrille = grille; this.cetteGrille = grille;
this.cetteTaille = taille; 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(){ public boolean goRight(){
if(coordY+1 < this.cetteTaille){ if(coordY+1 < this.cetteTaille){
@ -44,11 +45,9 @@ public class These {
} }
return false; 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(){ public boolean goDown(){
if(coordX+1 < this.cetteTaille){ if(coordX+1 < this.cetteTaille){
@ -59,11 +58,9 @@ public class These {
} }
return false; 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(){ public boolean goLeft(){
if(coordY-1 >= 0){ if(coordY-1 >= 0){
@ -75,11 +72,9 @@ public class These {
} }
return false; 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(){ public boolean goTop(){
if(coordX-1 >= 0){ if(coordX-1 >= 0){
@ -93,11 +88,10 @@ public class These {
} }
/* ======================== regarder ======================== */ /* ======================== 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(){ public boolean debordementVerticaux(){
//renvoie true s'il y a débordement sinon false //renvoie true s'il y a débordement sinon false
@ -106,11 +100,9 @@ public class These {
} }
return LIBRE; 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(){ public boolean lookBot(){
if(coordY+1 < this.cetteTaille){ if(coordY+1 < this.cetteTaille){
@ -120,11 +112,9 @@ public class These {
} }
return LIBRE; 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(){ public boolean lookLeft(){
if(coordY+1 < this.cetteTaille){ if(coordY+1 < this.cetteTaille){
@ -134,11 +124,9 @@ public class These {
} }
return LIBRE; 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(){ public boolean lookTop(){
if(coordY+1 < this.cetteTaille){ if(coordY+1 < this.cetteTaille){
@ -151,10 +139,9 @@ public class These {
// Gestion Fin // 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){ public boolean isArrived(int finalX, int finalY){
// renvoie un boolean // renvoie un boolean
@ -166,20 +153,16 @@ public class These {
} }
// Miscelaneous // 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(){ public void printPlacement(){
System.out.println("La position en X vaut : "+coordX+" et en y : "+coordY); 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(){ public int[] getCoord(){
int[] coordonnes = new int[2]; int[] coordonnes = new int[2];

View File

@ -1,29 +1,30 @@
import javax.swing.*; import javax.swing.*;
import java.awt.event.*; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
public class Creer implements ActionListener { public class Creer implements ActionListener {
private String cet_event, f_option = "Nouvelle Grille"; private String cet_event, f_option = "Nouvelle Grille";
private JFrame cette_frame; 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){ public Creer(JFrame frame_initial){
super(); super();
this.cette_frame=frame_initial; 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){ public void actionPerformed(ActionEvent e){
this.cet_event=e.getActionCommand(); this.cet_event=e.getActionCommand();

View File

@ -2,8 +2,10 @@ import java.awt.event.*;
import javax.swing.JFrame; import javax.swing.JFrame;
import javax.swing.JOptionPane; 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 * @version 1.1
* @author Matthis Fauvet * @author Matthis Fauvet
*/ */
@ -17,21 +19,20 @@ public class Importer implements ActionListener {
int valeur0, valeur1, valeur2, valeur3, valeur4; 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){ public Importer(JFrame une_frame){
this.cette_option="Importer Grille"; this.cette_option="Importer Grille";
this.cette_frame = une_frame; 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){ public void actionPerformed(ActionEvent e){
this.cet_event=e.getActionCommand(); this.cet_event=e.getActionCommand();
if(cet_event.equals(this.cette_option)){ if(cet_event.equals(this.cette_option)){

View File

@ -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 * @version 1.1
* @author Matthis Fauvet * @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) { public static int[] reverse(int[] un_tableau) {
int taille = un_tableau.length; int taille = un_tableau.length;
@ -31,11 +28,11 @@ public class outils {
} }
return cette_copie; 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){ public static int[] concatenate(int[] first_tab, int[] tab_to_add){
int taille = first_tab.length; int taille = first_tab.length;
@ -55,11 +52,11 @@ public class outils {
} }
return tableau_temp; 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){ public static void PrintGrilleBool(boolean[][] leTableau, int saTaille){
for(int i=0; i<saTaille; i++){ for(int i=0; i<saTaille; i++){
@ -70,11 +67,11 @@ public class outils {
} }
System.out.print("\n ------------ \n FIN \n"); 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){ public static void PrintGrilleCell(Cellules[][] leTableau, int saTaille){
for(int i=0; i<saTaille; i++){ for(int i=0; i<saTaille; i++){
@ -85,11 +82,11 @@ public class outils {
} }
System.out.print("\n ------------ \n FIN \n"); 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){ public static int[] ParcoursCell(Cellules[][] leTableau, int saTaille){
int[] ceTableau = new int[4]; int[] ceTableau = new int[4];
@ -106,11 +103,10 @@ public class outils {
} }
return ceTableau; 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){ public static byte[] ConvertToByte(int[] leTableau){
byte[] taByte = new byte[leTableau.length]; byte[] taByte = new byte[leTableau.length];
@ -119,11 +115,12 @@ public class outils {
} }
return taByte; 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) { public static void printInt(int[] leTableau, int saTaille) {
for(int i=0; i<saTaille;i++){ for(int i=0; i<saTaille;i++){
@ -131,11 +128,13 @@ public class outils {
} }
System.out.print("\n"); 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) { public static void printBool(boolean[] leTableau, int saTaille) {
for(int i=0; i<saTaille*saTaille;i++){ for(int i=0; i<saTaille*saTaille;i++){
@ -143,11 +142,11 @@ public class outils {
} }
System.out.print("\n"); 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){ public static boolean[] PutToVertical(boolean[][] leTableau, int saTaille){
boolean[] resultat = new boolean[saTaille*saTaille]; boolean[] resultat = new boolean[saTaille*saTaille];
@ -161,6 +160,11 @@ public class outils {
return resultat; 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){ public static int moyenneTabint(int[] leTableau){
int somme = 0; int somme = 0;
for(int valeur : leTableau){ for(int valeur : leTableau){