codeFinal+docs+clean
This commit is contained in:
parent
7c89ff9cf0
commit
fb71c40735
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -2,35 +2,61 @@ import javax.swing.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.File;
|
||||
|
||||
/**
|
||||
* La classe <code>AutomatiqueActionListener</code> 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 !");
|
||||
|
||||
@ -1,22 +1,51 @@
|
||||
import javax.swing.*;
|
||||
import java.awt.event.*;
|
||||
|
||||
/**
|
||||
* La classe <code>CaseMouseListener</code> 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 {
|
||||
|
||||
@ -1,30 +1,58 @@
|
||||
import javax.swing.*;
|
||||
import java.awt.*;
|
||||
|
||||
|
||||
/**
|
||||
* La classe <code>FenetreChoix</code> 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));
|
||||
}
|
||||
|
||||
@ -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 <code>FenetreModif</code> 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 <code>fenetreModification</code> 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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,25 +1,53 @@
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.*;
|
||||
|
||||
|
||||
/**
|
||||
* La classe <code>FenetrePrincipale</code> 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.");
|
||||
}
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
@ -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 <code>GrilleExisteActionListener</code> 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,11 +1,31 @@
|
||||
import java.awt.*;
|
||||
|
||||
/**
|
||||
* La classe <code>GrillePainter</code> est utilisée pour dessiner la grille de Sudoku et ses valeurs dans le panneau de saisie.
|
||||
*
|
||||
* Elle fournit une méthode statique <code>dessinerGrille</code> 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 (<code>SaisieGrille</code>) 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++) {
|
||||
|
||||
@ -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 <code>GrilleVideActionListener</code> 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);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
65
src/Grilles.java
Normal file
65
src/Grilles.java
Normal file
@ -0,0 +1,65 @@
|
||||
import javax.swing.*;
|
||||
import java.io.*;
|
||||
|
||||
/**
|
||||
* La classe <code>Grilles</code> contient des méthodes pour manipuler les grilles Sudoku.
|
||||
*
|
||||
* Elle comporte deux méthodes statiques :
|
||||
* - <code>grilleExiste</code> pour lire une grille à partir d'un fichier existant et stocker ses valeurs dans une grille.
|
||||
* - <code>grilleVide</code> 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
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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 <code>Lecteur</code> est utilisée pour lire les données d'un fichier de grille.
|
||||
*
|
||||
* Elle comporte une méthode statique <code>lecture</code> 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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 <code>MainCreation</code> 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);
|
||||
}
|
||||
}
|
||||
});*/
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,9 +1,24 @@
|
||||
|
||||
/**
|
||||
* La classe <code>MainJeu</code> 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();
|
||||
}
|
||||
}
|
||||
|
||||
@ -2,30 +2,55 @@ import javax.swing.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.File;
|
||||
|
||||
/**
|
||||
* La classe <code>ManuelActionListener</code> 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);
|
||||
}
|
||||
|
||||
@ -3,36 +3,48 @@ import java.awt.*;
|
||||
import java.io.*;
|
||||
import javax.swing.filechooser.FileNameExtensionFilter;
|
||||
|
||||
/**
|
||||
* La classe <code>Register</code> est utilisée pour enregistrer une grille Sudoku dans un fichier.
|
||||
* Elle comporte une méthode statique <code>sauvegarde</code> 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");
|
||||
}
|
||||
}
|
||||
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é
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,22 +1,41 @@
|
||||
import javax.swing.*;
|
||||
import java.awt.event.*;
|
||||
|
||||
/**
|
||||
* La classe <code>Reinitialiser</code> 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();
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,19 +1,37 @@
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.event.*;
|
||||
|
||||
|
||||
/**
|
||||
* La classe <code>ReinitialiserActionListener</code> 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);
|
||||
}
|
||||
|
||||
@ -1,4 +1,17 @@
|
||||
/**
|
||||
* La classe <code>Resolveur</code> est utilisée pour résoudre une grille Sudoku.
|
||||
* Elle comporte une méthode statique <code>resoudreSudoku</code> 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++) {
|
||||
|
||||
@ -2,6 +2,18 @@ import javax.swing.*;
|
||||
import java.awt.*;
|
||||
import java.awt.event.*;
|
||||
|
||||
/**
|
||||
* La classe <code>SaisieGrille</code> 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.");
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user