makefile

src/AutomatiqueActionListener.java

@@ -0,0 +1,32 @@
+
+import javax.swing.*;
+import java.awt.event.*;
+
+
+public class AutomatiqueActionListener implements ActionListener {
+    private JFrame choixFrame;
+
+    public AutomatiqueActionListener(JFrame choixFrame) {
+        this.choixFrame = choixFrame;
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        choixFrame.dispose();
+
+        int[][] grille = GenerateurSudoku.genererGrille();
+        System.out.println("Grille Sudoku générée avec succès.");
+
+        long startTime = System.nanoTime();
+        if (Resolveur.resoudreSudoku(grille)) {
+            long endTime = System.nanoTime();
+            long duration = (endTime - startTime) / 1000000;
+
+            FenetrePrincipale fenetrePrincipale = new FenetrePrincipale();
+            fenetrePrincipale.afficher(true, grille);
+            JOptionPane.showMessageDialog(null, "Grille résolue avec succès en " + duration + " millisecondes !");
+        } else {
+            JOptionPane.showMessageDialog(null, "Impossible de résoudre la grille.");
+        }
+    }
+}

src/CaseMouseListener.java

@@ -0,0 +1,78 @@
+import javax.swing.*;
+import java.awt.event.*;
+
+public class CaseMouseListener extends MouseAdapter {
+    private SaisieGrille panel;
+
+    public CaseMouseListener(SaisieGrille panel) {
+        this.panel = panel;
+    }
+
+    @Override
+    public void mouseClicked(MouseEvent e) {
+        int x = e.getX() / panel.getTailleCellule();
+        int y = e.getY() / panel.getTailleCellule();
+        if (x >= 0 && x < panel.getTailleGrille() * panel.getTailleRegion() && y >= 0 && y < panel.getTailleGrille() * panel.getTailleRegion()) {
+            panel.setLigneSelectionnee(y);
+            panel.setColonneSelectionnee(x);
+            System.out.println("Case sélectionnée : (" + panel.getLigneSelectionnee() + ", " + panel.getColonneSelectionnee() + ")");
+            if (panel.getGrilleInitiale()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] == 0) {
+                String[] options = {"Incertain", "Valider"};
+                JTextField textField = new JTextField();
+                Object[] message = {
+                    "Entrez la valeur pour la cellule sélectionnée :", 
+                    textField
+                };
+                int option = JOptionPane.showOptionDialog(null, message, "Entrez un nombre", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
+                if (option == 1) {
+                    String valeurStr = textField.getText();
+                    try {
+                        int valeur = Integer.parseInt(valeurStr);
+                        if (panel.validerChiffre(panel.getLigneSelectionnee(), panel.getColonneSelectionnee(), valeur)) {
+                            panel.getGrille()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] = valeur;
+                            panel.repaint();
+                        } else {
+                            JOptionPane.showMessageDialog(null, "Ce chiffre ne respecte pas les contraintes du Sudoku. Veuillez choisir un autre chiffre.");
+                        }
+                    } catch (NumberFormatException ex) {
+                        JOptionPane.showMessageDialog(null, "Saisie invalide. Veuillez entrer un nombre.");
+                    }
+                } else if (option == 0) {
+                    // Le joueur a choisi "Incertain"
+                    JTextField[] incertainFields = new JTextField[4];
+                    for (int i = 0; i < 4; i++) {
+                        incertainFields[i] = new JTextField();
+                    }
+                    Object[] incertainMessage = {
+                        "Entrez les valeurs incertaines pour la cellule sélectionnée :",
+                        "Valeur 1 (obligatoire):", incertainFields[0],
+                        "Valeur 2 (obligatoire):", incertainFields[1],
+                        "Valeur 3 (optionnelle):", incertainFields[2],
+                        "Valeur 4 (optionnelle):", incertainFields[3]
+                    };
+                    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
+                        if (!incertainFields[0].getText().isEmpty() && !incertainFields[1].getText().isEmpty()) {
+                            // Récupérer les valeurs incertaines saisies par le joueur
+                            int valeursIncertaines = 0;
+                            for (int i = 0; i < 4; i++) {
+                                if (!incertainFields[i].getText().isEmpty()) {
+                                    int valeur = Integer.parseInt(incertainFields[i].getText());
+                                    valeursIncertaines |= (valeur << (i * 4));
+                                }
+                            }
+                            // Mettre à jour la grille avec les valeurs incertaines
+                            panel.getGrille()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] = valeursIncertaines;
+                            panel.repaint();
+                        } else {
+                            JOptionPane.showMessageDialog(null, "Les deux premières valeurs incertaines sont obligatoires.");
+                        }
+                    }
+                }
+            } else {
+                JOptionPane.showMessageDialog(null, "Vous ne pouvez pas modifier la valeur par défaut.");
+            }
+        }
+    }
+}

src/FenetreChoix.java

@@ -0,0 +1,31 @@
+import javax.swing.*;
+import java.awt.*;
+
+
+public class FenetreChoix {
+    public void afficher() {
+        JFrame choixFrame = new JFrame("Choix de résolution du Sudoku");
+        choixFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        choixFrame.setSize(400, 200);
+        choixFrame.setLayout(new BorderLayout());
+        choixFrame.setLocationRelativeTo(null);
+
+        JLabel label = new JLabel("Choisissez le mode de résolution du Sudoku :");
+        label.setHorizontalAlignment(JLabel.CENTER);
+
+        JButton automatiqueButton = new JButton("Automatique");
+        JButton manuelButton = new JButton("Manuel");
+
+        JPanel boutonsPanel = new JPanel();
+        boutonsPanel.setLayout(new FlowLayout());
+        boutonsPanel.add(automatiqueButton);
+        boutonsPanel.add(manuelButton);
+
+        choixFrame.add(label, BorderLayout.NORTH);
+        choixFrame.add(boutonsPanel, BorderLayout.CENTER);
+        choixFrame.setVisible(true);
+
+        automatiqueButton.addActionListener(new AutomatiqueActionListener(choixFrame));
+        manuelButton.addActionListener(new ManuelActionListener(choixFrame));
+    }
+}

src/FenetrePrincipale.java

@@ -0,0 +1,25 @@
+
+import javax.swing.*;
+import java.awt.*;
+
+
+public class FenetrePrincipale {
+    public void afficher(boolean modeAutomatique, int[][] grille) {
+        JFrame frame = new JFrame("Sudoku");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        SaisieGrille saisieGrille = new SaisieGrille(grille);
+
+        if (!modeAutomatique) {
+            JButton reinitialiserButton = new JButton("Réinitialiser");
+            reinitialiserButton.addActionListener(new ReinitialiserActionListener(grille, saisieGrille));
+            frame.add(reinitialiserButton, BorderLayout.SOUTH);
+        }
+
+        frame.add(saisieGrille, BorderLayout.CENTER);
+        frame.pack();
+        frame.setLocationRelativeTo(null);
+        frame.setVisible(true);
+
+        System.out.println("La fenêtre Sudoku a été affichée.");
+    }
+}

src/GenerateurSudoku.java

@@ -0,0 +1,20 @@
+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;
+    }
+}

src/GrillePainter.java

@@ -0,0 +1,29 @@
+import java.awt.*;
+
+public class GrillePainter {
+    public static void dessinerGrille(Graphics g, SaisieGrille panel) {
+        Graphics2D g2d = (Graphics2D) g;
+        Stroke ancienStroke = g2d.getStroke();
+        g2d.setStroke(new BasicStroke(4));
+
+        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());
+                g2d.drawLine(i * panel.getTailleCellule(), 0, i * panel.getTailleCellule(), panel.getTailleGrille() * panel.getTailleRegion() * panel.getTailleCellule());
+            }
+        }
+
+        g2d.setStroke(ancienStroke);
+
+        for (int i = 0; i < panel.getTailleGrille() * panel.getTailleRegion(); i++) {
+            for (int j = 0; j < panel.getTailleGrille() * panel.getTailleRegion(); j++) {
+                g.setColor(Color.BLACK);
+                g.drawRect(j * panel.getTailleCellule(), i * panel.getTailleCellule(), panel.getTailleCellule(), panel.getTailleCellule());
+                int valeur = panel.getGrille()[i][j];
+                if (valeur != 0) {
+                    g.drawString(String.valueOf(valeur), j * panel.getTailleCellule() + panel.getTailleCellule() / 2, i * panel.getTailleCellule() + panel.getTailleCellule() / 2);
+                }
+            }
+        }
+    }
+}

src/GrilleSudokuDessin.java

@@ -0,0 +1,46 @@
+import javax.swing.*;
+import java.awt.*;
+
+public class GrilleSudokuDessin extends JPanel {
+    private static final int TAILLE_GRILLE = 3;
+    private static final int TAILLE_REGION = 3;
+    private static final int TAILLE_CELLULE = 50;
+
+    private int[][] grille;
+
+    public GrilleSudokuDessin(int[][] grille) {
+        this.grille = grille;
+        setPreferredSize(new Dimension(TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE));
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+
+        Graphics2D g2d = (Graphics2D) g;
+        // Définir l'épaisseur de la ligne
+        g2d.setStroke(new BasicStroke(20)); // Épaisseur de ligne de 4 pixels
+
+        // Dessiner les lignes de la grille (en gras pour les contours)
+        for (int i = 0; i <= TAILLE_GRILLE * TAILLE_REGION; i++) {
+            if (i % TAILLE_REGION == 0) {
+                g2d.drawRect(0, i * TAILLE_CELLULE - 2, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, 4);
+                g2d.drawRect(i * TAILLE_CELLULE - 2, 0, 4, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE);
+            } else {
+                g2d.drawRect(0, i * TAILLE_CELLULE - 1, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, 2);
+                g2d.drawRect(i * TAILLE_CELLULE - 1, 0, 2, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE);
+            }
+        }
+
+        // Dessiner les valeurs de la grille
+        g.setColor(Color.BLACK);
+        for (int i = 0; i < grille.length; i++) {
+            for (int j = 0; j < grille[i].length; j++) {
+                int valeur = grille[i][j];
+                if (valeur != 0) {
+                    g.drawString(String.valueOf(valeur), j * TAILLE_CELLULE + TAILLE_CELLULE / 2, i * TAILLE_CELLULE + TAILLE_CELLULE / 2);
+                }
+            }
+        }
+    }
+}

src/Grilles.java

@@ -0,0 +1,58 @@
+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 Grilles{
+	public static void grilleExiste(String name) {
+    
+    int valeur[] = new int[9];
+    int valeur_en_fin[][]= new int[9][9];
+
+    int valeur_actuelle=0;
+    int tabcase[][]= new int[9][9];
+    try{
+      FileInputStream fichier = new FileInputStream(name);
+      DataInputStream flux = new DataInputStream(fichier);
+
+      try{
+        for(int i=0; i<9; i++){
+          valeur[i]=flux.readInt();
+        }
+        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);
+      }
+      valeur_actuelle=0;
+    }
+  }
+
+    public static void grilleVide(int [][] g) {
+    	int [][] remp = new int [9][9];
+        for(int i = 0 ; i < 9 ; i++){
+        	for(int j = 0 ; j < 9 ; j++){
+        		remp[i][j] = 0;
+        	}
+        }
+        g = remp;
+    }
+}

src/Lecteur.java

@@ -0,0 +1,45 @@
+import javax.swing.*;
+import java.awt.*;
+import java.io.*;
+import javax.swing.filechooser.FileNameExtensionFilter;
+
+public class Lecteur{
+	public static void lecture(String name, int [][] g) {
+    
+    int valeur[] = new int[9];
+    int valeur_en_fin[][]= new int[9][9];
+
+    int valeur_actuelle=0;
+
+    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]);
+        }
+        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;
+    }
+  }
+}

src/MainCreation.java

@@ -0,0 +1,98 @@
+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 MainCreation {
+    public static void main(String[] args) {
+        int [][] grille = new int [9][9];
+        //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
+        sel.setHorizontalAlignment(JLabel.CENTER);
+        JButton grilleVide = new JButton("Grille vide");
+        JButton grilleExiste = new JButton("Grille Existante");
+
+        JPanel boutonsSelect = new JPanel();
+        boutonsSelect.setLayout(new FlowLayout());
+        boutonsSelect.add(grilleVide);
+        boutonsSelect.add(grilleExiste);
+
+        selF.add(sel, BorderLayout.NORTH);
+        selF.add(boutonsSelect, BorderLayout.CENTER);
+        selF.setVisible(true);
+        //Action des bouton
+        grilleVide.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                selF.dispose();
+                Grilles.grilleVide(grille);
+                fenetreModification(grille);
+            }
+        });
+        grilleExiste.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                selF.dispose();
+                JFileChooser fichier = new JFileChooser();
+
+                FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri");
+                fichier.setFileFilter(filter);
+
+                File workingDirectory = new File(System.getProperty("user.dir"));
+                fichier.setCurrentDirectory(workingDirectory);
+                JPanel panneau = new JPanel();
+                int valeur_de_retour = fichier.showOpenDialog(panneau);
+                if(valeur_de_retour == JFileChooser.APPROVE_OPTION) {
+                    Lecteur.lecture(fichier.getSelectedFile().getName(), grille);
+                    fenetreModification(grille);
+                }
+            }
+        });
+    }
+
+    private 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");
+        register.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e){
+                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) {
+                    Register.sauvegarde(fileChooser.getSelectedFile().getName(), grille);
+                }
+            }
+        });
+
+            frame.add(register, BorderLayout.SOUTH); // Ajouter le bouton "Enregistrer"
+
+        frame.add(saisieGrille, BorderLayout.CENTER); // Ajouter la grille à la fenêtre
+
+        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.");
+    }
+}

src/MainJeu.java

@@ -0,0 +1,9 @@
+
+public class MainJeu {
+    public static void main(String[] args) {
+        System.out.println("Le programme Main a démarré.");
+
+        FenetreChoix fenetreChoix = new FenetreChoix();
+        fenetreChoix.afficher();
+    }
+}

src/ManuelActionListener.java

@@ -0,0 +1,23 @@
+
+import javax.swing.*;
+import java.awt.event.*;
+
+
+public class ManuelActionListener implements ActionListener {
+    private JFrame choixFrame;
+
+    public ManuelActionListener(JFrame choixFrame) {
+        this.choixFrame = choixFrame;
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        choixFrame.dispose();
+
+        int[][] grille = GenerateurSudoku.genererGrille();
+        System.out.println("Grille Sudoku générée avec succès.");
+
+        FenetrePrincipale fenetrePrincipale = new FenetrePrincipale();
+        fenetrePrincipale.afficher(false, grille);
+    }
+}

src/OuvertureFichier.java

@@ -0,0 +1,27 @@
+import java.io.*;
+
+public class OuvertureFichier {
+    public static int[][] lireFichier(File fichier) {
+    int[][] grille = new int[9][9];
+    try (BufferedReader br = new BufferedReader(new FileReader(fichier))) {
+        String ligne;
+        int i = 0;
+        while ((ligne = br.readLine()) != null && i < 9) {
+            for (int j = 0; j < Math.min(ligne.length(), 9); j++) {
+                char caractere = ligne.charAt(j);
+                if (caractere != ' ') {
+                    // Convertir chaque caractère en valeur numérique
+                    int valeur = Integer.parseInt(String.valueOf(caractere), 16);
+                    grille[i][j] = valeur;
+                }
+            }
+            i++;
+        }
+    } catch (IOException e) {
+        e.printStackTrace();
+    }
+    return grille;
+}
+
+
+}

src/Register.java

@@ -0,0 +1,37 @@
+import javax.swing.*;
+import java.awt.*;
+import java.io.*;
+import javax.swing.filechooser.FileNameExtensionFilter;
+
+public class Register{
+	public static void sauvegarde(String name, int [][] g){
+		int val[] = new int[9];
+
+  		int actuVal=0;
+  		int v=0;
+
+  		try{
+    		FileOutputStream fichier = new FileOutputStream(name);
+    		DataOutputStream flux = new DataOutputStream(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é");
+  		}
+	}
+}

src/Reinitialiser.java

@@ -0,0 +1,22 @@
+import javax.swing.*;
+import java.awt.event.*;
+
+public class Reinitialiser implements ActionListener {
+    private int[][] grille;
+    private SaisieGrille panneauSaisie;
+
+    public Reinitialiser(int[][] grille, SaisieGrille panneauSaisie) {
+        this.grille = grille;
+        this.panneauSaisie = panneauSaisie;
+    }
+
+    @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
+        panneauSaisie.repaint();
+    }
+}

src/ReinitialiserActionListener.java

@@ -0,0 +1,20 @@
+
+import javax.swing.*;
+import java.awt.event.*;
+
+
+public class ReinitialiserActionListener implements ActionListener {
+    private int[][] grille;
+    private SaisieGrille saisieGrille;
+
+    public ReinitialiserActionListener(int[][] grille, SaisieGrille saisieGrille) {
+        this.grille = grille;
+        this.saisieGrille = saisieGrille;
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        Reinitialiser reinitialiser = new Reinitialiser(grille, saisieGrille);
+        reinitialiser.actionPerformed(e);
+    }
+}

src/Resolveur.java

@@ -0,0 +1,74 @@
+public class Resolveur {
+    public static boolean resoudreSudoku(int[][] grille) {
+        int row = -1;
+        int col = -1;
+        boolean estVide = true;
+
+        // Recherche d'une cellule vide dans la grille
+        for (int i = 0; i < grille.length; i++) {
+            for (int j = 0; j < grille[i].length; j++) {
+                if (grille[i][j] == 0) {
+                    row = i;
+                    col = j;
+                    // Cellule vide trouvée
+                    estVide = false;
+                    break;
+                }
+            }
+            if (!estVide) {
+                break;
+            }
+        }
+
+        // Si la grille est pleine, le Sudoku est résolu
+        if (estVide) {
+            return true;
+        }
+
+        // Essayer de placer les chiffres de 1 à 9 dans la cellule vide
+        for (int num = 1; num <= 9; num++) {
+            if (estCoupValide(grille, row, col, num)) {
+                grille[row][col] = num;
+                // Résoudre récursivement le Sudoku
+                if (resoudreSudoku(grille)) {
+                    return true;
+                }
+                // Annuler la valeur si la solution n'est pas possible
+                grille[row][col] = 0;
+            }
+        }
+        // Aucune solution n'est possible pour cette cellule
+        return false;
+    }
+
+    // Vérifie si un nombre peut être placé dans une cellule spécifique
+    private static boolean estCoupValide(int[][] grille, int row, int col, int num) {
+        // Vérifie la ligne
+        for (int x = 0; x < 9; x++) {
+            if (grille[row][x] == num) {
+                return false;
+            }
+        }
+
+        // Vérifie la colonne
+        for (int y = 0; y < 9; y++) {
+            if (grille[y][col] == num) {
+                return false;
+            }
+        }
+
+        // Vérifie la région 3x3
+        int regionRowStart = row - row % 3;
+        int regionColStart = col - col % 3;
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                if (grille[i + regionRowStart][j + regionColStart] == num) {
+                    return false;
+                }
+            }
+        }
+
+        // La valeur peut être placée dans cette cellule
+        return true;
+    }
+}

src/SaisieGrille.java

@@ -0,0 +1,105 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public class SaisieGrille extends JPanel {
+    private static final int TAILLE_GRILLE = 3;
+    private static final int TAILLE_REGION = 3;
+    private static final int TAILLE_CELLULE = 50;
+    private int[][] grille;
+    private int[][] grilleInitiale;
+    private int ligneSelectionnee = -1;
+    private int colonneSelectionnee = -1;
+
+    public SaisieGrille(int[][] grille) {
+        this.grille = grille;
+        this.grilleInitiale = new int[grille.length][grille[0].length];
+        for (int i = 0; i < grille.length; i++) {
+            for (int j = 0; j < grille[i].length; j++) {
+                this.grilleInitiale[i][j] = grille[i][j];
+            }
+        }
+        setPreferredSize(new Dimension(TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE));
+        setFocusable(true);
+
+        addMouseListener(new CaseMouseListener(this));
+    }
+
+    public int[][] getGrilleInitiale() {
+        return grilleInitiale;
+    }
+
+    public int getTailleGrille() {
+        return TAILLE_GRILLE;
+    }
+
+    public int getTailleRegion() {
+        return TAILLE_REGION;
+    }
+
+    public int getTailleCellule() {
+        return TAILLE_CELLULE;
+    }
+
+    public void setLigneSelectionnee(int ligneSelectionnee) {
+        this.ligneSelectionnee = ligneSelectionnee;
+    }
+
+    public void setColonneSelectionnee(int colonneSelectionnee) {
+        this.colonneSelectionnee = colonneSelectionnee;
+    }
+
+    public int getLigneSelectionnee() {
+        return ligneSelectionnee;
+    }
+
+    public int getColonneSelectionnee() {
+        return colonneSelectionnee;
+    }
+
+    public int[][] getGrille() {
+        return grille;
+    }
+
+    public boolean validerChiffre(int ligne, int colonne, int chiffre) {
+        // Vérifier si le chiffre est entre 1 et 9
+        if (chiffre < 1 || chiffre > 9) {
+            return false;
+        }
+
+        // Vérifier la ligne
+        for (int j = 0; j < grille.length; j++) {
+            if (grille[ligne][j] == chiffre && j != colonne) {
+                return false;
+            }
+        }
+
+        // Vérifier la colonne
+        for (int i = 0; i < grille.length; i++) {
+            if (grille[i][colonne] == chiffre && i != ligne) {
+                return false;
+            }
+        }
+
+        // Vérifier 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++) {
+            for (int j = regionX * TAILLE_REGION; j < (regionX + 1) * TAILLE_REGION; j++) {
+                if (grille[i][j] == chiffre && (i != ligne || j != colonne)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        GrillePainter.dessinerGrille(g, this);
+    }
+
+
+}

src/SudokuGenerator.java

@@ -0,0 +1,114 @@
+import javax.swing.*;
+import java.io.*;
+
+public class SudokuGenerator {
+    public static int[][] generateGrid() {
+        // grille par défaut
+        int[][] grid = {
+            {0, 0, 0, 9, 0, 5, 0, 0, 4},
+            {5, 0, 3, 0, 0, 4, 0, 8, 7},
+            {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 grid;
+    }
+
+    public static int[][] readGridFromFile() {
+        int[][] grid = new int[9][9];
+        JFileChooser fileChooser = new JFileChooser();
+        int result = fileChooser.showOpenDialog(null);
+        if (result == JFileChooser.APPROVE_OPTION) {
+            File selectedFile = fileChooser.getSelectedFile();
+            try (BufferedReader reader = new BufferedReader(new FileReader(selectedFile))) {
+                for (int i = 0; i < 9; i++) {
+                    String line = reader.readLine();
+                    // Vérifier la longueur de la ligne lue
+                    if (line.length() != 9) {
+                        JOptionPane.showMessageDialog(null, "Invalid file format. Please select a file with correct Sudoku grid format.");
+                        return generateGrid(); // Charger la grille par défaut en cas d'erreur
+                    }
+                    for (int j = 0; j < 9; j++) {
+                        char ch = line.charAt(j);
+                        if (ch >= '1' && ch <= '9') {
+                            grid[i][j] = Character.getNumericValue(ch);
+                        } else {
+                            grid[i][j] = 0;
+                        }
+                    }
+                }
+                if (!isGridValid(grid)) {
+                    JOptionPane.showMessageDialog(null, "Invalid Sudoku grid. Loading default grid.");
+                    return generateGrid(); // Charger la grille par défaut en cas de grille invalide
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return grid;
+    }
+
+    // Méthode pour vérifier si la grille est valide
+    private static boolean isGridValid(int[][] grid) {
+        for (int i = 0; i < 9; i++) {
+            if (!isRowValid(grid, i) || !isColumnValid(grid, i) || !isRegionValid(grid, i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Méthode pour vérifier s'il n'y a pas de chiffres en double sur une ligne donnée
+    private static boolean isRowValid(int[][] grid, int row) {
+        boolean[] seen = new boolean[10]; // Tableau pour suivre les chiffres déjà rencontrés
+        for (int i = 0; i < 9; i++) {
+            int num = grid[row][i];
+            if (num != 0) {
+                if (seen[num]) {
+                    return false; // Le chiffre est déjà apparu sur cette ligne
+                }
+                seen[num] = true;
+            }
+        }
+        return true; // Aucun chiffre en double sur la ligne
+    }
+
+    // Méthode pour vérifier s'il n'y a pas de chiffres en double sur une colonne donnée
+    private static boolean isColumnValid(int[][] grid, int col) {
+        boolean[] seen = new boolean[10]; // Tableau pour suivre les chiffres déjà rencontrés
+        for (int i = 0; i < 9; i++) {
+            int num = grid[i][col];
+            if (num != 0) {
+                if (seen[num]) {
+                    return false; // Le chiffre est déjà apparu sur cette colonne
+                }
+                seen[num] = true;
+            }
+        }
+        return true; // Aucun chiffre en double sur la colonne
+    }
+
+    // Méthode pour vérifier s'il n'y a pas de chiffres en double dans une région donnée
+    private static boolean isRegionValid(int[][] grid, int region) {
+        int rowOffset = (region / 3) * 3;
+        int colOffset = (region % 3) * 3;
+        boolean[] seen = new boolean[10]; // Tableau pour suivre les chiffres déjà rencontrés
+        for (int i = rowOffset; i < rowOffset + 3; i++) {
+            for (int j = colOffset; j < colOffset + 3; j++) {
+                int num = grid[i][j];
+                if (num != 0) {
+                    if (seen[num]) {
+                        return false; // Le chiffre est déjà apparu dans cette région
+                    }
+                    seen[num] = true;
+                }
+            }
+        }
+        return true; // Aucun chiffre en double dans la région
+    }
+}