Ryuk/Sudoku
3
1
Fork 0
Code Issues 8 Pull Requests Actions Projects Releases 1 Wiki Activity

Compare commits

base: Ryuk:sooolve
Branches Tags
Ryuk:master Ryuk:udp Ryuk:sooolve Ryuk:tests Ryuk:createPlusMultiDoku Ryuk:refactor Ryuk:HAAAAAAAAAAA
Ryuk:v1.0
..
compare: Ryuk:createPlusMultiDoku
Branches Tags
Ryuk:master Ryuk:udp Ryuk:sooolve Ryuk:tests Ryuk:createPlusMultiDoku Ryuk:refactor Ryuk:HAAAAAAAAAAA
Ryuk:v1.0

4 Commits
sooolve ... createPlus

Author SHA1 Message Date
Persson-dev
1e67e7a9d4 fix renderable multidoku max coords
All checks were successful
Linux arm64 / Build (push) Successful in 29s
Details
2025-02-02 00:37:07 +01:00
Melvyn
70eef1646d refactor
All checks were successful
Linux arm64 / Build (push) Successful in 31s
Details
2025-02-02 00:16:27 +01:00
Persson-dev
5dfe4382fe feat: render new sudoku types
All checks were successful
Linux arm64 / Build (push) Successful in 27s
Details
2025-02-02 00:10:25 +01:00
Melvyn
059886c2a4 feat : createPlusMMultidoku
All checks were successful
Linux arm64 / Build (push) Successful in 30s
Details
2025-02-02 00:02:47 +01:00
43 changed files with 608 additions and 2027 deletions
Expand all files Collapse all files

2
.github/workflows/build.yml vendored
View File

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

0
app/src/main/resources/INFECTED.ttf → app/INFECTED.ttf
View File

0
app/src/main/resources/arial.ttf → app/arial.ttf
View File

0
app/src/main/resources/arial_bold.ttf → app/arial_bold.ttf
View File

0
app/src/main/resources/background.png → app/background.png
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 399 KiB

After

Width:  |  Height:  |  Size: 399 KiB

13
app/build.gradle
View File

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

0
app/src/main/resources/cheri.ttf → app/cheri.ttf
View File

0
app/src/main/resources/comic.ttf → app/comic.ttf
View File

551
app/save/save-1.json
View File

@@ -1,551 +0,0 @@
{
"cells": [
{
"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,
"immutable": true,
"symbolIndex": 1
},
{
"blockID": 2,
"symbolIndex": -1
},
{
"blockID": 2,
"symbolIndex": -1
},
{
"blockID": 0,
"immutable": true,
"symbolIndex": 8
},
{
"blockID": 0,
"immutable": true,
"symbolIndex": 2
},
{
"blockID": 0,
"symbolIndex": -1
},
{
"blockID": 1,
"symbolIndex": -1
},
{
"blockID": 1,
"immutable": true,
"symbolIndex": 0
},
{
"blockID": 1,
"symbolIndex": -1
},
{
"blockID": 2,
"symbolIndex": -1
},
{
"blockID": 2,
"symbolIndex": -1
},
{
"blockID": 2,
"symbolIndex": -1
},
{
"blockID": 0,
"immutable": true,
"symbolIndex": 5
},
{
"blockID": 0,
"symbolIndex": -1
},
{
"blockID": 0,
"symbolIndex": -1
},
{
"blockID": 1,
"symbolIndex": -1
},
{
"blockID": 1,
"symbolIndex": -1
},
{
"blockID": 1,
"symbolIndex": -1
},
{
"blockID": 2,
"symbolIndex": -1
},
{
"blockID": 2,
"immutable": true,
"symbolIndex": 8
},
{
"blockID": 2,
"symbolIndex": -1
},
{
"blockID": 3,
"symbolIndex": -1
},
{
"blockID": 3,
"symbolIndex": -1
},
{
"blockID": 3,
"immutable": true,
"symbolIndex": 1
},
{
"blockID": 4,
"immutable": true,
"symbolIndex": 5
},
{
"blockID": 4,
"immutable": true,
"symbolIndex": 6
},
{
"blockID": 4,
"immutable": true,
"symbolIndex": 0
},
{
"blockID": 5,
"symbolIndex": -1
},
{
"blockID": 5,
"immutable": true,
"symbolIndex": 3
},
{
"blockID": 5,
"symbolIndex": -1
},
{
"blockID": 3,
"symbolIndex": -1
},
{
"blockID": 3,
"symbolIndex": -1
},
{
"blockID": 3,
"symbolIndex": -1
},
{
"blockID": 4,
"symbolIndex": -1
},
{
"blockID": 4,
"immutable": true,
"symbolIndex": 7
},
{
"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": 8,
"symbolIndex": -1
},
{
"blockID": 8,
"symbolIndex": -1
},
{
"blockID": 6,
"symbolIndex": -1
},
{
"blockID": 6,
"symbolIndex": -1
},
{
"blockID": 6,
"symbolIndex": -1
},
{
"blockID": 7,
"immutable": true,
"symbolIndex": 4
},
{
"blockID": 7,
"symbolIndex": -1
},
{
"blockID": 7,
"symbolIndex": -1
},
{
"blockID": 8,
"immutable": true,
"symbolIndex": 6
},
{
"blockID": 8,
"immutable": true,
"symbolIndex": 7
},
{
"blockID": 8,
"symbolIndex": -1
},
{
"blockID": 6,
"immutable": true,
"symbolIndex": 0
},
{
"blockID": 6,
"symbolIndex": -1
},
{
"blockID": 6,
"symbolIndex": -1
},
{
"blockID": 7,
"symbolIndex": -1
},
{
"blockID": 7,
"symbolIndex": -1
},
{
"blockID": 7,
"symbolIndex": -1
},
{
"blockID": 8,
"immutable": true,
"symbolIndex": 3
},
{
"blockID": 8,
"symbolIndex": -1
},
{
"blockID": 8,
"symbolIndex": -1
}
],
"blocks": [
{"cellIDs": [
0,
1,
2,
9,
10,
11,
18,
19,
20
]},
{"cellIDs": [
3,
4,
5,
12,
13,
14,
21,
22,
23
]},
{"cellIDs": [
6,
7,
8,
15,
16,
17,
24,
25,
26
]},
{"cellIDs": [
27,
28,
29,
36,
37,
38,
45,
46,
47
]},
{"cellIDs": [
30,
31,
32,
39,
40,
41,
48,
49,
50
]},
{"cellIDs": [
33,
34,
35,
42,
43,
44,
51,
52,
53
]},
{"cellIDs": [
54,
55,
56,
63,
64,
65,
72,
73,
74
]},
{"cellIDs": [
57,
58,
59,
66,
67,
68,
75,
76,
77
]},
{"cellIDs": [
60,
61,
62,
69,
70,
71,
78,
79,
80
]}
],
"multidoku": [{
"blockWidth": 3,
"cells": [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
79,
80
],
"blocks": [
0,
1,
2,
3,
4,
5,
6,
7,
8
],
"constraints": [
0,
1,
2
]
}]
}

554
app/save/save.json
View File

@@ -1,554 +0,0 @@
{
"cells": [
{
"blockID": 0,
"immutable": true,
"symbolIndex": 5
},
{
"blockID": 0,
"symbolIndex": -1
},
{
"blockID": 0,
"immutable": true,
"symbolIndex": 6
},
{
"blockID": 1,
"immutable": true,
"symbolIndex": 7
},
{
"blockID": 1,
"symbolIndex": -1
},
{
"blockID": 1,
"immutable": true,
"symbolIndex": 1
},
{
"blockID": 2,
"symbolIndex": -1
},
{
"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": 0,
"symbolIndex": -1
},
{
"blockID": 1,
"symbolIndex": -1
},
{
"blockID": 1,
"symbolIndex": -1
},
{
"blockID": 1,
"immutable": true,
"symbolIndex": 8
},
{
"blockID": 2,
"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,
"symbolIndex": -1
},
{
"blockID": 5,
"symbolIndex": -1
},
{
"blockID": 3,
"immutable": true,
"symbolIndex": 1
},
{
"blockID": 3,
"immutable": true,
"symbolIndex": 2
},
{
"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,
"immutable": true,
"symbolIndex": 6
},
{
"blockID": 3,
"immutable": true,
"symbolIndex": 8
},
{
"blockID": 3,
"symbolIndex": -1
},
{
"blockID": 3,
"symbolIndex": -1
},
{
"blockID": 4,
"symbolIndex": -1
},
{
"blockID": 4,
"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
},
{
"blockID": 7,
"immutable": true,
"symbolIndex": 4
},
{
"blockID": 7,
"immutable": true,
"symbolIndex": 5
},
{
"blockID": 7,
"immutable": true,
"symbolIndex": 0
},
{
"blockID": 8,
"symbolIndex": -1
},
{
"blockID": 8,
"symbolIndex": -1
},
{
"blockID": 8,
"symbolIndex": -1
}
],
"blocks": [
{"cellIDs": [
0,
1,
2,
9,
10,
11,
18,
19,
20
]},
{"cellIDs": [
3,
4,
5,
12,
13,
14,
21,
22,
23
]},
{"cellIDs": [
6,
7,
8,
15,
16,
17,
24,
25,
26
]},
{"cellIDs": [
27,
28,
29,
36,
37,
38,
45,
46,
47
]},
{"cellIDs": [
30,
31,
32,
39,
40,
41,
48,
49,
50
]},
{"cellIDs": [
33,
34,
35,
42,
43,
44,
51,
52,
53
]},
{"cellIDs": [
54,
55,
56,
63,
64,
65,
72,
73,
74
]},
{"cellIDs": [
57,
58,
59,
66,
67,
68,
75,
76,
77
]},
{"cellIDs": [
60,
61,
62,
69,
70,
71,
78,
79,
80
]}
],
"multidoku": [{
"blockWidth": 3,
"cells": [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
79,
80
],
"blocks": [
0,
1,
2,
3,
4,
5,
6,
7,
8
],
"constraints": [
0,
1,
2
]
}]
}

32
app/src/main/java/gui/AssetManager.java
View File

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

16
app/src/main/java/gui/Main.java
View File

@@ -2,10 +2,15 @@ package gui;
import gui.constants.Fonts; import gui.constants.Fonts;
import gui.constants.Images; import gui.constants.Images;
import gui.constants.Symbols;
import gui.menu.MainMenu; import gui.menu.MainMenu;
import gui.menu.StateMachine; import gui.menu.StateMachine;
import imgui.app.Application; import imgui.app.Application;
import imgui.app.Configuration; import imgui.app.Configuration;
import sudoku.io.SudokuPrinter;
import sudoku.structure.Difficulty;
import sudoku.structure.MultiDoku;
import sudoku.structure.SudokuFactory;
public class Main extends Application { public class Main extends Application {
@@ -31,7 +36,7 @@ public class Main extends Application {
@Override @Override
protected void preRun() { protected void preRun() {
super.preRun(); super.preRun();
Images.reloadImages(); Images.loadImages();
} }
@Override @Override
@@ -41,6 +46,13 @@ public class Main extends Application {
} }
public static void main(String[] args) { public static void main(String[] args) {
launch(new Main()); MultiDoku doku = SudokuFactory.createBasicPlusShapedMultidoku(3, 3, SudokuFactory.DEFAULT_CONSTRAINTS);
try {
SudokuFactory.fillDoku(doku, Difficulty.Easy);
} catch (Exception e) {
throw new RuntimeException();
}
SudokuPrinter.printMultiDoku(doku, 3, 3, Symbols.Numbers);
//launch(new Main());
} }
} }

30
app/src/main/java/gui/RenderableMultidoku.java
View File

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

13
app/src/main/java/gui/constants/Fonts.java
View File

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

13
app/src/main/java/gui/constants/Images.java
View File

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

1
app/src/main/java/gui/constants/Options.java
View File

@@ -4,6 +4,5 @@ public class Options {
public static Symbols Symboles = Symbols.Numbers; public static Symbols Symboles = Symbols.Numbers;
public static float BackgroundSpeed = 1.0f; public static float BackgroundSpeed = 1.0f;
public static String BackgroundPath = "background.png";
} }

10
app/src/main/java/gui/constants/SudokuType.java
View File

@@ -14,10 +14,14 @@ public enum SudokuType {
(constraints, params) -> SudokuFactory.createBasicEmptyRectangleDoku(params[0], params[1], constraints)), (constraints, params) -> SudokuFactory.createBasicEmptyRectangleDoku(params[0], params[1], constraints)),
RandomBloc("Blocs aléatoires", 1, RandomBloc("Blocs aléatoires", 1,
(constraints, params) -> SudokuFactory.createBasicEmptyRandomBlockDoku(params[0], constraints)), (constraints, params) -> SudokuFactory.createBasicEmptyRandomBlockDoku(params[0], constraints)),
MultiDokuSquare("Multidoku carré (X)", 1, MultiDokuXSquare("Multidoku carré (X)", 1,
(constraints, params) -> SudokuFactory.createBasicXShapedMultidoku(params[0], constraints)), (constraints, params) -> SudokuFactory.createBasicXShapedMultidoku(params[0], constraints)),
MultidokuRectangle("Multidoku rectangle (X)", 2, MultidokuXRectangle("Multidoku rectangle (X)", 2,
(constraints, params) -> SudokuFactory.createBasicXShapedMultidoku(params[0], params[1], constraints)); (constraints, params) -> SudokuFactory.createBasicXShapedMultidoku(params[0], params[1], constraints)),
MultiDokuPSquare("Multidoku carré (+)", 1,
(constraints, params) -> SudokuFactory.createBasicPlusShapedMultidoku(params[0], constraints)),
MultiDokuPRectangle("Multidoku rectangle (+)", 2,
(constraints, params) -> SudokuFactory.createBasicPlusShapedMultidoku(params[0], params[1], constraints));
String displayName; String displayName;
SudokuMaker maker; SudokuMaker maker;

9
app/src/main/java/gui/menu/ConnexionStatusView.java
View File

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

6
app/src/main/java/gui/menu/MultiMenu.java
View File

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

5
app/src/main/java/gui/menu/MultiPlayerView.java
View File

@@ -78,9 +78,4 @@ public class MultiPlayerView extends BaseView {
renderGameStatus(); renderGameStatus();
} }
@Override
public void cleanResources() {
this.selector.clean();
}
} }

28
app/src/main/java/gui/menu/OptionsMenu.java
View File

@@ -1,11 +1,8 @@
package gui.menu; package gui.menu;
import gui.constants.Images;
import gui.constants.Options; import gui.constants.Options;
import gui.constants.Symbols; import gui.constants.Symbols;
import imgui.ImGui; import imgui.ImGui;
import imgui.extension.imguifiledialog.ImGuiFileDialog;
import imgui.extension.imguifiledialog.flag.ImGuiFileDialogFlags;
import imgui.type.ImInt; import imgui.type.ImInt;
public class OptionsMenu extends BaseView { public class OptionsMenu extends BaseView {
@@ -17,30 +14,6 @@ public class OptionsMenu extends BaseView {
super(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 @Override
public void render() { public void render() {
ImGui.text("Options"); ImGui.text("Options");
@@ -50,7 +23,6 @@ public class OptionsMenu extends BaseView {
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]; Options.BackgroundSpeed = backgroundSpeed[0];
} }
renderImageSelectButton();
renderReturnButton(); renderReturnButton();
} }

5
app/src/main/java/gui/menu/SoloMenu.java
View File

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

3
app/src/main/java/gui/menu/SudokuView.java
View File

@@ -92,7 +92,6 @@ public class SudokuView extends BaseView {
} }
private void startSolve(Solver solver) { private void startSolve(Solver solver) {
this.doku.clearMutableCells();
resolveThread = new Thread(() -> { resolveThread = new Thread(() -> {
List<SolverStep> steps = new ArrayList<>(); List<SolverStep> steps = new ArrayList<>();
try { try {
@@ -159,8 +158,6 @@ public class SudokuView extends BaseView {
private void renderClearButton() { private void renderClearButton() {
if (centeredButton("Effacer")) { if (centeredButton("Effacer")) {
this.doku.clearMutableCells(); this.doku.clearMutableCells();
this.resolved = false;
this.unresolved = false;
} }
} }

15
app/src/main/java/gui/widget/SmoothProgressBar.java
View File

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

43
app/src/main/java/gui/widget/SudokuSelector.java
View File

@@ -15,7 +15,6 @@ import sudoku.constraint.IConstraint;
import sudoku.structure.Difficulty; import sudoku.structure.Difficulty;
import sudoku.structure.MultiDoku; import sudoku.structure.MultiDoku;
import sudoku.structure.SudokuFactory; import sudoku.structure.SudokuFactory;
import sudoku.structure.SudokuFiller;
public class SudokuSelector { public class SudokuSelector {
@@ -36,15 +35,10 @@ public class SudokuSelector {
private final String confirmMessage; private final String confirmMessage;
private Thread genThread = null;
private final SmoothProgressBar genProgressBar;
public SudokuSelector(boolean canGenEmptyGrid, String confirmMessage) { public SudokuSelector(boolean canGenEmptyGrid, String confirmMessage) {
this.canGenEmptyGrid = canGenEmptyGrid; this.canGenEmptyGrid = canGenEmptyGrid;
this.confirmMessage = confirmMessage; this.confirmMessage = confirmMessage;
initConstraints(); initConstraints();
this.genProgressBar = new SmoothProgressBar();
} }
private List<IConstraint> getConstraints() { private List<IConstraint> getConstraints() {
@@ -62,40 +56,16 @@ public class SudokuSelector {
} }
} }
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) { private void selectSudoku(MultiDoku doku, boolean empty) {
this.doku = doku; this.doku = doku;
ImGui.openPopup("genProgress");
this.genThread = new Thread(() -> {
try {
if (!empty) { if (!empty) {
SudokuFiller.fillDoku(doku, Difficulty.values()[difficulty.get()]); try {
// SudokuFactory.fillDoku(doku, Difficulty.values()[difficulty.get()]); SudokuFactory.fillDoku(doku, Difficulty.values()[difficulty.get()]);
}
this.onSelect.emit(this.doku);
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); e.printStackTrace();
} }
}); }
this.genThread.start(); this.onSelect.emit(this.doku);
} }
public void renderFileDialog() { public void renderFileDialog() {
@@ -161,12 +131,7 @@ public class SudokuSelector {
if (ImGui.button("À partir d'un fichier")) { if (ImGui.button("À partir d'un fichier")) {
ImGuiFileDialog.openDialog("browse-sudoku", "Choisissez un fichier", ".json", "."); ImGuiFileDialog.openDialog("browse-sudoku", "Choisissez un fichier", ".json", ".");
} }
renderGenProgress();
renderFileDialog(); renderFileDialog();
} }
public void clean() {
stopGenThread();
}
} }

6
app/src/main/java/network/client/Client.java
View File

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

41
app/src/main/java/sudoku/io/ConsoleInterface.java
View File

@@ -227,7 +227,7 @@ public class ConsoleInterface {
saveMultiDoku(doku); saveMultiDoku(doku);
break; break;
case "solution": case "solution":
solve(doku, listSymbols, width, height); solve(doku);
break; break;
case "exit": case "exit":
exit(); exit();
@@ -238,50 +238,19 @@ public class ConsoleInterface {
} }
} }
private void applyStep(SolverStep step) { private void solve(MultiDoku doku){
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')."); 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()) { switch (reader.next()) {
case "human": case "human":
new HumanSolver().solve(doku, steps); new HumanSolver().solve(doku);
break; break;
case "mixed": case "mixed":
new MixedSolver().solve(doku, steps); new MixedSolver().solve(doku);
break; break;
default: default:
new RandomSolver().solve(doku, steps); new RandomSolver().solve(doku);
break; break;
} }
showSolveSteps(doku, listSymbols, width, height, steps);
} }
private void play(MultiDoku doku, List<String> listSymbols, int width, int height) { private void play(MultiDoku doku, List<String> listSymbols, int width, int height) {

7
app/src/main/java/sudoku/solver/HintHelper.java
View File

@@ -9,10 +9,11 @@ import java.util.Random;
import sudoku.structure.Cell; import sudoku.structure.Cell;
import sudoku.structure.MultiDoku; import sudoku.structure.MultiDoku;
//TODO
public class HintHelper { public class HintHelper {
public static record Hint(Cell cell, int newValue) {} public static record Hint(Cell cell, int newValue) {
}
public static Hint getHint(MultiDoku doku, Solver solver) { public static Hint getHint(MultiDoku doku, Solver solver) {
doku.getStateManager().pushState(); doku.getStateManager().pushState();
@@ -35,7 +36,7 @@ public class HintHelper {
if (newValue == Cell.NOSYMBOL) if (newValue == Cell.NOSYMBOL)
return new Hint(cell, newValue); return new Hint(cell, newValue);
// we have to change the cell value // we have to change the cell value
if (oldValue != Cell.NOSYMBOL) if (oldValue != Cell.NOSYMBOL && newValue != oldValue)
return new Hint(cell, newValue); return new Hint(cell, newValue);
// there is a valid move // there is a valid move

51
app/src/main/java/sudoku/solver/HumanSolver.java
View File

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

103
app/src/main/java/sudoku/solver/MixedSolver.java
View File

@@ -1,37 +1,18 @@
package sudoku.solver; package sudoku.solver;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Random;
import java.util.concurrent.CancellationException; import java.util.concurrent.CancellationException;
import java.util.logging.Level;
import gui.constants.Symbols;
import sudoku.io.SudokuPrinter;
import sudoku.structure.Cell; import sudoku.structure.Cell;
import sudoku.structure.MultiDoku; 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 * Résout le MultiDoku passé en paramètre, avec règles de déduction et
* backtracking. * backtracking.
@@ -41,59 +22,55 @@ public class MixedSolver implements Solver {
*/ */
@Override @Override
public boolean solve(MultiDoku doku, List<SolverStep> steps) { public boolean solve(MultiDoku doku, List<SolverStep> steps) {
Random rand = new Random();
if (Thread.interrupted()) { if (Thread.interrupted()) {
throw new CancellationException("User wants to stop the solver"); throw new CancellationException("User wants to stop the solver");
} }
if (doku.isSolved()) 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(),
Symbols.Numbers));
if (doku.isSolved()) {
return true; return true;
}
int symbolCount = doku.getSubGrid(0).getSize(); Cell cellToFill = doku.getFirstEmptyCell();
if (cellToFill == null) {
return false;
}
// on remplit les cases par déduction List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
for (Cell cell : doku.getCells()) {
if (!cell.isMutable() || !cell.isEmpty())
continue;
List<Integer> possibleSymbols = cell.getPossibleSymbols();
if (possibleSymbols.size() == 1) { if (possibleSymbols.size() == 1) {
cell.setSymbolIndex(possibleSymbols.getFirst()); cellToFill.setSymbolIndex(possibleSymbols.getFirst());
addStep(cell, steps); addStep(cellToFill, steps);
if (solve(doku, steps)) if (this.solve(doku, steps)) {
return true;
cell.setSymbolIndex(Cell.NOSYMBOL);
return false;
}
}
// on ne peut plus remplir de cases, on tente de backtrack
for (int maxPossibilities = 2; maxPossibilities <= symbolCount; maxPossibilities++) {
List<Cell> backtrackCells = new ArrayList<>();
while (backtrackCells.isEmpty()) {
backtrackCells = findCellToBacktrack(doku, maxPossibilities);
// grille non résolvable
if (backtrackCells == null) {
return false;
}
maxPossibilities++;
}
// on fait du backtracking
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; return true;
} }
} }
backtrackCell.setSymbolIndex(Cell.NOSYMBOL);
while (!possibleSymbols.isEmpty()) {
int nextPossibleSymbolIndex = rand.nextInt(possibleSymbols.size());
int nextSymbol = possibleSymbols.get(nextPossibleSymbolIndex);
cellToFill.setSymbolIndex(nextSymbol);
addStep(cellToFill, steps);
if (this.solve(doku, steps)) {
return true;
} }
cellToFill.setSymbolIndex(Cell.NOSYMBOL);
addStep(cellToFill, steps);
possibleSymbols.remove(nextPossibleSymbolIndex);
} }
return doku.isSolved();
return false;
} }
} }

11
app/src/main/java/sudoku/solver/RandomSolver.java
View File

@@ -3,9 +3,13 @@ package sudoku.solver;
import java.util.List; import java.util.List;
import java.util.Random; import java.util.Random;
import java.util.concurrent.CancellationException; import java.util.concurrent.CancellationException;
import java.util.logging.Level;
import gui.constants.Symbols;
import sudoku.io.SudokuPrinter;
import sudoku.structure.Cell; import sudoku.structure.Cell;
import sudoku.structure.MultiDoku; import sudoku.structure.MultiDoku;
import sudoku.structure.Sudoku;
public class RandomSolver implements Solver { public class RandomSolver implements Solver {
@@ -24,6 +28,13 @@ public class RandomSolver implements Solver {
if (Thread.interrupted()) if (Thread.interrupted())
throw new CancellationException("User wants to stop the solver"); 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(),
Symbols.Numbers));
if (doku.isSolved()) { if (doku.isSolved()) {
return true; return true;
} }

16
app/src/main/java/sudoku/solver/StupidSolver.java
View File

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

43
app/src/main/java/sudoku/structure/Block.java
View File

@@ -4,41 +4,28 @@ import java.util.ArrayList;
import java.util.List; 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 { 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; private final List<Cell> cells;
/** /**
* Liste de Sudoku qui contiennent le block * List de sudoku qui contiennent le block
* Pour un accès plus rapide aux sudokus. * Pour un acces plus rapide aux sudokus
*/ */
private final List<Sudoku> 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) { public Block(List<Cell> cells) {
this.cells = cells; this.cells = cells;
this.sudokus = new ArrayList<>(); this.sudokus = new ArrayList<>();
} }
/**
* Crée un Block avec une liste de Cell vide.
*/
public Block() { public Block() {
this(new ArrayList<>()); this(new ArrayList<>());
} }
@@ -46,16 +33,13 @@ public class Block {
public List<Cell> getCells() { public List<Cell> getCells() {
return cells; return cells;
} }
public List<Sudoku> getSudokus() {
return sudokus;
}
/** /**
* Ajoute une Cell au Block * Ajoute une Cell au Block
* *
* @param newCell Cell, à ajouter * @param newCell Cell, à ajouter
*/ */
public void addCell(Cell newCell) { void addCell(Cell newCell) {
this.cells.add(newCell); this.cells.add(newCell);
} }
@@ -73,5 +57,16 @@ public class Block {
return false; return false;
} }
// </editor-fold> public boolean containsCell(Cell cell) {
for (Cell cellTmp : this.cells) {
if (cellTmp.equals(cell)) {
return true;
}
}
return false;
}
public List<Sudoku> getSudokus() {
return sudokus;
}
} }

56
app/src/main/java/sudoku/structure/Cell.java
View File

@@ -9,8 +9,6 @@ import java.util.List;
*/ */
public class Cell { public class Cell {
// <editor-fold defaultstate="collapsed" desc="ATTRIBUTS">
/** /**
* Constante de valeur d'index de symbole quand il n'y en a pas, * Constante de valeur d'index de symbole quand il n'y en a pas,
* soit que la Cell est vide. * soit que la Cell est vide.
@@ -31,10 +29,6 @@ public class Cell {
*/ */
private boolean isMutable = true; private boolean isMutable = true;
// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="METHODES">
public Cell() { public Cell() {
this(Cell.NOSYMBOL); this(Cell.NOSYMBOL);
} }
@@ -52,22 +46,6 @@ public class Cell {
return this.symbolIndex; 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) { public void setSymbolIndex(int symbolIndex) {
this.symbolIndex = symbolIndex; this.symbolIndex = symbolIndex;
} }
@@ -79,16 +57,22 @@ public class Cell {
this.isMutable = false; this.isMutable = false;
} }
public Block getBlock() {
return this.blockContainer;
}
public void setBlock(Block block) { public void setBlock(Block block) {
this.blockContainer = block; this.blockContainer = block;
} }
/** /**
* Vide la Cell. * Remove the current symbolIndex and returns it
* @return integer symbolIndex cleared
*/ */
public void clearCurrentSymbol() { public int clearCurrentSymbol() {
int i = this.symbolIndex;
setSymbolIndex(NOSYMBOL); setSymbolIndex(NOSYMBOL);
return i;
} }
/** /**
@@ -99,6 +83,14 @@ public class Cell {
return this.symbolIndex == Cell.NOSYMBOL; 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. * Vide la Cell, en renvoie l'ancien index du symbole qui était dedans.
* @return int, index du symbole anciennement contenue dans la Cell. * @return int, index du symbole anciennement contenue dans la Cell.
@@ -109,11 +101,6 @@ public class Cell {
return oldSymbol; 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) { public boolean canHaveValue(int value) {
for (Sudoku s :getBlock().getSudokus()) { for (Sudoku s :getBlock().getSudokus()) {
int cellIndex = s.getCells().indexOf(this); int cellIndex = s.getCells().indexOf(this);
@@ -129,10 +116,6 @@ public class Cell {
return true; 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() { public List<Integer> getPossibleSymbols() {
List<Integer> result = new ArrayList<>(); List<Integer> result = new ArrayList<>();
for (int i = 0; i < getBlock().getSudokus().get(0).getSize(); i++) { for (int i = 0; i < getBlock().getSudokus().get(0).getSize(); i++) {
@@ -142,11 +125,6 @@ public class Cell {
return result; 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) { public boolean trySetValue(int newValue) {
if (!isMutable()) if (!isMutable())
return false; return false;
@@ -155,6 +133,4 @@ public class Cell {
setSymbolIndex(newValue); setSymbolIndex(newValue);
return true; return true;
} }
// </editor-fold>
} }

23
app/src/main/java/sudoku/structure/Coordinate.java
View File

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

36
app/src/main/java/sudoku/structure/Difficulty.java
View File

@@ -1,32 +1,26 @@
package sudoku.structure; 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 { public enum Difficulty {
VeryEasy("Très facile", 0.1), VeryEasy("Très facile", 0.1), Easy("Facile", 0.25), Medium("Moyen", 0.5), Hard("Difficile", 0.75), VeryHard("Impossible", 0.78);
Easy("Facile", 0.25),
Medium("Moyen", 0.5),
Hard("Difficile", 0.75),
VeryHard("Impossible", 0.78);
/**
* Le pourcentage de Cell à enlever.
*/
final double factor; final double factor;
/**
* Le nom de la difficulté.
*/
final String displayName; final String displayName;
Difficulty(String displayName, double factor) { private Difficulty(String displayName, double factor) {
this.factor = factor; this.factor = factor;
this.displayName = displayName; this.displayName = displayName;
} }
public String getDisplayName() {
return displayName;
}
public double getFactor() {
return factor;
}
private static final String[] difficultyNames; private static final String[] difficultyNames;
static { static {
@@ -37,14 +31,6 @@ public enum Difficulty {
} }
} }
public String getDisplayName() {
return displayName;
}
public double getFactor() {
return factor;
}
public static String[] getDifficultyNames() { public static String[] getDifficultyNames() {
return difficultyNames; return difficultyNames;
} }

226
app/src/main/java/sudoku/structure/MultiDoku.java
View File

@@ -1,99 +1,32 @@
package sudoku.structure; package sudoku.structure;
import sudoku.io.SudokuSerializer;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Random;
import java.util.Set; import java.util.Set;
import sudoku.io.SudokuSerializer;
/** /**
* @class MultiDoku * @class MultiDoku
* @brief Représente une grille de 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 { public class MultiDoku {
// <editor-fold defaultstate="collapsed" desc="ATTRIBUTS">
/** /**
* Liste des sous-Sudoku contenue dans le multidoku. * Liste des sous-Sudoku contenue dans le multidoku.
*/ */
private final List<Sudoku> subGrids; private final List<Sudoku> subGrids;
/**
* Pile, qui contient des états du MultiDoku,
* utile pour la résolution.
*/
private final StateManager stateManager; private final StateManager stateManager;
// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="METHODES">
public MultiDoku(List<Sudoku> subGrids) { public MultiDoku(List<Sudoku> subGrids) {
this.subGrids = subGrids; this.subGrids = subGrids;
this.stateManager = new StateManager(this); this.stateManager = new StateManager(this);
} }
/**
* Check si le MultiDoku est résolu, c'est à dire complet et cohérent avec ses contraintes.
*
* @return boolean, true s'il est résolu et false sinon.
*/
public boolean isSolved() {
for (Sudoku sudoku : this.subGrids) {
if (!sudoku.isSolved())
return false;
}
return true;
}
/**
* Renvoie la liste des Cells préalablement remplies du MultiDoku.
*
* @return List<Cell>, vide si aucune Cell n'est remplie.
*/
public List<Cell> getFilledCells() {
List<Cell> result = new ArrayList<>();
for (Cell cell : this.getCells()) {
if (!cell.isEmpty()) {
result.add(cell);
}
}
return result;
}
/**
* Renvoie la liste des Cells vides du MultiDoku.
*
* @return List<Cell>, vide si aucune Cell ne l'est.
*/
public List<Cell> getEmptyCells() {
List<Cell> result = new ArrayList<>();
for (Cell cell : this.getCells()) {
if (cell.isEmpty()) {
result.add(cell);
}
}
return result;
}
/**
* 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 le nombre de sudoku contenu dans ce MultiDoku. * Renvoie le nombre de sudoku contenu dans ce MultiDoku.
* *
@@ -127,6 +60,95 @@ public class MultiDoku {
return new ArrayList<>(cellsSet); 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 résolu, c'est à dire complet et cohérent avec ses contraintes.
*
* @return boolean, true s'il est résolu et false sinon.
*/
public boolean isSolved() {
for (Sudoku sudoku : this.subGrids) {
if (!sudoku.isSolved())
return false;
}
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.
*
* @return List<Cell>, vide si aucune Cell n'est remplie.
*/
public List<Cell> getFilledCells() {
List<Cell> result = new ArrayList<>();
for (Cell cell : this.getCells()) {
if (!cell.isEmpty()) {
result.add(cell);
}
}
return result;
}
/**
* Renvoie la liste des Cells vides du MultiDoku.
*
* @return List<Cell>, vide si aucune Cell ne l'est.
*/
public List<Cell> getEmptyCells() {
List<Cell> result = new ArrayList<>();
for (Cell cell : this.getCells()) {
if (cell.isEmpty()) {
result.add(cell);
}
}
return result;
}
/**
* Vide une Cell donnée.
*
* @param cell Cell, à vider.
*/
public void empty(Cell cell) {
List<Cell> cells = getCells();
Cell cellToEmpty = cells.get(cells.indexOf(cell));
cellToEmpty.setSymbolIndex(Cell.NOSYMBOL);
}
/** /**
* Renvoie le nombre de Cell contenue dans le MultiDoku. * Renvoie le nombre de Cell contenue dans le MultiDoku.
* *
@@ -145,9 +167,22 @@ public class MultiDoku {
} }
} }
public StateManager getStateManager() {
return stateManager;
}
/** /**
* Vide les Cells modifiable. * Renvoie une Cell vide choisie aléatoirement.
*
* @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() { public void clearMutableCells() {
for (Sudoku s : getSubGrids()) { for (Sudoku s : getSubGrids()) {
for (Cell cell : s.getCells()) { for (Cell cell : s.getCells()) {
@@ -157,53 +192,8 @@ 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() { public MultiDoku clone() {
// TODO: C'est pas dingue de le faire comme ça... // TODO: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah
return SudokuSerializer.deserializeSudoku(SudokuSerializer.serializeSudoku(this)); return SudokuSerializer.deserializeSudoku(SudokuSerializer.serializeSudoku(this));
} }
// </editor-fold>
} }

24
app/src/main/java/sudoku/structure/StateManager.java
View File

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

193
app/src/main/java/sudoku/structure/Sudoku.java
View File

@@ -12,33 +12,24 @@ import sudoku.constraint.IConstraint;
*/ */
public class Sudoku { public class Sudoku {
// <editor-fold defaultstate="collapsed" desc="ATTRIBUTS">
/** /**
* Liste des Block contenus dans le Sudoku. * Liste des Block contenus dans le Sudoku.
*/ */
private final List<Block> blocks; private final List<Block> blocks;
/** /**
* Liste des Cells contenus dans le Sudoku. * Liste des Cells contenus dans le Sudoku.
*/ */
private final List<Cell> cells; private List<Cell> cells = new ArrayList<>();
/** /**
* Liste des contraintes (TODO) du Sudoku. * Liste des contraintes (TODO) du Sudoku.
*/ */
private final List<IConstraint> constraints; private final List<IConstraint> constraints;
/** /**
* Largeur des Blocks s'ils sont rectangulaires, * Largeur des Blocks s'ils sont rectangulaires, valant 0 si ce n'est pas le
* valant 0 si ce n'est pas le cas. * cas.
*/ */
private int blockWidth; private int blockWidth;
// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="METHODES">
public Sudoku(List<Cell> cells, List<Block> blocks, List<IConstraint> constraints) { public Sudoku(List<Cell> cells, List<Block> blocks, List<IConstraint> constraints) {
this.cells = cells; this.cells = cells;
this.blocks = blocks; this.blocks = blocks;
@@ -106,79 +97,31 @@ public class Sudoku {
} }
/** /**
* Vérifie si le Sudoku est résolue, soit complet et cohérent avec ses * Vide la Cell dotn les coordonnées sont renseignées de son symbole.
* contraintes.
* *
* @return boolean, valant true si le Sudoku est résolu, false sinon. * @param x int, abscisse de la Cell voulue.
* @param y int, coordonnée de la Cell voulue.
*/ */
public boolean isSolved() {
boolean isComplete = isComplete();
boolean isValid = isValid();
return isComplete && isValid;
}
/** public void clearCell(int x, int y) {
* 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;
}
/**
* 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)); assert (isValidCoords(x, y));
try { Cell cell = getCell(x, y);
return this.cells.get(index); cell.setSymbolIndex(Cell.NOSYMBOL);
} catch (IndexOutOfBoundsException e) {
return null;
}
} }
/** /**
* Renvoie la 1re Cell vide du Sudoku. * Vide toutes les Cell du Sudoku.
*
* @return Cell, une Cell vide, ou null s'il n'y en a pas.
*/ */
public Cell getFirstEmptyCell() { public void clear() {
for (Cell cell : this.cells) { for (int i = 0; i < getSize() * getSize(); i++) {
if (cell.isEmpty()) { Cell cell = getCell(i);
return cell; if (cell.isMutable())
cell.setSymbolIndex(Cell.NOSYMBOL);
} }
} }
return null;
public int getBlockWidth() {
return blockWidth;
} }
/** /**
@@ -246,14 +189,24 @@ public class Sudoku {
return true; return true;
} }
public boolean hasConstraint(Constraint constraint) { public Cell getCell(int x, int y) {
return this.constraints.contains(constraint.getConstraint()); int index = toIndex(x, y);
assert (isValidCoords(x, y));
try {
return this.cells.get(index);
} catch (IndexOutOfBoundsException e) {
return null;
}
} }
public Cell getCell(int i) { public Cell getCell(int i) {
return this.cells.get(i); return this.cells.get(i);
} }
public List<IConstraint> getConstraints() {
return constraints;
}
public int getSize() { public int getSize() {
return this.blocks.size(); return this.blocks.size();
} }
@@ -266,19 +219,16 @@ public class Sudoku {
return this.blocks; return this.blocks;
} }
public List<IConstraint> getConstraints() { /**
return constraints; * Vérifie si une Cell appartient au Sudoku.
*
* @param cell Cell, cellule dont on veut vérifier l'appartenance au Sudoku.
* @return boolean, vaut true si la Cell appartient au Sudoku.
*/
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() { public String toString() {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
sb.append("Sudoku {"); sb.append("Sudoku {");
@@ -293,6 +243,71 @@ public class Sudoku {
return sb.toString(); 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.getConstraint());
}
} }

219
app/src/main/java/sudoku/structure/SudokuFactory.java
View File

@@ -27,11 +27,8 @@ public class SudokuFactory {
* Comprend les contraintes de blocs, de lignes, et de colonnes. * Comprend les contraintes de blocs, de lignes, et de colonnes.
*/ */
public static List<IConstraint> DEFAULT_CONSTRAINTS = SudokuFactory public static List<IConstraint> DEFAULT_CONSTRAINTS = SudokuFactory
.fromConstraints(Arrays.asList( .fromConstraints(Arrays.asList(Constraint.Block, Constraint.Column,
Constraint.Block, Constraint.Line));
Constraint.Column,
Constraint.Line)
);
/** /**
* Créée des Cells et les met dans une liste de taille size. * Créée des Cells et les met dans une liste de taille size.
@@ -68,6 +65,9 @@ public class SudokuFactory {
int index = ((y + blockY * height) * size + (x + blockX * width)); int index = ((y + blockY * height) * size + (x + blockX * width));
Cell blockCell = cells.get(index); Cell blockCell = cells.get(index);
blockCell.setBlock(newBlock); blockCell.setBlock(newBlock);
// List<Block> blockContainers = new ArrayList<>();
// blockContainers.add(newBlock);
// blockCell.setBlockContainers(blockContainers);
newBlock.addCell(blockCell); newBlock.addCell(blockCell);
} }
} }
@@ -86,7 +86,7 @@ public class SudokuFactory {
*/ */
public static MultiDoku createBasicEmptyRectangleDoku(int widthBlock, int heightBlock, public static MultiDoku createBasicEmptyRectangleDoku(int widthBlock, int heightBlock,
List<IConstraint> constraints) { List<IConstraint> constraints) {
return new MultiDoku(List.of(createRectangleSudoku(widthBlock, heightBlock, constraints))); return new MultiDoku(Arrays.asList(createRectangleSudoku(widthBlock, heightBlock, constraints)));
} }
/** /**
@@ -96,7 +96,63 @@ public class SudokuFactory {
* @return MultiDoku, MultiDoku vide. * @return MultiDoku, MultiDoku vide.
*/ */
public static MultiDoku createBasicEmptySquareDoku(int size, List<IConstraint> constraints) { public static MultiDoku createBasicEmptySquareDoku(int size, List<IConstraint> constraints) {
return new MultiDoku(List.of(createSquareSudoku(size, constraints))); return new MultiDoku(Arrays.asList(createSquareSudoku(size, constraints)));
}
/**
* Place des Cells immutables de valeurs fournies, aux Coordinate fournies dans
* le MultiDoku doku fourni.
*
* @param doku MultiDoku, MultiDoku à remplir.
* @param immutableCells Map<Coordinate, Integer>, association de Coordinate
* coordonnées et Integer valeurs, correspondant aux cases
* à remplir.
*/
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();
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;
} }
/** /**
@@ -171,9 +227,6 @@ public class SudokuFactory {
* Créée un MultiDoku de Blocks carrés de taille size composé de cinq Sudokus, * 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 * dont un central qui partage chacun de ses Blockss d'angle avec un autre
* Sudoku. * Sudoku.
* 2 3
* 1
* 4 5
* *
* @param size int, largeur des Blocks unitraires des Sudokus à crééer. * @param size int, largeur des Blocks unitraires des Sudokus à crééer.
* @return MultiDoku, MultiDoku de forme X. * @return MultiDoku, MultiDoku de forme X.
@@ -185,21 +238,24 @@ public class SudokuFactory {
} }
/** /**
* Créée un MultiDoku de Blocks rectangulaires de forme X, de taille width par height composé * Créée un MultiDoku de Blocks rectangulaires de forme width par height composé
* de cinq Sudokus, * de cinq Sudokus,
* dont un central qui partage chacun de ses Blocks d'angle avec un autre * dont un central qui partage chacun de ses Blocks d'angle avec un autre
* Sudoku. * Sudoku.
* 2 3
* 1
* 4 5
* *
* @param width int, largeur des Blocks unitaires des Sudokus à crééer. * @param width int, largeur des Blocks unitraires des Sudokus à crééer.
* @param height int, hauteur des Blocks unitaires des Sudokus à crééer. * @param height int, hauteur des Blocks unitraires des Sudokus à crééer.
* @return MultiDoku, MultiDoku de forme X. * @return MultiDoku, MultiDoku de forme X.
*/ */
public static MultiDoku createBasicXShapedMultidoku(int width, int height, List<IConstraint> constraints) { public static MultiDoku createBasicXShapedMultidoku(int width, int height, List<IConstraint> constraints) {
assert (width > 1 && height > 1); assert (width > 1 && height > 1);
/*
* 2 3
* 1
* 4 5
*/
Sudoku sudoku1 = createRectangleSudoku(width, height, constraints); Sudoku sudoku1 = createRectangleSudoku(width, height, constraints);
Sudoku sudoku2 = createRectangleSudoku(width, height, constraints); Sudoku sudoku2 = createRectangleSudoku(width, height, constraints);
Sudoku sudoku3 = createRectangleSudoku(width, height, constraints); Sudoku sudoku3 = createRectangleSudoku(width, height, constraints);
@@ -215,16 +271,13 @@ public class SudokuFactory {
} }
/** /**
* Créée un MultiDoku de Blocks carrés de forme +, de taille size composé * TODO
* de cinq Sudokus, * Créée un MultiDoku de Blocks carrés de taille size composé de cinq Sudokus,
* dont un central qui partage chacun de ses Blocks de bord avec un autre * dont un central qui partage chacun de ses Blockss d'angle avec un autre
* Sudoku. * Sudoku.
* 3
* 2 1 4
* 5
* *
* @param size int, largeur des Blocks unitaires des Sudokus à crééer. * @param size int, largeur des Blocks unitraires des Sudokus à crééer.
* @return MultiDoku, MultiDoku de forme +. * @return MultiDoku, MultiDoku de forme X.
*/ */
public static MultiDoku createBasicPlusShapedMultidoku(int size, List<IConstraint> constraints) { public static MultiDoku createBasicPlusShapedMultidoku(int size, List<IConstraint> constraints) {
assert (size > 1); assert (size > 1);
@@ -233,21 +286,25 @@ public class SudokuFactory {
} }
/** /**
* Créée un MultiDoku de Blocks rectangulaires de forme +, de taille width par height composé * TODO
* Créée un MultiDoku de Blocks rectangulaires de forme width par height composé
* de cinq Sudokus, * de cinq Sudokus,
* dont un central qui partage chacun de ses Blocks de bord avec un autre * dont un central qui partage chacun de ses Blocks d'angle avec un autre
* Sudoku. * Sudoku.
* 3
* 2 1 4
* 5
* *
* @param width int, largeur des Blocks unitaires des Sudokus à crééer. * @param width int, largeur des Blocks unitraires des Sudokus à crééer.
* @param height int, hauteur des Blocks unitaires des Sudokus à crééer. * @param height int, hauteur des Blocks unitraires des Sudokus à crééer.
* @return MultiDoku, MultiDoku de forme +. * @return MultiDoku, MultiDoku de forme X.
*/ */
public static MultiDoku createBasicPlusShapedMultidoku(int width, int height, List<IConstraint> constraints) { public static MultiDoku createBasicPlusShapedMultidoku(int width, int height, List<IConstraint> constraints) {
assert (width > 1 && height > 1); assert (width > 1 && height > 1);
/*
* 3
* 2 1 4
* 5
*/
Sudoku sudoku1 = createRectangleSudoku(width, height, constraints); Sudoku sudoku1 = createRectangleSudoku(width, height, constraints);
Sudoku sudoku2 = createRectangleSudoku(width, height, constraints); Sudoku sudoku2 = createRectangleSudoku(width, height, constraints);
Sudoku sudoku3 = createRectangleSudoku(width, height, constraints); Sudoku sudoku3 = createRectangleSudoku(width, height, constraints);
@@ -262,13 +319,25 @@ public class SudokuFactory {
return new MultiDoku(Arrays.asList(sudoku1, sudoku2, sudoku3, sudoku4, sudoku5)); return new MultiDoku(Arrays.asList(sudoku1, sudoku2, sudoku3, sudoku4, sudoku5));
} }
/** public static void fillDoku(MultiDoku doku, Difficulty difficulty) throws Exception {
* Crée un Sudoku vide avec les Blocks aléatoires. Solver solver = new RandomSolver();
* solver.solve(doku);
* @param blockSize int, la taille des Block. int nbCellsToEmpty = (int) (difficulty.getFactor() * doku.getNbCells());
* @param constraints List<IConstraint>, la liste des contraintes. boolean successfull = newDokuFromFilledOne(doku, nbCellsToEmpty, solver);
* @return MultiDoku, avec un seul Sudoku. doku.setFilledCellsImmutable();
*/ }
public static MultiDoku fromfile(String filePath) {
try {
String content = Files.readString(Paths.get(filePath));
MultiDoku doku = SudokuSerializer.deserializeSudoku(content);
return doku;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
public static MultiDoku createBasicEmptyRandomBlockDoku(int blockSize, List<IConstraint> constraints) { public static MultiDoku createBasicEmptyRandomBlockDoku(int blockSize, List<IConstraint> constraints) {
int blockCellCount = blockSize * blockSize; int blockCellCount = blockSize * blockSize;
List<Cell> cells = initCells(blockCellCount); List<Cell> cells = initCells(blockCellCount);
@@ -289,79 +358,9 @@ public class SudokuFactory {
for (Block block : blocks) { for (Block block : blocks) {
block.getSudokus().add(sudoku); block.getSudokus().add(sudoku);
} }
return new MultiDoku(List.of(sudoku)); return new MultiDoku(Arrays.asList(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) { public static List<IConstraint> fromConstraints(List<Constraint> constraints) {
List<IConstraint> iconstraints = new ArrayList<>(); List<IConstraint> iconstraints = new ArrayList<>();
for (Constraint cons : constraints) { for (Constraint cons : constraints) {

78
app/src/main/java/sudoku/structure/SudokuFiller.java
View File

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

19
app/src/test/java/sudoku/SudokuSerializerTest.java
View File

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

146
app/src/test/java/sudoku/solver/SolverTest.java
View File

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