Algorithme de PLEDGE en JAVASCHOOL

Algorithme de PLEDGE en JAVASCHOOL - LABYRINTHE

Bonjour,
je suis a la recherche d'un algorithme complet codé en java, a faire compiler sous javaschool.
les besoins sont les suivants :
1/ charger une image de labyrinthe de 500 pixel maximum
2/ pixeliser en java cette image en blanc pour les cases vides et en noir pour les bordures/murs
3/placer un curseur a un endroit de l'image
4/implémenter un algorithme de pledge pour sortir du labyrinthe

je remercier par avance, toute personne qui a certainement travailler sur le sujet lorsqu'il était étudiant !

sous javaschool :
début d'algo

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package Image;
 
import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
 
import javax.imageio.ImageIO;
 
public class Image {
 
public static void displayImage(File file, BufferedImage img) {
        int height = img.getHeight();
        int width = img.getWidth();
        for (int x = 0; x < width; x++)
        for (int y = 0; y < height; y++) {
            Color pixel = new Color(img.getRGB(x, y));
            System.out.printf("%s (x=%d, y=%d) : red=%d, green=%d, blue=%d, alpha=%d\n",
                file.getAbsolutePath(), x, y,
                pixel.getRed(), pixel.getGreen(), pixel.getBlue(), pixel.getAlpha());
        }
    }
public static void main(String[] args) {
        File path = new File("C:/Users/bureau/Desktop/M2/IMM/Tp/IMM");
        //new File("Labyrinthe_1_mathis.jpeg")
        for (File file : path.listFiles()) {
            try {
                BufferedImage img = ImageIO.read(file);
                if (img != null)
                    displayImage(file, img);
            } catch (IOException e) {
                continue;
            }
        }
    }
}

retourne a la compilation
Attention: il faut un block "void main()" pour que le programme puisse se compiler
Attention: on ne peut normalement pas définir de package Java en JavaScool
le programme risque de ne pas s'exécuter correctement

Code:

1
2
3
4
 Erreur de syntaxe ligne 13 :
  error: (illegal start of expression) L'instruction (ou la précédente) est tronquée ou mal écrite
public class Image {
^

j'ai bien pris note de la formulation de code a inclure sur el forum pardonnez moi.
je profite de ce message pour vous faire part de mon avancement sur le projet
j'ai récupéré des bloc de code que je n'arrive pas a assembler pour que cela compile sous javaschool: ( attention c tres long code code)

1er bloc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
 
package jeu;
 
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
public class FenetreLab extends JFrame implements ActionListener{
 
	/************************************** VARIABLES **************************************/
 
	private int size;
	private GridSol grilleSol;
	private FenetreLab lab1;
	private FenetreLab lab2;
	private FenetreLab lab3;
	private FenetreLab labNoSol;
	private Labyrinthe labyrinthe;
	private JLabel enTete;
 
	public JButton showSoluce;
 
 
	 /************************************** CONSTRUCTEUR **********************************/
 
	public FenetreLab(int numLab) {
		super("Résolution d'un labyrinthe");
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
		this.setResizable(false);
		this.setJMenuBar(BarreMenu());
		this.size = numLab;
 
		Font police = new Font("Trebuchet MS", Font.BOLD, 17);
		Font police2 = new Font("Trebuchet MS", Font.BOLD, 20);
		labyrinthe = new Labyrinthe(size);
		showSoluce = new JButton("Afficher le chemin");
 
		enTete = new JLabel("Algorithme de résolution d'un labyrinthe");
		enTete.setHorizontalAlignment(JLabel.CENTER);
		enTete.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
		enTete.setFont(police);
 
		showSoluce.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
		showSoluce.setHorizontalAlignment(JButton.CENTER);
		showSoluce.addActionListener(this);
		showSoluce.setFont(police2);
 
		this.add(enTete, BorderLayout.NORTH);
		this.add(labyrinthe, BorderLayout.CENTER);
		this.add(showSoluce, BorderLayout.SOUTH);
 
		pack();
 
	}
 
	/************************************** MENU **********************************/
 
	private JMenuBar BarreMenu() {
 
     	JMenuBar BarreMenu = new JMenuBar();
 
     	JMenu Jeu = new JMenu("Labyrinthe");	
     	BarreMenu.add(Jeu);
 
     	JMenuItem item = new JMenuItem("Taille 1");			
        Jeu.add(item);												
        item.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                LabTaille1();
 
            }
        });
 
     	item = new JMenuItem("Taille 2");			
        Jeu.add(item);												
        item.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                LabTaille2();
 
            }
        });
 
     	item = new JMenuItem("Taille 3");			
        Jeu.add(item);												
        item.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                LabTaille3();
 
            }
        });
 
     	item = new JMenuItem("Aucune solution");			
        Jeu.add(item);												
        item.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                LabNoSol();
 
            }
        });
 
     	return BarreMenu;
     }
 
 
	/************************************** FONCTIONS **********************************/
 
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == showSoluce) {
			//Si une solution a été trouvée
			 if(labyrinthe.resolutionLab(0, 0)) {
				 //Alors créer une fenêtre contenant la solution
				 grilleSol = new GridSol(labyrinthe.grille);
			 	 grilleSol.setLocationRelativeTo(null);
			 	 grilleSol.setVisible(true);
			 	 showSoluce.setEnabled(false);
			 } 
			 //Sinon
			 else {
				 //Afficher un message d'information
				 JOptionPane.showMessageDialog(this, "Aucune sortie n'a été trouvée :(");
			 }
		}
	}
 
	private void LabTaille1() {
		lab1 = new FenetreLab(1);
		lab1.setLocationRelativeTo(null);
		lab1.setVisible(true);
		this.dispose();
 
	}
 
	private void LabTaille2() {
		lab2 = new FenetreLab(2);
		lab2.setLocationRelativeTo(null);
		lab2.setVisible(true);
		this.dispose();
 
	}
 
	private void LabTaille3() {
		lab3 = new FenetreLab(3);
		lab3.setLocationRelativeTo(null);
		lab3.setVisible(true);
		this.dispose();
 
	}
 
	private void LabNoSol() {
		labNoSol = new FenetreLab(4);
		labNoSol.setLocationRelativeTo(null);
		labNoSol.setVisible(true);
		this.dispose();
 
	}
 
	/************************************** FONCTION MAIN **********************************/
 
	public static void main(String[] args) {
 
		FenetreLab fenetre = new FenetreLab(1);
		fenetre.setLocationRelativeTo(null);
		fenetre.setVisible(true);
	} //Fin main()
 
} //Fin class

2ieme BLOC :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
 
package jeu;
 
import java.awt.*;
import javax.swing.*;
 
public class GridSol extends JFrame{
 
	/************************************** VARIABLES **************************************/
 
	private int [][] soluceGrille;
	private ImageIcon caseVide = new ImageIcon(new ImageIcon(getClass().getResource("/Vide.png")).getImage().getScaledInstance(35, 35, Image.SCALE_DEFAULT));
	private ImageIcon caseMur = new ImageIcon(new ImageIcon(getClass().getResource("/Mur.png")).getImage().getScaledInstance(35, 35, Image.SCALE_DEFAULT));
	private ImageIcon caseDepArr = new ImageIcon(new ImageIcon(getClass().getResource("/DepArr.png")).getImage().getScaledInstance(35, 35, Image.SCALE_DEFAULT));
 
	/************************************** CONSTRUCTEUR **************************************/
 
	public GridSol(int gridSol[][]) {
		super("Labyrinthe Résolu");
		this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		this.setResizable(false);
		this.soluceGrille = gridSol;
 
		Font police = new Font("Trebuchet MS", Font.BOLD, 25);
		JLabel enTete = new JLabel("Solution du labyrinthe");
 
		enTete.setHorizontalAlignment(JLabel.CENTER);
		enTete.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
		enTete.setFont(police);
 
		this.add(enTete, BorderLayout.NORTH);
		affichage();
 
		pack();
 
	}
 
	/************************************** FONCTIONS **************************************/
 
	public void affichage() {
 
		Dimension dim = new Dimension(caseVide.getIconWidth(), caseVide.getIconHeight());
		JButton [][] button = new JButton[soluceGrille.length][soluceGrille[0].length];
		JPanel panel = new JPanel();
		panel.setLayout(new GridLayout(soluceGrille.length, soluceGrille[0].length));
 
		for (int i = 0; i < soluceGrille.length; ++i)
				for (int j = 0; j < soluceGrille[0].length; ++j) {
 
					soluceGrille[soluceGrille.length-1][soluceGrille[0].length-1] = 7;
 
					if (soluceGrille[i][j] == 0 || soluceGrille[i][j] == 3) 
						//Image de fond blanc
						button[i][j] = new JButton(caseVide);
 
					else if (soluceGrille[i][j] == 1)
						//Image de fond noir
						button[i][j] = new JButton(caseMur);
 
					else if (soluceGrille[i][j] == 7)
						//Image de fond orange
						button[i][j] = new JButton(caseDepArr);
 
					else 
						//Image de fond orange
						button[i][j] = new JButton(caseDepArr);
 
					button[i][j].setPreferredSize(dim);
					button[i][j].setBorder(null);
					panel.add(button[i][j]);
 
				}
 
		this.add(panel, BorderLayout.CENTER);
 
	} //Fin affichage()
 
} //Fin class

3iemebloc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
package jeu;
 
import javax.swing.*;
import java.awt.*;
 
public class Labyrinthe extends JPanel{
 
	/************************************** VARIABLES **************************************/
 
	private int taille;
	private ImageIcon caseVide = new ImageIcon(new ImageIcon(getClass().getResource("/Vide.png")).getImage().getScaledInstance(35, 35, Image.SCALE_DEFAULT));
	private ImageIcon caseMur = new ImageIcon(new ImageIcon(getClass().getResource("/Mur.png")).getImage().getScaledInstance(35, 35, Image.SCALE_DEFAULT));
	private Dimension dim = new Dimension(caseVide.getIconWidth(), caseVide.getIconHeight());
 
	public int[][] grille;
	public JButton[][] button;
	public JPanel panel;
 
	/************************************** CONSTRUCTEUR **********************************/
 
	public Labyrinthe(int taille){
		this.taille = taille;
		creerLab();
	}
 
	/************************************** FONCTIONS *************************************/
 
	public void creerLab() {
 
			if (taille == 1) {
 
				//Création du labyrinthe de taille 1, les "1" seront des murs et les "0" des espaces vides
				grille = new int[][]{
					    { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
					    { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1 },
					    { 1, 1, 0, 1, 0, 1, 0, 1, 0, 1 },
			    		    { 1, 0, 0, 1, 0, 1, 1, 1, 0, 1 },
			    	            { 1, 0, 1, 1, 0, 0, 0, 0, 0, 1 },
			    		    { 1, 0, 1, 1, 0, 1, 1, 1, 0, 1 },
			    		    { 1, 0, 1, 1, 0, 1, 0, 0, 0, 1 },
			    		    { 1, 0, 0, 1, 0, 1, 1, 1, 1, 1 },
			    		    { 1, 0, 1, 1, 0, 0, 0, 0, 0, 1 },
			    		    { 1, 1, 1, 1, 1, 1, 1, 1, 0, 0 }
				};
 
			}
 
			else if (taille == 2) {
 
				//Création du labyrinthe de taille 2, les "1" seront des murs et les "0" des espaces vides
				grille = new int[][]{
					    { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1 },
					    { 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0 },
					    { 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0 },
					    { 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0 },
					    { 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0 },
					    { 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0 },
					    { 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0 },
					    { 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0 },
					    { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1 },
					    { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0 }
				 };
 
			}
 
			else if (taille == 3) {
 
				//Création du labyrinthe de taille 3, les "1" seront des murs et les "0" des espaces vides
				grille = new int[][]{
					    { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1 },
					    { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
					    { 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 },
					    { 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1 },
					    { 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1 },
					    { 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1 },
					    { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1 },
					    { 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1 },
					    { 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1 },
					    { 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0 },
					    { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 },
					    { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0 }
				};
 
			}
 
			else {
 
				//Création du labyrinthe sans issue de taille autre, les "1" seront des murs et les "0" des espaces vides
				grille = new int[][]{
					    { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
					    { 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
					    { 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 },
					    { 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1 },
					    { 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1 },
					    { 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1 },
					    { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1 },
					    { 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1 },
					    { 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1 },
					    { 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1 },
					    { 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1 },
					    { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
				};
			}
 
			//Création d'une matrice de boutons
			button = new JButton[grille.length][grille[0].length];
			panel = new JPanel();
			panel.setLayout(new GridLayout(grille.length, grille[0].length));
			this.setBorder(BorderFactory.createEmptyBorder(13, 13, 13, 13));
 
			//Début de parcours de la matrice
			for (int i = 0; i < grille.length; ++i)
				for (int j = 0; j < grille[0].length; ++j) {
 
					if (grille[i][j] == 0)  
						//Image de fond blanc
						button[i][j] = new JButton(caseVide);
 
					else 
						//Image de fond noir
						button[i][j] = new JButton(caseMur);
 
					button[i][j].setPreferredSize(dim);
					button[i][j].setBorder(null);
					panel.add(button[i][j]);
 
				} //Fin de parcours de la matrice
 
			this.add(panel);
 
		} //Fin creerLab()
 
	/************************************** ALGORITHME DE RESOLUTION *************************************/
 
		public boolean resolutionLab(int pos_x, int pos_y) {
 
				boolean done = false;
 
				//Si la fonction estValide() renvoie true
				if (estValide(pos_x, pos_y)) {
 
					grille[pos_x][pos_y] = 3;
 
					//Si la case passée en paramètre est la dernière case du labyrinthe
					if (pos_x == grille.length-1 && pos_y == grille[0].length-1)
						return true;
 
					else {
						//Appels récursifs
						done = resolutionLab(pos_x + 1, pos_y);
						if (!done)
							done = resolutionLab(pos_x, pos_y + 1);
						if (!done)
							done = resolutionLab(pos_x - 1, pos_y);
						if (!done)
							done = resolutionLab(pos_x, pos_y - 1);
					}
					if (done) 
			            		grille[pos_x][pos_y] = 7;
 
				}
 
			return done;
 
		} //Fin resolutionLab()
 
		private boolean estValide(int pos_x, int pos_y) {
 
			boolean result = false;
 
		      //Si la case passée en paramètre est dans les dimensions du labyrinthe
		      if (pos_x >= 0 && pos_x < grille.length && pos_y >= 0 && pos_y < grille[0].length)
		    	 //Et si la case est un espace vide
		         if (grille[pos_x][pos_y] == 0)
		            result = true;
 
		      return result;
 
		} //Fin estValide()
 
} //Fin class

Je ne connais pas du tout Java is cool bidule, mais ce que je peux te dire c'est que ton code fonctionne sous eclipse parfaitement (bon j'ai dut remplacer les imageicon par du simple texte), et en plus il m'affiche une solution ;)

merci Mr WAX,
JAVASCHOOL est un outil "scolaire" mis a disposition des lycéens ou étudiant, une forme de générateur de code java.
c'est justement la grosse problématique que j'ai : sous cet outil : les fonctions déclarées ainsi que les variables doivent etre parfaitement définies et ordonnancées faute d'erreur de compil ou de non reconnaissance.
le premier message de cetet discussion en est la preuve
Code:

1 2 3 4 5 6 7 8 9 Attention: il faut un block "void main()" pour que le programme puisse se compiler Attention: on ne peut normalement pas définir de package Java en JavaScool le programme risque de ne pas s'exécuter correctement Erreur de syntaxe ligne 13 : error: (illegal start of expression) L'instruction (ou la précédente) est tronquée ou mal écrite public class Image { ^
si un expert JAVASCHOOL pouvait y jeter un œil ( et le récuperer après ...!!) ce serait sincèrement sympa
merci à tous

Je comprends pas, on te force à utiliser cet outil, Java's Cool, de but en blanc sans t'avoir donné la moindre formation préalable ?

Dans ce cas, je comprends que ce soit agaçant, mais tu dois commencer par te former à cet outil. Ensuite, une fois que tu auras une formation de débutant saine, tu pourras revenir à la problématique de résoudre un labyrinthe. Le message te dit que tu as besoin d'un "bloc" void main(), et l'habitude rendra évidente qu'il faut en faire un et comment. Le message te dit qu'il ne faut pas mettre d'instruction package, et l'habitude de ne jamais en avoir t'aidera à ne pas mettre cette ligne, sans t'inquiéter.

1 pièce(s) jointe(s)

je reviens vers la communauté et les expert JAVA.
pas d'avancement sur ce projet en javascool.
mais des nouveautés dans les fonctionnalités : il est demandé en introduction de faire un menu.
ce menu proposerait deux choix:
le premier : charger une image de labyrinthe ( sur internet) n'importe laquelle ( conditions 500 pixels maxi)
le second choisir une taille de labyrinthe ( 1 2 ou 3) dont le code java a été implémenté plus haut dans la discussion.

est ce qu'une bonne âme pourrait m'aider a coder ce menu ?

j'ajoute qu'une fois l'image chargée ( option 1du menu) il faut la pixeliser et ressortir le blanc ou le noir avec des 0 ou des 1. ( classique pour un pro du code java)
j'ai fait des recherches de codes java

pour charger une image et pixeliser :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 import java.awt.Color; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imageio.ImageIO; public class Image { public static void displayImage(File file, BufferedImage img) { int height = img.getHeight(); int width = img.getWidth(); for (int x = 0; x < width; x++) for (int y = 0; y < height; y++) { Color pixel = new Color(img.getRGB(x, y)); System.out.printf("%s (x=%d, y=%d) : red=%d, green=%d, blue=%d, alpha=%d\n", file.getAbsolutePath(), x, y, pixel.getRed(), pixel.getGreen(), pixel.getBlue(), pixel.getAlpha()); } } public static void main(String[] args) { File path = new File("C:/Users/bureau/Labyrinthe.jpeg"); for (File file : path.listFiles()) { try { BufferedImage img = ImageIO.read(file); if (img != null) displayImage(file, img); } catch (IOException e) { continue; } } } }