diff --git a/out/AutomatiqueActionListener.class b/out/AutomatiqueActionListener.class deleted file mode 100644 index 71d5119..0000000 Binary files a/out/AutomatiqueActionListener.class and /dev/null differ diff --git a/out/CaseMouseListener.class b/out/CaseMouseListener.class deleted file mode 100644 index cfb8716..0000000 Binary files a/out/CaseMouseListener.class and /dev/null differ diff --git a/out/FenetreChoix.class b/out/FenetreChoix.class deleted file mode 100644 index f204a25..0000000 Binary files a/out/FenetreChoix.class and /dev/null differ diff --git a/out/FenetreModif$1.class b/out/FenetreModif$1.class deleted file mode 100644 index 84eaabf..0000000 Binary files a/out/FenetreModif$1.class and /dev/null differ diff --git a/out/FenetreModif.class b/out/FenetreModif.class deleted file mode 100644 index 5e1dabe..0000000 Binary files a/out/FenetreModif.class and /dev/null differ diff --git a/out/FenetrePrincipale.class b/out/FenetrePrincipale.class deleted file mode 100644 index c76e9e8..0000000 Binary files a/out/FenetrePrincipale.class and /dev/null differ diff --git a/out/GenerateurSudoku.class b/out/GenerateurSudoku.class deleted file mode 100644 index baf4bc2..0000000 Binary files a/out/GenerateurSudoku.class and /dev/null differ diff --git a/out/GrilleExisteActionListener.class b/out/GrilleExisteActionListener.class deleted file mode 100644 index f9e2114..0000000 Binary files a/out/GrilleExisteActionListener.class and /dev/null differ diff --git a/out/GrillePainter.class b/out/GrillePainter.class deleted file mode 100644 index 577e558..0000000 Binary files a/out/GrillePainter.class and /dev/null differ diff --git a/out/GrilleSudokuDessin.class b/out/GrilleSudokuDessin.class deleted file mode 100644 index 28cb06b..0000000 Binary files a/out/GrilleSudokuDessin.class and /dev/null differ diff --git a/out/GrilleVideActionListener.class b/out/GrilleVideActionListener.class deleted file mode 100644 index 5132c2d..0000000 Binary files a/out/GrilleVideActionListener.class and /dev/null differ diff --git a/out/Grilles.class b/out/Grilles.class deleted file mode 100644 index 18560e4..0000000 Binary files a/out/Grilles.class and /dev/null differ diff --git a/out/Lecteur.class b/out/Lecteur.class deleted file mode 100644 index 8e08d2c..0000000 Binary files a/out/Lecteur.class and /dev/null differ diff --git a/out/MainCreation.class b/out/MainCreation.class deleted file mode 100644 index 94b2805..0000000 Binary files a/out/MainCreation.class and /dev/null differ diff --git a/out/MainJeu.class b/out/MainJeu.class deleted file mode 100644 index a6c5bec..0000000 Binary files a/out/MainJeu.class and /dev/null differ diff --git a/out/ManuelActionListener.class b/out/ManuelActionListener.class deleted file mode 100644 index 05ad053..0000000 Binary files a/out/ManuelActionListener.class and /dev/null differ diff --git a/out/OuvertureFichier.class b/out/OuvertureFichier.class deleted file mode 100644 index 039a049..0000000 Binary files a/out/OuvertureFichier.class and /dev/null differ diff --git a/out/Register.class b/out/Register.class deleted file mode 100644 index 3d22e40..0000000 Binary files a/out/Register.class and /dev/null differ diff --git a/out/Reinitialiser.class b/out/Reinitialiser.class deleted file mode 100644 index 7a9179d..0000000 Binary files a/out/Reinitialiser.class and /dev/null differ diff --git a/out/ReinitialiserActionListener.class b/out/ReinitialiserActionListener.class deleted file mode 100644 index 76190d5..0000000 Binary files a/out/ReinitialiserActionListener.class and /dev/null differ diff --git a/out/Resolveur.class b/out/Resolveur.class deleted file mode 100644 index c039556..0000000 Binary files a/out/Resolveur.class and /dev/null differ diff --git a/out/SaisieGrille.class b/out/SaisieGrille.class deleted file mode 100644 index ab56530..0000000 Binary files a/out/SaisieGrille.class and /dev/null differ diff --git a/out/SudokuGenerator.class b/out/SudokuGenerator.class deleted file mode 100644 index c8d4474..0000000 Binary files a/out/SudokuGenerator.class and /dev/null differ diff --git a/src/AutomatiqueActionListener.java b/src/AutomatiqueActionListener.java index 4168113..2c8ce63 100644 --- a/src/AutomatiqueActionListener.java +++ b/src/AutomatiqueActionListener.java @@ -2,35 +2,61 @@ import javax.swing.*; import java.awt.event.*; import java.io.File; +/** + * La classe AutomatiqueActionListener est un écouteur d'événements utilisé pour gérer l'action + * lorsqu'on clique sur le bouton "Automatique" dans la fenêtre de choix. + * Elle permet de choisir un fichier contenant une grille de Sudoku, de la résoudre automatiquement + * et d'afficher le résultat dans une nouvelle fenêtre. + * + * Elle implémente l'interface ActionListener pour écouter les événements liés au bouton. + * + * @author Dick Adrien + * @version 3.0 + */ public class AutomatiqueActionListener implements ActionListener { private JFrame choixFrame; + /** + * Constructeur de la classe AutomatiqueActionListener. + * + * @param choixFrame La fenêtre de choix du Sudoku. + */ public AutomatiqueActionListener(JFrame choixFrame) { this.choixFrame = choixFrame; } + /** + * Méthode appelée lorsque l'action associée à ce listener est déclenchée, c'est-à-dire lorsque le bouton + * "Automatique" est cliqué. + * + * @param e L'événement associé à l'action. + */ @Override public void actionPerformed(ActionEvent e) { + // Ferme la fenêtre de choix du Sudoku. choixFrame.dispose(); - int[][] grille = new int[9][9]; // Création d'une grille vide + // Crée une grille vide de Sudoku. + int[][] grille = new int[9][9]; - // Ouverture du sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille + // Ouvre un sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille. JFileChooser fileChooser = new JFileChooser(); int returnValue = fileChooser.showOpenDialog(null); + // Vérifie si l'utilisateur a sélectionné un fichier. if (returnValue == JFileChooser.APPROVE_OPTION) { File selectedFile = fileChooser.getSelectedFile(); - // Lecture de la grille à partir du fichier sélectionné + // Lit la grille à partir du fichier sélectionné. Lecteur.lecture(selectedFile, grille); - // Résolution du Sudoku + // Résout le Sudoku. long startTime = System.nanoTime(); if (Resolveur.resoudreSudoku(grille)) { long endTime = System.nanoTime(); long duration = (endTime - startTime) / 1000000; + // Affiche la grille résolue dans une nouvelle fenêtre. FenetrePrincipale fenetrePrincipale = new FenetrePrincipale(); fenetrePrincipale.afficher(true, grille); JOptionPane.showMessageDialog(null, "Grille résolue avec succès en " + duration + " millisecondes !"); diff --git a/src/CaseMouseListener.java b/src/CaseMouseListener.java index fc4a43a..53d4217 100644 --- a/src/CaseMouseListener.java +++ b/src/CaseMouseListener.java @@ -1,22 +1,51 @@ import javax.swing.*; import java.awt.event.*; +/** + * La classe CaseMouseListener est un écouteur d'événements de souris utilisé pour gérer les actions + * lorsque l'utilisateur clique sur une case de la grille de Sudoku. + * Elle permet à l'utilisateur de sélectionner une case, d'y entrer un chiffre ou des valeurs incertaines. + * + * Elle étend MouseAdapter pour gérer les événements de souris de manière simplifiée. + * + * Elle utilise des boîtes de dialogue JOptionPane pour permettre à l'utilisateur d'entrer des chiffres ou des valeurs incertaines. + * + * @author Dick Adrien + * @version 8.0 + */ public class CaseMouseListener extends MouseAdapter { private SaisieGrille panel; + /** + * Constructeur de la classe CaseMouseListener. + * + * @param panel Le panneau de saisie de la grille de Sudoku associé à cet écouteur. + */ public CaseMouseListener(SaisieGrille panel) { this.panel = panel; } + /** + * Méthode appelée lorsque l'utilisateur clique sur une case de la grille de Sudoku. + * + * @param e L'événement de souris associé au clic. + */ @Override public void mouseClicked(MouseEvent e) { + // Convertit les coordonnées du clic en indices de ligne et de colonne dans la grille. int x = e.getX() / panel.getTailleCellule(); int y = e.getY() / panel.getTailleCellule(); + + // Vérifie si les coordonnées se trouvent dans la grille. if (x >= 0 && x < panel.getTailleGrille() * panel.getTailleRegion() && y >= 0 && y < panel.getTailleGrille() * panel.getTailleRegion()) { + // Enregistre la ligne et la colonne sélectionnées. panel.setLigneSelectionnee(y); panel.setColonneSelectionnee(x); System.out.println("Case sélectionnée : (" + panel.getLigneSelectionnee() + ", " + panel.getColonneSelectionnee() + ")"); + + // Vérifie si la case sélectionnée peut être modifiée. if (panel.getGrilleInitiale()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] == 0) { + // Affiche une boîte de dialogue pour permettre à l'utilisateur d'entrer un chiffre ou des valeurs incertaines. String[] options = {"Incertain", "Valider"}; JTextField textField = new JTextField(); Object[] message = { @@ -25,12 +54,16 @@ public class CaseMouseListener extends MouseAdapter { }; int option = JOptionPane.showOptionDialog(null, message, "Entrez un nombre", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]); if (option == 1) { + // L'utilisateur a choisi de valider un chiffre. String valeurStr = textField.getText(); try { int valeur = Integer.parseInt(valeurStr); + // Vérifie si le chiffre est valide pour cette case. if (panel.validerChiffre(panel.getLigneSelectionnee(), panel.getColonneSelectionnee(), valeur)) { + // Met à jour la grille et la redessine si le chiffre est valide. panel.getGrille()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] = valeur; panel.repaint(); + // Vérifie si la grille est complète après la mise à jour. if (panel.grilleComplete()) { panel.afficherBravo(); } @@ -41,7 +74,7 @@ public class CaseMouseListener extends MouseAdapter { JOptionPane.showMessageDialog(null, "Saisie invalide. Veuillez entrer un nombre."); } } else if (option == 0) { - // Le joueur a choisi "Incertain" + // L'utilisateur a choisi "Incertain". JTextField[] incertainFields = new JTextField[4]; for (int i = 0; i < 4; i++) { incertainFields[i] = new JTextField(); @@ -55,9 +88,9 @@ public class CaseMouseListener extends MouseAdapter { }; int incertainOption = JOptionPane.showOptionDialog(null, incertainMessage, "Entrez les valeurs incertaines", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, null, null); if (incertainOption == JOptionPane.OK_OPTION) { - // Vérifier que les valeurs obligatoires sont remplies + // Vérifie que les valeurs obligatoires sont remplies. if (!incertainFields[0].getText().isEmpty() && !incertainFields[1].getText().isEmpty()) { - // Vérifier que les valeurs incertaines sont valides + // Vérifie que les valeurs incertaines sont valides. boolean valeursValides = true; for (int i = 0; i < 4; i++) { if (!incertainFields[i].getText().isEmpty()) { @@ -69,7 +102,7 @@ public class CaseMouseListener extends MouseAdapter { } } if (valeursValides) { - // Récupérer les valeurs incertaines saisies par le joueur + // Récupère les valeurs incertaines saisies par l'utilisateur. int valeursIncertaines = 0; for (int i = 0; i < 4; i++) { if (!incertainFields[i].getText().isEmpty()) { @@ -77,7 +110,7 @@ public class CaseMouseListener extends MouseAdapter { valeursIncertaines |= (valeur << (i * 4)); } } - // Mettre à jour la grille avec les valeurs incertaines + // Met à jour la grille avec les valeurs incertaines et la redessine. panel.getGrille()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] = valeursIncertaines; panel.repaint(); } else { diff --git a/src/FenetreChoix.java b/src/FenetreChoix.java index d34c45c..c358812 100644 --- a/src/FenetreChoix.java +++ b/src/FenetreChoix.java @@ -1,30 +1,58 @@ import javax.swing.*; import java.awt.*; - +/** + * La classe FenetreChoix est utilisée pour afficher la fenêtre de choix de mode de résolution du Sudoku. + * Elle crée une fenêtre avec deux boutons, l'un pour le mode automatique et l'autre pour le mode manuel. + * Lorsque l'utilisateur choisit l'un des modes, la fenêtre se ferme. + * + * @author Dick Adrien + * @version 2.0 + */ public class FenetreChoix { + /** + * Affiche la fenêtre de choix. + */ public void afficher() { + // Crée une nouvelle fenêtre avec un titre. JFrame choixFrame = new JFrame("Choix de résolution du Sudoku"); + + // Définit l'opération de fermeture par défaut de la fenêtre. choixFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + + // Définit la taille de la fenêtre. choixFrame.setSize(400, 200); + + // Définit le gestionnaire de disposition de la fenêtre. choixFrame.setLayout(new BorderLayout()); + + // Centre la fenêtre sur l'écran. choixFrame.setLocationRelativeTo(null); + // Crée un label pour afficher un message d'instruction. JLabel label = new JLabel("Choisissez le mode de résolution du Sudoku :"); label.setHorizontalAlignment(JLabel.CENTER); + // Crée deux boutons pour les modes automatique et manuel. JButton automatiqueButton = new JButton("Automatique"); JButton manuelButton = new JButton("Manuel"); + // Crée un panel pour contenir les boutons et définit son gestionnaire de disposition. JPanel boutonsPanel = new JPanel(); boutonsPanel.setLayout(new FlowLayout()); + + // Ajoute les boutons au panel. boutonsPanel.add(automatiqueButton); boutonsPanel.add(manuelButton); + // Ajoute le label et le panel de boutons à la fenêtre. choixFrame.add(label, BorderLayout.NORTH); choixFrame.add(boutonsPanel, BorderLayout.CENTER); + + // Rend la fenêtre visible. choixFrame.setVisible(true); + // Associe un écouteur d'événements aux boutons pour gérer les actions. automatiqueButton.addActionListener(new AutomatiqueActionListener(choixFrame)); manuelButton.addActionListener(new ManuelActionListener(choixFrame)); } diff --git a/src/FenetreModif.java b/src/FenetreModif.java index 7918950..a198128 100644 --- a/src/FenetreModif.java +++ b/src/FenetreModif.java @@ -2,45 +2,53 @@ import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.io.*; -import java.io.File; -import java.io.PrintWriter; -import java.io.FileWriter; -import java.io.IOException; -import javax.swing.JFileChooser; import javax.swing.filechooser.FileNameExtensionFilter; +/** + * La classe FenetreModif est utilisée pour afficher une fenêtre permettant de modifier une grille Sudoku et de l'enregistrer dans un fichier. + * Elle comporte une méthode statique fenetreModification qui prend en paramètre une grille Sudoku, puis affiche une fenêtre avec la grille et un bouton d'enregistrement. + * + * @author Raban Hugo + * @version 3.0 + */ public class FenetreModif{ + /** + * Méthode statique pour afficher une fenêtre permettant de modifier une grille Sudoku et de l'enregistrer dans un fichier. + * + * @param grille La grille Sudoku à modifier. + */ public static void fenetreModification(int[][] grille) { - JFrame frame = new JFrame("Sudoku"); - frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); - SaisieGrille saisieGrille = new SaisieGrille(grille); // Utilisation de la classe SaisieGrille pour permettre la saisie des valeurs - JButton register = new JButton("Enregistrer"); + JFrame frame = new JFrame("Sudoku"); // Crée une nouvelle fenêtre avec le titre "Sudoku" + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Définit l'action par défaut lorsque la fenêtre est fermée + SaisieGrille saisieGrille = new SaisieGrille(grille); // Crée une nouvelle instance de SaisieGrille avec la grille Sudoku fournie + JButton register = new JButton("Enregistrer"); // Crée un nouveau bouton "Enregistrer" + + // Ajoute un écouteur d'événements au bouton "Enregistrer" register.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e){ - JFileChooser fileChooser = new JFileChooser(); + JFileChooser fileChooser = new JFileChooser(); // Crée un sélecteur de fichiers - FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri"); - fileChooser.setFileFilter(filter); + FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri"); // Définit un filtre pour les fichiers avec l'extension .gri + fileChooser.setFileFilter(filter); // Applique le filtre au sélecteur de fichiers - File workingDirectory = new File(System.getProperty("user.dir")); - fileChooser.setCurrentDirectory(workingDirectory); + File workingDirectory = new File(System.getProperty("user.dir")); // Récupère le répertoire de travail de l'application + fileChooser.setCurrentDirectory(workingDirectory); // Définit le répertoire de départ du sélecteur de fichiers JPanel panneau = new JPanel(); - int valeur_de_retour = fileChooser.showOpenDialog(panneau); - if(valeur_de_retour == JFileChooser.APPROVE_OPTION) { - Register.sauvegarde(fileChooser.getSelectedFile(), grille); + int valeur_de_retour = fileChooser.showOpenDialog(panneau); // Affiche le sélecteur de fichiers et attend la sélection d'un fichier + if(valeur_de_retour == JFileChooser.APPROVE_OPTION) { // Si un fichier est sélectionné + Register.sauvegarde(fileChooser.getSelectedFile(), grille); // Enregistre la grille dans le fichier sélectionné en utilisant la méthode sauvegarde de la classe Register } } }); - frame.add(register, BorderLayout.SOUTH); // Ajouter le bouton "Enregistrer" + frame.add(register, BorderLayout.SOUTH); // Ajoute le bouton "Enregistrer" en bas de la fenêtre + frame.add(saisieGrille, BorderLayout.CENTER); // Ajoute la grille à la fenêtre - frame.add(saisieGrille, BorderLayout.CENTER); // Ajouter la grille à la fenêtre + frame.pack(); // Ajuste la taille de la fenêtre pour qu'elle s'adapte à son contenu + frame.setLocationRelativeTo(null); // Centre la fenêtre sur l'écran + frame.setVisible(true); // Rend la fenêtre visible - frame.pack(); - frame.setLocationRelativeTo(null); // Centrer la fenêtre sur l'écran - frame.setVisible(true); - - System.out.println("La fenêtre de création a été affichée."); + System.out.println("La fenêtre de création a été affichée."); // Affiche un message dans la console pour indiquer que la fenêtre a été affichée } -} \ No newline at end of file +} diff --git a/src/FenetrePrincipale.java b/src/FenetrePrincipale.java index 3a3f703..ecc0cb5 100644 --- a/src/FenetrePrincipale.java +++ b/src/FenetrePrincipale.java @@ -1,25 +1,53 @@ - import javax.swing.*; import java.awt.*; - +/** + * La classe FenetrePrincipale est utilisée pour afficher la fenêtre principale du jeu Sudoku. + * Elle affiche une grille de Sudoku dans une fenêtre Swing. + * + * Elle prend en compte le mode de jeu (automatique ou manuel) pour personnaliser l'affichage. + * Si le mode est manuel, un bouton de réinitialisation est également affiché. + * + * @author Dick Adrien + * @version 2.0 + */ public class FenetrePrincipale { + /** + * Affiche la fenêtre principale du Sudoku. + * + * @param modeAutomatique Indique si le mode de jeu est automatique ou manuel. + * @param grille La grille de Sudoku à afficher. + */ public void afficher(boolean modeAutomatique, int[][] grille) { + // Crée une nouvelle fenêtre avec un titre. JFrame frame = new JFrame("Sudoku"); + + // Définit l'opération de fermeture par défaut de la fenêtre. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + + // Crée un composant pour la saisie de la grille de Sudoku. SaisieGrille saisieGrille = new SaisieGrille(grille); + // Si le mode n'est pas automatique, ajoute un bouton de réinitialisation. if (!modeAutomatique) { JButton reinitialiserButton = new JButton("Réinitialiser"); reinitialiserButton.addActionListener(new ReinitialiserActionListener(grille, saisieGrille)); frame.add(reinitialiserButton, BorderLayout.SOUTH); } + // Ajoute le composant de saisie de la grille à la fenêtre. frame.add(saisieGrille, BorderLayout.CENTER); + + // Ajuste la taille de la fenêtre en fonction de son contenu. frame.pack(); + + // Centre la fenêtre sur l'écran. frame.setLocationRelativeTo(null); + + // Rend la fenêtre visible. frame.setVisible(true); + // Affiche un message dans la console pour indiquer que la fenêtre Sudoku a été affichée. System.out.println("La fenêtre Sudoku a été affichée."); } } diff --git a/src/GenerateurSudoku.java b/src/GenerateurSudoku.java deleted file mode 100644 index 0106136..0000000 --- a/src/GenerateurSudoku.java +++ /dev/null @@ -1,20 +0,0 @@ -import javax.swing.*; - -public class GenerateurSudoku { - public static int[][] genererGrille() { - // grille par défaut - int[][] grille = { - {0, 0, 0, 0, 9, 5, 0, 0, 4}, - {5, 3, 0, 4, 0, 8, 7, 0, 2}, - {0, 0, 0, 7, 0, 0, 6, 0, 3}, - {9, 0, 0, 0, 3, 4, 0, 8, 0}, - {0, 4, 0, 0, 1, 0, 0, 7, 0}, - {0, 2, 0, 5, 7, 0, 0, 0, 6}, - {4, 0, 9, 0, 0, 2, 0, 0, 0}, - {6, 0, 7, 9, 0, 3, 0, 2, 1}, - {2, 0, 0, 6, 5, 0, 0, 0, 0} - }; - - return grille; - } -} diff --git a/src/GrilleExisteActionListener.java b/src/GrilleExisteActionListener.java index 90c7491..9f09e43 100644 --- a/src/GrilleExisteActionListener.java +++ b/src/GrilleExisteActionListener.java @@ -1,38 +1,64 @@ import javax.swing.*; -import java.awt.*; +import javax.swing.filechooser.FileNameExtensionFilter; import java.awt.event.*; import java.io.*; -import java.io.File; -import java.io.PrintWriter; -import java.io.FileWriter; -import java.io.IOException; -import javax.swing.JFileChooser; -import javax.swing.filechooser.FileNameExtensionFilter; -public class GrilleExisteActionListener implements ActionListener{ +/** + * La classe GrilleExisteActionListener est un écouteur d'événements utilisé pour gérer l'action de sélectionner une grille existante. + * + * Lorsque l'utilisateur clique sur le bouton pour choisir une grille existante, cet écouteur est déclenché. + * + * Il ferme la fenêtre de choix actuelle, ouvre un sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille existant, puis charge la grille à partir de ce fichier. + * + * Si l'utilisateur sélectionne un fichier valide, la grille est chargée à partir de ce fichier et une nouvelle fenêtre de modification est affichée avec cette grille. + * + * @author Raban Hugo + * @version 4.0 + */ +public class GrilleExisteActionListener implements ActionListener { private JFrame choixFrame; + /** + * Constructeur de la classe GrilleExisteActionListener. + * + * @param choixFrame La fenêtre de choix actuelle. + */ public GrilleExisteActionListener(JFrame choixFrame) { this.choixFrame = choixFrame; } + /** + * Méthode actionPerformed qui est appelée lorsque l'action est déclenchée (l'utilisateur clique sur le bouton). + * + * @param e L'événement d'action associé à cette action. + */ @Override - public void actionPerformed(ActionEvent e) { + // Ferme la fenêtre de choix actuelle choixFrame.dispose(); - int [][] grille = new int [9][9]; - JFileChooser fileChooser = new JFileChooser(); - FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri"); + // Crée une nouvelle grille vide + int[][] grille = new int[9][9]; + + // Ouvre le sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille + JFileChooser fileChooser = new JFileChooser(); + FileNameExtensionFilter filter = new FileNameExtensionFilter("Fichier grille", "gri"); fileChooser.setFileFilter(filter); + // Définit le répertoire de travail actuel comme répertoire initial du sélecteur de fichiers File workingDirectory = new File(System.getProperty("user.dir")); fileChooser.setCurrentDirectory(workingDirectory); - JPanel panneau = new JPanel(); - int valeur_de_retour = fileChooser.showOpenDialog(panneau); - if(valeur_de_retour == JFileChooser.APPROVE_OPTION) { + + // Affiche le sélecteur de fichiers dans un panneau + JPanel panel = new JPanel(); + int returnValue = fileChooser.showOpenDialog(panel); + + // Si l'utilisateur a sélectionné un fichier valide + if (returnValue == JFileChooser.APPROVE_OPTION) { + // Charge la grille à partir du fichier sélectionné Lecteur.lecture(fileChooser.getSelectedFile(), grille); + // Affiche une nouvelle fenêtre de modification avec la grille chargée FenetreModif.fenetreModification(grille); } } -} \ No newline at end of file +} diff --git a/src/GrillePainter.java b/src/GrillePainter.java index f60250f..653e6a7 100644 --- a/src/GrillePainter.java +++ b/src/GrillePainter.java @@ -1,11 +1,31 @@ import java.awt.*; +/** + * La classe GrillePainter est utilisée pour dessiner la grille de Sudoku et ses valeurs dans le panneau de saisie. + * + * Elle fournit une méthode statique dessinerGrille qui prend en charge le dessin de la grille et des valeurs de la grille. + * + * Elle utilise les informations fournies par le panneau de saisie (SaisieGrille) pour dessiner correctement la grille. + * + * Elle utilise la classe Graphics2D pour dessiner des formes et des textes. + * + * @author Dick Adrien + * @version 4.0 + */ public class GrillePainter { + + /** + * Méthode statique pour dessiner la grille de Sudoku et ses valeurs dans le panneau de saisie. + * + * @param g Le contexte graphique dans lequel dessiner. + * @param panel Le panneau de saisie de la grille de Sudoku. + */ public static void dessinerGrille(Graphics g, SaisieGrille panel) { Graphics2D g2d = (Graphics2D) g; Stroke ancienStroke = g2d.getStroke(); g2d.setStroke(new BasicStroke(4)); + // Dessine les lignes de la grille for (int i = 0; i <= panel.getTailleGrille() * panel.getTailleRegion(); i++) { if (i % panel.getTailleRegion() == 0) { g2d.drawLine(0, i * panel.getTailleCellule(), panel.getTailleGrille() * panel.getTailleRegion() * panel.getTailleCellule(), i * panel.getTailleCellule()); @@ -15,6 +35,7 @@ public class GrillePainter { g2d.setStroke(ancienStroke); + // Dessine les valeurs de la grille for (int i = 0; i < panel.getTailleGrille() * panel.getTailleRegion(); i++) { for (int j = 0; j < panel.getTailleGrille() * panel.getTailleRegion(); j++) { g.setColor(Color.BLACK); @@ -22,9 +43,11 @@ public class GrillePainter { int valeur = panel.getGrille()[i][j]; if (valeur != 0) { + // Dessine la valeur dans la case if (valeur < 10) { g.drawString(String.valueOf(valeur), j * panel.getTailleCellule() + panel.getTailleCellule() / 2, i * panel.getTailleCellule() + panel.getTailleCellule() / 2); } else { + // Si la valeur est incertaine, la décompose et la dessine dans les sous-cases int[] valeurs = decomposerValeurs(valeur); for (int k = 0; k < valeurs.length; k++) { int xOffset = (k % 2) * panel.getTailleCellule() / 2; @@ -37,6 +60,12 @@ public class GrillePainter { } } + /** + * Méthode privée pour décomposer une valeur incertaine en ses sous-valeurs. + * + * @param valeursIncertaines La valeur incertaine à décomposer. + * @return Un tableau d'entiers contenant les sous-valeurs. + */ private static int[] decomposerValeurs(int valeursIncertaines) { int[] valeurs = new int[4]; for (int i = 0; i < 4; i++) { diff --git a/src/GrilleVideActionListener.java b/src/GrilleVideActionListener.java index 35aed73..55ca395 100644 --- a/src/GrilleVideActionListener.java +++ b/src/GrilleVideActionListener.java @@ -1,28 +1,44 @@ import javax.swing.*; -import java.awt.*; import java.awt.event.*; import java.io.*; -import java.io.File; -import java.io.PrintWriter; -import java.io.FileWriter; -import java.io.IOException; -import javax.swing.JFileChooser; -import javax.swing.filechooser.FileNameExtensionFilter; -public class GrilleVideActionListener implements ActionListener{ +/** + * La classe GrilleVideActionListener est un écouteur d'événements utilisé pour gérer l'action de sélectionner une grille vide. + * + * Lorsque l'utilisateur clique sur le bouton pour choisir une grille vide, cet écouteur est déclenché. + * + * Il crée une grille vide, ferme la fenêtre de choix actuelle, puis affiche une nouvelle fenêtre de modification avec cette grille vide. + * + * @author Raban Hugo + * @version 2.0 + */ +public class GrilleVideActionListener implements ActionListener { private JFrame choixFrame; + /** + * Constructeur de la classe GrilleVideActionListener. + * + * @param choixFrame La fenêtre de choix actuelle. + */ public GrilleVideActionListener(JFrame choixFrame) { this.choixFrame = choixFrame; } + /** + * Méthode actionPerformed qui est appelée lorsque l'action est déclenchée (l'utilisateur clique sur le bouton). + * + * @param e L'événement d'action associé à cette action. + */ @Override - public void actionPerformed(ActionEvent e) { - int [][] grille = new int [9][9]; - choixFrame.dispose(); + // Crée une nouvelle grille vide + int[][] grille = new int[9][9]; Grilles.grilleVide(grille); + + // Ferme la fenêtre de choix actuelle + choixFrame.dispose(); + + // Affiche une nouvelle fenêtre de modification avec la grille vide FenetreModif.fenetreModification(grille); } - -} \ No newline at end of file +} diff --git a/src/Grilles.java b/src/Grilles.java new file mode 100644 index 0000000..d7d28e0 --- /dev/null +++ b/src/Grilles.java @@ -0,0 +1,65 @@ +import javax.swing.*; +import java.io.*; + +/** + * La classe Grilles contient des méthodes pour manipuler les grilles Sudoku. + * + * Elle comporte deux méthodes statiques : + * - grilleExiste pour lire une grille à partir d'un fichier existant et stocker ses valeurs dans une grille. + * - grilleVide pour initialiser une grille avec des valeurs vides (0). + * + * @author Raban Hugo + * @version 2.0 + */ +public class Grilles { + /** + * Méthode statique pour lire les données d'un fichier et les stocker dans une grille. + * + * @param name Le nom du fichier à lire. + */ + public static void grilleExiste(String name) { + int valeur[] = new int[9]; // Tableau pour stocker les valeurs lues temporairement + int valeurEnFin[][] = new int[9][9]; // Tableau pour stocker les valeurs de la grille + + int valeurActuelle = 0; + + try { + FileInputStream fichier = new FileInputStream(name); // Crée un flux pour lire le fichier + DataInputStream flux = new DataInputStream(fichier); // Crée un flux de données pour lire les données à partir du flux de fichier + + try { + // Lecture des données du fichier + for (int i = 0; i < 9; i++) { + valeur[i] = flux.readInt(); // Lecture d'une ligne de valeurs dans le tableau temporaire + } + flux.close(); // Fermeture du flux de données + } catch (IOException e) { + System.out.println("Erreur lors de la lecture du fichier."); // Gestion des erreurs de lecture + } + } catch (FileNotFoundException e) { + System.out.println("Fichier non trouvé."); // Gestion des erreurs de fichier non trouvé + } + + // Transformation des valeurs lues en tableau 2D pour la grille + for (int i = 0; i < 9; i++) { + for (int j = 8; j >= 0; j--) { + valeurActuelle = valeur[i] % 10; // Extrait le chiffre des unités de la valeur + valeur[i] = (valeur[i] - valeurActuelle) / 10; // Supprime le chiffre extrait de la valeur + valeurEnFin[i][j] = valeurActuelle; // Stocke la valeur dans la grille + } + } + } + + /** + * Méthode statique pour initialiser une grille avec des valeurs vides (0). + * + * @param g La grille à initialiser. + */ + public static void grilleVide(int[][] g) { + for (int i = 0; i < 9; i++) { + for (int j = 0; j < 9; j++) { + g[i][j] = 0; // Initialise chaque cellule de la grille avec la valeur 0 + } + } + } +} diff --git a/src/Lecteur.java b/src/Lecteur.java index 619a279..919f033 100644 --- a/src/Lecteur.java +++ b/src/Lecteur.java @@ -1,45 +1,49 @@ -import javax.swing.*; -import java.awt.*; import java.io.*; -import javax.swing.filechooser.FileNameExtensionFilter; -public class Lecteur{ - public static void lecture(File name, int [][] g) { - - int valeur[] = new int[9]; - int valeur_en_fin[][]= new int[9][9]; +/** + * La classe Lecteur est utilisée pour lire les données d'un fichier de grille. + * + * Elle comporte une méthode statique lecture qui prend en entrée un fichier et une grille, puis lit les données du fichier pour les stocker dans la grille. + * + * Le fichier doit contenir une grille Sudoku sous forme de chiffres, où chaque ligne représente une ligne de la grille et chaque chiffre représente une valeur dans la grille. + * + * @author Raban Hugo + * @version 5.0 + */ +public class Lecteur { + /** + * Méthode statique pour lire les données d'un fichier et les stocker dans une grille. + * + * @param fichier Le fichier à lire. + * @param grille La grille dans laquelle stocker les données lues. + */ + public static void lecture(File fichier, int[][] grille) { + int[] valeurs = new int[9]; // Tableau pour stocker les valeurs lues temporairement - int valeur_actuelle=0; + try { + FileInputStream fileInputStream = new FileInputStream(fichier); // Crée un flux pour lire le fichier + DataInputStream dataInputStream = new DataInputStream(fileInputStream); // Crée un flux de données pour lire les données à partir du flux de fichier - try{ - FileInputStream fichier = new FileInputStream(name); - DataInputStream flux = new DataInputStream(fichier); - - try{ - for(int i=0; i<9; i++){ - valeur[i]=flux.readInt(); - System.out.print(valeur[i]); + try { + // Lecture des données du fichier + for (int i = 0; i < 9; i++) { + valeurs[i] = dataInputStream.readInt(); // Lecture d'une ligne de valeurs dans le tableau temporaire + } + dataInputStream.close(); // Fermeture du flux de données + } catch (IOException e) { + System.out.println("Erreur lors de la lecture du fichier."); // Gestion des erreurs de lecture + } + } catch (FileNotFoundException e) { + System.out.println("Fichier non trouvé."); // Gestion des erreurs de fichier non trouvé + } + + // Transformation des valeurs lues en tableau 2D pour la grille + for (int i = 0; i < 9; i++) { + for (int j = 8; j >= 0; j--) { + int valeurActuelle = valeurs[i] % 10; // Extrait le chiffre des unités de la valeur + valeurs[i] = (valeurs[i] - valeurActuelle) / 10; // Supprime le chiffre extrait de la valeur + grille[i][j] = valeurActuelle; // Stocke la valeur dans la grille + } } - flux.close(); - }catch(IOException e){ - System.out.println("Lecture fichier impossible"); - } - }catch(FileNotFoundException e){ - System.out.println("Fichier non trouvé"); } - - for(int i=0; i<9; i++){ - for(int j=8; j>=0; j--){ - valeur_actuelle=valeur[i]; - - valeur_actuelle=valeur_actuelle%10; - valeur[i]=(valeur[i]-valeur_actuelle)/10; - - valeur_en_fin[i][j]=valeur_actuelle; - System.out.print(valeur_actuelle); - g[i][j] = valeur_actuelle; - } - valeur_actuelle=0; - } - } -} \ No newline at end of file +} diff --git a/src/MainCreation.java b/src/MainCreation.java index 7867bb3..9ec5691 100644 --- a/src/MainCreation.java +++ b/src/MainCreation.java @@ -1,24 +1,31 @@ import javax.swing.*; import java.awt.*; import java.awt.event.*; -import java.io.*; -import java.io.File; -import java.io.PrintWriter; -import java.io.FileWriter; -import java.io.IOException; -import javax.swing.JFileChooser; -import javax.swing.filechooser.FileNameExtensionFilter; +/** + * La classe MainCreation est utilisée pour démarrer l'application de création de grille de Sudoku. + * + * Elle crée une fenêtre de sélection pour choisir entre une grille vide ou une grille existante. + * + * L'utilisateur peut sélectionner l'une des deux options en cliquant sur les boutons correspondants. + * + * Les actions des boutons sont gérées par des écouteurs d'événements spécifiques. + * + * Elle utilise les classes GrilleVideActionListener et GrilleExisteActionListener pour gérer les actions des boutons. + * + * @author Raban Hugo + * @version 3.0 + */ public class MainCreation { public static void main(String[] args) { - //Création de la fenetre de selection + choix du dossier + // Création de la fenetre de selection + choix du dossier JFrame selF = new JFrame("Choix de résolution du Sudoku"); selF.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); selF.setSize(400, 200); selF.setLayout(new BorderLayout()); selF.setLocationRelativeTo(null); - JLabel sel = new JLabel("Quelle grilles souhaitez vous ?"); - //Création des boutons + JLabel sel = new JLabel("Quelle grille souhaitez-vous ?"); + // Création des boutons sel.setHorizontalAlignment(JLabel.CENTER); JButton grilleVide = new JButton("Grille vide"); JButton grilleExiste = new JButton("Grille Existante"); @@ -31,34 +38,8 @@ public class MainCreation { selF.add(sel, BorderLayout.NORTH); selF.add(boutonsSelect, BorderLayout.CENTER); selF.setVisible(true); - //Action des bouton + // Action des boutons grilleVide.addActionListener(new GrilleVideActionListener(selF)); grilleExiste.addActionListener(new GrilleExisteActionListener(selF)); - /*grilleVide.addActionListener(new ActionListener() { - public void actionPerformed(ActionEvent e) { - selF.dispose(); - Grilles.grilleVide(grille); - FenetreModif.fenetreModification(grille); - } - });*/ - /* grilleExiste.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - selF.dispose(); - JFileChooser fileChooser = new JFileChooser(); - - FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri"); - fileChooser.setFileFilter(filter); - - File workingDirectory = new File(System.getProperty("user.dir")); - fileChooser.setCurrentDirectory(workingDirectory); - JPanel panneau = new JPanel(); - int valeur_de_retour = fileChooser.showOpenDialog(panneau); - if(valeur_de_retour == JFileChooser.APPROVE_OPTION) { - Lecteur.lecture(fileChooser.getSelectedFile(), grille); - FenetreModif.fenetreModification(grille); - } - } - });*/ } } diff --git a/src/MainJeu.java b/src/MainJeu.java index 8641b8e..cd59eea 100644 --- a/src/MainJeu.java +++ b/src/MainJeu.java @@ -1,9 +1,24 @@ - +/** + * La classe MainJeu est utilisée pour démarrer le programme du jeu. + * Elle crée une instance de la classe FenetreChoix et affiche la fenêtre de choix du jeu. + * + * @author Dick Adrien + * @version 2.0 + */ public class MainJeu { + /** + * La méthode principale qui lance le programme. + * + * @param args les arguments de la ligne de commande (non utilisés dans cet exemple) + */ public static void main(String[] args) { + // Affiche un message indiquant que le programme principal a démarré. System.out.println("Le programme Main a démarré."); + // Crée une instance de la classe FenetreChoix pour afficher la fenêtre de choix du jeu. FenetreChoix fenetreChoix = new FenetreChoix(); + + // Appelle la méthode pour afficher la fenêtre de choix du jeu. fenetreChoix.afficher(); } } diff --git a/src/ManuelActionListener.java b/src/ManuelActionListener.java index 6342f73..ca9a798 100644 --- a/src/ManuelActionListener.java +++ b/src/ManuelActionListener.java @@ -2,30 +2,55 @@ import javax.swing.*; import java.awt.event.*; import java.io.File; +/** + * La classe ManuelActionListener est un écouteur d'événements utilisé pour gérer l'action + * lorsqu'on clique sur le bouton "Manuel" dans la fenêtre de choix. + * Elle permet de choisir un fichier contenant une grille de Sudoku et d'afficher la grille dans une nouvelle fenêtre + * pour que l'utilisateur puisse la résoudre manuellement. + * + * Elle implémente l'interface ActionListener pour écouter les événements liés au bouton. + * + * @author Dick Adrien + * @version 2.0 + */ public class ManuelActionListener implements ActionListener { private JFrame choixFrame; + /** + * Constructeur de la classe ManuelActionListener. + * + * @param choixFrame La fenêtre de choix du Sudoku. + */ public ManuelActionListener(JFrame choixFrame) { this.choixFrame = choixFrame; } + /** + * Méthode appelée lorsque l'action associée à ce listener est déclenchée, c'est-à-dire lorsque le bouton + * "Manuel" est cliqué. + * + * @param e L'événement associé à l'action. + */ @Override public void actionPerformed(ActionEvent e) { + // Ferme la fenêtre de choix du Sudoku. choixFrame.dispose(); - int[][] grille = new int[9][9]; // Création d'une grille vide + // Crée une grille vide de Sudoku. + int[][] grille = new int[9][9]; - // Ouverture du sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille + // Ouvre un sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille. JFileChooser fileChooser = new JFileChooser(); int returnValue = fileChooser.showOpenDialog(null); + // Vérifie si l'utilisateur a sélectionné un fichier. if (returnValue == JFileChooser.APPROVE_OPTION) { File selectedFile = fileChooser.getSelectedFile(); - // Lecture de la grille à partir du fichier sélectionné + // Lit la grille à partir du fichier sélectionné. Lecteur.lecture(selectedFile, grille); - // Affichage de la grille dans la fenêtre principale en mode manuel + // Affiche la grille dans la fenêtre principale en mode manuel. FenetrePrincipale fenetrePrincipale = new FenetrePrincipale(); fenetrePrincipale.afficher(false, grille); } diff --git a/src/Register.java b/src/Register.java index 8bb978e..d665fcc 100644 --- a/src/Register.java +++ b/src/Register.java @@ -3,36 +3,48 @@ import java.awt.*; import java.io.*; import javax.swing.filechooser.FileNameExtensionFilter; +/** + * La classe Register est utilisée pour enregistrer une grille Sudoku dans un fichier. + * Elle comporte une méthode statique sauvegarde qui prend en paramètre un fichier et une grille Sudoku, puis enregistre la grille dans le fichier. + * + * @author Raban Hugo + * @version 3.0 + */ public class Register{ - public static void sauvegarde(File name, int [][] g){ - int val[] = new int[9]; + /** + * Méthode statique pour enregistrer une grille Sudoku dans un fichier. + * + * @param name Le fichier dans lequel enregistrer la grille. + * @param g La grille Sudoku à enregistrer. + */ + public static void sauvegarde(File name, int [][] g){ + int val[] = new int[9]; // Tableau pour stocker temporairement les valeurs à écrire dans le fichier - int actuVal=0; - int v=0; + int actuVal=0; + int v=0; - try{ - FileOutputStream fichier = new FileOutputStream(name); - DataOutputStream flux = new DataOutputStream(fichier); + try{ + FileOutputStream fichier = new FileOutputStream(name); // Crée un flux de sortie vers le fichier spécifié + DataOutputStream flux = new DataOutputStream(fichier); // Utilise un flux de données pour écrire dans le fichier - try{ - - - for(int i=0; i<9; i++){ - for(int j=0; j<9; j++){ - actuVal = g[i][j]; - v = (v*10) - actuVal; - } - flux.writeInt(-v); - v=0; - actuVal=0; - } - flux.close(); - }catch(IOException e){ - System.out.println("Lecture fichier imposible"); - } - }catch(FileNotFoundException e){ - System.out.println("Fichier non trouvé"); - } - System.out.print("Fichier enregistrer"); - } -} \ No newline at end of file + try{ + // Parcourt la grille et écrit chaque valeur dans le fichier + for(int i=0; i<9; i++){ + for(int j=0; j<9; j++){ + actuVal = g[i][j]; + v = (v*10) - actuVal; + } + flux.writeInt(-v); // Écrit la valeur dans le fichier (avec un signe négatif pour distinguer les valeurs positives) + v=0; // Réinitialise la valeur temporaire + actuVal=0; + } + flux.close(); // Ferme le flux de sortie + }catch(IOException e){ + System.out.println("Lecture fichier imposible"); // Affiche un message d'erreur en cas de problème lors de l'écriture dans le fichier + } + }catch(FileNotFoundException e){ + System.out.println("Fichier non trouvé"); // Affiche un message d'erreur si le fichier spécifié n'est pas trouvé + } + System.out.print("Fichier enregistré"); // Affiche un message de confirmation dans la console une fois que l'enregistrement est terminé + } +} diff --git a/src/Reinitialiser.java b/src/Reinitialiser.java index a5c8bc3..1cb49e7 100644 --- a/src/Reinitialiser.java +++ b/src/Reinitialiser.java @@ -1,22 +1,41 @@ import javax.swing.*; import java.awt.event.*; +/** + * La classe Reinitialiser est un écouteur d'événements utilisé pour réinitialiser la grille Sudoku. + * Elle implémente l'interface ActionListener. + * + * @author Dick Adrien + * @version 1.0 + */ public class Reinitialiser implements ActionListener { - private int[][] grille; - private SaisieGrille panneauSaisie; + private int[][] grille; // La grille Sudoku + private SaisieGrille panneauSaisie; // Le panneau de saisie de la grille + /** + * Constructeur de la classe Reinitialiser. + * + * @param grille La grille Sudoku à réinitialiser. + * @param panneauSaisie Le panneau de saisie associé à la grille. + */ public Reinitialiser(int[][] grille, SaisieGrille panneauSaisie) { this.grille = grille; this.panneauSaisie = panneauSaisie; } + /** + * Méthode appelée lorsqu'un événement d'action est déclenché, en l'occurrence lorsque le bouton de réinitialisation est cliqué. + * Cette méthode réinitialise la grille en copiant la grille initiale et redessine le panneau de saisie. + * + * @param e L'événement d'action. + */ @Override public void actionPerformed(ActionEvent e) { // Réinitialiser la grille en copiant la grille initiale for (int i = 0; i < grille.length; i++) { System.arraycopy(panneauSaisie.getGrilleInitiale()[i], 0, grille[i], 0, grille[i].length); } - // Redessiner le panneau + // Redessiner le panneau de saisie panneauSaisie.repaint(); } } diff --git a/src/ReinitialiserActionListener.java b/src/ReinitialiserActionListener.java index 75818ab..cb5a546 100644 --- a/src/ReinitialiserActionListener.java +++ b/src/ReinitialiserActionListener.java @@ -1,19 +1,37 @@ - import javax.swing.*; import java.awt.event.*; - +/** + * La classe ReinitialiserActionListener est un écouteur d'événements utilisé pour gérer les actions associées à la réinitialisation de la grille Sudoku. + * Elle implémente l'interface ActionListener. + * + * @author Dick Adrien + * @version 1.0 + */ public class ReinitialiserActionListener implements ActionListener { - private int[][] grille; - private SaisieGrille saisieGrille; + private int[][] grille; // La grille Sudoku + private SaisieGrille saisieGrille; // Le panneau de saisie de la grille + /** + * Constructeur de la classe ReinitialiserActionListener. + * + * @param grille La grille Sudoku à réinitialiser. + * @param saisieGrille Le panneau de saisie associé à la grille. + */ public ReinitialiserActionListener(int[][] grille, SaisieGrille saisieGrille) { this.grille = grille; this.saisieGrille = saisieGrille; } + /** + * Méthode appelée lorsqu'un événement d'action est déclenché, en l'occurrence lorsque le bouton de réinitialisation est cliqué. + * Cette méthode crée une instance de la classe Reinitialiser et appelle sa méthode actionPerformed. + * + * @param e L'événement d'action. + */ @Override public void actionPerformed(ActionEvent e) { + // Créer une instance de Reinitialiser et appeler sa méthode actionPerformed Reinitialiser reinitialiser = new Reinitialiser(grille, saisieGrille); reinitialiser.actionPerformed(e); } diff --git a/src/Resolveur.java b/src/Resolveur.java index 44fd1e6..e0cd49d 100644 --- a/src/Resolveur.java +++ b/src/Resolveur.java @@ -1,4 +1,17 @@ +/** + * La classe Resolveur est utilisée pour résoudre une grille Sudoku. + * Elle comporte une méthode statique resoudreSudoku qui prend en paramètre une grille Sudoku à résoudre. + * + * @author Dick Adrien + * @version 1.0 + */ public class Resolveur { + /** + * Méthode statique pour résoudre une grille Sudoku. + * + * @param grille La grille Sudoku à résoudre. + * @return true si la grille est résolue avec succès, false sinon. + */ public static boolean resoudreSudoku(int[][] grille) { int row = -1; int col = -1; @@ -41,7 +54,15 @@ public class Resolveur { return false; } - // Vérifie si un nombre peut être placé dans une cellule spécifique + /** + * Vérifie si un nombre peut être placé dans une cellule spécifique de la grille. + * + * @param grille La grille Sudoku. + * @param row L'indice de ligne de la cellule. + * @param col L'indice de colonne de la cellule. + * @param num Le nombre à vérifier. + * @return true si le nombre peut être placé dans la cellule, false sinon. + */ private static boolean estCoupValide(int[][] grille, int row, int col, int num) { // Vérifie la ligne for (int x = 0; x < 9; x++) { diff --git a/src/SaisieGrille.java b/src/SaisieGrille.java index 0174b9c..03aa1d3 100644 --- a/src/SaisieGrille.java +++ b/src/SaisieGrille.java @@ -2,6 +2,18 @@ import javax.swing.*; import java.awt.*; import java.awt.event.*; +/** + * La classe SaisieGrille est un composant graphique utilisé pour afficher et manipuler une grille de Sudoku. + * Elle permet à l'utilisateur de sélectionner des cellules et d'y entrer des chiffres. + * Elle fournit également des méthodes pour valider les chiffres entrés et vérifier si la grille est complète. + * + * Elle étend JPanel pour être utilisée comme composant graphique dans une fenêtre Swing. + * + * Elle utilise un gestionnaire d'événements de souris pour gérer la sélection des cellules. + * + * @author Dick Adrien + * @version 8.0 + */ public class SaisieGrille extends JPanel { private static final int TAILLE_GRILLE = 3; private static final int TAILLE_REGION = 3; @@ -11,6 +23,11 @@ public class SaisieGrille extends JPanel { private int ligneSelectionnee = -1; private int colonneSelectionnee = -1; + /** + * Constructeur de la classe SaisieGrille. + * + * @param grille La grille de Sudoku à afficher et à manipuler. + */ public SaisieGrille(int[][] grille) { this.grille = grille; this.grilleInitiale = new int[grille.length][grille[0].length]; @@ -22,9 +39,12 @@ public class SaisieGrille extends JPanel { setPreferredSize(new Dimension(TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE)); setFocusable(true); + // Ajoute un écouteur d'événements de souris pour gérer la sélection des cellules. addMouseListener(new CaseMouseListener(this)); } + // Méthodes d'accès aux attributs + public int[][] getGrilleInitiale() { return grilleInitiale; } @@ -61,27 +81,29 @@ public class SaisieGrille extends JPanel { return grille; } + // Méthodes de validation et de vérification de la grille + public boolean validerChiffre(int ligne, int colonne, int chiffre) { - // Vérifier si le chiffre est entre 1 et 9 + // Vérifie si le chiffre est entre 1 et 9 if (chiffre < 1 || chiffre > 9) { return false; } - // Vérifier la ligne + // Vérifie la ligne for (int j = 0; j < grille.length; j++) { if (grille[ligne][j] == chiffre && j != colonne) { return false; } } - // Vérifier la colonne + // Vérifie la colonne for (int i = 0; i < grille.length; i++) { if (grille[i][colonne] == chiffre && i != ligne) { return false; } } - // Vérifier la région + // Vérifie la région int regionX = colonne / TAILLE_REGION; int regionY = ligne / TAILLE_REGION; for (int i = regionY * TAILLE_REGION; i < (regionY + 1) * TAILLE_REGION; i++) { @@ -92,7 +114,7 @@ public class SaisieGrille extends JPanel { } } - // Vérifier les valeurs incertaines dans la cellule + // Vérifie les valeurs incertaines dans la cellule int valeursIncertaines = grille[ligne][colonne]; for (int i = 0; i < 4; i++) { int valeur = (valeursIncertaines >> (i * 4)) & 0xF; @@ -115,12 +137,16 @@ public class SaisieGrille extends JPanel { return true; } + // Méthode de dessin de la grille + @Override protected void paintComponent(Graphics g) { super.paintComponent(g); GrillePainter.dessinerGrille(g, this); } + // Méthode pour afficher un message de réussite + public void afficherBravo() { JOptionPane.showMessageDialog(this, "Bravo ! La grille est complétée avec succès."); }