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:
parent
02891f03fd
commit
0f2b78e1dd
@ -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) {
|
||||
|
@ -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 =========================*/
|
||||
|
@ -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();
|
||||
|
@ -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;
|
||||
|
@ -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
13
Fenetre.java
@ -1,7 +1,6 @@
|
||||
import javax.swing.*;
|
||||
/**
|
||||
* La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
|
||||
* pour regarder le parcours qu'emprunte l'algorithme
|
||||
* La class fenetre est une classe qui a simplement pour but de créer une Fenetre, puis attendre que des class hérite d'elle afin d'utiliser sa JFrame
|
||||
* @version 1.1
|
||||
* @author Matthis Fauvet
|
||||
*/
|
||||
@ -9,10 +8,7 @@ public class Fenetre{
|
||||
protected JFrame fenetre;
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre un objet de type These qui est l'objet qui va parcourir notre labyrinthe
|
||||
* @param grille grille C'est la grille qui va être parcourue comme le labyrinthe
|
||||
* @param coord Ce sont les coordonnées des portes d'entrées et de sortie
|
||||
* Contructeur
|
||||
*/
|
||||
public Fenetre() {
|
||||
this.fenetre = new JFrame("Creation du programme");
|
||||
@ -23,10 +19,7 @@ public class Fenetre{
|
||||
}
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre un objet de type These qui est l'objet qui va parcourir notre labyrinthe
|
||||
* @param grille grille C'est la grille qui va être parcourue comme le labyrinthe
|
||||
* @param coord Ce sont les coordonnées des portes d'entrées et de sortie
|
||||
* Cette méthode a pour but de fermer la fenetre quand on le demande
|
||||
*/
|
||||
public void closeFrame() {
|
||||
this.fenetre.dispose();
|
||||
|
@ -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 --------------- ==============================*/
|
||||
|
@ -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 ============================================================================= */
|
||||
|
@ -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);
|
||||
|
@ -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(){
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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();
|
||||
|
@ -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();
|
||||
|
@ -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();
|
||||
}
|
||||
|
@ -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();
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
@ -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);
|
||||
|
@ -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++;
|
||||
|
@ -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++;
|
||||
|
@ -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
10
Start.java
@ -1,16 +1,10 @@
|
||||
/**
|
||||
* La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
|
||||
* pour regarder le parcours qu'emprunte l'algorithme
|
||||
* Start est la class main, c'est celle ci qu'il faut lancer au départ et qui lance tout notre programme
|
||||
* @version 1.1
|
||||
* @author Matthis Fauvet
|
||||
*/
|
||||
public class Start {
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
*/
|
||||
|
||||
public static void main(String[] args) {
|
||||
FenetreInit une_fenetre = new FenetreInit();
|
||||
une_fenetre.Initialisation();
|
||||
|
87
These.java
87
These.java
@ -1,6 +1,6 @@
|
||||
/**
|
||||
* La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
|
||||
* pour regarder le parcours qu'emprunte l'algorithme
|
||||
* These est une class qui est utilisé par l'algo aléatoire pour parcourir un tableau
|
||||
* il faut créer un objet Thesee et lui donner une grille dans laquelle il pourra progrésser
|
||||
* @version 1.1
|
||||
* @author Matthis Fauvet
|
||||
*/
|
||||
@ -16,11 +16,13 @@ public class These {
|
||||
private int cetteTaille;
|
||||
|
||||
private boolean[][] cetteGrille;
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Constructeur
|
||||
* @param x position initiale
|
||||
* @param y position initiale
|
||||
* @param taille taille du tableau que thesee doit parcourir
|
||||
* @param grille tableau que these devra parcourir
|
||||
*/
|
||||
public These(int x, int y, int taille, boolean[][] grille){
|
||||
this.coordX = x;
|
||||
@ -28,11 +30,10 @@ public class These {
|
||||
this.cetteGrille = grille;
|
||||
this.cetteTaille = taille;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode essaie de faire bouger thesee a droite, si c'est possible, thesee bouge et renvoie true, sinon false
|
||||
*/
|
||||
public boolean goRight(){
|
||||
if(coordY+1 < this.cetteTaille){
|
||||
@ -44,11 +45,9 @@ public class These {
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode essaie de faire bouger thesee en bas, si c'est possible, thesee bouge et renvoie true, sinon false
|
||||
*/
|
||||
public boolean goDown(){
|
||||
if(coordX+1 < this.cetteTaille){
|
||||
@ -59,11 +58,9 @@ public class These {
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode essaie de faire bouger thesee a gauche, si c'est possible, thesee bouge et renvoie true, sinon false
|
||||
*/
|
||||
public boolean goLeft(){
|
||||
if(coordY-1 >= 0){
|
||||
@ -75,11 +72,9 @@ public class These {
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode essaie de faire bouger thesee en haut , si c'est possible, thesee bouge et renvoie true, sinon false
|
||||
*/
|
||||
public boolean goTop(){
|
||||
if(coordX-1 >= 0){
|
||||
@ -93,11 +88,10 @@ public class These {
|
||||
}
|
||||
|
||||
/* ======================== regarder ======================== */
|
||||
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode renvoie true si les thesee venait a être en dehors du tab
|
||||
*/
|
||||
public boolean debordementVerticaux(){
|
||||
//renvoie true s'il y a débordement sinon false
|
||||
@ -106,11 +100,9 @@ public class These {
|
||||
}
|
||||
return LIBRE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode fait regarder son bas a Thesee, thesee renvoie l'etat de la case regardé
|
||||
*/
|
||||
public boolean lookBot(){
|
||||
if(coordY+1 < this.cetteTaille){
|
||||
@ -120,11 +112,9 @@ public class These {
|
||||
}
|
||||
return LIBRE;
|
||||
}
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
|
||||
/**
|
||||
* Cette méthode fait regarder sa gauche a Thesee, thesee renvoie l'etat de la case regardé
|
||||
*/
|
||||
public boolean lookLeft(){
|
||||
if(coordY+1 < this.cetteTaille){
|
||||
@ -134,11 +124,9 @@ public class These {
|
||||
}
|
||||
return LIBRE;
|
||||
}
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
|
||||
/**
|
||||
* Cette méthode fait regarder a Thesee la case au dessus de lui, thesee renvoie l'etat de la case regardé
|
||||
*/
|
||||
public boolean lookTop(){
|
||||
if(coordY+1 < this.cetteTaille){
|
||||
@ -151,10 +139,9 @@ public class These {
|
||||
|
||||
// Gestion Fin
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Méthode qui regarde si thésée est arrivé a la case de fin
|
||||
* @param finalX Coordonné X de la fin
|
||||
* @param finalY Coordonné X de la fin
|
||||
*/
|
||||
public boolean isArrived(int finalX, int finalY){
|
||||
// renvoie un boolean
|
||||
@ -166,20 +153,16 @@ public class These {
|
||||
}
|
||||
|
||||
// Miscelaneous
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* cette méthode print la position actuelle de These
|
||||
*/
|
||||
public void printPlacement(){
|
||||
System.out.println("La position en X vaut : "+coordX+" et en y : "+coordY);
|
||||
}
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* cette méthode renvoie la position actuelle de These dans un tab de int[]
|
||||
*/
|
||||
public int[] getCoord(){
|
||||
int[] coordonnes = new int[2];
|
||||
|
21
creer.java
21
creer.java
@ -1,29 +1,30 @@
|
||||
import javax.swing.*;
|
||||
import java.awt.event.*;
|
||||
/**
|
||||
* La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
|
||||
* pour regarder le parcours qu'emprunte l'algorithme
|
||||
* La class Creer se lance si et seuelemnt si l'utilisateur décide de creéer un nouveau labyrinthe (!importer)
|
||||
* Ensuite, on doit lancer les classes suivante afin de pouvoir creér ntore Labyrinthe
|
||||
*
|
||||
* @version 1.1
|
||||
* @author Matthis Fauvet
|
||||
*/
|
||||
|
||||
public class Creer implements ActionListener {
|
||||
private String cet_event, f_option = "Nouvelle Grille";
|
||||
private JFrame cette_frame;
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Constructeur
|
||||
* @param frame_initial On récupère la fenetre précédente pour pouvoir la fermer un peu plus tard
|
||||
*/
|
||||
public Creer(JFrame frame_initial){
|
||||
super();
|
||||
this.cette_frame=frame_initial;
|
||||
}
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode d'active si et seulement si l'utilisateur a cliqué sur "nouvelle grille". Elle permet de créer un objet FenetreDefSize pourprendre en main
|
||||
* la suite du programme
|
||||
*
|
||||
* @param e on récupère la raison de l'evenement pour comparer les possibilitées
|
||||
*/
|
||||
public void actionPerformed(ActionEvent e){
|
||||
this.cet_event=e.getActionCommand();
|
||||
|
113
importer.java
113
importer.java
@ -2,67 +2,68 @@ import java.awt.event.*;
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.JOptionPane;
|
||||
/**
|
||||
* La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
|
||||
* pour regarder le parcours qu'emprunte l'algorithme
|
||||
* La class importer implémente un Action Listener pour lancer les prochaine partie du programme :
|
||||
* permet das un premier temps de laisser l'utilisateur aller chercher le fichier qu'il souhaite importer (FileImport)
|
||||
* Ensuite, le programme va lire ce fichier (Lecture)
|
||||
* Et enfin, il va générer une grille en se basant sur le contenur du fichier
|
||||
* @version 1.1
|
||||
* @author Matthis Fauvet
|
||||
*/
|
||||
public class Importer implements ActionListener {
|
||||
String cette_option;
|
||||
String cet_event;
|
||||
String ce_chemin;
|
||||
JFrame cette_frame;
|
||||
Lecture cette_lecture;
|
||||
FenetreImpGrille cette_fenetre;
|
||||
int valeur0, valeur1, valeur2, valeur3, valeur4;
|
||||
String cette_option;
|
||||
String cet_event;
|
||||
String ce_chemin;
|
||||
JFrame cette_frame;
|
||||
Lecture cette_lecture;
|
||||
FenetreImpGrille cette_fenetre;
|
||||
int valeur0, valeur1, valeur2, valeur3, valeur4;
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
/**
|
||||
* Constructeur qui prend en paramètre la fenetre précédente
|
||||
* @param une_frame on récupère la premiere fenetre pour la fermer un peu plus tard
|
||||
*/
|
||||
public Importer(JFrame une_frame){
|
||||
this.cette_option="Importer Grille";
|
||||
this.cette_frame = une_frame;
|
||||
}
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
*/
|
||||
public void actionPerformed(ActionEvent e){
|
||||
this.cet_event=e.getActionCommand();
|
||||
if(cet_event.equals(this.cette_option)){
|
||||
//System.out.println("Importation de la grille");
|
||||
|
||||
/*cherche le chemin du fichier */
|
||||
FileImport un_test = new FileImport();
|
||||
this.ce_chemin = un_test.Parcours();
|
||||
|
||||
if(this.ce_chemin == ""){
|
||||
JOptionPane.showMessageDialog(null, "Aucun fichier n'a été importé, le programme va se clore a la suite de cette fenetre", "Erreur d'importation", JOptionPane.ERROR_MESSAGE);
|
||||
System.exit(1);
|
||||
}
|
||||
|
||||
/*lecture du fichier */
|
||||
this.cette_lecture = new Lecture(this.ce_chemin);
|
||||
|
||||
this.valeur0=this.cette_lecture.GetHeader(0);
|
||||
this.valeur1=this.cette_lecture.GetHeader(1);
|
||||
this.valeur2=this.cette_lecture.GetHeader(2);
|
||||
this.valeur3=this.cette_lecture.GetHeader(3);
|
||||
this.valeur4=this.cette_lecture.GetHeader(4);
|
||||
|
||||
/*Fermeture de la première fenètre */
|
||||
cette_frame.dispose();
|
||||
|
||||
/* Ouverture de la nouvelle */
|
||||
|
||||
this.cette_fenetre = new FenetreImpGrille();
|
||||
|
||||
cette_fenetre.ImporterGrille(this.valeur0, this.valeur1, this.valeur2, this.valeur3, this.valeur4, this.cette_lecture.GetOffset());
|
||||
public Importer(JFrame une_frame){
|
||||
this.cette_option="Importer Grille";
|
||||
this.cette_frame = une_frame;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Si l'utilisateur décide d'importer un grille, alors on choisit un fichier, on le lit, on créer un fenetre en se basant dessus.
|
||||
* @param e on prend l'évènement en param afin de le traiter
|
||||
*/
|
||||
|
||||
public void actionPerformed(ActionEvent e){
|
||||
this.cet_event=e.getActionCommand();
|
||||
if(cet_event.equals(this.cette_option)){
|
||||
//System.out.println("Importation de la grille");
|
||||
|
||||
/*cherche le chemin du fichier */
|
||||
FileImport un_test = new FileImport();
|
||||
this.ce_chemin = un_test.Parcours();
|
||||
|
||||
if(this.ce_chemin == ""){
|
||||
JOptionPane.showMessageDialog(null, "Aucun fichier n'a été importé, le programme va se clore a la suite de cette fenetre", "Erreur d'importation", JOptionPane.ERROR_MESSAGE);
|
||||
System.exit(1);
|
||||
}
|
||||
|
||||
/*lecture du fichier */
|
||||
this.cette_lecture = new Lecture(this.ce_chemin);
|
||||
|
||||
this.valeur0=this.cette_lecture.GetHeader(0);
|
||||
this.valeur1=this.cette_lecture.GetHeader(1);
|
||||
this.valeur2=this.cette_lecture.GetHeader(2);
|
||||
this.valeur3=this.cette_lecture.GetHeader(3);
|
||||
this.valeur4=this.cette_lecture.GetHeader(4);
|
||||
|
||||
/*Fermeture de la première fenètre */
|
||||
cette_frame.dispose();
|
||||
|
||||
/* Ouverture de la nouvelle */
|
||||
|
||||
this.cette_fenetre = new FenetreImpGrille();
|
||||
|
||||
cette_fenetre.ImporterGrille(this.valeur0, this.valeur1, this.valeur2, this.valeur3, this.valeur4, this.cette_lecture.GetOffset());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
80
outils.java
80
outils.java
@ -1,6 +1,5 @@
|
||||
/**
|
||||
* La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
|
||||
* pour regarder le parcours qu'emprunte l'algorithme
|
||||
* La class outils ne propose que des méthodes Static qui ont pour but de simplifier certaine action mais aussi d'éviter d'alourdir trop notre code
|
||||
* @version 1.1
|
||||
* @author Matthis Fauvet
|
||||
*/
|
||||
@ -15,10 +14,8 @@ public class outils {
|
||||
}
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode a pour objectif de changer l'ordre des elt dans un tableau simple
|
||||
* @param un_tableau tableau de int
|
||||
*/
|
||||
public static int[] reverse(int[] un_tableau) {
|
||||
int taille = un_tableau.length;
|
||||
@ -31,11 +28,11 @@ public class outils {
|
||||
}
|
||||
return cette_copie;
|
||||
}
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode static a pour objectif de prendre deux tab de int et de n'en faire plus qu'un, de les concaténés
|
||||
* @param first_tab voici notre premier tab
|
||||
* @param tab_to_add voici le code a ajouter
|
||||
*/
|
||||
public static int[] concatenate(int[] first_tab, int[] tab_to_add){
|
||||
int taille = first_tab.length;
|
||||
@ -55,11 +52,11 @@ public class outils {
|
||||
}
|
||||
return tableau_temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
|
||||
* @param unPerso On rentre
|
||||
* @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
|
||||
* @param coord tableau double dimension qui stock les différentes Cellules.
|
||||
* Cette méthode permet de de print un tableau de boolea
|
||||
* @param leTableau Tableau de bollean
|
||||
* @param saTaille sa taille
|
||||
*/
|
||||
public static void PrintGrilleBool(boolean[][] leTableau, int saTaille){
|
||||
for(int i=0; i<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){
|
||||
|
Loading…
Reference in New Issue
Block a user