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 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) {

View File

@ -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 =========================*/

View File

@ -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();

View File

@ -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;

View File

@ -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;

View File

@ -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();

View File

@ -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 --------------- ==============================*/

View File

@ -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 ============================================================================= */

View File

@ -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);

View File

@ -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(){

View File

@ -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);

View File

@ -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();

View File

@ -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 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();

View File

@ -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();
}

View File

@ -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();

View File

@ -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;
}

View File

@ -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;
}
}

View File

@ -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);

View File

@ -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++;

View File

@ -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++;

View File

@ -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;

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
* 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();

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
* 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];

View File

@ -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();

View File

@ -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());
}
}
}
}

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
* 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<saTaille; i++){
@ -70,11 +67,11 @@ public class outils {
}
System.out.print("\n ------------ \n FIN \n");
}
/**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
* @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 Cellules
* @param leTableau Tableau de Cellules
* @param saTaille sa taille
*/
public static void PrintGrilleCell(Cellules[][] leTableau, int saTaille){
for(int i=0; i<saTaille; i++){
@ -85,11 +82,11 @@ public class outils {
}
System.out.print("\n ------------ \n FIN \n");
}
/**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
* @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 parcourir un tableau de cellules et renvoie les coord de la porte d'entrée et de la sortie
* @param leTableau Tableau de Cellules
* @param saTaille sa taille
*/
public static int[] ParcoursCell(Cellules[][] leTableau, int saTaille){
int[] ceTableau = new int[4];
@ -106,11 +103,10 @@ public class outils {
}
return ceTableau;
}
/**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
* @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 transformer un tableau de int en un tableau de byte[]
* @param leTableau Tableau de int
*/
public static byte[] ConvertToByte(int[] leTableau){
byte[] taByte = new byte[leTableau.length];
@ -119,11 +115,12 @@ public class outils {
}
return taByte;
}
/**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
* @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 print les elts d'un tableau de int simple
* @param leTableau Tableau de int
* @param saTaille sa taille
*/
public static void printInt(int[] leTableau, int saTaille) {
for(int i=0; i<saTaille;i++){
@ -131,11 +128,13 @@ public class outils {
}
System.out.print("\n");
}
/**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
* @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 parcourir un tableau de boolean et affiche chaque elt parcourue
* @param leTableau Tableau de boolean
* @param saTaille sa taille
*/
public static void printBool(boolean[] leTableau, int saTaille) {
for(int i=0; i<saTaille*saTaille;i++){
@ -143,11 +142,11 @@ public class outils {
}
System.out.print("\n");
}
/**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
* @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 mettre la totalité des elt dans un tableau a double dimension dans un tableau simple
* @param leTableau Grille de boolean
* @param saTaille sa taille
*/
public static boolean[] PutToVertical(boolean[][] leTableau, int saTaille){
boolean[] resultat = new boolean[saTaille*saTaille];
@ -161,6 +160,11 @@ public class outils {
return resultat;
}
/**
* Cette méthode permet de parcourir un tableau de int et renvoie la moyenne des différentes valeur dans le tab
* @param leTableau Tableau de Cellules
* @param saTaille sa taille
*/
public static int moyenneTabint(int[] leTableau){
int somme = 0;
for(int valeur : leTableau){