yes

Reviewed-on: #37

.github/workflows/build.yml

@@ -19,7 +19,7 @@ jobs:
         uses: gradle/actions/setup-gradle@v4
      
       - name: Build with Gradle
-        run: ./gradlew build
+        run: ./gradlew assemble
 
       - name: Test
         run: ./gradlew test

app/build.gradle

@@ -11,8 +11,6 @@ plugins {
     id 'application'
 }
 
-project.ext.os = System.properties['os.name'].toLowerCase().split(" ")[0]
-
 repositories {
     // Use Maven Central for resolving dependencies.
     mavenCentral()
@@ -20,7 +18,8 @@ repositories {
 
 dependencies {
     // Use JUnit Jupiter for testing.
-    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.1'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
 
     implementation 'org.json:json:20250107'
 
@@ -28,7 +27,9 @@ dependencies {
 
     implementation "org.lwjgl:lwjgl-stb:3.3.4"
 
-    runtimeOnly "org.lwjgl:lwjgl-stb::natives-$os"
+    implementation "org.lwjgl:lwjgl-stb::natives-linux"
+    implementation "org.lwjgl:lwjgl-stb::natives-windows"
+    implementation "org.lwjgl:lwjgl-stb::natives-macos"
 }
 
 application {
@@ -48,6 +49,10 @@ jar {
     } 
 }
 
+test {
+    useJUnitPlatform()
+}
+
 run {
     enableAssertions = true
 }

app/save/save-1.json

@@ -6,26 +6,30 @@
       },
       {
          "blockID": 0,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 8
       },
       {
          "blockID": 0,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 1,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 1,
+         "immutable": true,
+         "symbolIndex": 2
+      },
+      {
+         "blockID": 1,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 2,
          "immutable": true,
          "symbolIndex": 1
       },
-      {
-         "blockID": 1,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 1,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 1,
-         "symbolIndex": -1
-      },
       {
          "blockID": 2,
          "symbolIndex": -1
@@ -35,8 +39,9 @@
          "symbolIndex": -1
       },
       {
-         "blockID": 2,
+         "blockID": 0,
-         "symbolIndex": -1
+         "immutable": true,
+         "symbolIndex": 8
       },
       {
          "blockID": 0,
@@ -47,17 +52,13 @@
          "blockID": 0,
          "symbolIndex": -1
       },
-      {
-         "blockID": 0,
-         "immutable": true,
-         "symbolIndex": 4
-      },
       {
          "blockID": 1,
          "symbolIndex": -1
       },
       {
          "blockID": 1,
+         "immutable": true,
          "symbolIndex": 0
       },
       {
@@ -66,13 +67,11 @@
       },
       {
          "blockID": 2,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 6
       },
       {
          "blockID": 2,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 8
       },
       {
          "blockID": 2,
@@ -81,35 +80,27 @@
       {
          "blockID": 0,
          "immutable": true,
-         "symbolIndex": 3
-      },
-      {
-         "blockID": 0,
-         "immutable": true,
-         "symbolIndex": 6
-      },
-      {
-         "blockID": 0,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 1,
-         "immutable": true,
          "symbolIndex": 5
       },
+      {
+         "blockID": 0,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 0,
+         "symbolIndex": -1
+      },
       {
          "blockID": 1,
          "symbolIndex": -1
       },
       {
          "blockID": 1,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 7
       },
       {
-         "blockID": 2,
+         "blockID": 1,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 2
       },
       {
          "blockID": 2,
@@ -118,85 +109,49 @@
       {
          "blockID": 2,
          "immutable": true,
-         "symbolIndex": 4
-      },
-      {
-         "blockID": 3,
-         "immutable": true,
          "symbolIndex": 8
       },
       {
-         "blockID": 3,
+         "blockID": 2,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 2
       },
       {
          "blockID": 3,
-         "immutable": true,
-         "symbolIndex": 3
-      },
-      {
-         "blockID": 4,
-         "immutable": true,
-         "symbolIndex": 6
-      },
-      {
-         "blockID": 4,
          "symbolIndex": -1
       },
       {
-         "blockID": 4,
+         "blockID": 3,
          "symbolIndex": -1
       },
       {
-         "blockID": 5,
+         "blockID": 3,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 5,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 5,
          "immutable": true,
          "symbolIndex": 1
       },
       {
-         "blockID": 3,
+         "blockID": 4,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 3,
-         "immutable": true,
-         "symbolIndex": 4
-      },
-      {
-         "blockID": 3,
          "immutable": true,
          "symbolIndex": 5
       },
       {
          "blockID": 4,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 4,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 4,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 5,
-         "immutable": true,
-         "symbolIndex": 8
-      },
-      {
-         "blockID": 5,
          "immutable": true,
          "symbolIndex": 6
       },
+      {
+         "blockID": 4,
+         "immutable": true,
+         "symbolIndex": 0
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "immutable": true,
+         "symbolIndex": 3
+      },
       {
          "blockID": 5,
          "symbolIndex": -1
@@ -211,8 +166,7 @@
       },
       {
          "blockID": 3,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 6
       },
       {
          "blockID": 4,
@@ -225,33 +179,101 @@
       },
       {
          "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 3,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 3,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 3,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 6,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 6,
+         "immutable": true,
+         "symbolIndex": 6
+      },
+      {
+         "blockID": 6,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 7,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 7,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 7,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 8,
          "immutable": true,
          "symbolIndex": 8
       },
       {
-         "blockID": 5,
+         "blockID": 8,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 4
       },
       {
-         "blockID": 5,
+         "blockID": 8,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 5
-      },
-      {
-         "blockID": 5,
-         "immutable": true,
-         "symbolIndex": 3
       },
       {
          "blockID": 6,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 4
       },
       {
          "blockID": 6,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 3
       },
       {
          "blockID": 6,
@@ -260,7 +282,7 @@
       {
          "blockID": 7,
          "immutable": true,
-         "symbolIndex": 8
+         "symbolIndex": 4
       },
       {
          "blockID": 7,
@@ -268,16 +290,6 @@
       },
       {
          "blockID": 7,
-         "immutable": true,
-         "symbolIndex": 1
-      },
-      {
-         "blockID": 8,
-         "immutable": true,
-         "symbolIndex": 5
-      },
-      {
-         "blockID": 8,
          "symbolIndex": -1
       },
       {
@@ -286,49 +298,14 @@
          "symbolIndex": 6
       },
       {
-         "blockID": 6,
+         "blockID": 8,
          "immutable": true,
-         "symbolIndex": 1
+         "symbolIndex": 7
-      },
-      {
-         "blockID": 6,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 6,
-         "immutable": true,
-         "symbolIndex": 8
-      },
-      {
-         "blockID": 7,
-         "immutable": true,
-         "symbolIndex": 3
-      },
-      {
-         "blockID": 7,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 7,
-         "immutable": true,
-         "symbolIndex": 6
       },
       {
          "blockID": 8,
          "symbolIndex": -1
       },
-      {
-         "blockID": 8,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 8,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 6,
-         "symbolIndex": -1
-      },
       {
          "blockID": 6,
          "immutable": true,
@@ -338,10 +315,13 @@
          "blockID": 6,
          "symbolIndex": -1
       },
+      {
+         "blockID": 6,
+         "symbolIndex": -1
+      },
       {
          "blockID": 7,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 7
       },
       {
          "blockID": 7,
@@ -354,7 +334,7 @@
       {
          "blockID": 8,
          "immutable": true,
-         "symbolIndex": 1
+         "symbolIndex": 3
       },
       {
          "blockID": 8,
@@ -362,8 +342,7 @@
       },
       {
          "blockID": 8,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 8
       }
    ],
    "blocks": [

app/save/save.json

@@ -2,338 +2,320 @@
    "cells": [
       {
          "blockID": 0,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 0,
-         "immutable": true,
-         "symbolIndex": 8
-      },
-      {
-         "blockID": 0,
-         "immutable": true,
-         "symbolIndex": 1
-      },
-      {
-         "blockID": 1,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 1,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 1,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 2,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 2,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 2,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 0,
-         "immutable": true,
-         "symbolIndex": 2
-      },
-      {
-         "blockID": 0,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 0,
-         "immutable": true,
-         "symbolIndex": 4
-      },
-      {
-         "blockID": 1,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 1,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 1,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 2,
-         "immutable": true,
-         "symbolIndex": 6
-      },
-      {
-         "blockID": 2,
-         "immutable": true,
-         "symbolIndex": 8
-      },
-      {
-         "blockID": 2,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 0,
-         "immutable": true,
-         "symbolIndex": 3
-      },
-      {
-         "blockID": 0,
-         "immutable": true,
-         "symbolIndex": 6
-      },
-      {
-         "blockID": 0,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 1,
          "immutable": true,
          "symbolIndex": 5
       },
       {
-         "blockID": 1,
+         "blockID": 0,
          "symbolIndex": -1
       },
+      {
+         "blockID": 0,
+         "immutable": true,
+         "symbolIndex": 6
+      },
       {
          "blockID": 1,
          "immutable": true,
          "symbolIndex": 7
       },
       {
-         "blockID": 2,
+         "blockID": 1,
-         "immutable": true,
-         "symbolIndex": 2
-      },
-      {
-         "blockID": 2,
          "symbolIndex": -1
       },
       {
-         "blockID": 2,
+         "blockID": 1,
-         "immutable": true,
-         "symbolIndex": 4
-      },
-      {
-         "blockID": 3,
-         "immutable": true,
-         "symbolIndex": 8
-      },
-      {
-         "blockID": 3,
-         "immutable": true,
-         "symbolIndex": 2
-      },
-      {
-         "blockID": 3,
-         "immutable": true,
-         "symbolIndex": 3
-      },
-      {
-         "blockID": 4,
-         "immutable": true,
-         "symbolIndex": 6
-      },
-      {
-         "blockID": 4,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 4,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 5,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 5,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 5,
          "immutable": true,
          "symbolIndex": 1
       },
       {
-         "blockID": 3,
+         "blockID": 2,
          "symbolIndex": -1
       },
       {
-         "blockID": 3,
+         "blockID": 2,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 2,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 0,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 0,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 0,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 1,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 1,
+         "immutable": true,
+         "symbolIndex": 2
+      },
+      {
+         "blockID": 1,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 2,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 2,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 2,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 0,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 0,
          "immutable": true,
          "symbolIndex": 4
       },
       {
-         "blockID": 3,
+         "blockID": 0,
-         "immutable": true,
-         "symbolIndex": 5
-      },
-      {
-         "blockID": 4,
          "symbolIndex": -1
       },
       {
-         "blockID": 4,
+         "blockID": 1,
          "symbolIndex": -1
       },
       {
-         "blockID": 4,
+         "blockID": 1,
          "symbolIndex": -1
       },
       {
-         "blockID": 5,
+         "blockID": 1,
          "immutable": true,
          "symbolIndex": 8
       },
       {
-         "blockID": 5,
+         "blockID": 2,
-         "immutable": true,
-         "symbolIndex": 6
-      },
-      {
-         "blockID": 5,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 3,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 3,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 3,
-         "immutable": true,
-         "symbolIndex": 6
-      },
-      {
-         "blockID": 4,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 4,
          "immutable": true,
          "symbolIndex": 7
       },
+      {
+         "blockID": 2,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 2,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 3,
+         "immutable": true,
+         "symbolIndex": 6
+      },
+      {
+         "blockID": 3,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 3,
+         "symbolIndex": -1
+      },
       {
          "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
          "immutable": true,
          "symbolIndex": 8
       },
       {
          "blockID": 5,
-         "immutable": true,
-         "symbolIndex": 4
-      },
-      {
-         "blockID": 5,
-         "immutable": true,
-         "symbolIndex": 5
-      },
-      {
-         "blockID": 5,
-         "immutable": true,
-         "symbolIndex": 3
-      },
-      {
-         "blockID": 6,
-         "immutable": true,
-         "symbolIndex": 4
-      },
-      {
-         "blockID": 6,
-         "immutable": true,
-         "symbolIndex": 3
-      },
-      {
-         "blockID": 6,
          "symbolIndex": -1
       },
       {
-         "blockID": 7,
+         "blockID": 5,
-         "immutable": true,
-         "symbolIndex": 8
-      },
-      {
-         "blockID": 7,
          "symbolIndex": -1
       },
       {
-         "blockID": 7,
+         "blockID": 3,
          "immutable": true,
          "symbolIndex": 1
       },
       {
-         "blockID": 8,
+         "blockID": 3,
          "immutable": true,
-         "symbolIndex": 5
+         "symbolIndex": 2
       },
       {
-         "blockID": 8,
+         "blockID": 3,
          "symbolIndex": -1
       },
       {
-         "blockID": 8,
+         "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
          "immutable": true,
          "symbolIndex": 6
       },
       {
-         "blockID": 6,
+         "blockID": 3,
-         "immutable": true,
-         "symbolIndex": 1
-      },
-      {
-         "blockID": 6,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 6,
          "immutable": true,
          "symbolIndex": 8
       },
       {
-         "blockID": 7,
+         "blockID": 3,
-         "immutable": true,
-         "symbolIndex": 3
-      },
-      {
-         "blockID": 7,
          "symbolIndex": -1
       },
       {
-         "blockID": 7,
+         "blockID": 3,
-         "immutable": true,
-         "symbolIndex": 6
-      },
-      {
-         "blockID": 8,
          "symbolIndex": -1
       },
       {
-         "blockID": 8,
+         "blockID": 4,
          "symbolIndex": -1
       },
       {
-         "blockID": 8,
+         "blockID": 4,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 6,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 6,
          "immutable": true,
          "symbolIndex": 0
       },
+      {
+         "blockID": 4,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 5,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 6,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 6,
+         "immutable": true,
+         "symbolIndex": 5
+      },
+      {
+         "blockID": 6,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 7,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 7,
+         "immutable": true,
+         "symbolIndex": 1
+      },
+      {
+         "blockID": 7,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 8,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 8,
+         "immutable": true,
+         "symbolIndex": 7
+      },
+      {
+         "blockID": 8,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 6,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 6,
+         "immutable": true,
+         "symbolIndex": 8
+      },
+      {
+         "blockID": 6,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 7,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 7,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 7,
+         "immutable": true,
+         "symbolIndex": 6
+      },
+      {
+         "blockID": 8,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 8,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 8,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 6,
+         "symbolIndex": -1
+      },
+      {
+         "blockID": 6,
+         "symbolIndex": -1
+      },
       {
          "blockID": 6,
          "symbolIndex": -1
@@ -341,20 +323,17 @@
       {
          "blockID": 7,
          "immutable": true,
-         "symbolIndex": 7
+         "symbolIndex": 4
       },
       {
          "blockID": 7,
-         "symbolIndex": -1
+         "immutable": true,
+         "symbolIndex": 5
       },
       {
          "blockID": 7,
-         "symbolIndex": -1
-      },
-      {
-         "blockID": 8,
          "immutable": true,
-         "symbolIndex": 1
+         "symbolIndex": 0
       },
       {
          "blockID": 8,
@@ -362,8 +341,11 @@
       },
       {
          "blockID": 8,
-         "immutable": true,
+         "symbolIndex": -1
-         "symbolIndex": 8
+      },
+      {
+         "blockID": 8,
+         "symbolIndex": -1
       }
    ],
    "blocks": [

app/src/main/java/gui/AssetManager.java

@@ -0,0 +1,32 @@
+package gui;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class AssetManager {
+
+	public static byte[] getResource(String name) {
+		// we first search it in files
+		File f = new File(name);
+		if (f.exists()){
+			FileInputStream fis;
+			try {
+				fis = new FileInputStream(f);
+				return fis.readAllBytes();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		// then in the jar
+		InputStream is = ClassLoader.getSystemResourceAsStream(name);
+		try {
+			return is.readAllBytes();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+}

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

@@ -1,8 +1,9 @@
 package gui;
 
+import gui.constants.Fonts;
+import gui.constants.Images;
 import gui.menu.MainMenu;
 import gui.menu.StateMachine;
-import imgui.ImGui;
 import imgui.app.Application;
 import imgui.app.Configuration;
 
@@ -30,7 +31,7 @@ public class Main extends Application {
     @Override
     protected void preRun() {
         super.preRun();
-        Images.loadImages();
+        Images.reloadImages();
     }
 
     @Override

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

@@ -47,8 +47,6 @@ public class RenderableMultidoku {
 		return cells.get(index);
 	}
 
-	
-
 	private static record PositionConstraint(Sudoku sudoku1, Sudoku sudoku2, Coordinate offset) {
 	}
 

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

@@ -1,5 +1,6 @@
-package gui;
+package gui.constants;
 
+import gui.AssetManager;
 import imgui.ImFont;
 import imgui.ImFontConfig;
 import imgui.ImFontGlyphRangesBuilder;
@@ -20,15 +21,15 @@ public class Fonts {
 		ImFontGlyphRangesBuilder builder = new ImFontGlyphRangesBuilder();
 		builder.addRanges(ImGui.getIO().getFonts().getGlyphRangesDefault());
 		builder.addRanges(ImGui.getIO().getFonts().getGlyphRangesCyrillic());
-		// builder.addRanges(ImGui.getIO().getFonts().getGlyphRangesChineseFull());
+		
 		ImFontConfig cfg = new ImFontConfig();
 		cfg.setGlyphRanges(builder.buildRanges());
 
-		COMIC = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "comic.ttf", 50.0f);
+		COMIC = ImGui.getIO().getFonts().addFontFromMemoryTTF(AssetManager.getResource("comic.ttf"), 50.0f);
-		ARIAL_BOLD = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "arial_bold.ttf", 50.0f);
+		ARIAL_BOLD = ImGui.getIO().getFonts().addFontFromMemoryTTF(AssetManager.getResource("arial_bold.ttf"), 50.0f);
-		ARIAL = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "arial.ttf", 50.0f, cfg);
+		ARIAL = ImGui.getIO().getFonts().addFontFromMemoryTTF(AssetManager.getResource("arial.ttf"), 50.0f, cfg);
-		CHERI = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "cheri.ttf", 50.0f);
+		CHERI = ImGui.getIO().getFonts().addFontFromMemoryTTF(AssetManager.getResource("cheri.ttf"), 50.0f);
-		INFECTED = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "INFECTED.ttf", 50.0f);
+		INFECTED = ImGui.getIO().getFonts().addFontFromMemoryTTF(AssetManager.getResource("INFECTED.ttf"), 50.0f);
 	}
 
 }

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

@@ -1,20 +1,25 @@
-package gui;
+package gui.constants;
 
 import java.nio.ByteBuffer;
 
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.stb.STBImage;
 
+import gui.AssetManager;
+
 public class Images {
 
 	public static int BACKGROUND;
 
-	private static int loadTexture(String fileName) {
+	private static int loadTexture(byte[] imageData) {
 		int[] width = new int[1];
 		int[] height = new int[1];
 		int[] channelCount = new int[1];
 
-		ByteBuffer pixels = STBImage.stbi_load(fileName, width, height, channelCount, 4);
+		ByteBuffer img = ByteBuffer.allocateDirect(imageData.length);
+		img.put(imageData);
+		img.flip();
+		ByteBuffer pixels = STBImage.stbi_load_from_memory(img, width, height, channelCount, 4);
 
 		int textureID = GL11.glGenTextures();
 		GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureID);
@@ -32,8 +37,8 @@ public class Images {
 		return textureID;
 	}
 
-	public static void loadImages() {
+	public static void reloadImages() {
-		BACKGROUND = loadTexture("background.png");
+		BACKGROUND = loadTexture(AssetManager.getResource(Options.BackgroundPath));
 	}
 
 }

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

@@ -1,8 +1,9 @@
-package gui;
+package gui.constants;
 
 public class Options {
 
 	public static Symbols Symboles = Symbols.Numbers;
 	public static float BackgroundSpeed = 1.0f;
+	public static String BackgroundPath = "background.png";
 
 }

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;;
 
@@ -33,7 +33,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 +43,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/ConnexionStatusView.java

@@ -14,12 +14,12 @@ public class ConnexionStatusView extends BaseView {
 
 	private String displayText = "Connecting ...";
 
-	public ConnexionStatusView(StateMachine stateMachine, String address, short port)
+	public ConnexionStatusView(StateMachine stateMachine, String pseudo, String address, short port)
 			throws UnknownHostException, IOException {
 		super(stateMachine);
 		Thread t = new Thread(() -> {
 			try {
-				this.client = new Client(address, port);
+				this.client = new Client(pseudo, address, port);
 				bindListeners();
 			} catch (IOException e) {
 				e.printStackTrace();
@@ -29,12 +29,13 @@ public class ConnexionStatusView extends BaseView {
 		t.start();
 	}
 
-	public ConnexionStatusView(StateMachine stateMachine, short port) throws UnknownHostException, IOException {
+	public ConnexionStatusView(StateMachine stateMachine, String pseudo, short port)
+			throws UnknownHostException, IOException {
 		super(stateMachine);
 		Thread t = new Thread(() -> {
 			try {
 				this.server = new Server(port);
-				this.client = new Client("localhost", port);
+				this.client = new Client(pseudo, "localhost", port);
 				bindListeners();
 			} catch (IOException e) {
 				e.printStackTrace();

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

@@ -1,6 +1,7 @@
 package gui.menu;
 
 import java.io.IOException;
+import java.util.Random;
 
 import imgui.ImGui;
 import imgui.ImVec2;
@@ -11,6 +12,7 @@ public class MultiMenu extends BaseView {
 
 	private final ImInt port = new ImInt(25565);
 	private final ImString address = new ImString("localhost");
+	private final ImString pseudo = new ImString("Joueur" + new Random().nextInt());
 
 	public MultiMenu(StateMachine stateMachine) {
 		super(stateMachine);
@@ -20,10 +22,12 @@ public class MultiMenu extends BaseView {
 	private void renderCreate() {
 		ImVec2 displaySize = ImGui.getIO().getDisplaySize();
 		ImGui.beginChild("##CreateGame", new ImVec2(displaySize.x / 2.0f, displaySize.y * 8.0f / 9.0f));
-		ImGui.inputInt("Port", port);
+		if (ImGui.inputInt("Port", port))
+			port.set(Math.clamp(port.get(), 1, 65535));
+		ImGui.inputText("Pseudo", pseudo);
 		if (ImGui.button("Créer")) {
 			try {
-				this.stateMachine.pushState(new ConnexionStatusView(stateMachine, (short) port.get()));
+				this.stateMachine.pushState(new ConnexionStatusView(stateMachine, pseudo.get(), (short) port.get()));
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
@@ -35,12 +39,13 @@ public class MultiMenu extends BaseView {
 		ImVec2 displaySize = ImGui.getIO().getDisplaySize();
 		ImGui.beginChild("##JoinGame", new ImVec2(displaySize.x / 2.0f, displaySize.y * 8.0f / 9.0f));
 		ImGui.inputText("Adresse", address);
-		ImGui.inputInt("Port", port);
+		if (ImGui.inputInt("Port", port))
+			port.set(Math.clamp(port.get(), 1, 65535));
+		ImGui.inputText("Pseudo", pseudo);
 		if (ImGui.button("Rejoindre")) {
 			try {
 				this.stateMachine.pushState(new ConnexionStatusView(stateMachine, address.get(), (short) port.get()));
 			} catch (IOException e) {
-				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 		}

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

@@ -68,7 +68,8 @@ public class MultiPlayerView extends BaseView {
 	}
 
 	private void renderTimer() {
-		ImGui.inputInt("Temps de la partie (minutes)", gameDurationMinutes);
+		if (ImGui.inputInt("Temps de la partie (minutes)", gameDurationMinutes))
+			gameDurationMinutes.set(Math.clamp(gameDurationMinutes.get(), 1, 90));
 	}
 
 	@Override
@@ -77,4 +78,9 @@ public class MultiPlayerView extends BaseView {
 		renderGameStatus();
 	}
 
+	@Override
+	public void cleanResources() {
+		this.selector.clean();
+	}
+
 }

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

@@ -1,28 +1,56 @@
 package gui.menu;
 
-import gui.Options;
+import gui.constants.Images;
-import gui.Symbols;
+import gui.constants.Options;
+import gui.constants.Symbols;
 import imgui.ImGui;
+import imgui.extension.imguifiledialog.ImGuiFileDialog;
+import imgui.extension.imguifiledialog.flag.ImGuiFileDialogFlags;
 import imgui.type.ImInt;
 
 public class OptionsMenu extends BaseView {
 
 	private ImInt currentValue = new ImInt();
-	private float backgroundSpeed[] = new float[]{Options.BackgroundSpeed};
+	private float backgroundSpeed[] = new float[] { Options.BackgroundSpeed };
 
 	public OptionsMenu(StateMachine stateMachine) {
 		super(stateMachine);
 	}
 
+	private void renderImageSelectDialog() {
+		if (ImGuiFileDialog.display("browse-img", ImGuiFileDialogFlags.None)) {
+			if (ImGuiFileDialog.isOk()) {
+				var selection = ImGuiFileDialog.getSelection();
+				for (var entry : selection.entrySet()) {
+					try {
+						String filePath = entry.getValue();
+						Options.BackgroundPath = filePath;
+						Images.reloadImages();
+					} catch (Exception e) {
+						e.printStackTrace();
+					}
+				}
+			}
+			ImGuiFileDialog.close();
+		}
+	}
+
+	private void renderImageSelectButton() {
+		if (ImGui.button("Changer de fond d'écran"))
+			ImGuiFileDialog.openDialog("browse-img", "Choisissez un fichier", ".png,.jpg,.jpeg", ".");
+		renderImageSelectDialog();
+	}
+
 	@Override
 	public void render() {
 		ImGui.text("Options");
-		if(ImGui.combo("Jeu de symboles", currentValue, Symbols.getSymbolsNames())){
+		if (ImGui.combo("Jeu de symboles", currentValue, Symbols.getSymbolsNames())) {
 			Options.Symboles = Symbols.values()[currentValue.get()];
 		}
-		if(ImGui.sliderFloat("Vitesse d'animation de l'arrière plan", backgroundSpeed, 0.0f, 10.0f)){
+		if (ImGui.sliderFloat("Vitesse d'animation de l'arrière plan", backgroundSpeed, 0.0f, 10.0f)) {
 			Options.BackgroundSpeed = backgroundSpeed[0];
 		}
+		renderImageSelectButton();
 		renderReturnButton();
 	}
 

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

@@ -25,4 +25,9 @@ public class SoloMenu extends BaseView {
 		renderReturnButton();
 	}
 
+	@Override
+	public void cleanResources() {
+		this.sudokuSelector.clean();
+	}
+
 }

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;
@@ -7,9 +9,12 @@ import imgui.ImGui;
 import imgui.ImGuiStyle;
 import sudoku.io.SudokuSerializer;
 import sudoku.solver.BacktrackingSolver;
+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;
 
 public class SudokuView extends BaseView {
@@ -20,6 +25,8 @@ public class SudokuView extends BaseView {
 	private String lastSavePath = null;
 
 	private boolean resolved = false;
+	// if the solver can't solve
+	private volatile boolean unresolved = false;
 
 	public SudokuView(StateMachine stateMachine, MultiDoku doku) {
 		super(stateMachine);
@@ -68,10 +75,28 @@ public class SudokuView extends BaseView {
 			stopResolve();
 	}
 
+	private void renderHintButton() {
+		if (!this.resolved && centeredButton("Indice")) {
+			Hint hint = HintHelper.getHint(this.doku, new BacktrackingSolver());
+			assert (hint != null);
+			hint.cell().setSymbolIndex(hint.newValue());
+			if (this.doku.isSolved())
+				this.sudokuRenderer.onResolve.emit();
+		}
+	}
+
+	private void renderUnsolvableText() {
+		if (this.unresolved)
+			ImGui.text("Impossible de résoudre avec l'algorithme actuel !");
+
+	}
+
 	private void startSolve(Solver solver) {
+		this.doku.clearMutableCells();
 		resolveThread = new Thread(() -> {
+			List<SolverStep> steps = new ArrayList<>();
 			try {
-				solver.solve(this.doku);
+				unresolved = !solver.solve(this.doku, steps);
 			} catch (CancellationException e) {
 				System.out.println("The user is bored !");
 			}
@@ -79,6 +104,11 @@ public class SudokuView extends BaseView {
 		});
 	}
 
+	private void renderResolvedText() {
+		if (this.resolved)
+			ImGui.text("Bravo !");
+	}
+
 	private void renderSolvePopup() {
 		if (ImGui.beginPopup("solve")) {
 			if (ImGui.button("Résoudre avec backtrace")) {
@@ -102,16 +132,14 @@ public class SudokuView extends BaseView {
 			ImGui.beginDisabled();
 
 		if (!this.resolved && centeredButton("Résoudre")) {
-			// beginSolve = true;
 			ImGui.openPopup("solve");
 		}
 
 		if (resolveThread != null)
 			ImGui.endDisabled();
 
-		if (this.resolved) {
+		renderResolvedText();
-			ImGui.text("Bravo !");
+		renderUnsolvableText();
-		}
 
 		renderSolvePopup();
 	}
@@ -128,9 +156,19 @@ public class SudokuView extends BaseView {
 		}
 	}
 
+	private void renderClearButton() {
+		if (centeredButton("Effacer")) {
+			this.doku.clearMutableCells();
+			this.resolved = false;
+			this.unresolved = false;
+		}
+	}
+
 	@Override
 	public void render() {
 		sudokuRenderer.render();
+		renderHintButton();
+		renderClearButton();
 		renderSolveButton();
 		renderSaveButton();
 		renderCancelButton();

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/SmoothProgressBar.java

@@ -9,13 +9,22 @@ public class SmoothProgressBar {
 	private final float speed = 2.0f;
 	private final float clipConstant = 0.001f;
 
-	public void render(String label, ImVec2 size, float progress) {
+	private void updateProgress(float newProgress) {
-		float delta = progress - lastProgress;
+		float delta = newProgress - lastProgress;
 		if (Math.abs(delta) < clipConstant)
-			lastProgress = progress;
+			lastProgress = newProgress;
 		else
 			lastProgress = lastProgress + delta * ImGui.getIO().getDeltaTime() * speed;
+	}
+
+	public void render(String label, ImVec2 size, float progress) {
+		updateProgress(progress);
 		ImGui.progressBar(lastProgress, size, label);
 	}
 
+	public void render(float progress) {
+		updateProgress(progress);
+		ImGui.progressBar(lastProgress);
+	}
+
 }

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;
@@ -84,8 +84,8 @@ public class SudokuRenderer {
 					}
 				} else {
 					if (ImGui.button(Options.Symboles.getSymbols().get(i), cellSize)) {
-						if (currentCell.trySetValue(i))
+						currentCell.setSymbolIndex(i);
-							this.onCellChange.emit(currentCell);
+						this.onCellChange.emit(currentCell);
 						if (this.doku.getDoku().isSolved())
 							this.onResolve.emit();
 						ImGui.closeCurrentPopup();
@@ -117,6 +117,7 @@ public class SudokuRenderer {
 					ImGui.sameLine();
 				int index = y * doku.getWidth() + x;
 				Cell cell = doku.getCell(x, y);
+				ImGui.beginDisabled(cell == null);
 				if (cell == null) {
 					ImGui.pushStyleColor(ImGuiCol.Border, TRANSPARENT);
 					ImGui.pushStyleColor(ImGuiCol.Button, TRANSPARENT);
@@ -141,6 +142,7 @@ public class SudokuRenderer {
 						currentCell = cell;
 					}
 				}
+				ImGui.endDisabled();
 				ImGui.popStyleColor(2);
 			}
 		}

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

@@ -4,16 +4,18 @@ 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;
+import sudoku.structure.SudokuFiller;
 
 public class SudokuSelector {
 
@@ -24,7 +26,7 @@ public class SudokuSelector {
 
 	private final ImInt sudokuType = new ImInt(0);
 
-	private final ImInt difficulty = new ImInt(Difficulty.Medium.ordinal());
+	private final ImInt difficulty = new ImInt(Difficulty.Easy.ordinal());
 	private final List<ImBoolean> contraints = new ArrayList<>();
 
 	private final ImInt sudokuSize = new ImInt(3);
@@ -34,37 +36,66 @@ public class SudokuSelector {
 
 	private final String confirmMessage;
 
+	private Thread genThread = null;
+
+	private final SmoothProgressBar genProgressBar;
+
 	public SudokuSelector(boolean canGenEmptyGrid, String confirmMessage) {
 		this.canGenEmptyGrid = canGenEmptyGrid;
 		this.confirmMessage = confirmMessage;
 		initConstraints();
+		this.genProgressBar = new SmoothProgressBar();
 	}
 
-	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())));
+		}
+	}
+
+	private void stopGenThread() {
+		if (this.genThread != null) {
+			this.genThread.interrupt();
+			this.genThread = null;
+		}
+	}
+
+	private void renderGenProgress() {
+		if (ImGui.beginPopup("genProgress")) {
+			ImGui.text("Chargement de la grille ...");
+			int filled = this.doku.getFilledCells().size();
+			int total = this.doku.getCells().size();
+			this.genProgressBar.render(filled / (float) total);
+			ImGui.endPopup();
+		} else {
+			stopGenThread();
 		}
 	}
 
 	private void selectSudoku(MultiDoku doku, boolean empty) {
 		this.doku = doku;
-		if (!empty) {
+		ImGui.openPopup("genProgress");
+		this.genThread = new Thread(() -> {
 			try {
-				SudokuFactory.fillDoku(doku, Difficulty.values()[difficulty.get()]);
+				if (!empty) {
+					SudokuFiller.fillDoku(doku, Difficulty.values()[difficulty.get()]);
+					// SudokuFactory.fillDoku(doku, Difficulty.values()[difficulty.get()]);
+				}
+				this.onSelect.emit(this.doku);
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
-		}
+		});
-		this.onSelect.emit(this.doku);
+		this.genThread.start();
 	}
 
 	public void renderFileDialog() {
@@ -98,7 +129,8 @@ public class SudokuSelector {
 		SudokuType currentType = SudokuType.values()[sudokuType.get()];
 		switch (currentType.getMakerParamCount()) {
 			case 1:
-				ImGui.inputInt("Taille", sudokuSize);
+				if (ImGui.inputInt("Taille", sudokuSize))
+					sudokuSize.set(Math.clamp(sudokuSize.get(), 1, 10));
 				if (ImGui.button(confirmMessage)) {
 					selectSudoku(currentType.createDoku(getConstraints(), sudokuSize.get()), false);
 				}
@@ -108,8 +140,10 @@ public class SudokuSelector {
 				break;
 
 			case 2:
-				ImGui.inputInt("Largeur", sudokuHeight);
+				if (ImGui.inputInt("Longueur", sudokuWidth))
-				ImGui.inputInt("Longueur", sudokuWidth);
+					sudokuWidth.set(Math.clamp(sudokuWidth.get(), 1, 10));
+				if (ImGui.inputInt("Hauteur", sudokuHeight))
+					sudokuHeight.set(Math.clamp(sudokuHeight.get(), 1, 10));
 				if (ImGui.button(confirmMessage)) {
 					selectSudoku(currentType.createDoku(getConstraints(), sudokuWidth.get(), sudokuHeight.get()),
 							false);
@@ -127,7 +161,12 @@ public class SudokuSelector {
 		if (ImGui.button("À partir d'un fichier")) {
 			ImGuiFileDialog.openDialog("browse-sudoku", "Choisissez un fichier", ".json", ".");
 		}
+		renderGenProgress();
 		renderFileDialog();
 	}
 
+	public void clean() {
+		stopGenThread();
+	}
+
 }

app/src/main/java/network/client/Client.java

@@ -28,12 +28,10 @@ public class Client {
 
 	String disconnectReason = null;
 
-	public Client(String address, short port) throws UnknownHostException, IOException {
+	public Client(String pseudo, String address, short port) throws UnknownHostException, IOException {
 		this.clientConnection = new ClientConnexion(address, port, this);
 		this.game = new Game();
-		// temp
+		login(pseudo);
-		Random r = new Random();
-		login("Player" + r.nextInt());
 	}
 
 	public void login(String pseudo) {

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

@@ -3,15 +3,48 @@
  */
 package sudoku;
 
+import gui.RenderableMultidoku;
+import gui.constants.Symbols;
 import sudoku.io.ConsoleInterface;
+import sudoku.io.SudokuPrinter;
+import sudoku.io.SudokuSerializer;
+import sudoku.solver.RandomSolver;
+import sudoku.structure.MultiDoku;
+import sudoku.structure.SudokuFactory;
 
 public class Main {
     public String getGreeting() {
         return "Hello World!";
     }
 
+    public static void voidTest(){
+        MultiDoku md = SudokuFactory.createBasicXShapedMultidoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
+        SudokuPrinter.printMultiDoku(RenderableMultidoku.fromMultidoku(md), Symbols.Numbers, 3, 3);
+        SudokuSerializer.saveMultiDoku(md);
+    }
+
+    public static void filledTest(){
+        MultiDoku md = SudokuFactory.createBasicXShapedMultidoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
+        new RandomSolver().solve(md);
+        SudokuPrinter.printMultiDoku(RenderableMultidoku.fromMultidoku(md), Symbols.Numbers, 3, 3);
+        SudokuSerializer.saveMultiDoku(md);
+    }
+
+    public static void overwriteTest(int n){
+        MultiDoku md = SudokuFactory.createBasicXShapedMultidoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
+        new RandomSolver().solve(md);
+        SudokuPrinter.printMultiDoku(RenderableMultidoku.fromMultidoku(md), Symbols.Numbers, 3, 3);
+        SudokuSerializer.saveMultiDoku(md, n);
+    }
+
     public static void main(String[] args) {
         ConsoleInterface console = new ConsoleInterface();
-        console.start();
+        /*
+        voidTest();
+        filledTest();
+        overwriteTest(0);
+        overwriteTest(17)
+        */
+        console.welcome();
     }
 }

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,68 +1,118 @@
 package sudoku.io;
 
+import gui.RenderableMultidoku;
+import gui.constants.Symbols;
+import sudoku.constraint.*;
+import sudoku.solver.*;
+import sudoku.structure.*;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Scanner;
 
-import sudoku.constraint.Constraint;
-import sudoku.solver.RandomSolver;
-import sudoku.structure.Difficulty;
-import sudoku.structure.MultiDoku;
-import sudoku.structure.Sudoku;
-import sudoku.structure.SudokuFactory;
-
 public class ConsoleInterface {
     public Scanner reader = new Scanner(System.in);
 
-    public void start(){
+    public void welcome() {
-        welcome();
+        System.out.println("Welcome to our Sudoku Solver!");
+        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();
+        } else {
+            createDoku();
+        }
+    }
+
+    private void useSavedDoku() {
+        System.out.println("What save should we use? Please enter the save number.");
+        MultiDoku md = saveChoice();
+        int blockWidth = md.getSubGrid(0).getBlockWidth();
+        int blockHeight = md.getSubGrid(0).getBlocks().getFirst().getCells().size() / blockWidth;
+        List<String> listSymbols = pickSymbols(blockWidth * blockHeight);
+        System.out.println("This is the saved sudoku:");
+        showMultidoku(md, listSymbols, blockWidth, blockHeight);
+        do {
+            turn(md, listSymbols, blockWidth, blockHeight);
+        } while (!md.isSolved());
+        congrats();
+    }
+
+    public void createDoku() {
         System.out.println("First of all, you need to tell me the size of the sudoku you want to generate.");
         int width = getBlockWidth();
         int height = getBlockHeight();
         System.out.println("Your sudoku will have blocks of a " + width + " x " + height + " format.");
         int numberOfSymbols = width * height;
-        System.out.println("Would you like to pick the " + numberOfSymbols + " symbols from the sudoku? (y/n, default 'no' will use numbers)" );
+        List<String> listSymbols = pickSymbols(numberOfSymbols);
-        List<String> listSymbols = new ArrayList<>();
+        List<IConstraint> listConstraints = getListConstraints();
-        if(reader.next().equalsIgnoreCase("y")){
+        System.out.println("Now that we have the size of our sudoku, " +
-            pickSymbols(listSymbols, numberOfSymbols);
+                "would you rather have a single grid ('one', default), " +
-        }
-        else {
-            // TODO
-            System.out.println("Simon doit finir sa partie.");
-            assert false;
-        }
-        List<Constraint> 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') ?");
-        List<Sudoku> subGrids = new ArrayList<>();
         MultiDoku doku;
         if (reader.next().equalsIgnoreCase("multi")) {
+            doku = SudokuFactory.createBasicXShapedMultidoku(width, height, listConstraints);
+        } else {
             doku = SudokuFactory.createBasicEmptyRectangleDoku(width, height, listConstraints);
         }
-        else {
-            doku = SudokuFactory.createBasicXShapedMultidoku(width, height, listConstraints);
-        }
         System.out.println("Your sudoku will look like this:");
-        // TODO printMultiDoku method not yet implemented
+        showMultidoku(doku, listSymbols, width, height);
-        SudokuPrinter.printMultiDoku(doku, width, height);
+        System.out.println(
-        System.out.println("We now will fill this sudoku.");
+                "You can now manually fill this sudoku ('fill'), or generate a playable one ('generate', default):");
-        System.out.println("What level of difficulty would you like? ('very easy', 'easy', 'medium' (default), 'hard', 'full' (sudoku fully completed))");
+        if (reader.next().equalsIgnoreCase("fill")) {
+            findSolution(doku, listSymbols, width, height);
+        } else {
+            playableDoku(doku, listSymbols, width, height);
+        }
+    }
+
+    private void playableDoku(MultiDoku doku, List<String> listSymbols, int width, int height) {
+        System.out.println("We will now fill this sudoku.");
+        System.out.println("What level of difficulty would you like?" +
+                " ('very easy', 'easy', 'medium' (default), 'hard', 'full' (sudoku fully completed))");
         String difficulty = reader.next().toLowerCase();
         if (difficulty.equals("full")) {
             generateFullDoku(doku);
-        }
+            System.out.println("Here's your sudoku !");
-        else {
+            exit();
+        } else {
             generatePartialDoku(doku, difficulty);
+            System.out.println("Here's your sudoku !");
+            showMultidoku(doku, listSymbols, width, height);
+            do {
+                turn(doku, listSymbols, width, height);
+            } while (!doku.isSolved());
+            congrats();
         }
-        System.out.println("Here's your sudoku !");
-        SudokuPrinter.printMultiDoku(doku, width, height);
     }
 
-    public void welcome(){
+    private void findSolution(MultiDoku doku, List<String> listSymbols, int width, int height){
-        System.out.println("Welcome to our Sudoku Solver!");
+        do {
-        System.out.println("This is the project of Melvyn Bauvent, Lilas Grenier and Simon Priblyski.");
+            turn(doku, listSymbols, width, height);
+        } while (!doku.isSolved());
+        System.out.println("This doku can be solved like this :");
+        showMultidoku(doku, listSymbols, width, height);
+        exit();
+
+    }
+
+    private void congrats() {
+        System.out.println("Congrats! You've solved this sudoku! We hope this was fun! Let's play together again!");
+        System.exit(0);
+    }
+
+    private MultiDoku saveChoice() {
+        int nbSave;
+        MultiDoku md = null;
+        do {
+            nbSave = reader.nextInt();
+            try {
+                md = SudokuSerializer.getSavedMultiDoku(nbSave);
+            } catch (Exception e) {
+                System.out.println("There seems to be a problem with this save, please try again.");
+            }
+        } while (md == null);
+        return md;
     }
 
     public int getBlockWidth() {
@@ -93,36 +143,55 @@ public class ConsoleInterface {
         return (size > 0);
     }
 
-    private void pickSymbols(List<String> listSymbols, int numberOfSymbols) {
+    private List<String> pickSymbols(int numberOfSymbols) {
-        System.out.println("You have chosen to pick your own symbols.");
+        System.out.println("Would you like to pick the " + numberOfSymbols
-        for (int i = 0; i < numberOfSymbols; i++) {
+                + " symbols from the sudoku? (y/n, default 'no')");
-            System.out.println("Choose for the symbol number " + i + ": ");
+        if (reader.next().equalsIgnoreCase("y")) {
-            String newSymbol = reader.next();
+            List<String> listSymbols = new ArrayList<>();
-            while (listSymbols.contains(newSymbol)) {
+            System.out.println("You have chosen to pick your own symbols.");
-                System.out.println("This symbol has already been given. Try again:");
+            for (int i = 0; i < numberOfSymbols; i++) {
-                newSymbol = reader.next();
+                System.out.println("Choose for the symbol number " + i + ": ");
+                String newSymbol = reader.next();
+                while (listSymbols.contains(newSymbol)) {
+                    System.out.println("This symbol has already been given. Try again:");
+                    newSymbol = reader.next();
+                }
+                listSymbols.add(newSymbol);
             }
-            listSymbols.add(newSymbol);
+            System.out.println("You chose the symbols: " + listSymbols.toString());
+            return listSymbols;
+        } else {
+            System.out.println(
+                    "What existing sets of symbols do you want to use? Numbers ('n', default), letters ('l'), or emojis ('e', may not work on all consoles)?");
+            return switch (reader.next().toLowerCase()) {
+                case "l" -> Symbols.Letters.getSymbols();
+                case "e" -> Symbols.Emojis.getSymbols();
+                default -> Symbols.Numbers.getSymbols();
+            };
         }
-        System.out.println("You chose the symbols: " + listSymbols.toString());
     }
 
-    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')");
+        System.out.println(
-        if(reader.next().equalsIgnoreCase("y")){
+                "The sudoku have constraints of blocks, lines and columns. Would you like to add the diagonal constraints ? (y/n, default 'no')");
-            listConstraints.add(Constraint.Diagonal);
+        if (reader.next().equalsIgnoreCase("y")) {
+            listConstraints.add(Constraint.Diagonal.getConstraint());
         }
         return listConstraints;
     }
 
     private void generatePartialDoku(MultiDoku doku, String difficultyName) {
         Difficulty difficulty;
-        switch (difficultyName){
+        switch (difficultyName) {
-            case "very easy": difficulty = Difficulty.VeryEasy;
+            case "very easy":
-            case "easy": difficulty = Difficulty.Easy;
+                difficulty = Difficulty.VeryEasy;
-            case "hard": difficulty = Difficulty.Hard;
+            case "easy":
-            default: difficulty = Difficulty.Medium;
+                difficulty = Difficulty.Easy;
+            case "hard":
+                difficulty = Difficulty.Hard;
+            default:
+                difficulty = Difficulty.Medium;
         }
         try {
             SudokuFactory.fillDoku(doku, difficulty);
@@ -135,4 +204,133 @@ public class ConsoleInterface {
         new RandomSolver().solve(doku);
     }
 
+    private void showMultidoku(MultiDoku doku, List<String> listSymbols, int width, int height) {
+        showMultiDoku(RenderableMultidoku.fromMultidoku(doku), listSymbols, width, height);
+    }
+
+    private void showMultiDoku(RenderableMultidoku doku, List<String> listSymbols, int width, int height) {
+        SudokuPrinter.printMultiDokuWithIndex(doku, listSymbols, width, height);
+    }
+
+    private void saveMultiDoku(MultiDoku doku) {
+        System.out.println("Number of the file to overwrite ('-1' or unused save file number to create a new save) :");
+        int n = reader.nextInt();
+        String path = SudokuSerializer.saveMultiDoku(doku, n);
+        System.out.println("The path to your save is:" + path);
+    }
+
+    private void turn(MultiDoku doku, List<String> listSymbols, int width, int height) {
+        System.out.println(
+                "You can now put a number in a cell ('play', default), save the state of the doku ('save'), show a solution ('solution') or exit the program ('exit').");
+        switch (reader.next()) {
+            case "save":
+                saveMultiDoku(doku);
+                break;
+            case "solution":
+                solve(doku, listSymbols, width, height);
+                break;
+            case "exit":
+                exit();
+                break;
+            default:
+                play(doku, listSymbols, width, height);
+                break;
+        }
+    }
+
+    private void applyStep(SolverStep step) {
+        step.getCell().setSymbolIndex(step.getNewValue());
+    }
+
+    private boolean showStep(MultiDoku doku, List<String> listSymbols, int width, int height, SolverStep step) {
+        System.out.println("Here is the step : \n");
+        showMultidoku(doku, listSymbols, width, height);
+        applyStep(step);
+        System.out.println("\nTurns into :\n");
+        showMultidoku(doku, listSymbols, width, height);
+        System.out.println("Do you want to see the next step ? (y/n, default n)");
+        return reader.next().equals("y");
+    }
+
+    private void showSolveSteps(MultiDoku doku, List<String> listSymbols, int width, int height, List<SolverStep> steps) {
+        System.out.println("Would you like to see the steps of the solver ? (y/n, default n)");
+        doku.getStateManager().popState();
+        switch (reader.next()) {
+            case "y":
+                int stepCount = 0;
+                while(stepCount < steps.size() && showStep(doku, listSymbols, width, height, steps.get(stepCount))){stepCount++;}
+                break;
+        
+            default:
+                break;
+        }
+    }
+
+    private void solve(MultiDoku doku, List<String> listSymbols, int width, int height){
+        System.out.println("Pick a solver to use : random ('random', default), human ('human') or mixed solver ('mixed').");
+        List<SolverStep> steps = new ArrayList<>();
+        doku.getStateManager().pushState();
+        switch (reader.next()) {
+            case "human":
+                new HumanSolver().solve(doku, steps);
+                break;
+            case "mixed":
+                new MixedSolver().solve(doku, steps);
+                break;
+            default:
+                new RandomSolver().solve(doku, steps);
+                break;
+        }
+        showSolveSteps(doku, listSymbols, width, height, steps);
+    }
+
+    private void play(MultiDoku doku, List<String> listSymbols, int width, int height) {
+        int x, y;
+        RenderableMultidoku rdoku = RenderableMultidoku.fromMultidoku(doku);
+        do {
+            System.out.println("Line of the cell to fill:");
+            y = reader.nextInt();
+            System.out.println("Column of the cell to fill:");
+            x = reader.nextInt();
+        } while (!isValidCoordinates(rdoku, width, height, x-1, y-1));
+        Cell cell = rdoku.getCell(x-1, y-1);
+        System.out.println("Character to put in the (" + x + ", " + y + ") cell:");
+        String character = reader.next();
+        while (!isValidSymbol(character, listSymbols, width * height)) {
+            System.out.println("This is not a valid symbol; try again:");
+            character = reader.next();
+        }
+        cell.setSymbolIndex(indexOfSymbol(character, listSymbols, width * height));
+        showMultiDoku(rdoku, listSymbols, width, height);
+    }
+
+    private boolean isValidCoordinates(RenderableMultidoku doku, int width, int height, int x, int y) {
+        if (doku.getCell(x, y) != null) {
+            return true;
+        }
+        return false;
+    }
+
+    private int indexOfSymbol(String symbol, List<String> listSymbols, int nbSymbols) {
+        for (int i = 0; i < nbSymbols; i++) {
+            if (listSymbols.get(i).equals(symbol)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private boolean isValidSymbol(String symbol, List<String> listSymbols, int size) {
+        for (int i = 0; i < size; i++) {
+            if (listSymbols.get(i).equals(symbol)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void exit() {
+        System.out.println("Thank you for playing!");
+        System.exit(0);
+    }
 }

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

@@ -1,18 +1,39 @@
 package sudoku.io;
 
+import gui.RenderableMultidoku;
+import gui.constants.Symbols;
+import sudoku.structure.Cell;
 import sudoku.structure.MultiDoku;
 import sudoku.structure.Sudoku;
 
-public class SudokuPrinter {
+import java.util.List;
 
-	public static void printRectangleSudoku(final Sudoku s, int blockWidth, int blockHeight) {
+public class SudokuPrinter {
+	public static final String ANSI_RESET = "\u001B[0m";
+	public static final String ANSI_RED = "\u001B[31m";
+	public static final String ANSI_GREEN = "\u001B[32m";
+	public static final String ANSI_YELLOW = "\u001B[33m";
+	public static final String ANSI_BLUE = "\u001B[34m";
+	public static final String ANSI_PURPLE = "\u001B[35m";
+	public static final String ANSI_CYAN = "\u001B[36m";
+
+	public static void printRectangleSudoku(final Sudoku s, int blockWidth, int blockHeight, Symbols symbols) {
+		printRectangleSudoku(s, blockWidth, blockHeight, symbols.getSymbols());
+	}
+
+	public static void printRectangleSudoku(final Sudoku s, int blockWidth, int blockHeight, List<String> listSymbols) {
 		for (int y = 0; y < s.getSize(); y++) {
 			if (y % blockHeight == 0 && y > 0) {
 				System.out.println();
 			}
 			StringBuilder line = new StringBuilder("[ ");
 			for (int x = 0; x < s.getSize(); x++) {
-				line.append((s.getCell(x, y).getSymbolIndex() + 1)).append(" ");
+				Cell c = s.getCell(x, y);
+				if (c.getSymbolIndex() == Cell.NOSYMBOL) {
+					line.append("  ");
+				} else {
+					line.append(listSymbols.get(c.getSymbolIndex())).append(" ");
+				}
 				if (x % blockWidth == blockWidth - 1 && x != blockWidth * blockHeight - 1) {
 					line.append("| ");
 				}
@@ -22,7 +43,118 @@ public class SudokuPrinter {
 		}
 	}
 
-	public static String toStringRectangleSudoku(final Sudoku s, int blockWidth, int blockHeight) {
+	public static void printRectangleSudokuWithIndex(final Sudoku s, int blockWidth, int blockHeight,
+			List<String> listSymbols) {
+		StringBuilder header = new StringBuilder("");
+		header.append("    ");
+		for (int x = 0; x < blockWidth*blockHeight; x++) {
+			header.append(x + 1).append(" ");
+			if (x % blockWidth == blockWidth - 1 && x != blockWidth * blockHeight - 1) {
+				header.append("  ");
+			}
+		}
+		header.append("\n");
+		System.out.println(header);
+		for (int y = 0; y < s.getSize(); y++) {
+			if (y % blockHeight == 0 && y > 0) {
+				System.out.println();
+			}
+			StringBuilder line = new StringBuilder(y + 1);
+			line.append(" [ ");
+			for (int x = 0; x < s.getSize(); x++) {
+				Cell c = s.getCell(x, y);
+				if (c.getSymbolIndex() == Cell.NOSYMBOL) {
+					line.append("  ");
+				} else {
+					line.append(listSymbols.get(c.getSymbolIndex())).append(" ");
+				}
+				if (x % blockWidth == blockWidth - 1 && x != blockWidth * blockHeight - 1) {
+					line.append("| ");
+				}
+			}
+			line.append("]");
+			System.out.println(line);
+		}
+	}
+
+	public static void printMultiDoku(final RenderableMultidoku rm, Symbols symbols, int blockWidth, int blockHeight) {
+		printMultiDoku(rm, symbols.getSymbols(), blockWidth, blockHeight);
+	}
+
+	public static void printMultiDoku(final RenderableMultidoku rm, List<String> listSymbols, int blockWidth,
+			int blockHeight) {
+		StringBuilder line = new StringBuilder("\n");
+		int nBlockInWidth = rm.getWidth() / blockWidth;
+		for (int y = 0; y < rm.getHeight(); y++) {
+			if (y % blockHeight == 0) {
+				line.append("__".repeat(Math.max(0, rm.getWidth() + nBlockInWidth))).append("_\n");
+			}
+			line.append("[ ");
+			for (int x = 0; x < rm.getWidth(); x++) {
+				if (x % blockWidth == 0 && x > 0) {
+					line.append("| ");
+				}
+				Cell cell = rm.getCell(x, y);
+				if (cell != null) {
+					if (cell.getSymbolIndex() == Cell.NOSYMBOL) {
+						line.append("- ");
+					} else {
+						line.append(listSymbols.get(cell.getSymbolIndex())).append(" ");
+					}
+				} else {
+					line.append("  ");
+				}
+			}
+			line.append("]\n");
+		}
+		line.append("__".repeat(Math.max(0, rm.getWidth() + nBlockInWidth))).append("_\n");
+		System.out.println(line);
+	}
+
+	public static void printMultiDokuWithIndex(final RenderableMultidoku rm, List<String> listSymbols, int blockWidth,
+			int blockHeight) {
+		StringBuilder line = new StringBuilder("\n");
+		line.append("    ");
+		for (int x = 0; x < rm.getWidth(); x++) {
+			line.append(x + 1).append(" ");
+			if (x % blockWidth == blockWidth - 1 && x != blockWidth * blockHeight - 1) {
+				line.append("  ");
+			}
+		}
+		line.append("\n");
+		int nBlockInWidth = rm.getWidth() / blockWidth;
+		for (int y = 0; y < rm.getHeight(); y++) {
+			if (y % blockHeight == 0) {
+				line.append("  ").append("__".repeat(Math.max(0, rm.getWidth() + nBlockInWidth))).append("_\n");
+			}
+			line.append(y+1).append(" [ ");
+			for (int x = 0; x < rm.getWidth(); x++) {
+				if (x % blockWidth == 0 && x > 0) {
+					line.append("| ");
+				}
+				Cell cell = rm.getCell(x, y);
+				if (cell != null) {
+					if (cell.getSymbolIndex() == Cell.NOSYMBOL) {
+						line.append("- ");
+					} else {
+						line.append(listSymbols.get(cell.getSymbolIndex())).append(" ");
+					}
+				} else {
+					line.append("  ");
+				}
+			}
+			line.append("]\n");
+		}
+		line.append("  ").append("__".repeat(Math.max(0, rm.getWidth() + nBlockInWidth))).append("_\n");
+		System.out.println(line);
+	}
+
+	public static String toStringRectangleSudoku(final Sudoku s, int blockWidth, int blockHeight, Symbols symbols) {
+		return toStringRectangleSudoku(s, blockWidth, blockHeight, symbols.getSymbols());
+	}
+
+	public static String toStringRectangleSudoku(final Sudoku s, int blockWidth, int blockHeight,
+			List<String> listSymbols) {
 		StringBuilder result = new StringBuilder();
 		for (int y = 0; y < s.getSize(); y++) {
 			// Ajouter une ligne vide entre les blocs horizontaux
@@ -32,7 +164,12 @@ public class SudokuPrinter {
 			StringBuilder line = new StringBuilder("[ ");
 			for (int x = 0; x < s.getSize(); x++) {
 				// Ajouter la valeur de la cellule
-				line.append((s.getCell(x, y).getSymbolIndex() + 1)).append(" ");
+				Cell cell = s.getCell(x, y);
+				if (cell.getSymbolIndex() == Cell.NOSYMBOL) {
+					line.append("  ");
+				} else {
+					line.append(listSymbols.get(cell.getSymbolIndex())).append(" ");
+				}
 
 				// Ajouter un séparateur vertical entre les blocs
 				if (x % blockWidth == blockWidth - 1 && x != s.getSize() - 1) {
@@ -45,7 +182,21 @@ public class SudokuPrinter {
 		return result.toString();
 	}
 
-	public static void printMultiDoku(final MultiDoku doku, int blockWidth, int blockHeight){
+	public static void printMultiDoku(final MultiDoku doku, int blockWidth, int blockHeight, Symbols symbols) {
-		// TODO
+		if (doku.getNbSubGrids() == 1) {
+			printRectangleSudoku(doku.getSubGrid(0), blockWidth, blockHeight, symbols);
+		} else {
+			printMultiDoku(RenderableMultidoku.fromMultidoku(doku), symbols, blockWidth, blockHeight);
+		}
 	}
+
+	public static void printMultiDokuWithIndex(final MultiDoku doku, int blockWidth, int blockHeight, Symbols symbols) {
+		if (doku.getNbSubGrids() == 1) {
+			printRectangleSudokuWithIndex(doku.getSubGrid(0), blockWidth, blockHeight, symbols.getSymbols());
+		} else {
+			printMultiDokuWithIndex(RenderableMultidoku.fromMultidoku(doku), symbols.getSymbols(), blockWidth,
+					blockHeight);
+		}
+	}
+
 }

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;
@@ -44,7 +45,7 @@ public class SudokuSerializer {
 				}
 
 				int blockID = blockIds.indexOf(block);
-				assert(blockID >= 0);
+				assert (blockID >= 0);
 				int symbolIndex = cell.getSymbolIndex();
 
 				JSONObject cellJsonObject = new JSONObject();
@@ -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);
@@ -124,17 +134,14 @@ public class SudokuSerializer {
 	 * @return String, the path of the save.
 	 */
 	public static String saveMultiDoku(final MultiDoku doku) {
-
 		JSONObject jsonRoot = serializeSudoku(doku);
 
 		File f = new File("save", "save.json");
 		int i = 0;
-
 		while (f.exists()) {
 			String newName = "save-" + ++i + ".json";
 			f = new File("save", newName);
 		}
-
 		try (FileWriter file = new FileWriter(f)) {
 			file.write(jsonRoot.toString(3));
 		} catch (IOException e) {
@@ -143,6 +150,25 @@ public class SudokuSerializer {
 		return f.getAbsolutePath();
 	}
 
+	public static String saveMultiDoku(final MultiDoku doku, final int saveToOverwrite) {
+		File f;
+		if (saveToOverwrite == 0) {
+			f = new File("save", "save.json");
+		} else {
+			f = new File("save", "save-" + saveToOverwrite + ".json");
+		}
+		if (!f.exists()) {
+			return saveMultiDoku(doku);
+		} else {
+			try (FileWriter file = new FileWriter(f)) {
+				file.write(serializeSudoku(doku).toString(3));
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return f.getAbsolutePath();
+		}
+	}
+
 	/**
 	 * Get a MultiDoku from a pre-existing json save file.
 	 * 
@@ -217,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);
@@ -231,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/HintHelper.java

@@ -0,0 +1,53 @@
+package sudoku.solver;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import sudoku.structure.Cell;
+import sudoku.structure.MultiDoku;
+
+//TODO
+public class HintHelper {
+
+	public static record Hint(Cell cell, int newValue) {}
+
+	public static Hint getHint(MultiDoku doku, Solver solver) {
+		doku.getStateManager().pushState();
+		doku.clearMutableCells();
+		if (!solver.solve(doku))
+			return null;
+		var stateSolved = doku.getStateManager().popAndGetState();
+		// find differences
+		Map<Cell, Integer> newValues = new HashMap<>();
+		for (var entry : stateSolved.entrySet()) {
+			Cell cell = entry.getKey();
+			// we only want the cells that can be filled
+			if (!cell.isMutable())
+				continue;
+			int oldValue = cell.getSymbolIndex();
+			int newValue = stateSolved.get(cell);
+			if (oldValue == newValue)
+				continue;
+			// we have to clear the cell
+			if (newValue == Cell.NOSYMBOL)
+				return new Hint(cell, newValue);
+			// we have to change the cell value
+			if (oldValue != Cell.NOSYMBOL)
+				return new Hint(cell, newValue);
+
+			// there is a valid move
+			newValues.put(cell, newValue);
+		}
+
+		// this is too complex just for fetching a random entry, but whatever ...
+		Random r = new Random();
+		List<Cell> cells = new ArrayList<>(newValues.keySet());
+		Cell randomCell = cells.get(r.nextInt(cells.size()));
+		int randomCellValue = newValues.get(randomCell);
+		return new Hint(randomCell, randomCellValue);
+	}
+
+}

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

@@ -1,13 +1,9 @@
 package sudoku.solver;
 
 import java.util.List;
-import java.util.concurrent.CancellationException;
-import java.util.logging.Level;
 
-import sudoku.io.SudokuPrinter;
 import sudoku.structure.Cell;
 import sudoku.structure.MultiDoku;
-import sudoku.structure.Sudoku;
 
 public class HumanSolver implements Solver {
 
@@ -18,38 +14,26 @@ 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())
+		while (!doku.isSolved()) {
-			throw new CancellationException("User wants to stop the solver");
+			boolean filledCell = false;
-
+			for (Cell cell : doku.getCells()) {
-		Sudoku sudoku = doku.getSubGrid(0);
+				if (!cell.isMutable() || !cell.isEmpty())
-		logger.log(Level.FINE,
+					continue;
-				'\n' + SudokuPrinter.toStringRectangleSudoku(sudoku,
+				
-						sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getBlockWidth(),
+				List<Integer> possibleSymbols = cell.getPossibleSymbols();
-						sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getSize() / sudoku.getBlockWidth()));
+				if (possibleSymbols.size() == 1) {
-
+					cell.setSymbolIndex(possibleSymbols.getFirst());
-		if (doku.isSolved()) {
+					addStep(cell, steps);
-			return true;
+					filledCell = true;
-		}
+				}
-
-		List<Cell> cellsToFill = doku.getEmptyCells();
-		if (cellsToFill.isEmpty()) {
-			return false;
-		}
-
-		for (Cell cellToFill : cellsToFill) {
-
-			List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
-			if (possibleSymbols.size() != 1) {
-				continue;
 			}
-
+			// on ne peut plus remplir de cases, on abandonne
-			cellToFill.setSymbolIndex(possibleSymbols.getFirst());
+			if (!filledCell)
-
+				return false;
-			return this.solve(doku);
 		}
 
-		return doku.isSolved();
+		return true;
 	}
 
 }

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

@@ -1,71 +1,99 @@
 package sudoku.solver;
 
+import java.util.ArrayList;
 import java.util.List;
-import java.util.Random;
 import java.util.concurrent.CancellationException;
-import java.util.logging.Level;
 
-import sudoku.io.SudokuPrinter;
 import sudoku.structure.Cell;
 import sudoku.structure.MultiDoku;
-import sudoku.structure.Sudoku;
 
-public class MixedSolver implements Solver{
+public class MixedSolver implements Solver {
 
-	/**
+    private List<Cell> findCellToBacktrack(MultiDoku doku, int maxPossibilities) {
+        int symbolCount = doku.getSubGrid(0).getSize();
+        if (maxPossibilities > symbolCount)
+            return null;
+
+        List<Cell> backtrackCells = new ArrayList<>();
+
+        for (Cell cell : doku.getCells()) {
+            if (!cell.isMutable() || !cell.isEmpty())
+                continue;
+
+            List<Integer> possibleSymbols = cell.getPossibleSymbols();
+            if (possibleSymbols.size() == maxPossibilities) {
+                backtrackCells.add(cell);
+            }
+
+            // grille non résolvable
+            if (possibleSymbols.size() == 0)
+                return null;
+        }
+        return backtrackCells;
+    }
+
+    /**
      * Résout le MultiDoku passé en paramètre, avec règles de déduction et
      * backtracking.
      *
      * @param doku MultiDoku, MultiDoku à résoudre.
      * @return boolean, valant true si le MultiDoku est résolu, false sinon.
      */
-	@Override
+    @Override
-    public boolean solve(MultiDoku doku) {
+    public boolean solve(MultiDoku doku, List<SolverStep> steps) {
-        Random rand = new Random();
-
         if (Thread.interrupted()) {
             throw new CancellationException("User wants to stop the solver");
         }
 
-        Sudoku sudoku = doku.getSubGrid(0);
+        if (doku.isSolved())
-        logger.log(Level.FINE,
-                '\n' + SudokuPrinter.toStringRectangleSudoku(
-                        sudoku,
-                        sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getBlockWidth(),
-                        sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getSize() / sudoku.getBlockWidth()));
-
-        if (doku.isSolved()) {
             return true;
-        }
 
-        Cell cellToFill = doku.getFirstEmptyCell();
+        int symbolCount = doku.getSubGrid(0).getSize();
-        if (cellToFill == null) {
-            return false;
-        }
 
-        List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
+        // on remplit les cases par déduction
+        for (Cell cell : doku.getCells()) {
+            if (!cell.isMutable() || !cell.isEmpty())
+                continue;
 
-        if (possibleSymbols.size() == 1) {
+            List<Integer> possibleSymbols = cell.getPossibleSymbols();
-            cellToFill.setSymbolIndex(possibleSymbols.getFirst());
+            if (possibleSymbols.size() == 1) {
-            if (this.solve(doku)) {
+                cell.setSymbolIndex(possibleSymbols.getFirst());
-                return true;
+                addStep(cell, steps);
+                if (solve(doku, steps))
+                    return true;
+                cell.setSymbolIndex(Cell.NOSYMBOL);
+                return false;
             }
         }
 
-        while (!possibleSymbols.isEmpty()) {
+        // on ne peut plus remplir de cases, on tente de backtrack
-            int nextPossibleSymbolIndex = rand.nextInt(possibleSymbols.size());
+        for (int maxPossibilities = 2; maxPossibilities <= symbolCount; maxPossibilities++) {
-            int nextSymbol = possibleSymbols.get(nextPossibleSymbolIndex);
+            List<Cell> backtrackCells = new ArrayList<>();
-
+            while (backtrackCells.isEmpty()) {
-            cellToFill.setSymbolIndex(nextSymbol);
+                backtrackCells = findCellToBacktrack(doku, maxPossibilities);
-            if (this.solve(doku)) {
+                // grille non résolvable
-                return true;
+                if (backtrackCells == null) {
+                    return false;
+                }
+                maxPossibilities++;
             }
-            cellToFill.setSymbolIndex(Cell.NOSYMBOL);
+            // on fait du backtracking
-            possibleSymbols.remove(nextPossibleSymbolIndex);
+            for (Cell backtrackCell : backtrackCells) {
+                List<Integer> possibilities = backtrackCell.getPossibleSymbols();
 
+                // System.out.println("Backtraing on " + backtrackCell);
+
+                // on tente de placer chacun des symboles
+                for (int symbol : possibilities) {
+                    backtrackCell.setSymbolIndex(symbol);
+                    if (solve(doku, steps)) {
+                        return true;
+                    }
+                }
+                backtrackCell.setSymbolIndex(Cell.NOSYMBOL);
+            }
         }
-
+        return doku.isSolved();
-        return false;
     }
 
 }

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

@@ -3,37 +3,27 @@ package sudoku.solver;
 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.CancellationException;
-import java.util.logging.Level;
 
-import sudoku.io.SudokuPrinter;
 import sudoku.structure.Cell;
 import sudoku.structure.MultiDoku;
-import sudoku.structure.Sudoku;
 
 public class RandomSolver implements Solver {
 
-	/**
+    /**
      * Résout, si possible, le multidoku passé en paramètre
      * en testant toutes les possibilités, de manière aléatoire, avec un algorithme
      * de backtracking.
      *
      * @param doku Multidoku, à résoudre
-     * @param rand Random, pour tester aléatoirement les symboles
      * @return boolean, true s'il est résolu ou false s'il ne l'est pas.
      */
-	@Override
+    @Override
-    public boolean solve(MultiDoku doku) {
+    public boolean solve(MultiDoku doku, List<SolverStep> steps) {
         Random rand = new Random();
 
         if (Thread.interrupted())
             throw new CancellationException("User wants to stop the solver");
 
-        Sudoku sudoku = doku.getSubGrid(0);
-        logger.log(Level.FINE,
-                '\n' + SudokuPrinter.toStringRectangleSudoku(sudoku,
-                        sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getBlockWidth(),
-                        sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getSize() / sudoku.getBlockWidth()));
-
         if (doku.isSolved()) {
             return true;
         }
@@ -50,10 +40,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

@@ -8,14 +8,18 @@ import sudoku.structure.MultiDoku;
 
 public interface Solver {
 
-	/**
+    /**
      * Log du Solver, qui garde trace des actions réalisées.
      */
     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.
      *
      * @param doku MultiDoku, MultiDoku dont on veut le nombre de solutions.
@@ -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/solver/StupidSolver.java

@@ -1,5 +1,6 @@
 package sudoku.solver;
 
+import java.util.List;
 import java.util.concurrent.CancellationException;
 
 import sudoku.structure.MultiDoku;
@@ -8,9 +9,9 @@ import sudoku.structure.Sudoku;
 /**
  * Class de test non utilisé
  */
-public class StupidSolver {
+public class StupidSolver implements Solver{
 
-	private static boolean solve(Sudoku sudoku, int index) {
+	private boolean solve(Sudoku sudoku, int index, List<SolverStep> steps) {
 		// mécanisme d'abandon
 		if (Thread.interrupted())
 			throw new CancellationException("User wants to stop the solver");
@@ -21,27 +22,30 @@ public class StupidSolver {
 
 		// si la case n'est pas modifiable, on passe à la suivante
 		if (!sudoku.getCell(index).isMutable())
-			return solve(sudoku, index + 1);
+			return solve(sudoku, index + 1, steps);
 
 		for (int symbol = 0; symbol < sudoku.getSize(); symbol++) {
 			if (sudoku.getCell(index).trySetValue(symbol)) {
+				addStep(sudoku.getCell(index), steps);
 				// on tente de placer sur la case suivante
-				if (solve(sudoku, index + 1)) {
+				if (solve(sudoku, index + 1, steps)) {
 					return true;
 				}
 			}
 		}
 		// on a tout essayé et rien n'a fonctionné
 		sudoku.getCell(index).empty();
+		addStep(sudoku.getCell(index), steps);
 		return false;
 	}
 
-	public static boolean solve(MultiDoku doku) {
+	@Override
+	public boolean solve(MultiDoku doku, List<SolverStep> steps) {
 		if (doku.isSolved())
 			return true;
 
 		for (Sudoku sudoku : doku.getSubGrids()) {
-			if (!solve(sudoku, 0))
+			if (!solve(sudoku, 0, steps))
 				return false;
 		}
 		return true;

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

@@ -4,28 +4,41 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * Class qui représente les block de chaque sudoku,
+ * Class qui représente les Block de chaque Sudoku,
- * Un block étant un ensemble de cellule avec une contrainte de block qui lui
+ * Un Block étant un ensemble de cellule avec une contrainte de block qui lui
- * ait associé
+ * ait associé.
  */
 public class Block {
 
+	// <editor-fold defaultstate="collapsed" desc="ATTRIBUTS">
+
 	/**
-	 * L'ensemble des cellules du block
+	 * L'ensemble des cellules du block.
 	 */
 	private final List<Cell> cells;
 
 	/**
-	 * List de sudoku qui contiennent le block
+	 * Liste de Sudoku qui contiennent le block
-	 * Pour un acces plus rapide aux sudokus
+	 * Pour un accès plus rapide aux sudokus.
 	 */
 	private final List<Sudoku> sudokus;
 
+	// </editor-fold>
+
+	// <editor-fold defaultstate="collapsed" desc="METHODES">
+
+	/**
+	 * Crée un Block avec une liste de Cell donnée.
+	 * @param cells List<Cell>
+	 */
 	public Block(List<Cell> cells) {
 		this.cells = cells;
 		this.sudokus = new ArrayList<>();
 	}
 
+	/**
+	 * Crée un Block avec une liste de Cell vide.
+	 */
 	public Block() {
 		this(new ArrayList<>());
 	}
@@ -33,13 +46,16 @@ public class Block {
 	public List<Cell> getCells() {
 		return cells;
 	}
+	public List<Sudoku> getSudokus() {
+		return sudokus;
+	}
 
 	/**
 	 * Ajoute une Cell au Block
 	 * 
 	 * @param newCell Cell, à ajouter
 	 */
-	void addCell(Cell newCell) {
+	public void addCell(Cell newCell) {
 		this.cells.add(newCell);
 	}
 
@@ -57,16 +73,5 @@ public class Block {
 		return false;
 	}
 
-	public boolean containsCell(Cell cell) {
+	// </editor-fold>
-		for (Cell cellTmp : this.cells) {
-			if (cellTmp.equals(cell)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	public List<Sudoku> getSudokus() {
-		return sudokus;
-	}
 }

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

@@ -9,6 +9,8 @@ import java.util.List;
  */
 public class Cell {
 
+	// <editor-fold defaultstate="collapsed" desc="ATTRIBUTS">
+
 	/**
 	 * Constante de valeur d'index de symbole quand il n'y en a pas,
 	 * soit que la Cell est vide.
@@ -29,6 +31,10 @@ public class Cell {
 	 */
 	private boolean isMutable = true;
 
+	// </editor-fold>
+
+	// <editor-fold defaultstate="collapsed" desc="METHODES">
+
 	public Cell() {
 		this(Cell.NOSYMBOL);
 	}
@@ -46,6 +52,22 @@ public class Cell {
 		return this.symbolIndex;
 	}
 
+	/**
+	 * Renvoie le Block qui la contient.
+	 * @return Block.
+	 */
+	public Block getBlock() {
+		return this.blockContainer;
+	}
+
+	/**
+	 * Renvoie si la Cell est modifiable
+	 * @return boolean, true si elle est modifiable ou false sinon.
+	 */
+	public boolean isMutable() {
+		return this.isMutable;
+	}
+
 	public void setSymbolIndex(int symbolIndex) {
 		this.symbolIndex = symbolIndex;
 	}
@@ -57,22 +79,16 @@ public class Cell {
 		this.isMutable = false;
 	}
 
-	public Block getBlock() {
-		return this.blockContainer;
-	}
 
 	public void setBlock(Block block) {
 		this.blockContainer = block;
 	}
 
 	/**
-	 * Remove the current symbolIndex and returns it
+	 * Vide la Cell.
-	 * @return integer symbolIndex cleared
 	 */
-	public int clearCurrentSymbol() {
+	public void clearCurrentSymbol() {
-		int i = this.symbolIndex;
 		setSymbolIndex(NOSYMBOL);
-		return i;
 	}
 
 	/**
@@ -83,14 +99,6 @@ public class Cell {
 		return this.symbolIndex == Cell.NOSYMBOL;
 	}
 
-	/**
-	 * Renvoie si la Cell est modifiable
-	 * @return boolean, true si elle est modifiable ou false sinon.
-	 */
-	public boolean isMutable() {
-		return this.isMutable;
-	}
-
 	/**
 	 * Vide la Cell, en renvoie l'ancien index du symbole qui était dedans.
 	 * @return int, index du symbole anciennement contenue dans la Cell.
@@ -101,6 +109,11 @@ public class Cell {
 		return oldSymbol;
     }
 
+	/**
+	 * Vérifie si la Cell peut prendre ce symbole par rapport aux contraintes de ses Sudokus.
+	 * @param value int, index du symbole
+	 * @return boolean, true si elle peut, false sinon.
+	 */
 	public boolean canHaveValue(int value) {
 		for (Sudoku s :getBlock().getSudokus()) {
 			int cellIndex = s.getCells().indexOf(this);
@@ -116,6 +129,10 @@ public class Cell {
 		return true;
 	}
 
+	/**
+	 * Renvoie les symboles que peut prendre cette Cell par rapport aux contraintes de ses Sudokus.
+	 * @return List<Integer>, la liste des symboles possibles.
+	 */
 	public List<Integer> getPossibleSymbols() {
 		List<Integer> result = new ArrayList<>();
 		for (int i = 0; i < getBlock().getSudokus().get(0).getSize(); i++) {
@@ -125,6 +142,11 @@ public class Cell {
 		return result;
 	}
 
+	/**
+	 * Essaye de placer la valeur et renvoie false si ce n'est pas possible.
+	 * @param newValue int, valeur à placer.
+	 * @return boolean, true si la Cell à pris la valeur newValue, false sinon.
+	 */
 	public boolean trySetValue(int newValue) {
 		if (!isMutable())
 			return false;
@@ -133,4 +155,6 @@ public class Cell {
 		setSymbolIndex(newValue);
 		return true;
 	}
+
+	// </editor-fold>
 }

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

@@ -1,10 +1,12 @@
 package sudoku.structure;
 
 /**
- * Représente les coordonnées d'une Cell
+ * Représente les coordonnées d'une Cell.
  */
 public class Coordinate {
 
+    // <editor-fold defaultstate="collapsed" desc="ATTRIBUTS">
+
     /**
      * L'abscisse de la Cell.
      */
@@ -14,6 +16,10 @@ public class Coordinate {
      */
     private int y;
 
+    // </editor-fold>
+
+    // <editor-fold defaultstate="collapsed" desc="METHODES">
+
     public Coordinate(int x, int y) {
         this.x = x;
         this.y = y;
@@ -35,16 +41,23 @@ public class Coordinate {
         this.y = y;
     }
 
-    public int calculateIndex(int size) {
+    /**
-        return this.y * size + this.x;
+     * Ajoute la Coordiante donnée à celle-ci.
-    }
+     * @param other Coordiante, à ajouter.
-
+     * @return Coordinate, le résultat de l'addition.
+     */
     public Coordinate add(Coordinate other) {
         return new Coordinate(this.x + other.x, this.y + other.y);
     }
 
+    /**
+     * Soustrait la Coordiante donnée à celle-ci.
+     * @param other Coordiante, à soustraire.
+     * @return Coordinate, le résultat de la soustraction.
+     */
     public Coordinate sub(Coordinate other) {
         return new Coordinate(this.x - other.x, this.y - other.y);
     }
 
+    // </editor-fold>
 }

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

@@ -1,26 +1,32 @@
 package sudoku.structure;
 
-//TODO: melvyn va passer par là
+/**
+ * Les difficultés d'un Sudoku,
+ * représente le nombre de cases à enlever, en proportion, à un Sudoku.
+ * Par exemple, avec 0.1 de factor, on enlevera 10% des cases.
+ */
 public enum Difficulty {
 
-	VeryEasy("Très facile", 0.1), Easy("Facile", 0.25), Medium("Moyen", 0.5), Hard("Difficile", 0.75), VeryHard("Impossible", 0.78);
+	VeryEasy("Très facile", 0.1),
+	Easy("Facile", 0.25),
+	Medium("Moyen", 0.5),
+	Hard("Difficile", 0.75),
+	VeryHard("Impossible", 0.78);
 
+	/**
+	 * Le pourcentage de Cell à enlever.
+	 */
 	final double factor;
+	/**
+	 * Le nom de la difficulté.
+	 */
 	final String displayName;
 
-	private Difficulty(String displayName, double factor) {
+	Difficulty(String displayName, double factor) {
 		this.factor = factor;
 		this.displayName = displayName;
 	}
 
-	public String getDisplayName() {
-		return displayName;
-	}
-
-	public double getFactor() {
-		return factor;
-	}
-
 	private static final String[] difficultyNames;
 
 	static {
@@ -31,6 +37,14 @@ public enum Difficulty {
 		}
 	}
 
+	public String getDisplayName() {
+		return displayName;
+	}
+
+	public double getFactor() {
+		return factor;
+	}
+
 	public static String[] getDifficultyNames() {
 		return difficultyNames;
 	}

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

@@ -1,89 +1,45 @@
 package sudoku.structure;
 
+import sudoku.io.SudokuSerializer;
+
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Random;
 import java.util.Set;
 
-import sudoku.io.SudokuSerializer;
-
 /**
  * @class MultiDoku
  * @brief Représente une grille de Multidoku.
- *        Une grille de sudoku est un multidoku avec un seul sous-sudoku
+ *        Une grille de sudoku est un multidoku avec un seul sous-sudoku.
  */
 public class MultiDoku {
 
+	// <editor-fold defaultstate="collapsed" desc="ATTRIBUTS">
+
 	/**
 	 * Liste des sous-Sudoku contenue dans le multidoku.
 	 */
 	private final List<Sudoku> subGrids;
 
+	/**
+	 * Pile, qui contient des états du MultiDoku,
+	 * utile pour la résolution.
+	 */
 	private final StateManager stateManager;
 
+	// </editor-fold>
+
+	// <editor-fold defaultstate="collapsed" desc="METHODES">
+
 	public MultiDoku(List<Sudoku> subGrids) {
 		this.subGrids = subGrids;
 		this.stateManager = new StateManager(this);
 	}
 
 	/**
-	 * Renvoie le nombre de sudoku contenu dans ce MultiDoku.
+	 * Check si le MultiDoku est résolu, c'est à dire complet et cohérent avec ses contraintes. 
 	 * 
-	 * @return int
+	 * @return boolean, true s'il est résolu et false sinon.
-	 */
-	public int getNbSubGrids() {
-		return subGrids.size();
-	}
-
-	/**
-	 * Renvoie la ie sudoku contenue dans ce MultiDoku.
-	 * 
-	 * @param i int, indice du sudoku à renvoyer.
-	 * @return Sudoku, ie Sudoku
-	 */
-	public Sudoku getSubGrid(int i) {
-		return subGrids.get(i);
-	}
-
-	/**
-	 * Renvoie la liste des Cells contenue dans ce MultiDoku,
-	 * soit les Cells contenues de chaques sous-Sudoku.
-	 * 
-	 * @return List<Cell>
-	 */
-	public List<Cell> getCells() {
-		Set<Cell> cellsSet = new HashSet<>();
-		for (Sudoku sudoku : subGrids) {
-			cellsSet.addAll(sudoku.getCells());
-		}
-		return new ArrayList<>(cellsSet);
-	}
-
-	@Override
-	public String toString() {
-		StringBuilder sb = new StringBuilder();
-		sb.append("Multidoku {");
-		for (Sudoku sudoku : subGrids) {
-			sb.append("\n\t").append(sudoku.toString());
-		}
-		sb.append("\n}");
-		return sb.toString();
-	}
-
-	/**
-	 * Renvoie les sous-Sudoku
-	 * 
-	 * @return List<Sudoku>
-	 */
-	public List<Sudoku> getSubGrids() {
-		return this.subGrids;
-	}
-
-	/**
-	 * Check si le MultiDoku est valide, en fonction de ses sous-Sudokus.
-	 * 
-	 * @return boolean, true s'il est valide et false sinon.
 	 */
 	public boolean isSolved() {
 		for (Sudoku sudoku : this.subGrids) {
@@ -93,21 +49,6 @@ public class MultiDoku {
 		return true;
 	}
 
-	/**
-	 * Renvoie la 1re Cell vide des sous-Sudoku.
-	 * 
-	 * @return Cell, une Cell vide, ou null s'il n'y en a pas.
-	 */
-	public Cell getFirstEmptyCell() {
-		for (Sudoku sudoku : this.subGrids) {
-			Cell cellTmp = sudoku.getFirstEmptyCell();
-			if (cellTmp != null) {
-				return cellTmp;
-			}
-		}
-		return null;
-	}
-
 	/**
 	 * Renvoie la liste des Cells préalablement remplies du MultiDoku.
 	 * 
@@ -139,14 +80,51 @@ public class MultiDoku {
 	}
 
 	/**
-	 * Vide une Cell donnée.
+	 * Renvoie la 1re Cell vide des sous-Sudoku.
-	 * 
+	 *
-	 * @param cell Cell, à vider.
+	 * @return Cell, une Cell vide, ou null s'il n'y en a pas.
 	 */
-	public void empty(Cell cell) {
+	public Cell getFirstEmptyCell() {
-		List<Cell> cells = getCells();
+		for (Sudoku sudoku : this.subGrids) {
-		Cell cellToEmpty = cells.get(cells.indexOf(cell));
+			Cell cellTmp = sudoku.getFirstEmptyCell();
-		cellToEmpty.setSymbolIndex(Cell.NOSYMBOL);
+			if (cellTmp != null) {
+				return cellTmp;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Renvoie le nombre de sudoku contenu dans ce MultiDoku.
+	 *
+	 * @return int
+	 */
+	public int getNbSubGrids() {
+		return subGrids.size();
+	}
+
+	/**
+	 * Renvoie la ie sudoku contenue dans ce MultiDoku.
+	 *
+	 * @param i int, indice du sudoku à renvoyer.
+	 * @return Sudoku, ie Sudoku
+	 */
+	public Sudoku getSubGrid(int i) {
+		return subGrids.get(i);
+	}
+
+	/**
+	 * Renvoie la liste des Cells contenue dans ce MultiDoku,
+	 * soit les Cells contenues de chaques sous-Sudoku.
+	 *
+	 * @return List<Cell>
+	 */
+	public List<Cell> getCells() {
+		Set<Cell> cellsSet = new HashSet<>();
+		for (Sudoku sudoku : subGrids) {
+			cellsSet.addAll(sudoku.getCells());
+		}
+		return new ArrayList<>(cellsSet);
 	}
 
 	/**
@@ -167,22 +145,9 @@ public class MultiDoku {
 		}
 	}
 
-	public StateManager getStateManager() {
-		return stateManager;
-	}
-
 	/**
-	 * Renvoie une Cell vide choisie aléatoirement.
+	 * Vide les Cells modifiable.
-	 *
-	 * @param rand Random, pour le choix aléatoire.
-	 * @return Cell, une Cell vide.
 	 */
-	public Cell getRandomEmptyCell(Random rand) {
-		List<Cell> emptyCells = getEmptyCells();
-		int randomIndex = rand.nextInt(emptyCells.size());
-		return emptyCells.get(randomIndex);
-	}
-
 	public void clearMutableCells() {
 		for (Sudoku s : getSubGrids()) {
 			for (Cell cell : s.getCells()) {
@@ -192,8 +157,53 @@ public class MultiDoku {
 		}
 	}
 
+	/**
+	 * Renvoie les sous-Sudoku
+	 *
+	 * @return List<Sudoku>
+	 */
+	public List<Sudoku> getSubGrids() {
+		return this.subGrids;
+	}
+
+	public StateManager getStateManager() {
+		return stateManager;
+	}
+
+	@Override
+	public boolean equals(Object other) {
+		if (!(other instanceof MultiDoku otherDoku))
+			return false;
+		if (this.getNbSubGrids() != otherDoku.getNbSubGrids())
+			return false;
+		for (int i = 0; i < this.getNbSubGrids(); i++) {
+			Sudoku sudoku = this.getSubGrid(i);
+			Sudoku otherSudoku = otherDoku.getSubGrid(i);
+			if (sudoku.getSize() != otherSudoku.getSize())
+				return false;
+			for (int j = 0; j < sudoku.getSize() * sudoku.getSize(); j++) {
+				if (sudoku.getCell(i).getSymbolIndex() != otherSudoku.getCell(i).getSymbolIndex())
+					return false;
+			}
+		}
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		sb.append("Multidoku {");
+		for (Sudoku sudoku : subGrids) {
+			sb.append("\n\t").append(sudoku.toString());
+		}
+		sb.append("\n}");
+		return sb.toString();
+	}
+
 	public MultiDoku clone() {
-		//TODO: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah
+		// TODO: C'est pas dingue de le faire comme ça...
 		return SudokuSerializer.deserializeSudoku(SudokuSerializer.serializeSudoku(this));
 	}
+
+	// </editor-fold>
 }

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

@@ -4,38 +4,60 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Stack;
 
-//TODO: doc
+/**
+ * Une pile, qui réprésente les états d'un MultiDoku,
+ * utile pour les Solvers.
+ */
 public class StateManager {
 
-	private final Stack<Map<Cell, Integer>> states;
+	/**
+	 * Le MultiDoku auquel il est associé.
+	 */
 	private final MultiDoku doku;
 
+	/**
+	 * La pile des états du MultiDoku associé.
+	 */
+	private final Stack<Map<Cell, Integer>> states;
+
 	public StateManager(MultiDoku doku) {
 		this.states = new Stack<>();
 		this.doku = doku;
 	}
 
-	public void pushState() {
+	public void forgetState() {
-		states.add(new HashMap<>());
-		saveState();
-	}
-
-	public void popState() {
-		assert (states.size() > 0);
-		restoreState();
 		states.pop();
 	}
 
-	private void restoreState() {
+	public Map<Cell, Integer> pushState() {
-		for (var entry : this.states.getLast().entrySet()) {
+		states.add(saveState());
+		return states.getLast();
+	}
+
+	public void popState() {
+		assert (!states.isEmpty());
+		restoreState(states.pop());
+	}
+
+	public Map<Cell, Integer> popAndGetState() {
+		assert (!states.isEmpty());
+		var currentState = saveState();
+		restoreState(states.pop());
+		return currentState;
+	}
+
+	public void restoreState(Map<Cell, Integer> state) {
+		for (var entry : state.entrySet()) {
 			entry.getKey().setSymbolIndex(entry.getValue());
 		}
 	}
 
-	private void saveState() {
+	private Map<Cell, Integer> saveState() {
+		Map<Cell, Integer> state = new HashMap<>();
 		for (Cell cell : this.doku.getCells()) {
-			states.getLast().put(cell, cell.getSymbolIndex());
+			state.put(cell, cell.getSymbolIndex());
 		}
+		return state;
 	}
 
 }

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

@@ -1,37 +1,45 @@
 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
  */
 public class Sudoku {
 
+	// <editor-fold defaultstate="collapsed" desc="ATTRIBUTS">
+
 	/**
 	 * Liste des Block contenus dans le Sudoku.
 	 */
 	private final List<Block> blocks;
+
 	/**
 	 * Liste des Cells contenus dans le Sudoku.
 	 */
-	private List<Cell> cells = new ArrayList<>();
+	private final List<Cell> cells;
+
 	/**
 	 * 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) {
+	// </editor-fold>
+
+	// <editor-fold defaultstate="collapsed" desc="METHODES">
+
+	public Sudoku(List<Cell> cells, List<Block> blocks, List<IConstraint> constraints) {
 		this.cells = cells;
 		this.blocks = blocks;
 		this.constraints = constraints;
@@ -49,6 +57,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 +68,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 +79,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;
 			}
@@ -91,34 +106,84 @@ public class Sudoku {
 	}
 
 	/**
-	 * Vide la Cell dotn les coordonnées sont renseignées de son symbole.
+	 * Vérifie si le Sudoku est résolue, soit complet et cohérent avec ses
-	 * @param x int, abscisse de la Cell voulue.
+	 * contraintes.
-	 * @param y int, coordonnée de la Cell voulue.
+	 *
+	 * @return boolean, valant true si le Sudoku est résolu, false sinon.
 	 */
-
+	public boolean isSolved() {
-	public void clearCell(int x, int y) {
+		boolean isComplete = isComplete();
-		assert (isValidCoords(x, y));
+		boolean isValid = isValid();
-		Cell cell = getCell(x, y);
+		return isComplete && isValid;
-		cell.setSymbolIndex(Cell.NOSYMBOL);
 	}
 
 	/**
-	 * Vide toutes les Cell du 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.
 	 */
-	public void clear() {
+	private boolean isComplete() {
-		for (int i = 0; i < getSize() * getSize(); i++) {
+		return getFirstEmptyCell() == null;
+	}
+
+	/**
+	 * 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() {
+		for (int i = 0; i < cells.size(); i++) {
 			Cell cell = getCell(i);
-			if (cell.isMutable())
+			if (cell.isEmpty())
-				cell.setSymbolIndex(Cell.NOSYMBOL);
+				continue;
+
+			Coordinate coordinate = toCoords(i);
+
+			int symbolPlaced = cell.empty();
+			if (!canBePlaced(coordinate.getX(), coordinate.getY(), symbolPlaced)) {
+				cell.setSymbolIndex(symbolPlaced);
+				return false;
+			}
+			cell.setSymbolIndex(symbolPlaced);
+		}
+		return true;
+	}
+
+	/**
+	 * Renvoie la Cell aux coordonées données.
+	 *
+	 * @param x int, abscisse.
+	 * @param y int, ordonnée.
+	 * @return Cell, si une Cell existe aux coordonnées données, null sinon.
+	 */
+	public Cell getCell(int x, int y) {
+		int index = toIndex(x, y);
+		assert (isValidCoords(x, y));
+		try {
+			return this.cells.get(index);
+		} catch (IndexOutOfBoundsException e) {
+			return null;
 		}
 	}
 
-	public int getBlockWidth() {
+	/**
-		return blockWidth;
+	 * Renvoie la 1re Cell vide du Sudoku.
+	 *
+	 * @return Cell, une Cell vide, ou null s'il n'y en a pas.
+	 */
+	public Cell getFirstEmptyCell() {
+		for (Cell cell : this.cells) {
+			if (cell.isEmpty()) {
+				return cell;
+			}
+		}
+		return null;
 	}
 
 	/**
 	 * 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 +191,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 +203,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 +221,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.
 	 */
@@ -178,24 +246,14 @@ public class Sudoku {
 		return true;
 	}
 
-	public Cell getCell(int x, int y) {
+	public boolean hasConstraint(Constraint constraint) {
-		int index = toIndex(x, y);
+		return this.constraints.contains(constraint.getConstraint());
-		assert (isValidCoords(x, y));
-		try {
-			return this.cells.get(index);
-		} catch (IndexOutOfBoundsException e) {
-			return null;
-		}
 	}
 
 	public Cell getCell(int i) {
 		return this.cells.get(i);
 	}
 
-	public List<Constraint> getConstraints() {
-		return constraints;
-	}
-
 	public int getSize() {
 		return this.blocks.size();
 	}
@@ -208,15 +266,19 @@ public class Sudoku {
 		return this.blocks;
 	}
 
-	/**
+	public List<IConstraint> getConstraints() {
-	 * Vérifie si une Cell appartient au Sudoku.
+		return constraints;
-	 * @param cell Cell, cellule dont on veut vérifier l'appartenance au Sudoku.
-	 * @return boolean, vaut true si la Cell appartient au Sudoku.
-	 */
-	public boolean contains(Cell cell) {
-		return this.cells.contains(cell);
 	}
 
+	public int getBlockWidth() {
+		return blockWidth;
+	}
+
+	public void setBlockWidth(int blockWidth) {
+		this.blockWidth = blockWidth;
+	}
+
+	@Override
 	public String toString() {
 		StringBuilder sb = new StringBuilder();
 		sb.append("Sudoku {");
@@ -231,65 +293,6 @@ public class Sudoku {
 		return sb.toString();
 	}
 
-	/**
+	// <editor-fold defaultstate="collapsed" desc="METHODES">
-	 * Renvoie la 1re Cell vide du Sudoku.
-	 * @return Cell, une Cell vide, ou null s'il n'y en a pas.
-	 */
-	public Cell getFirstEmptyCell() {
-		for (Cell cell : this.cells) {
-			if (cell.isEmpty()) {
-				return cell;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * 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() {
-		boolean isComplete = isComplete();
-		boolean isValid = isValid();
-		return isComplete && isValid;
-	}
-
-	/**
-	 * 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() {
-		return getFirstEmptyCell() == null;
-	}
-
-	/**
-	 * 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() {
-		for (int i = 0; i < cells.size(); i++) {
-			Cell cell = getCell(i);
-			if (cell.isEmpty())
-				continue;
-
-			Coordinate coordinate = toCoords(i);
-
-			int symbolPlaced = cell.empty();
-			if (!canBePlaced(coordinate.getX(), coordinate.getY(), symbolPlaced)) {
-				cell.setSymbolIndex(symbolPlaced);
-				return false;
-			}
-			cell.setSymbolIndex(symbolPlaced);
-		}
-		return true;
-	}
-
-	public void setBlockWidth(int blockWidth) {
-		this.blockWidth = blockWidth;
-	}
-
-	public boolean hasConstraint(Constraint constraint) {
-		return this.constraints.contains(constraint);
-	}
 
 }

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,16 @@ 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,9 +48,11 @@ 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
-	 * @param cells List<Cell>, liste des Cells à découper en Blocks.
+	 * les met dans une liste.
-	 * @param width int, largeur des Blocks à créer.
+	 * 
+	 * @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.
 	 * @return List<Block>, liste des Blocks créés.
 	 */
@@ -60,9 +68,6 @@ public class SudokuFactory {
 					int index = ((y + blockY * height) * size + (x + blockX * width));
 					Cell blockCell = cells.get(index);
 					blockCell.setBlock(newBlock);
-					// List<Block> blockContainers = new ArrayList<>();
-					// blockContainers.add(newBlock);
-					// blockCell.setBlockContainers(blockContainers);
 					newBlock.addCell(blockCell);
 				}
 			}
@@ -72,89 +77,37 @@ 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
-	 * @param widthBlock int, largeur des Blocks.
+	 * 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)));
+		return new MultiDoku(List.of(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)));
+		return new MultiDoku(List.of(createSquareSudoku(size, constraints)));
 	}
 
 	/**
-	 * Place des Cells immutables de valeurs fournies, aux Coordinate fournies dans le MultiDoku doku fourni.
+	 * Créée un Sudoku vide dont les Blocks sont de taille widthBlock par
-	 * @param doku           MultiDoku, MultiDoku à remplir.
+	 * heightBlock.
-	 * @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) -> {
-			for (Sudoku sudoku : doku.getSubGrids()) {
-				Cell cell = sudoku.getCell(coordinate.getX(), coordinate.getY());
-				if (cell != null) {
-					cell.setSymbolIndex(symbol);
-					cell.setImmutable();
-				}
-			}
-		});
-	}
-
-	/**
-	 * Créée un MultiDoku de difficulté difficulty à partir d'un MultiDoku fourni.
-	 *
-	 * @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.
-	 * @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 {
-
-		if (nbCellsToEmpty >= doku.getCells().size()) {
-			throw new Exception();
-		}
-
-		if (nbCellsToEmpty == 0) {
-			return true;
-		}
-
-		List<Cell> cellsThatCanBeEmptied = doku.getFilledCells();
-
-		while (!cellsThatCanBeEmptied.isEmpty()) {
-			int index = random.nextInt(cellsThatCanBeEmptied.size());
-			Cell cellToEmpty = cellsThatCanBeEmptied.get(index);
-
-			int oldSymbol = cellToEmpty.empty();
-
-			int nbDokuSultions = solver.countSolution(doku);
-			if (nbDokuSultions == 1) {
-				if (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.
 	 * @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 +121,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,51 +168,38 @@ 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.
+	 * 2 3
+	 *  1
+	 * 4 5
+	 *
 	 * @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 X, de taille width par height composé
+	 * de cinq Sudokus,
 	 * dont un central qui partage chacun de ses Blocks d'angle avec un autre
 	 * Sudoku.
+	 * 2 3
+	 *  1
+	 * 4 5
 	 *
-	 * @param width int, largeur des Blocks unitraires des Sudokus à crééer.
+	 * @param width  int, largeur des Blocks unitaires des Sudokus à crééer.
-	 * @param height int, hauteur des Blocks unitraires des Sudokus à crééer.
+	 * @param height int, hauteur des Blocks unitaires 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);
 
-		/*
-		 * 2 3
-		 * 1
-		 * 4 5
-		 */
-
 		Sudoku sudoku1 = createRectangleSudoku(width, height, constraints);
 		Sudoku sudoku2 = createRectangleSudoku(width, height, constraints);
 		Sudoku sudoku3 = createRectangleSudoku(width, height, constraints);
@@ -272,33 +214,68 @@ public class SudokuFactory {
 		return new MultiDoku(Arrays.asList(sudoku1, sudoku2, sudoku3, sudoku4, sudoku5));
 	}
 
-	public static void fillDoku(MultiDoku doku, Difficulty difficulty) throws Exception {
+	/**
-		Solver solver = new RandomSolver();
+	 * Créée un MultiDoku de Blocks carrés de forme +, de taille size composé
-		solver.solve(doku);
+	 * de cinq Sudokus,
-		int nbCellsToEmpty = (int) (difficulty.getFactor() * doku.getNbCells());
+	 * dont un central qui partage chacun de ses Blocks de bord avec un autre
-		boolean successfull = newDokuFromFilledOne(doku, nbCellsToEmpty, solver);
+	 * Sudoku.
-		doku.setFilledCellsImmutable();
+	 *   3
+	 * 2 1 4
+	 *   5
+	 *
+	 * @param size  int, largeur des Blocks unitaires des Sudokus à crééer.
+	 * @return MultiDoku, MultiDoku de forme +.
+	 */
+	public static MultiDoku createBasicPlusShapedMultidoku(int size, List<IConstraint> constraints) {
+		assert (size > 1);
+
+		return createBasicPlusShapedMultidoku(size, size, constraints);
 	}
 
-	public static MultiDoku fromfile(String filePath) {
+	/**
-		try {
+	 * Créée un MultiDoku de Blocks rectangulaires de forme +, de taille width par height composé
-			String content = Files.readString(Paths.get(filePath));
+	 * de cinq Sudokus,
-			MultiDoku doku = SudokuSerializer.deserializeSudoku(content);
+	 * dont un central qui partage chacun de ses Blocks de bord avec un autre
-			return doku;
+	 * Sudoku.
-		} catch (IOException e) {
+	 *   3
-			e.printStackTrace();
+	 * 2 1 4
-			return null;
+	 *   5
-		}
+	 *
+	 * @param width  int, largeur des Blocks unitaires des Sudokus à crééer.
+	 * @param height int, hauteur des Blocks unitaires des Sudokus à crééer.
+	 * @return MultiDoku, MultiDoku de forme +.
+	 */
+	public static MultiDoku createBasicPlusShapedMultidoku(int width, int height, List<IConstraint> constraints) {
+		assert (width > 1 && height > 1);
+
+		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 MultiDoku createBasicEmptyRandomBlockDoku(int blockSize, List<Constraint> constraints) {
+	/**
+	 * Crée un Sudoku vide avec les Blocks aléatoires.
+	 *
+	 * @param blockSize int, la taille des Block.
+	 * @param constraints List<IConstraint>, la liste des contraintes.
+	 * @return MultiDoku, avec un seul Sudoku.
+	 */
+	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++) {
+		for (int i = 0; i < blockCellCount; i++) {
 			Block b = new Block();
 			for (int j = 0; j < blockCellCount; j++) {
 				int cellIndex = r.nextInt(homeLessCells.size());
@@ -312,6 +289,84 @@ public class SudokuFactory {
 		for (Block block : blocks) {
 			block.getSudokus().add(sudoku);
 		}
-		return new MultiDoku(Arrays.asList(sudoku));
+		return new MultiDoku(List.of(sudoku));
+	}
+
+	/**
+	 * Créée un MultiDoku de difficulté difficulty à partir d'un MultiDoku fourni.
+	 *
+	 * @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.
+	 * @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 {
+
+		if (nbCellsToEmpty >= doku.getCells().size()) {
+			throw new Exception();
+		}
+
+		if (nbCellsToEmpty == 0) {
+			return true;
+		}
+
+		List<Cell> cellsThatCanBeEmptied = doku.getFilledCells();
+
+		int index = random.nextInt(cellsThatCanBeEmptied.size());
+		Cell cellToEmpty = cellsThatCanBeEmptied.get(index);
+
+		cellToEmpty.empty();
+
+		int nbDokuSultions = solver.countSolution(doku);
+		if (nbDokuSultions == 1) {
+            return newDokuFromFilledOne(doku, --nbCellsToEmpty, solver);
+		}
+
+		return false;
+	}
+
+	/**
+	 * Rempli un MultiDoku donné par rapport à un difficulté.
+	 *
+	 * @param doku MultiDoku, vide.
+	 * @param difficulty Difficulty, qui correspond au pourcentage de cases à enlever.
+     */
+	public static void fillDoku(MultiDoku doku, Difficulty difficulty) throws Exception {
+		Solver solver = new RandomSolver();
+		solver.solve(doku);
+		int nbCellsToEmpty = (int) (difficulty.getFactor() * doku.getNbCells());
+		newDokuFromFilledOne(doku, nbCellsToEmpty, solver);
+		doku.setFilledCellsImmutable();
+	}
+
+	/**
+	 * Génère un MultiDoku à partir d'un fichier de sauvegarde.
+	 *
+	 * @param filePath String, chemin du fichier.
+	 * @return MultiDoku.
+	 */
+	public static MultiDoku fromfile(String filePath) {
+		try {
+			String content = Files.readString(Paths.get(filePath));
+            return SudokuSerializer.deserializeSudoku(content);
+		} catch (IOException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	/**
+	 * Transforme des Constraint en IConstraint correspondants
+	 * @param constraints List<Constraints>
+	 * @return List<IConstraints>
+	 */
+	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/main/java/sudoku/structure/SudokuFiller.java

@@ -0,0 +1,78 @@
+package sudoku.structure;
+
+import java.util.List;
+import java.util.Random;
+
+import sudoku.solver.BacktrackingSolver;
+import sudoku.solver.HumanSolver;
+import sudoku.solver.MixedSolver;
+import sudoku.solver.RandomSolver;
+import sudoku.solver.Solver;
+
+public class SudokuFiller {
+
+	private static boolean isPossiblySolvable(MultiDoku doku) {
+		for (Cell cell : doku.getEmptyCells()) {
+			if (cell.getPossibleSymbols().size() == 0)
+				return false;
+		}
+		return true;
+	}
+
+	private static void tryFillRandomCells(MultiDoku doku) {
+		Random r = new Random();
+		while (isPossiblySolvable(doku)) {
+			int cellCount = doku.getEmptyCells().size();
+			if (cellCount == 0)
+				return;
+			Cell cellToFill = doku.getEmptyCells().get(r.nextInt(cellCount));
+			if (!cellToFill.isEmpty() || !cellToFill.isMutable())
+				continue;
+
+			List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
+			int symbolCount = possibleSymbols.size();
+			// la cellule n'a pas de valeur possible
+			if (symbolCount == 0)
+				return;
+
+			cellToFill.setSymbolIndex(possibleSymbols.get(r.nextInt(symbolCount)));
+		}
+	}
+
+	private static void removeRandomCell(MultiDoku doku) {
+		Random r = new Random();
+		int cellCount = doku.getFilledCells().size();
+		doku.getFilledCells().get(r.nextInt(cellCount)).clearCurrentSymbol();
+	}
+
+	private static void makeSolvable(MultiDoku doku) {
+		while (!isPossiblySolvable(doku)) {
+			removeRandomCell(doku);
+		}
+		Solver solver = new BacktrackingSolver();
+		boolean solvable = false;
+		while (!solvable) {
+			removeRandomCell(doku);
+			doku.getStateManager().pushState();
+			solvable = solver.solve(doku);
+			doku.getStateManager().popState();
+			System.out.println("eeeeeeeeeeeee");
+		}
+	}
+
+	private static void fillDoku(MultiDoku doku) {
+		tryFillRandomCells(doku);
+		makeSolvable(doku);
+	}
+
+	private static void setCellsImmutable(MultiDoku doku) {
+		for (Cell cell : doku.getFilledCells())
+			cell.setImmutable();
+	}
+
+	public static void fillDoku(MultiDoku doku, Difficulty difficulty) {
+		fillDoku(doku);
+		setCellsImmutable(doku);
+	}
+
+}

app/src/test/java/sudoku/SudokuSerializerTest.java

@@ -1,7 +1,6 @@
 package sudoku;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.File;
 import java.util.Random;
@@ -22,7 +21,7 @@ public class SudokuSerializerTest {
         new RandomSolver().solve(sudoku);
         JSONObject data = SudokuSerializer.serializeSudoku(sudoku);
         MultiDoku multiDoku = SudokuSerializer.deserializeSudoku(data);
-        assertTrue(data.toString().equals(SudokuSerializer.serializeSudoku(multiDoku).toString()));
+        assertEquals(data.toString(), SudokuSerializer.serializeSudoku(multiDoku).toString());
     }
 
     void testSaveWithSize(int blockWidth, int blockHeight) {
@@ -41,7 +40,7 @@ public class SudokuSerializerTest {
             File fileToDelete = new File(savePath);
             fileToDelete.delete();
         } catch (Exception e) {
-            e.printStackTrace();
+            System.out.println(e.getMessage());
             assert false;
         }
     }
@@ -52,25 +51,27 @@ public class SudokuSerializerTest {
         JSONObject data = SudokuSerializer.serializeSudoku(sudoku);
         MultiDoku multiDoku = SudokuSerializer.deserializeSudoku(data);
 
-        assertTrue(data.toString().equals(SudokuSerializer.serializeSudoku(multiDoku).toString()));
+        assertEquals(data.toString(), SudokuSerializer.serializeSudoku(multiDoku).toString());
     }
 
     @Test
     void testSerialize() {
         Random r = new Random();
         int testCount = 20;
+        int minSize = 2;
+        int maxSize = 3;
         for (int i = 0; i < testCount; i++) {
-            int blockWidth = r.nextInt(4) + 1;
+            int blockWidth = r.nextInt(maxSize - minSize + 1) + minSize;
-            int blockHeight = r.nextInt(4) + 1;
+            int blockHeight = r.nextInt(maxSize - minSize + 1) + minSize;
             testSerializeWithSize(blockWidth, blockHeight);
         }
         for (int i = 0; i < testCount; i++) {
-            int blockWidth = r.nextInt(4) + 1;
+            int blockWidth = r.nextInt(maxSize - minSize + 1) + minSize;
-            int blockHeight = r.nextInt(4) + 1;
+            int blockHeight = r.nextInt(maxSize - minSize + 1) + minSize;
             testSaveWithSize(blockWidth, blockHeight);
         }
         for (int i = 0; i < testCount; i++) {
-            int size = r.nextInt(2) + 2;
+            int size = r.nextInt(maxSize - minSize + 1) + minSize;
             testSerializeX(size);
         }
     }

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

@@ -1,32 +1,68 @@
 package sudoku.solver;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-import sudoku.io.SudokuPrinter;
+
 import sudoku.io.SudokuSerializer;
 import sudoku.structure.Cell;
+import sudoku.structure.Difficulty;
 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 {
+	private int ns = Cell.NOSYMBOL;
+	protected static HumanSolver h;
+	private static RandomSolver r;
+	private static MixedSolver m;
 
-	@Test
+	@BeforeAll
-	void solveTest() {
+	public static void initializeSolvers() {
-		Random rand = new Random();
+		h = new HumanSolver();
+		r = new RandomSolver();
+		m = new MixedSolver();
+	}
 
-		MultiDoku dokuToTest = SudokuFactory.createBasicEmptySquareDoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
+	private void testSize2(Solver solver) {
-		MultiDoku dokuResult = SudokuFactory.createBasicEmptySquareDoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
+		MultiDoku mdTest = SudokuFactory.createBasicEmptySquareDoku(2, SudokuFactory.DEFAULT_CONSTRAINTS);
+		MultiDoku mdResult = SudokuFactory.createBasicEmptySquareDoku(2, SudokuFactory.DEFAULT_CONSTRAINTS);
+		Sudoku test = mdTest.getSubGrid(0);
+		Sudoku result = mdResult.getSubGrid(0);
+		List<Integer> immutableCells = List.of(
+				ns, 2, 3, ns,
+				0, ns, ns, ns,
+				ns, ns, ns, 3,
+				ns, 0, 1, ns);
+		assertTrue(test.setImmutableCellsSymbol(immutableCells));
+		List<Integer> correctCells = List.of(
+			1, 2, 3, 0,
+			0, 3, 2, 1,
+			2, 1, 0, 3,
+			3, 0, 1, 2);
+			assertTrue(result.setCellsSymbol(correctCells));
+			assertTrue(result.isSolved());
+			
+		assertNotEquals(mdResult, mdTest);
+		solver.solve(mdTest);
+		assertTrue(mdTest.isSolved());
 
-		Sudoku sudokuToTest = dokuToTest.getSubGrid(0);
+		assertEquals(mdTest, mdResult);
-		Sudoku sudokuResult = dokuResult.getSubGrid(0);
+	}
 
-		int ns = Cell.NOSYMBOL;
+	private void testSize3(Solver solver) {
-		List<Integer> immutableCells = List.of(ns, ns, 0, ns, ns, 2, 8, ns, 1,
+		MultiDoku mdTest = SudokuFactory.createBasicEmptySquareDoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
+		MultiDoku mdResult = SudokuFactory.createBasicEmptySquareDoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
+		Sudoku test = mdTest.getSubGrid(0);
+		Sudoku result = mdResult.getSubGrid(0);
+		List<Integer> immutableCells = List.of(
+				ns, ns, 0, ns, ns, 2, 8, ns, 1,
 				ns, 3, ns, ns, 5, 6, 7, ns, ns,
 				ns, ns, ns, 8, ns, 7, ns, ns, 6,
 				0, ns, 1, ns, ns, ns, ns, ns, ns,
@@ -35,12 +71,9 @@ class SolverTest {
 				ns, ns, 6, ns, ns, 8, ns, 7, 5,
 				8, 0, ns, 7, ns, 5, 2, ns, 3,
 				5, ns, ns, ns, 3, 1, 0, ns, ns);
-
+		assert (test.setImmutableCellsSymbol(immutableCells));
-		assert (sudokuToTest.setImmutableCellsSymbol(immutableCells));
+		List<Integer> correctCells = List.of(
-
+				7, 6, 0, 3, 4, 2, 8, 5, 1,
-		SudokuPrinter.printRectangleSudoku(dokuToTest.getSubGrid(0), 3, 3);
-
-		List<Integer> correctCells = List.of(7, 6, 0, 3, 4, 2, 8, 5, 1,
 				2, 3, 8, 1, 5, 6, 7, 0, 4,
 				1, 4, 5, 8, 0, 7, 3, 2, 6,
 				0, 2, 1, 6, 8, 3, 5, 4, 7,
@@ -49,54 +82,43 @@ class SolverTest {
 				3, 1, 6, 0, 2, 8, 4, 7, 5,
 				8, 0, 4, 7, 6, 5, 2, 1, 3,
 				5, 7, 2, 4, 3, 1, 0, 6, 8);
+		assert (result.setCellsSymbol(correctCells));
+		assert (result.isSolved());
 
-		sudokuResult.setCellsSymbol(correctCells);
+		assertNotEquals(mdResult, mdTest);
+		solver.solve(mdTest);
+		assert (mdTest.isSolved());
+		assertEquals(mdTest, mdResult);
+	}
 
-		System.out.println("\n****************************Doku Control\n");
+	private void testMDSize3(Solver solver) {
-		SudokuPrinter.printRectangleSudoku(sudokuResult, 3, 3);
+		MultiDoku mdTest = SudokuFactory.createBasicXShapedMultidoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
-
+		try {
-		assert (dokuResult.isSolved());
+			SudokuFactory.fillDoku(mdTest, Difficulty.Easy);
-
+		} catch (Exception e) {
-		new RandomSolver().solve(dokuToTest);
+			assert (false);
-
-		System.out.println("\n****************************\nDoku solved");
-		SudokuPrinter.printRectangleSudoku(dokuToTest.getSubGrid(0), 3, 3);
-
-		assert (dokuToTest.isSolved());
-
-		for (Cell cell : sudokuToTest.getCells()) {
-			cell.setImmutable();
 		}
+		MultiDoku mdResult = SudokuSerializer.deserializeSudoku(SudokuSerializer.serializeSudoku(mdTest));
+		assertFalse(mdTest.isSolved());
+		assertFalse(mdResult.isSolved());
+		assertTrue(solver.solve(mdTest));
+		assertTrue(mdTest.isSolved());
+		assertFalse(mdResult.isSolved());
+		assertNotEquals(mdTest, mdResult);
+		solver.solve(mdResult);
+		assertEquals(mdTest, mdResult);
+	}
 
-		for (Cell cell : sudokuResult.getCells()) {
+	@Test
-			cell.setImmutable();
+	void solveTest() {
-		}
+		initializeSolvers();
-
+		testSize2(h);
-		assertEquals(SudokuSerializer.serializeSudoku(dokuResult).toString(),
+		testSize3(h);
-				SudokuSerializer.serializeSudoku(dokuToTest).toString());
+		testSize2(m);
-
+		testSize3(m);
-		MultiDoku dokuToTest2 = SudokuFactory.createBasicEmptySquareDoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
+		testMDSize3(m);
-		Sudoku sudokuToTest2 = dokuToTest2.getSubGrid(0);
+		testSize2(r);
-
+		testSize3(r);
-		List<Integer> immutableCells2 = List.of(ns, ns, 0, ns, ns, 2, 8, ns, 1,
+		testMDSize3(r);
-				1, 3, ns, ns, 5, 6, 7, ns, ns,
-				ns, ns, ns, 8, ns, 7, ns, ns, 6,
-				0, ns, 1, ns, ns, ns, ns, ns, ns,
-				4, 8, 7, 5, 1, ns, 6, ns, ns,
-				6, ns, 3, 2, ns, ns, ns, 8, 0,
-				ns, ns, 6, ns, ns, 8, ns, 7, 5,
-				8, 0, ns, 7, ns, 5, 2, ns, 3,
-				5, ns, ns, ns, 3, 1, 0, ns, ns);
-		sudokuToTest2.setImmutableCellsSymbol(immutableCells2);
-
-		boolean isSolved = new RandomSolver().solve(dokuToTest2);
-
-		assert (!isSolved);
-
-		MultiDoku dokuToTest3 = SudokuFactory.createBasicEmptySquareDoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
-
-		new RandomSolver().solve(dokuToTest3);
-
-		SudokuPrinter.printRectangleSudoku(dokuToTest3.getSubGrid(0), 3, 3);
 	}
 }