feat: multidoku rendu seems to work

app/src/main/java/sudoku/ContrainteCasePartagee.java

@@ -0,0 +1,31 @@
+package sudoku;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+public class ContrainteCasePartagee implements Contrainte {
+    private Set<Case> casesLiees;
+
+    public ContrainteCasePartagee(Collection<Case> cases) {
+        this.casesLiees = new HashSet<>(cases);
+    }
+
+    @Override
+    public boolean estRespectee(Grille grille, Case caseActuelle) {
+        if (!casesLiees.contains(caseActuelle))
+            return true;
+
+        Symbole reference = null;
+        for (Case c : casesLiees) {
+            if (c.getSymbole() == null)
+                continue;
+            if (reference == null) {
+                reference = c.getSymbole();
+            } else if (!c.getSymbole().equals(reference)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

app/src/main/java/sudoku/Multidoku.java

@@ -0,0 +1,118 @@
+package sudoku;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Multidoku {
+    private List<Sudoku> sudokus;
+    private List<SudokuPlacement> placements = new ArrayList<>();
+    private List<List<Case>> casesPartagees;
+    private List<Contrainte> contraintesPartagees;
+
+    // Pour cet exemple, nous allons associer à chaque sudoku un offset [offsetY,
+    // offsetX].
+    // Par exemple, le premier sudoku est affiché à (0,0) et le second à (ligne,
+    // colonne) donnée.
+
+    public Multidoku() {
+        this.sudokus = new ArrayList<>();
+        this.casesPartagees = new ArrayList<>();
+        this.contraintesPartagees = new ArrayList<>();
+    }
+
+    public void ajouterSudoku(Sudoku sudoku, int offsetLigne, int offsetColonne) {
+        placements.add(new SudokuPlacement(sudoku, offsetLigne, offsetColonne));
+    }
+
+    // Méthode d’affichage combiné
+    public String toStringCombined() {
+        // 1. Déterminer la taille globale de l’affichage
+        int maxLigne = 0, maxColonne = 0;
+        for (SudokuPlacement sp : placements) {
+            int taille = sp.getSudoku().getGrille().getTaille();
+            maxLigne = Math.max(maxLigne, sp.getOffsetLigne() + taille);
+            maxColonne = Math.max(maxColonne, sp.getOffsetColonne() + taille);
+        }
+
+        // 2. Créer une matrice globale et l'initialiser (ici avec "-" pour une case
+        // vide)
+        String[][] global = new String[maxLigne][maxColonne];
+        for (int i = 0; i < maxLigne; i++) {
+            for (int j = 0; j < maxColonne; j++) {
+                global[i][j] = " "; // ou " " selon votre choix
+            }
+        }
+
+        // 3. Pour chaque sudoku, placer l’affichage de ses cases dans la grille globale
+        for (SudokuPlacement sp : placements) {
+            Grille grille = sp.getSudoku().getGrille();
+            int taille = grille.getTaille();
+            for (int i = 0; i < taille; i++) {
+                for (int j = 0; j < taille; j++) {
+                    // Calcul des coordonnées globales
+                    int globalLigne = sp.getOffsetLigne() + i;
+                    int globalColonne = sp.getOffsetColonne() + j;
+                    // Ici, on récupère la représentation de la case via toString (possiblement avec
+                    // la couleur)
+                    global[globalLigne][globalColonne] = grille.getCase(i, j).toString();
+                }
+            }
+        }
+
+        // 4. Construire la chaîne finale d’affichage ligne par ligne
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < maxLigne; i++) {
+            for (int j = 0; j < maxColonne; j++) {
+                sb.append(global[i][j]).append(" ");
+            }
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    public void ajouterCasesPartagees(List<Case> cases) {
+        casesPartagees.add(new ArrayList<>(cases));
+        ajouterContraintePartagee(new ContrainteCasePartagee(cases));
+    }
+
+    public void ajouterContraintePartagee(Contrainte contrainte) {
+        contraintesPartagees.add(contrainte);
+    }
+
+    public boolean verifierContraintesPartagees() {
+        return contraintesPartagees.stream()
+                .allMatch(c -> c.estRespectee(null, null)); // Adaptation nécessaire selon votre logique
+    }
+
+    // Classe interne pour la contrainte de cases partagées
+    public static class ContrainteCasePartagee implements Contrainte {
+        private List<Case> casesLiees;
+
+        public ContrainteCasePartagee(List<Case> cases) {
+            this.casesLiees = new ArrayList<>(cases);
+        }
+
+        @Override
+        public boolean estRespectee(Grille grille, Case caseActuelle) {
+            Symbole reference = null;
+            for (Case c : casesLiees) {
+                if (c.getSymbole() != null) {
+                    if (reference == null) {
+                        reference = c.getSymbole();
+                    } else if (!c.getSymbole().equals(reference)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+    }
+
+    public List<Sudoku> getSudokus() {
+        return sudokus;
+    }
+
+    public List<List<Case>> getCasesPartagees() {
+        return casesPartagees;
+    }
+}

app/src/main/java/sudoku/SudokuPlacement.java

@@ -0,0 +1,25 @@
+package sudoku;
+
+public class SudokuPlacement {
+    private Sudoku sudoku;
+    private int offsetLigne;
+    private int offsetColonne;
+
+    public SudokuPlacement(Sudoku sudoku, int offsetLigne, int offsetColonne) {
+        this.sudoku = sudoku;
+        this.offsetLigne = offsetLigne;
+        this.offsetColonne = offsetColonne;
+    }
+
+    public Sudoku getSudoku() {
+        return sudoku;
+    }
+
+    public int getOffsetLigne() {
+        return offsetLigne;
+    }
+
+    public int getOffsetColonne() {
+        return offsetColonne;
+    }
+}

app/src/test/java/sudoku/TestMultidoku.java

@@ -0,0 +1,54 @@
+package sudoku;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+public class TestMultidoku {
+
+    @Test
+    public void testMultidoku() {
+        Multidoku multidoku = new Multidoku();
+        Sudoku s1 = new Sudoku(9);
+        Sudoku s2 = new Sudoku(9);
+
+        // Placer sudoku1 en haut à gauche (offset (0,0))
+        multidoku.ajouterSudoku(s1, 0, 0);
+        // Placer sudoku2 de façon à ce que sa case (0,0) se retrouve en (8,8) de la
+        // grille globale
+        multidoku.ajouterSudoku(s2, 8, 8);
+
+        // Créer un lien entre la case (8,8) de s1 et (0,0) de s2
+        List<Case> casesPartagees = Arrays.asList(
+                s1.getGrille().getCase(8, 8),
+                s2.getGrille().getCase(0, 0));
+        multidoku.ajouterCasesPartagees(casesPartagees);
+
+        ArrayList<Symbole> symboles = new ArrayList<>();
+        for (int i = 1; i <= 9; i++) {
+            symboles.add(Symbole.of(i));
+        }
+
+        s1.getGrille().setSymbolesPossibles(symboles);
+        List<Sudoku> sudokus = Arrays.asList(s1, s2);
+        for (Sudoku sudoku : sudokus) {
+            sudoku.getGrille().setSymbolesPossibles(symboles);
+            sudoku.ajouterContrainte(new ContrainteLigne());
+            sudoku.ajouterContrainte(new ContrainteColonne());
+            sudoku.ajouterContrainte(new ContrainteBloc());
+            sudoku.getGrille().creerBlocCarre();
+        }
+
+        System.out.println("Sudoku 1 :");
+        System.out.println(s1.getGrille().toString());
+
+        System.out.println("Sudoku 2 :");
+        System.out.println(s2.getGrille().toString());
+
+        System.out.println("\nAffichage Multidoku combiné :");
+        // TODO: Afficher le Multidoku combiné
+        System.out.println(multidoku.toStringCombined());
+    }
+}