fix renderable multidoku max coords

app/src/main/java/gui/Main.java

@@ -1,9 +1,16 @@
 package gui;
 
+import gui.constants.Fonts;
+import gui.constants.Images;
+import gui.constants.Symbols;
 import gui.menu.MainMenu;
 import gui.menu.StateMachine;
 import imgui.app.Application;
 import imgui.app.Configuration;
+import sudoku.io.SudokuPrinter;
+import sudoku.structure.Difficulty;
+import sudoku.structure.MultiDoku;
+import sudoku.structure.SudokuFactory;
 
 public class Main extends Application {
 
@@ -39,6 +46,13 @@ public class Main extends Application {
     }
 
     public static void main(String[] args) {
-        launch(new Main());
+        MultiDoku doku = SudokuFactory.createBasicPlusShapedMultidoku(3, 3, SudokuFactory.DEFAULT_CONSTRAINTS);
+        try {
+            SudokuFactory.fillDoku(doku, Difficulty.Easy);
+        } catch (Exception e) {
+            throw new RuntimeException();
+        }
+        SudokuPrinter.printMultiDoku(doku, 3, 3, Symbols.Numbers);
+        //launch(new Main());
     }
 }

app/src/main/java/gui/RenderableMultidoku.java

@@ -90,29 +90,23 @@ public class RenderableMultidoku {
 	}
 
 	private static Coordinate getMaxSudokuCoordinate(Map<Sudoku, Coordinate> sudokusOffset) {
-		Coordinate maxCoordinate = null;
+		int maxX = 0;
-		Sudoku maxSudoku = null;
+		int maxY = 0;
-		float maxDistanceSquared = 0;
+		Sudoku lastSudoku = null;
 		for (var entry : sudokusOffset.entrySet()) {
 			Coordinate coordinate = entry.getValue();
-			float distanceSquared = coordinate.getX() * coordinate.getX() + coordinate.getY() * coordinate.getY();
+			if (coordinate.getX() > maxX)
-			if (maxCoordinate == null) {
+			maxX = coordinate.getX();
-				maxCoordinate = coordinate;
+			if (coordinate.getY() > maxY)
-				maxDistanceSquared = distanceSquared;
+			maxY = coordinate.getY();
-				maxSudoku = entry.getKey();
+			lastSudoku = entry.getKey();
 		}
 
-			if (distanceSquared > maxDistanceSquared) {
+		Coordinate maxCoordinate = new Coordinate(maxX, maxY);
-				maxDistanceSquared = distanceSquared;
+		// tous les sudokus sont censés faire la même taille
-				maxSudoku = entry.getKey();
+		int sudokuSize = lastSudoku.getSize();
-				maxCoordinate = coordinate;
-			}
-		}
 
-		int blockWidth = maxSudoku.getBlockWidth();
+		return new Coordinate(maxCoordinate.getX() + sudokuSize, maxCoordinate.getY() + sudokuSize);
-		int blockHeight = maxSudoku.getSize() / blockWidth;
-
-		return new Coordinate(maxCoordinate.getX() + maxSudoku.getSize(), maxCoordinate.getY() + maxSudoku.getSize());
 	}
 
 	public static RenderableMultidoku fromMultidoku(MultiDoku doku) {

app/src/main/java/gui/constants/Fonts.java

@@ -1,4 +1,4 @@
-package gui;
+package gui.constants;
 
 import imgui.ImFont;
 import imgui.ImFontConfig;

app/src/main/java/gui/constants/Images.java

@@ -1,4 +1,4 @@
-package gui;
+package gui.constants;
 
 import java.nio.ByteBuffer;
 

app/src/main/java/gui/constants/Options.java

@@ -1,4 +1,4 @@
-package gui;
+package gui.constants;
 
 public class Options {
 

app/src/main/java/gui/constants/SudokuType.java

@@ -1,8 +1,8 @@
-package gui;
+package gui.constants;
 
 import java.util.List;
 
-import sudoku.constraint.Constraint;
+import sudoku.constraint.IConstraint;
 import sudoku.structure.MultiDoku;
 import sudoku.structure.SudokuFactory;;
 
@@ -14,10 +14,14 @@ public enum SudokuType {
 			(constraints, params) -> SudokuFactory.createBasicEmptyRectangleDoku(params[0], params[1], constraints)),
 	RandomBloc("Blocs aléatoires", 1,
 			(constraints, params) -> SudokuFactory.createBasicEmptyRandomBlockDoku(params[0], constraints)),
-	MultiDokuSquare("Multidoku carré (X)", 1,
+	MultiDokuXSquare("Multidoku carré (X)", 1,
 			(constraints, params) -> SudokuFactory.createBasicXShapedMultidoku(params[0], constraints)),
-	MultidokuRectangle("Multidoku rectangle (X)", 2,
+	MultidokuXRectangle("Multidoku rectangle (X)", 2,
-			(constraints, params) -> SudokuFactory.createBasicXShapedMultidoku(params[0], params[1], constraints));
+			(constraints, params) -> SudokuFactory.createBasicXShapedMultidoku(params[0], params[1], constraints)),
+	MultiDokuPSquare("Multidoku carré (+)", 1,
+			(constraints, params) -> SudokuFactory.createBasicPlusShapedMultidoku(params[0], constraints)),
+	MultiDokuPRectangle("Multidoku rectangle (+)", 2,
+			(constraints, params) -> SudokuFactory.createBasicPlusShapedMultidoku(params[0], params[1], constraints));
 
 	String displayName;
 	SudokuMaker maker;
@@ -33,7 +37,7 @@ public enum SudokuType {
 		return this.displayName;
 	}
 
-	public MultiDoku createDoku(List<Constraint> constraints, int... params) {
+	public MultiDoku createDoku(List<IConstraint> constraints, int... params) {
 		return maker.makeSudoku(constraints, params);
 	}
 
@@ -43,7 +47,7 @@ public enum SudokuType {
 
 	@FunctionalInterface
 	private static interface SudokuMaker {
-		MultiDoku makeSudoku(List<Constraint> constraints, int... params);
+		MultiDoku makeSudoku(List<IConstraint> constraints, int... params);
 	}
 
 	private static final String[] dokuNames;

app/src/main/java/gui/constants/Symbols.java

@@ -1,4 +1,4 @@
-package gui;
+package gui.constants;
 
 import java.util.ArrayList;
 import java.util.List;

app/src/main/java/gui/menu/OptionsMenu.java

@@ -1,7 +1,7 @@
 package gui.menu;
 
-import gui.Options;
+import gui.constants.Options;
-import gui.Symbols;
+import gui.constants.Symbols;
 import imgui.ImGui;
 import imgui.type.ImInt;
 

app/src/main/java/gui/menu/StateMachine.java

@@ -2,7 +2,7 @@ package gui.menu;
 
 import java.util.Stack;
 
-import gui.AnimatedBackground;
+import gui.widget.AnimatedBackground;
 import imgui.ImGui;
 import imgui.ImVec2;
 import imgui.flag.ImGuiKey;

app/src/main/java/gui/menu/SudokuView.java

@@ -1,5 +1,7 @@
 package gui.menu;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.CancellationException;
 
 import gui.widget.SudokuRenderer;
@@ -11,6 +13,7 @@ import sudoku.solver.HintHelper;
 import sudoku.solver.HumanSolver;
 import sudoku.solver.MixedSolver;
 import sudoku.solver.Solver;
+import sudoku.solver.SolverStep;
 import sudoku.solver.HintHelper.Hint;
 import sudoku.structure.MultiDoku;
 
@@ -90,8 +93,9 @@ public class SudokuView extends BaseView {
 
 	private void startSolve(Solver solver) {
 		resolveThread = new Thread(() -> {
+			List<SolverStep> steps = new ArrayList<>();
 			try {
-				unresolved = !solver.solve(this.doku);
+				unresolved = !solver.solve(this.doku, steps);
 			} catch (CancellationException e) {
 				System.out.println("The user is bored !");
 			}

app/src/main/java/gui/widget/AnimatedBackground.java

@@ -1,5 +1,7 @@
-package gui;
+package gui.widget;
 
+import gui.constants.Images;
+import gui.constants.Options;
 import imgui.ImGui;
 import imgui.ImVec2;
 import imgui.flag.ImGuiWindowFlags;

app/src/main/java/gui/widget/SudokuRenderer.java

@@ -9,11 +9,11 @@ import java.util.Set;
 import common.ConsumerSignal;
 import common.Signal;
 import gui.ColorGenerator;
-import gui.Fonts;
-import gui.Options;
-import gui.RenderableMultidoku;
-import gui.Symbols;
 import gui.ColorGenerator.Color;
+import gui.RenderableMultidoku;
+import gui.constants.Fonts;
+import gui.constants.Options;
+import gui.constants.Symbols;
 import imgui.ImGui;
 import imgui.ImVec2;
 import imgui.ImVec4;

app/src/main/java/gui/widget/SudokuSelector.java

@@ -4,13 +4,14 @@ import java.util.ArrayList;
 import java.util.List;
 
 import common.ConsumerSignal;
-import gui.SudokuType;
+import gui.constants.SudokuType;
 import imgui.ImGui;
 import imgui.extension.imguifiledialog.ImGuiFileDialog;
 import imgui.extension.imguifiledialog.flag.ImGuiFileDialogFlags;
 import imgui.type.ImBoolean;
 import imgui.type.ImInt;
 import sudoku.constraint.Constraint;
+import sudoku.constraint.IConstraint;
 import sudoku.structure.Difficulty;
 import sudoku.structure.MultiDoku;
 import sudoku.structure.SudokuFactory;
@@ -40,18 +41,18 @@ public class SudokuSelector {
 		initConstraints();
 	}
 
-	private List<Constraint> getConstraints() {
+	private List<IConstraint> getConstraints() {
-		List<Constraint> constraints = new ArrayList<>();
+		List<IConstraint> constraints = new ArrayList<>();
 		for (int i = 0; i < this.contraints.size(); i++) {
 			if (this.contraints.get(i).get())
-				constraints.add(Constraint.values()[i]);
+				constraints.add(Constraint.values()[i].getConstraint());
 		}
 		return constraints;
 	}
 
 	private void initConstraints() {
 		for (Constraint cons : Constraint.values()) {
-			contraints.add(new ImBoolean(SudokuFactory.DEFAULT_CONSTRAINTS.contains(cons)));
+			contraints.add(new ImBoolean(SudokuFactory.DEFAULT_CONSTRAINTS.contains(cons.getConstraint())));
 		}
 	}
 

app/src/main/java/sudoku/Main.java

@@ -4,17 +4,14 @@
 package sudoku;
 
 import gui.RenderableMultidoku;
-import gui.Symbols;
+import gui.constants.Symbols;
 import sudoku.io.ConsoleInterface;
 import sudoku.io.SudokuPrinter;
 import sudoku.io.SudokuSerializer;
 import sudoku.solver.RandomSolver;
-import sudoku.solver.Solver;
 import sudoku.structure.MultiDoku;
 import sudoku.structure.SudokuFactory;
 
-import java.util.Random;
-
 public class Main {
     public String getGreeting() {
         return "Hello World!";

app/src/main/java/sudoku/constraint/IConstraint.java

@@ -1,12 +1,12 @@
 package sudoku.constraint;
 
+import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 
 import sudoku.structure.Sudoku;
 
-public interface IConstraint {
+public interface IConstraint extends Serializable {
-
 	boolean canBePlaced(final Sudoku s, int x, int y, int newSymbolIndex);
 
 	default List<Integer> getPossibleSymbols(final Sudoku s, int x, int y) {

app/src/main/java/sudoku/io/ConsoleInterface.java

@@ -1,7 +1,7 @@
 package sudoku.io;
 
 import gui.RenderableMultidoku;
-import gui.Symbols;
+import gui.constants.Symbols;
 import sudoku.constraint.*;
 import sudoku.solver.*;
 import sudoku.structure.*;
@@ -15,7 +15,7 @@ public class ConsoleInterface {
 
     public void welcome() {
         System.out.println("Welcome to our Sudoku Solver!");
-        System.out.println("This is the project of Melvyn Bauvent, Lilas Grenier and Simon Priblyski.");
+        System.out.println("This is the project of Melvyn Bauvent, Lilas Grenier and Simon Pribylski.");
         System.out.println("Do you have a save sudoku you would like to continue? (y/n, default n)");
         if (reader.next().equalsIgnoreCase("y")) {
             useSavedDoku();
@@ -45,7 +45,7 @@ public class ConsoleInterface {
         System.out.println("Your sudoku will have blocks of a " + width + " x " + height + " format.");
         int numberOfSymbols = width * height;
         List<String> listSymbols = pickSymbols(numberOfSymbols);
-        List<Constraint> listConstraints = getListConstraints();
+        List<IConstraint> listConstraints = getListConstraints();
         System.out.println("Now that we have the size of our sudoku, " +
                 "would you rather have a single grid ('one', default), " +
                 "or a a multidoku composed of 5 subgrids ('multi') ?");
@@ -171,12 +171,12 @@ public class ConsoleInterface {
         }
     }
 
-    private List<Constraint> getListConstraints() {
+    private List<IConstraint> getListConstraints() {
-        List<Constraint> listConstraints = SudokuFactory.DEFAULT_CONSTRAINTS;
+        List<IConstraint> listConstraints = SudokuFactory.DEFAULT_CONSTRAINTS;
         System.out.println(
                 "The sudoku have constraints of blocks, lines and columns. Would you like to add the diagonal constraints ? (y/n, default 'no')");
         if (reader.next().equalsIgnoreCase("y")) {
-            listConstraints.add(Constraint.Diagonal);
+            listConstraints.add(Constraint.Diagonal.getConstraint());
         }
         return listConstraints;
     }

app/src/main/java/sudoku/io/SudokuPrinter.java

@@ -1,7 +1,7 @@
 package sudoku.io;
 
 import gui.RenderableMultidoku;
-import gui.Symbols;
+import gui.constants.Symbols;
 import sudoku.structure.Cell;
 import sudoku.structure.MultiDoku;
 import sudoku.structure.Sudoku;

app/src/main/java/sudoku/io/SudokuSerializer.java

@@ -12,6 +12,7 @@ import org.json.JSONArray;
 import org.json.JSONObject;
 
 import sudoku.constraint.Constraint;
+import sudoku.constraint.IConstraint;
 import sudoku.structure.Block;
 import sudoku.structure.Cell;
 import sudoku.structure.MultiDoku;
@@ -99,8 +100,17 @@ public class SudokuSerializer {
 
 			// serialize constraints
 
-			for (Constraint cons : sudoku.getConstraints()) {
+			for (IConstraint cons : sudoku.getConstraints()) {
-				constraintsJsonArray.put(cons.ordinal());
+				boolean constraintSerialized = false;
+				for (Constraint enumCons : Constraint.values()) {
+					if (cons.getClass().isAssignableFrom(enumCons.getConstraint().getClass())) {
+						constraintSerialized = true;
+						constraintsJsonArray.put(enumCons.ordinal());
+					}
+				}
+				if (!constraintSerialized) {
+					System.out.println("La contrainte " + cons.getClass() + " n'a pas pu être sérialisé !");
+				}
 			}
 
 			jsonSudoku.put("constraints", constraintsJsonArray);
@@ -125,6 +135,7 @@ public class SudokuSerializer {
 	 */
 	public static String saveMultiDoku(final MultiDoku doku) {
 		JSONObject jsonRoot = serializeSudoku(doku);
+
 		File f = new File("save", "save.json");
 		int i = 0;
 		while (f.exists()) {
@@ -143,14 +154,12 @@ public class SudokuSerializer {
 		File f;
 		if (saveToOverwrite == 0) {
 			f = new File("save", "save.json");
-		}
+		} else {
-		else {
 			f = new File("save", "save-" + saveToOverwrite + ".json");
 		}
 		if (!f.exists()) {
 			return saveMultiDoku(doku);
-		}
+		} else {
-		else {
 			try (FileWriter file = new FileWriter(f)) {
 				file.write(serializeSudoku(doku).toString(3));
 			} catch (IOException e) {
@@ -234,7 +243,7 @@ public class SudokuSerializer {
 
 			List<Cell> sudokuCells = new ArrayList<>();
 			List<Block> sudokuBlocks = new ArrayList<>();
-			List<Constraint> sudokuConstraints = new ArrayList<>();
+			List<IConstraint> sudokuConstraints = new ArrayList<>();
 
 			for (int j = 0; j < sudokuCellsJsonArray.length(); j++) {
 				int cellID = sudokuCellsJsonArray.getInt(j);
@@ -248,7 +257,7 @@ public class SudokuSerializer {
 
 			for (int j = 0; j < sudokuConstraintsJsonArray.length(); j++) {
 				int constraintID = sudokuConstraintsJsonArray.getInt(j);
-				sudokuConstraints.add(Constraint.values()[constraintID]);
+				sudokuConstraints.add(Constraint.values()[constraintID].getConstraint());
 			}
 
 			Sudoku s = new Sudoku(sudokuCells, sudokuBlocks, sudokuConstraints);

app/src/main/java/sudoku/solver/BacktrackingSolver.java

@@ -15,7 +15,7 @@ public class BacktrackingSolver implements Solver {
 	 * @return boolean, valant true si le MultiDoku est résolu, false sinon.
 	 */
 	@Override
-	public boolean solve(MultiDoku doku) {
+	public boolean solve(MultiDoku doku, List<SolverStep> steps) {
 		if (Thread.interrupted())
 			throw new CancellationException("User wants to stop the solver");
 
@@ -34,14 +34,14 @@ public class BacktrackingSolver implements Solver {
 		}
 
 		for (int symbol : possibleSymbols) {
-
 			cellToFill.setSymbolIndex(symbol);
-			if (this.solve(doku)) {
+			addStep(cellToFill, steps);
+			if (this.solve(doku, steps)) {
 				return true;
 			} else {
 				cellToFill.setSymbolIndex(Cell.NOSYMBOL);
+				addStep(cellToFill, steps);
 			}
-
 		}
 		return false;
 	}

app/src/main/java/sudoku/solver/HumanSolver.java

@@ -4,7 +4,7 @@ import java.util.List;
 import java.util.concurrent.CancellationException;
 import java.util.logging.Level;
 
-import gui.Symbols;
+import gui.constants.Symbols;
 import sudoku.io.SudokuPrinter;
 import sudoku.structure.Cell;
 import sudoku.structure.MultiDoku;
@@ -19,7 +19,7 @@ public class HumanSolver implements Solver {
 	 * @return boolean, valant true si le MultiDoku est résolu, false sinon.
 	 */
 	@Override
-	public boolean solve(MultiDoku doku) {
+	public boolean solve(MultiDoku doku, List<SolverStep> steps) {
 		if (Thread.interrupted())
 			throw new CancellationException("User wants to stop the solver");
 
@@ -47,8 +47,9 @@ public class HumanSolver implements Solver {
 			}
 
 			cellToFill.setSymbolIndex(possibleSymbols.getFirst());
+			addStep(cellToFill, steps);
 
-			return this.solve(doku);
+			return this.solve(doku, steps);
 		}
 
 		return doku.isSolved();

app/src/main/java/sudoku/solver/MixedSolver.java

@@ -5,7 +5,7 @@ import java.util.Random;
 import java.util.concurrent.CancellationException;
 import java.util.logging.Level;
 
-import gui.Symbols;
+import gui.constants.Symbols;
 import sudoku.io.SudokuPrinter;
 import sudoku.structure.Cell;
 import sudoku.structure.MultiDoku;
@@ -21,7 +21,7 @@ public class MixedSolver implements Solver{
      * @return boolean, valant true si le MultiDoku est résolu, false sinon.
      */
     @Override
-    public boolean solve(MultiDoku doku) {
+    public boolean solve(MultiDoku doku, List<SolverStep> steps) {
         Random rand = new Random();
 
         if (Thread.interrupted()) {
@@ -49,7 +49,8 @@ public class MixedSolver implements Solver{
 
         if (possibleSymbols.size() == 1) {
             cellToFill.setSymbolIndex(possibleSymbols.getFirst());
-            if (this.solve(doku)) {
+            addStep(cellToFill, steps);
+            if (this.solve(doku, steps)) {
                 return true;
             }
         }
@@ -59,10 +60,12 @@ public class MixedSolver implements Solver{
             int nextSymbol = possibleSymbols.get(nextPossibleSymbolIndex);
 
             cellToFill.setSymbolIndex(nextSymbol);
-            if (this.solve(doku)) {
+            addStep(cellToFill, steps);
+            if (this.solve(doku, steps)) {
                 return true;
             }
             cellToFill.setSymbolIndex(Cell.NOSYMBOL);
+            addStep(cellToFill, steps);
             possibleSymbols.remove(nextPossibleSymbolIndex);
 
         }

app/src/main/java/sudoku/solver/RandomSolver.java

@@ -5,7 +5,7 @@ import java.util.Random;
 import java.util.concurrent.CancellationException;
 import java.util.logging.Level;
 
-import gui.Symbols;
+import gui.constants.Symbols;
 import sudoku.io.SudokuPrinter;
 import sudoku.structure.Cell;
 import sudoku.structure.MultiDoku;
@@ -22,7 +22,7 @@ public class RandomSolver implements Solver {
      * @return boolean, true s'il est résolu ou false s'il ne l'est pas.
      */
     @Override
-    public boolean solve(MultiDoku doku) {
+    public boolean solve(MultiDoku doku, List<SolverStep> steps) {
         Random rand = new Random();
 
         if (Thread.interrupted())
@@ -51,10 +51,12 @@ public class RandomSolver implements Solver {
             int nextSymbol = possibleSymbols.get(nextPossibleSymbolIndex);
 
             cellToFill.setSymbolIndex(nextSymbol);
-            if (this.solve(doku)) {
+            addStep(cellToFill, steps);
+            if (this.solve(doku, steps)) {
                 return true;
             }
             cellToFill.setSymbolIndex(Cell.NOSYMBOL);
+            addStep(cellToFill, steps);
             possibleSymbols.remove(nextPossibleSymbolIndex);
 
         }

app/src/main/java/sudoku/solver/Solver.java

@@ -13,7 +13,11 @@ public interface Solver {
      */
     public static final Logger logger = Logger.getLogger("SolverLogger");
 
-	boolean solve(MultiDoku doku);
+    boolean solve(MultiDoku doku, List<SolverStep> solverSteps);
+
+    default boolean solve(MultiDoku doku) {
+        return solve(doku, null);
+    }
 
     /**
      * Compte le nombre de solutions possibles au MultiDoku passé en paramètres.
@@ -38,10 +42,20 @@ public interface Solver {
             cellToFill.setSymbolIndex(symbol);
             if (solve(doku)) {
                 result++;
+                if (result > 1) {
+                    doku.getStateManager().popState();
+                    return result;
+                }
             }
             doku.getStateManager().popState();
         }
         return result;
     }
 
+    default void addStep(Cell cell, List<SolverStep> steps) {
+        if (steps == null)
+            return;
+        steps.add(new SolverStep(cell));
+    }
+
 }

app/src/main/java/sudoku/solver/SolverStep.java

@@ -0,0 +1,23 @@
+package sudoku.solver;
+
+import sudoku.structure.Cell;
+
+public class SolverStep {
+
+	private final Cell cell;
+	private final int newValue;
+
+	public SolverStep(Cell cell) {
+		this.cell = cell;
+		this.newValue = cell.getSymbolIndex();
+	}
+
+	public int getNewValue() {
+		return newValue;
+	}
+
+	public Cell getCell() {
+		return cell;
+	}
+
+}

app/src/main/java/sudoku/structure/Sudoku.java

@@ -1,13 +1,11 @@
 package sudoku.structure;
 
-import sudoku.constraint.BlockConstraint;
-import sudoku.constraint.Constraint;
-import sudoku.constraint.IConstraint;
-import sudoku.io.SudokuPrinter;
-
 import java.util.ArrayList;
 import java.util.List;
 
+import sudoku.constraint.Constraint;
+import sudoku.constraint.IConstraint;
+
 /**
  * @class Sudoku
  * @brief Représent un Sudoku
@@ -25,13 +23,14 @@ public class Sudoku {
 	/**
 	 * Liste des contraintes (TODO) du Sudoku.
 	 */
-	private final List<Constraint> constraints;
+	private final List<IConstraint> constraints;
 	/**
-	 * Largeur des Blocks s'ils sont rectangulaires, valant 0 si ce n'est pas le cas.
+	 * Largeur des Blocks s'ils sont rectangulaires, valant 0 si ce n'est pas le
+	 * cas.
 	 */
 	private int blockWidth;
 
-	public Sudoku(List<Cell> cells, List<Block> blocks, List<Constraint> constraints) {
+	public Sudoku(List<Cell> cells, List<Block> blocks, List<IConstraint> constraints) {
 		this.cells = cells;
 		this.blocks = blocks;
 		this.constraints = constraints;
@@ -49,6 +48,7 @@ public class Sudoku {
 
 	/**
 	 * Transforme des coordonées d'une Cell en index.
+	 * 
 	 * @param x int, abscisse.
 	 * @param y int, ordonnée.
 	 * @return int, index correspondant.
@@ -59,7 +59,9 @@ public class Sudoku {
 
 	/**
 	 * Vérifie que des coordonnées correspondent bien à une Cell dans le Sudoku.
-	 * @return boolean, valant true si les coordonnées sont dans les bornes du Sudoku, false sinon.
+	 * 
+	 * @return boolean, valant true si les coordonnées sont dans les bornes du
+	 *         Sudoku, false sinon.
 	 */
 	public boolean isValidCoords(int x, int y) {
 		int index = toIndex(x, y);
@@ -68,21 +70,25 @@ public class Sudoku {
 
 	/**
 	 * Vérifie que l'index correspond bien à une Cell dans le Sudoku.
-	 * @return boolean, valant true si l'index est dans les bornes du Sudoku, false sinon.
+	 * 
+	 * @return boolean, valant true si l'index est dans les bornes du Sudoku, false
+	 *         sinon.
 	 */
 	public boolean isValidCoords(int index) {
 		return index < getSize() * getSize();
 	}
 
 	/**
-	 * Teste si on peut placer la value dans la Cell aux coordonnées x, y d'après les contraintes du Sudoku.
+	 * Teste si on peut placer la value dans la Cell aux coordonnées x, y d'après
+	 * les contraintes du Sudoku.
+	 * 
 	 * @param x     int, abscisse de la Cell voulue.
 	 * @param y     int, ordonnée de la Cell voulue.
 	 * @param value int, index du symbole qu'on veut placer.
 	 * @return boolean, true si on peut la placer et false sinon.
 	 */
 	public boolean canBePlaced(int x, int y, int value) {
-		for (Constraint constraint : this.constraints) {
+		for (IConstraint constraint : this.constraints) {
 			if (!constraint.canBePlaced(this, x, y, value)) {
 				return false;
 			}
@@ -92,6 +98,7 @@ public class Sudoku {
 
 	/**
 	 * Vide la Cell dotn les coordonnées sont renseignées de son symbole.
+	 * 
 	 * @param x int, abscisse de la Cell voulue.
 	 * @param y int, coordonnée de la Cell voulue.
 	 */
@@ -119,6 +126,7 @@ public class Sudoku {
 
 	/**
 	 * Place le symbole d'index value dans la Cell de coordonnées précisées.
+	 * 
 	 * @param x     int, abscisse de la Cell voulue.
 	 * @param y     int, coordonnée de la Cell voulue.
 	 * @param value int, index du symbole à placer.
@@ -126,7 +134,7 @@ public class Sudoku {
 	 */
 	public Cell setCellSymbol(int x, int y, int value) {
 		assert (isValidCoords(x, y));
-		for (Constraint constraint : this.constraints) {
+		for (IConstraint constraint : this.constraints) {
 			if (!constraint.canBePlaced(this, x, y, value)) {
 				return null;
 			}
@@ -138,6 +146,7 @@ public class Sudoku {
 
 	/**
 	 * Place les symboles d'index contenus dans values dans les cases du Sudoku.
+	 * 
 	 * @param values List<Integer>, liste des index des symboles à placer.
 	 * @return boolean, vaut true si les symboles ont été placés, false sinon.
 	 */
@@ -155,7 +164,9 @@ public class Sudoku {
 	}
 
 	/**
-	 * Place les symboles d'index contenus dans values dans les cases du Sudoku et rend ces cases immuables.
+	 * Place les symboles d'index contenus dans values dans les cases du Sudoku et
+	 * rend ces cases immuables.
+	 * 
 	 * @param values List<Integer>, liste des index des symboles à placer.
 	 * @return boolean, vaut true si les symboles ont été placés, false sinon.
 	 */
@@ -192,7 +203,7 @@ public class Sudoku {
 		return this.cells.get(i);
 	}
 
-	public List<Constraint> getConstraints() {
+	public List<IConstraint> getConstraints() {
 		return constraints;
 	}
 
@@ -210,6 +221,7 @@ public class Sudoku {
 
 	/**
 	 * Vérifie si une Cell appartient au Sudoku.
+	 * 
 	 * @param cell Cell, cellule dont on veut vérifier l'appartenance au Sudoku.
 	 * @return boolean, vaut true si la Cell appartient au Sudoku.
 	 */
@@ -233,6 +245,7 @@ public class Sudoku {
 
 	/**
 	 * Renvoie la 1re Cell vide du Sudoku.
+	 * 
 	 * @return Cell, une Cell vide, ou null s'il n'y en a pas.
 	 */
 	public Cell getFirstEmptyCell() {
@@ -245,7 +258,9 @@ public class Sudoku {
 	}
 
 	/**
-	 * Vérifie si le Sudoku est résolu, c'est à dire complet et cohérent avec ses contraintes.
+	 * Vérifie si le Sudoku est résolue, soit complet et cohérent avec ses
+	 * contraintes.
+	 * 
 	 * @return boolean, valant true si le Sudoku est résolu, false sinon.
 	 */
 	public boolean isSolved() {
@@ -256,6 +271,7 @@ public class Sudoku {
 
 	/**
 	 * Vérifie que le Sudoku est complet, soit qu'il n'y ait aucune case vide.
+	 * 
 	 * @return boolean, true si le Sudoku est complet, false sinon.
 	 */
 	private boolean isComplete() {
@@ -263,7 +279,9 @@ public class Sudoku {
 	}
 
 	/**
-	 * Vérifie si le Sudoku est valide, soit qu'il est cohérent avec ses contraintes.
+	 * Vérifie si le Sudoku est valide, soit qu'il est cohérent avec ses
+	 * contraintes.
+	 * 
 	 * @return bollean, true si le Sudoku est valide, false sinon
 	 */
 	private boolean isValid() {
@@ -289,7 +307,7 @@ public class Sudoku {
 	}
 
 	public boolean hasConstraint(Constraint constraint) {
-		return this.constraints.contains(constraint);
+		return this.constraints.contains(constraint.getConstraint());
 	}
 
 }

app/src/main/java/sudoku/structure/SudokuFactory.java

@@ -10,6 +10,7 @@ import java.util.Map;
 import java.util.Random;
 
 import sudoku.constraint.Constraint;
+import sudoku.constraint.IConstraint;
 import sudoku.io.SudokuSerializer;
 import sudoku.solver.RandomSolver;
 import sudoku.solver.Solver;
@@ -25,11 +26,13 @@ public class SudokuFactory {
 	 * Liste des contraintes par défaut d'un Multi- ou Sudoku.
 	 * Comprend les contraintes de blocs, de lignes, et de colonnes.
 	 */
-	public static List<Constraint> DEFAULT_CONSTRAINTS = Arrays.asList(Constraint.Block, Constraint.Column,
+	public static List<IConstraint> DEFAULT_CONSTRAINTS = SudokuFactory
-			Constraint.Line);
+			.fromConstraints(Arrays.asList(Constraint.Block, Constraint.Column,
+					Constraint.Line));
 
 	/**
 	 * Créée des Cells et les met dans une liste de taille size.
+	 * 
 	 * @param size int, nombre de Cells à initialiser.
 	 * @return List<Cell>, liste des Cells initialisées.
 	 */
@@ -42,7 +45,9 @@ public class SudokuFactory {
 	}
 
 	/**
-	 * Créée des Blocks de taille width par height à partir des cellules données, et les met dans une liste.
+	 * Créée des Blocks de taille width par height à partir des cellules données, et
+	 * les met dans une liste.
+	 * 
 	 * @param cells  List<Cell>, liste des Cells à découper en Blocks.
 	 * @param width  int, largeur des Blocks à créer.
 	 * @param height int, hauteur des Blocks à créer.
@@ -72,29 +77,36 @@ public class SudokuFactory {
 	}
 
 	/**
-	 * Créée un MultiDoku vide dont les Blocks sont de taille widthBlock par heightBlock.
+	 * Créée un MultiDoku vide dont les Blocks sont de taille widthBlock par
+	 * heightBlock.
+	 * 
 	 * @param widthBlock  int, largeur des Blocks.
 	 * @param heightBlock int, hauteur des Blocks.
 	 * @return MultiDoku, MultiDoku vide.
 	 */
 	public static MultiDoku createBasicEmptyRectangleDoku(int widthBlock, int heightBlock,
-			List<Constraint> constraints) {
+			List<IConstraint> constraints) {
 		return new MultiDoku(Arrays.asList(createRectangleSudoku(widthBlock, heightBlock, constraints)));
 	}
 
 	/**
 	 * Créée un MultiDoku vide dont les Blocks sont carrés de longueur size.
+	 * 
 	 * @param size int, taille des Blocks.
 	 * @return MultiDoku, MultiDoku vide.
 	 */
-	public static MultiDoku createBasicEmptySquareDoku(int size, List<Constraint> constraints) {
+	public static MultiDoku createBasicEmptySquareDoku(int size, List<IConstraint> constraints) {
 		return new MultiDoku(Arrays.asList(createSquareSudoku(size, constraints)));
 	}
 
 	/**
-	 * Place des Cells immutables de valeurs fournies, aux Coordinate fournies dans le MultiDoku doku fourni.
+	 * Place des Cells immutables de valeurs fournies, aux Coordinate fournies dans
+	 * le MultiDoku doku fourni.
+	 * 
 	 * @param doku           MultiDoku, MultiDoku à remplir.
-	 * @param immutableCells Map<Coordinate, Integer>, association de Coordinate coordonnées et Integer valeurs, correspondant aux cases à remplir.
+	 * @param immutableCells Map<Coordinate, Integer>, association de Coordinate
+	 *                       coordonnées et Integer valeurs, correspondant aux cases
+	 *                       à remplir.
 	 */
 	public static void setImmutableCells(MultiDoku doku, Map<Coordinate, Integer> immutableCells) {
 		immutableCells.forEach((coordinate, symbol) -> {
@@ -113,8 +125,10 @@ public class SudokuFactory {
 	 *
 	 * @param doku           MultiDoku, MultiDoku dont on doit vider des Cells.
 	 * @param nbCellsToEmpty int, nombre de cases à retirer.
-	 * @return boolean, valant true si un MultiDoku de difficulté donnée peut être créée, false sinon.
+	 * @return boolean, valant true si un MultiDoku de difficulté donnée peut être
-	 * @throws Exception si la difficulté n'est pas compatible avec la taille du MultiDoku.
+	 *         créée, false sinon.
+	 * @throws Exception si la difficulté n'est pas compatible avec la taille du
+	 *                   MultiDoku.
 	 */
 	public static boolean newDokuFromFilledOne(MultiDoku doku, int nbCellsToEmpty, Solver solver) throws Exception {
 
@@ -128,33 +142,28 @@ public class SudokuFactory {
 
 		List<Cell> cellsThatCanBeEmptied = doku.getFilledCells();
 
-		while (!cellsThatCanBeEmptied.isEmpty()) {
 		int index = random.nextInt(cellsThatCanBeEmptied.size());
 		Cell cellToEmpty = cellsThatCanBeEmptied.get(index);
 
-			int oldSymbol = cellToEmpty.empty();
+		cellToEmpty.empty();
 
 		int nbDokuSultions = solver.countSolution(doku);
 		if (nbDokuSultions == 1) {
-				if (newDokuFromFilledOne(doku, --nbCellsToEmpty, solver)) {
+            return newDokuFromFilledOne(doku, --nbCellsToEmpty, solver);
-					return true;
-				}
-			}
-
-			cellToEmpty.setSymbolIndex(oldSymbol);
-			cellsThatCanBeEmptied.remove(cellToEmpty);
 		}
 
 		return false;
 	}
 
 	/**
-	 * Créée un Sudoku vide dont les Blocks sont de taille widthBlock par heightBlock.
+	 * Créée un Sudoku vide dont les Blocks sont de taille widthBlock par
+	 * heightBlock.
+	 * 
 	 * @param widthBlock  int, largeur des Blocks.
 	 * @param heightBlock int, hauteur des Blocks.
 	 * @return Sudoku, Sudoku vide.
 	 */
-	private static Sudoku createRectangleSudoku(int widthBlock, int heightBlock, List<Constraint> constraints) {
+	private static Sudoku createRectangleSudoku(int widthBlock, int heightBlock, List<IConstraint> constraints) {
 		int symbolCount = widthBlock * heightBlock;
 		List<Cell> cases = initCells(symbolCount);
 		List<Block> blocs = initRectangleBlocs(cases, widthBlock, heightBlock);
@@ -168,15 +177,17 @@ public class SudokuFactory {
 
 	/**
 	 * Créée un Sudoku vide dont les Blocks sont carrés de longueur size.
+	 * 
 	 * @param size int, taille des Blocks.
 	 * @return Sudoku, Sudoku vide.
 	 */
-	private static Sudoku createSquareSudoku(int size, List<Constraint> constraints) {
+	private static Sudoku createSquareSudoku(int size, List<IConstraint> constraints) {
 		return createRectangleSudoku(size, size, constraints);
 	}
 
 	/**
 	 * Connecte deux Sudokus selon la décalage offset fourni.
+	 * 
 	 * @param sudoku1 Sudoku, premier sudoku à connecter.
 	 * @param sudoku2 Sudoku, second sudoku à connecter.
 	 * @param offset  Coordinate, décalage entre les deux Sudokus.
@@ -213,35 +224,22 @@ public class SudokuFactory {
 	}
 
 	/**
-	 * Créée un MultiDoku de Blocks carrés de taille size composé de cinq Sudokus, dont un central qui partage chacun de ses Blockss d'angle avec un autre Sudoku.
+	 * Créée un MultiDoku de Blocks carrés de taille size composé de cinq Sudokus,
+	 * dont un central qui partage chacun de ses Blockss d'angle avec un autre
+	 * Sudoku.
+	 * 
 	 * @param size int, largeur des Blocks unitraires des Sudokus à crééer.
 	 * @return MultiDoku, MultiDoku de forme X.
 	 */
-	public static MultiDoku createBasicXShapedMultidoku(int size, List<Constraint> constraints) {
+	public static MultiDoku createBasicXShapedMultidoku(int size, List<IConstraint> constraints) {
 		assert (size > 1);
 
-		/*
+		return createBasicXShapedMultidoku(size, size, constraints);
-		 * 2 3
-		 *  1
-		 * 4 5
-		 */
-
-		Sudoku sudoku1 = createSquareSudoku(size, constraints);
-		Sudoku sudoku2 = createSquareSudoku(size, constraints);
-		Sudoku sudoku3 = createSquareSudoku(size, constraints);
-		Sudoku sudoku4 = createSquareSudoku(size, constraints);
-		Sudoku sudoku5 = createSquareSudoku(size, constraints);
-
-		linkRectangleSudokus(sudoku1, sudoku2, new Coordinate(1 - size, 1 - size));
-		linkRectangleSudokus(sudoku1, sudoku3, new Coordinate(size - 1, 1 - size));
-		linkRectangleSudokus(sudoku1, sudoku4, new Coordinate(1 - size, size - 1));
-		linkRectangleSudokus(sudoku1, sudoku5, new Coordinate(size - 1, size - 1));
-
-		return new MultiDoku(Arrays.asList(sudoku1, sudoku2, sudoku3, sudoku4, sudoku5));
 	}
 
 	/**
-	 * Créée un MultiDoku de Blocks rectangulaires de forme width par height composé de cinq Sudokus,
+	 * Créée un MultiDoku de Blocks rectangulaires de forme width par height composé
+	 * de cinq Sudokus,
 	 * dont un central qui partage chacun de ses Blocks d'angle avec un autre
 	 * Sudoku.
 	 *
@@ -249,7 +247,7 @@ public class SudokuFactory {
 	 * @param height int, hauteur des Blocks unitraires des Sudokus à crééer.
 	 * @return MultiDoku, MultiDoku de forme X.
 	 */
-	public static MultiDoku createBasicXShapedMultidoku(int width, int height, List<Constraint> constraints) {
+	public static MultiDoku createBasicXShapedMultidoku(int width, int height, List<IConstraint> constraints) {
 		assert (width > 1 && height > 1);
 
 		/*
@@ -272,6 +270,55 @@ public class SudokuFactory {
 		return new MultiDoku(Arrays.asList(sudoku1, sudoku2, sudoku3, sudoku4, sudoku5));
 	}
 
+	/**
+	 * TODO
+	 * Créée un MultiDoku de Blocks carrés de taille size composé de cinq Sudokus,
+	 * dont un central qui partage chacun de ses Blockss d'angle avec un autre
+	 * Sudoku.
+	 *
+	 * @param size int, largeur des Blocks unitraires des Sudokus à crééer.
+	 * @return MultiDoku, MultiDoku de forme X.
+	 */
+	public static MultiDoku createBasicPlusShapedMultidoku(int size, List<IConstraint> constraints) {
+		assert (size > 1);
+
+		return createBasicPlusShapedMultidoku(size, size, constraints);
+	}
+
+	/**
+	 * TODO
+	 * Créée un MultiDoku de Blocks rectangulaires de forme width par height composé
+	 * de cinq Sudokus,
+	 * dont un central qui partage chacun de ses Blocks d'angle avec un autre
+	 * Sudoku.
+	 *
+	 * @param width  int, largeur des Blocks unitraires des Sudokus à crééer.
+	 * @param height int, hauteur des Blocks unitraires des Sudokus à crééer.
+	 * @return MultiDoku, MultiDoku de forme X.
+	 */
+	public static MultiDoku createBasicPlusShapedMultidoku(int width, int height, List<IConstraint> constraints) {
+		assert (width > 1 && height > 1);
+
+		/*
+		 *   3
+		 * 2 1 4
+		 *   5
+		 */
+
+		Sudoku sudoku1 = createRectangleSudoku(width, height, constraints);
+		Sudoku sudoku2 = createRectangleSudoku(width, height, constraints);
+		Sudoku sudoku3 = createRectangleSudoku(width, height, constraints);
+		Sudoku sudoku4 = createRectangleSudoku(width, height, constraints);
+		Sudoku sudoku5 = createRectangleSudoku(width, height, constraints);
+
+		linkRectangleSudokus(sudoku1, sudoku2, new Coordinate(1 - height, 0));
+		linkRectangleSudokus(sudoku1, sudoku3, new Coordinate(0, 1 - width));
+		linkRectangleSudokus(sudoku1, sudoku4, new Coordinate(height - 1, 0));
+		linkRectangleSudokus(sudoku1, sudoku5, new Coordinate(0, width - 1));
+
+		return new MultiDoku(Arrays.asList(sudoku1, sudoku2, sudoku3, sudoku4, sudoku5));
+	}
+
 	public static void fillDoku(MultiDoku doku, Difficulty difficulty) throws Exception {
 		Solver solver = new RandomSolver();
 		solver.solve(doku);
@@ -291,11 +338,10 @@ public class SudokuFactory {
 		}
 	}
 
-	public static MultiDoku createBasicEmptyRandomBlockDoku(int blockSize, List<Constraint> constraints) {
+	public static MultiDoku createBasicEmptyRandomBlockDoku(int blockSize, List<IConstraint> constraints) {
 		int blockCellCount = blockSize * blockSize;
 		List<Cell> cells = initCells(blockCellCount);
-		List<Cell> homeLessCells = new ArrayList<>();
+        List<Cell> homeLessCells = new ArrayList<>(cells);
-		homeLessCells.addAll(cells);
 		List<Block> blocks = new ArrayList<>();
 		Random r = new Random();
 		for (int i = 0; i < blockCellCount; i++) {
@@ -314,4 +360,12 @@ public class SudokuFactory {
 		}
 		return new MultiDoku(Arrays.asList(sudoku));
 	}
+
+	public static List<IConstraint> fromConstraints(List<Constraint> constraints) {
+		List<IConstraint> iconstraints = new ArrayList<>();
+		for (Constraint cons : constraints) {
+			iconstraints.add(cons.getConstraint());
+		}
+		return iconstraints;
+	}
 }

app/src/test/java/sudoku/solver/SolverTest.java

@@ -1,7 +1,12 @@
 package sudoku.solver;
 
-import gui.Symbols;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
+
+import gui.constants.Symbols;
 import sudoku.io.SudokuPrinter;
 import sudoku.io.SudokuSerializer;
 import sudoku.structure.Cell;
@@ -9,17 +14,10 @@ import sudoku.structure.MultiDoku;
 import sudoku.structure.Sudoku;
 import sudoku.structure.SudokuFactory;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import java.util.List;
-import java.util.Random;
-
 class SolverTest {
 
 	@Test
 	void solveTest() {
-		Random rand = new Random();
-
 		MultiDoku dokuToTest = SudokuFactory.createBasicEmptySquareDoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
 		MultiDoku dokuResult = SudokuFactory.createBasicEmptySquareDoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);