From 1c1da09e1fa318b4efcf7224c7bc5c7a7c5b38dc Mon Sep 17 00:00:00 2001 From: Morph01 Date: Fri, 7 Feb 2025 10:19:42 +0100 Subject: [PATCH] feat: multidoku rendu seems to work --- .../java/sudoku/ContrainteCasePartagee.java | 31 +++++ app/src/main/java/sudoku/Multidoku.java | 118 ++++++++++++++++++ app/src/main/java/sudoku/SudokuPlacement.java | 25 ++++ app/src/test/java/sudoku/TestMultidoku.java | 54 ++++++++ 4 files changed, 228 insertions(+) create mode 100644 app/src/main/java/sudoku/ContrainteCasePartagee.java create mode 100644 app/src/main/java/sudoku/Multidoku.java create mode 100644 app/src/main/java/sudoku/SudokuPlacement.java create mode 100644 app/src/test/java/sudoku/TestMultidoku.java diff --git a/app/src/main/java/sudoku/ContrainteCasePartagee.java b/app/src/main/java/sudoku/ContrainteCasePartagee.java new file mode 100644 index 0000000..09a0e01 --- /dev/null +++ b/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 casesLiees; + + public ContrainteCasePartagee(Collection 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; + } +} \ No newline at end of file diff --git a/app/src/main/java/sudoku/Multidoku.java b/app/src/main/java/sudoku/Multidoku.java new file mode 100644 index 0000000..2428162 --- /dev/null +++ b/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 sudokus; + private List placements = new ArrayList<>(); + private List> casesPartagees; + private List 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 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 casesLiees; + + public ContrainteCasePartagee(List 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 getSudokus() { + return sudokus; + } + + public List> getCasesPartagees() { + return casesPartagees; + } +} diff --git a/app/src/main/java/sudoku/SudokuPlacement.java b/app/src/main/java/sudoku/SudokuPlacement.java new file mode 100644 index 0000000..293b854 --- /dev/null +++ b/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; + } +} diff --git a/app/src/test/java/sudoku/TestMultidoku.java b/app/src/test/java/sudoku/TestMultidoku.java new file mode 100644 index 0000000..71845f4 --- /dev/null +++ b/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 casesPartagees = Arrays.asList( + s1.getGrille().getCase(8, 8), + s2.getGrille().getCase(0, 0)); + multidoku.ajouterCasesPartagees(casesPartagees); + + ArrayList symboles = new ArrayList<>(); + for (int i = 1; i <= 9; i++) { + symboles.add(Symbole.of(i)); + } + + s1.getGrille().setSymbolesPossibles(symboles); + List 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()); + } +}