fauvet/SAE21_2022
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
Cellules.java
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) {

17
ChoixAlgo.java
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 =========================*/

19
ChoixEtTaille.java
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();

11
Ecriture.java
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;

11
Exporter.java
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;

13
Fenetre.java
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();

14
FenetreDefSize.java
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 --------------- ==============================*/

18
FenetreImpGrille.java
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 ============================================================================= */

15
FenetreInit.java
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);

17
FenetreRndmGrille.java
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(){

19
FenetreVideGrille.java
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);

13
FileImport.java
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();

23
GestionChoixAlgo.java
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 où est affiché le lab pour voir si on la ferme ou non (tout dépend de l'algo)
*/
public GestionChoixAlgo(int uneTaille, JFrame uneFrame, ButtonGroup group0, ButtonGroup group1, boolean[][] uneGrille, Cellules[][] grilleCell,JFrame uneFenetre){
this.cetteFrame = uneFrame;
@ -32,12 +35,12 @@ public class GestionChoixAlgo extends JFrame implements ActionListener {
this.frameGrille=uneFenetre;
this.cetteGrille = uneGrille;
this.cetteGrilleCell=grilleCell;
}
}
/**
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
* @param unPerso On rentre
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
* @param coord tableau double dimension qui stock les différentes Cellules.
* Cette méthode, en fonction des JRadioButton sélectionné ou non, va dirigé le programme vers un type d'algo et son parcours précis
* important : Cette méthode ne se lance que si et seulement si le bouton a été préssé
* @param e raison de l'événement
*/
public void actionPerformed(ActionEvent e){
this.cetteFrame.dispose();

26
GestionExporter.java
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();
}

22
GestionModif.java
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();

25
Modifications.java
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;
}

23
ModificationsTab.java
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;
}
}

16
PanneauModification.java
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);

33
Parcours.java
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++;

31
ParcoursManuel.java
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++;

10
PreEcriture.java
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;

10
Start.java
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();

87
These.java
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];

21
creer.java
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();

113
importer.java
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());
}
}
}
}

80
outils.java
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){