Compare commits
34 Commits
b9788d6a51
...
refactor
| Author | SHA1 | Date | |
|---|---|---|---|
| b87bd5183e | |||
| a20a5387a7 | |||
| a1032335a5 | |||
| 336d8378ae | |||
| c165ecdae5 | |||
| 352aee49e4 | |||
| f22debdf5f | |||
| 02089c649b | |||
| e98199e1ec | |||
| 438252a8ca | |||
| caf6569409 | |||
| 3863c812c8 | |||
| 6d96455ac4 | |||
| a5c046f891 | |||
|
b7f9ca8a98 | ||
| a160042ef4 | |||
| f47e4cc309 | |||
| 25c2270a37 | |||
| bcded60fbe | |||
| edfffaf061 | |||
| a74bf42e59 | |||
| 1f92c49f3c | |||
| c262007ca8 | |||
| 73f572ee18 | |||
| ec07d88577 | |||
| 6caf5d5c54 | |||
|
696062e9db | ||
|
|
c825807aea | ||
| 39529e0b64 | |||
| 3fa22a4cf0 | |||
| 337911d038 | |||
| 1930bc02bd | |||
| 7789209651 | |||
| 9b776d4b0f |
BIN
app/background.png
Normal file
BIN
app/background.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 399 KiB |
@@ -11,6 +11,8 @@ plugins {
|
||||
id 'application'
|
||||
}
|
||||
|
||||
project.ext.os = System.properties['os.name'].toLowerCase().split(" ")[0]
|
||||
|
||||
repositories {
|
||||
// Use Maven Central for resolving dependencies.
|
||||
mavenCentral()
|
||||
@@ -20,27 +22,30 @@ dependencies {
|
||||
// Use JUnit Jupiter for testing.
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter:5.9.1'
|
||||
|
||||
// This dependency is used by the application.
|
||||
implementation 'com.google.guava:guava:31.1-jre'
|
||||
|
||||
// uml
|
||||
implementation 'com.github.javaparser:javaparser-symbol-solver-core:3.26.2'
|
||||
|
||||
implementation 'org.json:json:20250107'
|
||||
|
||||
implementation 'com.fasterxml.jackson.core:jackson-databind:2.18.2'
|
||||
|
||||
implementation "io.github.spair:imgui-java-app:1.88.0"
|
||||
|
||||
implementation "org.lwjgl:lwjgl-stb:3.3.4"
|
||||
|
||||
runtimeOnly "org.lwjgl:lwjgl-stb::natives-$os"
|
||||
}
|
||||
|
||||
application {
|
||||
// Define the main class for the application.
|
||||
mainClass = 'gui.Main'
|
||||
mainClass = 'org.polytech.ryuk.gui.Main'
|
||||
}
|
||||
|
||||
tasks.named('test') {
|
||||
// Use JUnit Platform for unit tests.
|
||||
useJUnitPlatform()
|
||||
// Add libraries into the final jar
|
||||
jar {
|
||||
archiveBaseName = rootProject.getName()
|
||||
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
|
||||
manifest {
|
||||
attributes "Main-Class": application.mainClass
|
||||
}
|
||||
from {
|
||||
configurations.compileClasspath.collect { it.isDirectory() ? it : zipTree(it) }
|
||||
}
|
||||
}
|
||||
|
||||
run {
|
||||
|
||||
572
app/save/save-1.json
Normal file
572
app/save/save-1.json
Normal file
@@ -0,0 +1,572 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"blockID": 0,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 2
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": 0
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"immutable": true,
|
||||
"symbolIndex": 5
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"immutable": true,
|
||||
"symbolIndex": 7
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"immutable": true,
|
||||
"symbolIndex": 2
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 2
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 5
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"immutable": true,
|
||||
"symbolIndex": 7
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 5
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"immutable": true,
|
||||
"symbolIndex": 5
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 0
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 7
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
}
|
||||
],
|
||||
"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
|
||||
]
|
||||
}]
|
||||
}
|
||||
572
app/save/save.json
Normal file
572
app/save/save.json
Normal file
@@ -0,0 +1,572 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"blockID": 0,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 2
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 0,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"immutable": true,
|
||||
"symbolIndex": 5
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 1,
|
||||
"immutable": true,
|
||||
"symbolIndex": 7
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"immutable": true,
|
||||
"symbolIndex": 2
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 2,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 2
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 5
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 3,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"immutable": true,
|
||||
"symbolIndex": 7
|
||||
},
|
||||
{
|
||||
"blockID": 4,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 5
|
||||
},
|
||||
{
|
||||
"blockID": 5,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 4
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"immutable": true,
|
||||
"symbolIndex": 5
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 3
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 6
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"immutable": true,
|
||||
"symbolIndex": 0
|
||||
},
|
||||
{
|
||||
"blockID": 6,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"immutable": true,
|
||||
"symbolIndex": 7
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 7,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"immutable": true,
|
||||
"symbolIndex": 1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"symbolIndex": -1
|
||||
},
|
||||
{
|
||||
"blockID": 8,
|
||||
"immutable": true,
|
||||
"symbolIndex": 8
|
||||
}
|
||||
],
|
||||
"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
|
||||
]
|
||||
}]
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
package game;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import sudoku.structure.MultiDoku;
|
||||
|
||||
public class Game {
|
||||
|
||||
public static enum GameState {
|
||||
GameNotStarted, GameGoing, GameEnd
|
||||
}
|
||||
|
||||
private final Map<Integer, Player> players;
|
||||
private GameState gameState;
|
||||
private MultiDoku doku;
|
||||
|
||||
public Game() {
|
||||
this.players = new HashMap<>();
|
||||
this.gameState = GameState.GameNotStarted;
|
||||
}
|
||||
|
||||
public Player getPlayerById(int id) {
|
||||
return players.get(id);
|
||||
}
|
||||
|
||||
public void addPlayer(Player player) {
|
||||
players.put(player.getId(), player);
|
||||
}
|
||||
|
||||
public void removePlayer(int id) {
|
||||
players.remove(id);
|
||||
}
|
||||
|
||||
public Map<Integer, Player> getPlayers() {
|
||||
return players;
|
||||
}
|
||||
|
||||
public void startGame(MultiDoku doku) {
|
||||
this.doku = doku;
|
||||
this.gameState = GameState.GameGoing;
|
||||
}
|
||||
|
||||
public GameState getGameState() {
|
||||
return gameState;
|
||||
}
|
||||
|
||||
public MultiDoku getDoku() {
|
||||
return doku;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
package gui;
|
||||
|
||||
import imgui.ImFont;
|
||||
import imgui.ImGui;
|
||||
|
||||
public class Fonts {
|
||||
|
||||
public static ImFont ARIAL;
|
||||
public static ImFont ARIAL_BOLD;
|
||||
public static ImFont CHERI;
|
||||
public static ImFont COMIC;
|
||||
public static ImFont INFECTED;
|
||||
|
||||
private static final String baseDir = "";
|
||||
|
||||
public static void createFonts() {
|
||||
COMIC = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "comic.ttf", 50.0f);
|
||||
ARIAL_BOLD = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "arial_bold.ttf", 50.0f);
|
||||
ARIAL = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "arial.ttf", 50.0f);
|
||||
CHERI = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "cheri.ttf", 50.0f);
|
||||
INFECTED = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "INFECTED.ttf", 50.0f);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
package gui.menu;
|
||||
|
||||
import gui.SudokuRenderer;
|
||||
import imgui.ImGui;
|
||||
import network.client.Client;
|
||||
import network.server.Server;
|
||||
|
||||
public class MultiPlayerDokuView extends BaseView{
|
||||
|
||||
private final Client client;
|
||||
private final Server server;
|
||||
private final SudokuRenderer sudokuRenderer;
|
||||
|
||||
public MultiPlayerDokuView(StateMachine stateMachine, Client client, Server server) {
|
||||
super(stateMachine);
|
||||
this.client = client;
|
||||
this.server = server;
|
||||
this.sudokuRenderer = new SudokuRenderer(this.client.getGame().getDoku());
|
||||
this.client.onDisconnect.connect(this::onDisconnect);
|
||||
}
|
||||
|
||||
public void onDisconnect() {
|
||||
if (server == null) {
|
||||
closeMenu();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void render() {
|
||||
this.sudokuRenderer.render();
|
||||
if (ImGui.button("Quitter")) {
|
||||
this.client.stop();
|
||||
this.closeMenu(3);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
package gui.menu;
|
||||
|
||||
import imgui.ImGui;
|
||||
|
||||
public class OptionsMenu extends BaseView {
|
||||
|
||||
public OptionsMenu(StateMachine stateMachine) {
|
||||
super(stateMachine);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void render() {
|
||||
// TODO Auto-generated method stub
|
||||
ImGui.text("Options");
|
||||
renderReturnButton();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
package network.client;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.Socket;
|
||||
import java.net.UnknownHostException;
|
||||
|
||||
import game.Player;
|
||||
import network.Connexion;
|
||||
import network.protocol.packets.ConnexionInfoPacket;
|
||||
import network.protocol.packets.DisconnectPacket;
|
||||
import network.protocol.packets.KeepAlivePacket;
|
||||
import network.protocol.packets.LoginPacket;
|
||||
import network.protocol.packets.PlayerJoinPacket;
|
||||
import network.protocol.packets.PlayerLeavePacket;
|
||||
import network.protocol.packets.StartGamePacket;
|
||||
import sudoku.io.SudokuSerializer;
|
||||
|
||||
public class ClientConnexion extends Connexion {
|
||||
|
||||
private final Client client;
|
||||
private Player player = null;
|
||||
|
||||
public ClientConnexion(String address, short port, Client client) throws UnknownHostException, IOException {
|
||||
super(new Socket(address, port));
|
||||
this.client = client;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
if (!this.isClosed()) {
|
||||
super.close();
|
||||
client.onDisconnect.emit();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(ConnexionInfoPacket packet) {
|
||||
this.player = this.client.getGame().getPlayerById(packet.getConnectionId());
|
||||
client.onConnect.emit();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(KeepAlivePacket packet) {
|
||||
// we just send the packet back to the server
|
||||
sendPacket(packet);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(DisconnectPacket packet) {
|
||||
this.client.disconnectReason = packet.getReason();
|
||||
close();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(LoginPacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketLogin'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(PlayerJoinPacket packet) {
|
||||
this.client.addPlayer(packet.getPlayer());
|
||||
System.out.println("[Client] " + packet.getPlayer().getPseudo() + " joined the game !");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(PlayerLeavePacket packet) {
|
||||
this.client.getGame().removePlayer(packet.getPlayer());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(StartGamePacket packet) {
|
||||
this.client.getGame().startGame(SudokuSerializer.deserializeSudoku(packet.getSerializedSudoku()));
|
||||
this.client.onGameStarted.emit();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package network.protocol;
|
||||
|
||||
import network.protocol.packets.ConnexionInfoPacket;
|
||||
import network.protocol.packets.DisconnectPacket;
|
||||
import network.protocol.packets.KeepAlivePacket;
|
||||
import network.protocol.packets.LoginPacket;
|
||||
import network.protocol.packets.PlayerJoinPacket;
|
||||
import network.protocol.packets.PlayerLeavePacket;
|
||||
import network.protocol.packets.StartGamePacket;
|
||||
|
||||
public interface PacketVisitor {
|
||||
|
||||
default void visitPacket(Packet packet) {
|
||||
packet.accept(this);
|
||||
}
|
||||
|
||||
void visitPacket(ConnexionInfoPacket packet);
|
||||
void visitPacket(DisconnectPacket packet);
|
||||
void visitPacket(KeepAlivePacket packet);
|
||||
void visitPacket(LoginPacket packet);
|
||||
void visitPacket(PlayerJoinPacket packet);
|
||||
void visitPacket(PlayerLeavePacket packet);
|
||||
void visitPacket(StartGamePacket packet);
|
||||
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
package network.protocol;
|
||||
|
||||
public enum Packets {
|
||||
|
||||
ConnectionInfo, KeepAlive, Disconnect, Login, PlayerJoin, PlayerLeave, StartGame
|
||||
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
package network.protocol.packets;
|
||||
|
||||
import network.protocol.Packet;
|
||||
import network.protocol.PacketVisitor;
|
||||
import network.protocol.Packets;
|
||||
|
||||
public class StartGamePacket extends Packet {
|
||||
|
||||
static private final long serialVersionUID = Packets.StartGame.ordinal();
|
||||
|
||||
private final String serializedSudoku;
|
||||
|
||||
public StartGamePacket(String serializedSudoku) {
|
||||
this.serializedSudoku = serializedSudoku;
|
||||
}
|
||||
|
||||
public String getSerializedSudoku() {
|
||||
return serializedSudoku;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(PacketVisitor packetVisitor) {
|
||||
packetVisitor.visitPacket(this);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,105 +0,0 @@
|
||||
package network.server;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.Socket;
|
||||
|
||||
import game.Player;
|
||||
import game.Game.GameState;
|
||||
import network.Connexion;
|
||||
import network.protocol.packets.ConnexionInfoPacket;
|
||||
import network.protocol.packets.DisconnectPacket;
|
||||
import network.protocol.packets.KeepAlivePacket;
|
||||
import network.protocol.packets.LoginPacket;
|
||||
import network.protocol.packets.PlayerJoinPacket;
|
||||
import network.protocol.packets.PlayerLeavePacket;
|
||||
import network.protocol.packets.StartGamePacket;
|
||||
import sudoku.io.SudokuSerializer;
|
||||
|
||||
public class ServerConnexion extends Connexion {
|
||||
|
||||
private final Server server;
|
||||
private final KeepAliveHandler keepAliveHandler;
|
||||
private boolean shouldClose = false;
|
||||
private Player player = null;
|
||||
|
||||
public ServerConnexion(Socket socket, Server server) throws IOException {
|
||||
super(socket);
|
||||
this.server = server;
|
||||
this.keepAliveHandler = new KeepAliveHandler(this);
|
||||
}
|
||||
|
||||
public boolean update() {
|
||||
if (shouldClose | isClosed())
|
||||
return false;
|
||||
return this.keepAliveHandler.update();
|
||||
}
|
||||
|
||||
public void nukeConnection() {
|
||||
if (player != null) {
|
||||
sendPacket(new DisconnectPacket("Le serveur a été fermé !"));
|
||||
this.server.broadcastPacket(new PlayerLeavePacket(player.getId()));
|
||||
this.server.getGame().removePlayer(player.getId());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public synchronized void close() {
|
||||
if(shouldClose)
|
||||
return;
|
||||
super.close();
|
||||
shouldClose = true;
|
||||
System.out.println("[Server] Closing connexion !");
|
||||
}
|
||||
|
||||
private void finishLogin() {
|
||||
// send players that have already joined (excluding this one)
|
||||
for (Player p : this.server.getGame().getPlayers().values()) {
|
||||
if (p.getId() != player.getId())
|
||||
sendPacket(new PlayerJoinPacket(p));
|
||||
}
|
||||
this.server.broadcastPacket(new PlayerJoinPacket(player));
|
||||
sendPacket(new ConnexionInfoPacket(player.getId()));
|
||||
if (this.server.getGame().getGameState() == GameState.GameGoing) {
|
||||
sendPacket(new StartGamePacket(SudokuSerializer.serializeSudoku(this.server.getGame().getDoku()).toString()));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(KeepAlivePacket packet) {
|
||||
this.keepAliveHandler.recievedKeepAlive(packet.getKeepAliveId());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(DisconnectPacket packet) {
|
||||
close();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(LoginPacket packet) {
|
||||
if (this.player != null)
|
||||
return;
|
||||
this.player = this.server.addPlayer(packet.getPseudo());
|
||||
finishLogin();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(ConnexionInfoPacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketConnexionInfo'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(PlayerJoinPacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketPlayerJoin'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(PlayerLeavePacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketPlayerLeave'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(StartGamePacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketStartGame'");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package org.polytech.ryuk.common;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
public class ConsumerSignal<T> {
|
||||
private final Set<Consumer<T>> listeners;
|
||||
|
||||
public ConsumerSignal() {
|
||||
this.listeners = new HashSet<>();
|
||||
}
|
||||
|
||||
public void connect(Consumer<T> listener) {
|
||||
this.listeners.add(listener);
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
this.listeners.clear();
|
||||
}
|
||||
|
||||
public void emit(T arg) {
|
||||
for (Consumer<T> listener : this.listeners) {
|
||||
listener.accept(arg);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package common;
|
||||
package org.polytech.ryuk.common;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
86
app/src/main/java/org/polytech/ryuk/game/Game.java
Normal file
86
app/src/main/java/org/polytech/ryuk/game/Game.java
Normal file
@@ -0,0 +1,86 @@
|
||||
package org.polytech.ryuk.game;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
public class Game {
|
||||
|
||||
public static enum GameState {
|
||||
GameNotStarted, GameGoing
|
||||
}
|
||||
|
||||
private final Map<Integer, Player> players;
|
||||
private final List<Player> leaderboard;
|
||||
private GameState gameState;
|
||||
private MultiDoku doku;
|
||||
private Instant startTime = null;
|
||||
private long gameDuration;
|
||||
|
||||
public Game() {
|
||||
this.players = new HashMap<>();
|
||||
this.leaderboard = new ArrayList<>();
|
||||
this.gameState = GameState.GameNotStarted;
|
||||
}
|
||||
|
||||
public Player getPlayerById(int id) {
|
||||
return players.get(id);
|
||||
}
|
||||
|
||||
public void addPlayer(Player player) {
|
||||
players.put(player.getId(), player);
|
||||
leaderboard.add(player);
|
||||
}
|
||||
|
||||
public void setPlayerRemainingCells(Player player, int newScore) {
|
||||
player.setRemainingCells(newScore);
|
||||
Collections.sort(this.leaderboard,
|
||||
(player1, player2) -> Integer.compare(player1.getRemainingCells(), player2.getRemainingCells()));
|
||||
}
|
||||
|
||||
public void removePlayer(int id) {
|
||||
this.leaderboard.remove(getPlayerById(id));
|
||||
this.players.remove(id);
|
||||
}
|
||||
|
||||
public Map<Integer, Player> getPlayers() {
|
||||
return players;
|
||||
}
|
||||
|
||||
public void startGame(MultiDoku doku, Instant startTime, long gameDuration) {
|
||||
this.doku = doku;
|
||||
this.gameState = GameState.GameGoing;
|
||||
this.startTime = startTime;
|
||||
this.gameDuration = gameDuration;
|
||||
}
|
||||
|
||||
public void stopGame() {
|
||||
this.gameState = GameState.GameNotStarted;
|
||||
}
|
||||
|
||||
public GameState getGameState() {
|
||||
return gameState;
|
||||
}
|
||||
|
||||
public MultiDoku getDoku() {
|
||||
return doku;
|
||||
}
|
||||
|
||||
public List<Player> getLeaderboard() {
|
||||
return leaderboard;
|
||||
}
|
||||
|
||||
public Instant getStartTime() {
|
||||
return startTime;
|
||||
}
|
||||
|
||||
public long getGameDuration() {
|
||||
return gameDuration;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package game;
|
||||
package org.polytech.ryuk.game;
|
||||
|
||||
import java.io.Serializable;
|
||||
|
||||
@@ -8,10 +8,20 @@ public class Player implements Serializable {
|
||||
|
||||
private final String pseudo;
|
||||
private final int id;
|
||||
private int score;
|
||||
|
||||
public Player(int id, String pseudo) {
|
||||
this.pseudo = pseudo;
|
||||
this.id = id;
|
||||
this.score = 0;
|
||||
}
|
||||
|
||||
public int getRemainingCells() {
|
||||
return score;
|
||||
}
|
||||
|
||||
void setRemainingCells(int score) {
|
||||
this.score = score;
|
||||
}
|
||||
|
||||
public String getPseudo() {
|
||||
@@ -0,0 +1,30 @@
|
||||
package org.polytech.ryuk.gui;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.ImVec2;
|
||||
import imgui.flag.ImGuiWindowFlags;
|
||||
|
||||
public class AnimatedBackground {
|
||||
|
||||
private float backgroundOffset = 0;
|
||||
|
||||
private static final float defaultSpeed = 0.05f;
|
||||
|
||||
public AnimatedBackground() {
|
||||
|
||||
}
|
||||
|
||||
public void render() {
|
||||
backgroundOffset += ImGui.getIO().getDeltaTime() * defaultSpeed * Options.BackgroundSpeed;
|
||||
var displaySize = ImGui.getIO().getDisplaySize();
|
||||
ImGui.setNextWindowPos(new ImVec2(0.0f, 0.0f));
|
||||
ImGui.setNextWindowSize(displaySize);
|
||||
ImGui.begin("Background", null, ImGuiWindowFlags.NoDecoration | ImGuiWindowFlags.NoMove
|
||||
| ImGuiWindowFlags.NoSavedSettings | ImGuiWindowFlags.NoBackground
|
||||
| ImGuiWindowFlags.NoBringToFrontOnFocus | ImGuiWindowFlags.NoInputs);
|
||||
ImGui.image(Images.BACKGROUND, displaySize, new ImVec2(backgroundOffset, backgroundOffset),
|
||||
new ImVec2(1.0f + backgroundOffset, 1.0f + backgroundOffset));
|
||||
ImGui.end();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package gui;
|
||||
package org.polytech.ryuk.gui;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
34
app/src/main/java/org/polytech/ryuk/gui/Fonts.java
Normal file
34
app/src/main/java/org/polytech/ryuk/gui/Fonts.java
Normal file
@@ -0,0 +1,34 @@
|
||||
package org.polytech.ryuk.gui;
|
||||
|
||||
import imgui.ImFont;
|
||||
import imgui.ImFontConfig;
|
||||
import imgui.ImFontGlyphRangesBuilder;
|
||||
import imgui.ImGui;
|
||||
|
||||
public class Fonts {
|
||||
|
||||
public static ImFont ARIAL;
|
||||
public static ImFont ARIAL_BOLD;
|
||||
public static ImFont CHERI;
|
||||
public static ImFont COMIC;
|
||||
public static ImFont INFECTED;
|
||||
public static ImFont EMOJIS;
|
||||
|
||||
private static final String baseDir = "";
|
||||
|
||||
public static void createFonts() {
|
||||
ImFontGlyphRangesBuilder builder = new ImFontGlyphRangesBuilder();
|
||||
builder.addRanges(ImGui.getIO().getFonts().getGlyphRangesDefault());
|
||||
builder.addRanges(ImGui.getIO().getFonts().getGlyphRangesCyrillic());
|
||||
// builder.addRanges(ImGui.getIO().getFonts().getGlyphRangesChineseFull());
|
||||
ImFontConfig cfg = new ImFontConfig();
|
||||
cfg.setGlyphRanges(builder.buildRanges());
|
||||
|
||||
COMIC = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "comic.ttf", 50.0f);
|
||||
ARIAL_BOLD = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "arial_bold.ttf", 50.0f);
|
||||
ARIAL = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "arial.ttf", 50.0f, cfg);
|
||||
CHERI = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "cheri.ttf", 50.0f);
|
||||
INFECTED = ImGui.getIO().getFonts().addFontFromFileTTF(baseDir + "INFECTED.ttf", 50.0f);
|
||||
}
|
||||
|
||||
}
|
||||
39
app/src/main/java/org/polytech/ryuk/gui/Images.java
Normal file
39
app/src/main/java/org/polytech/ryuk/gui/Images.java
Normal file
@@ -0,0 +1,39 @@
|
||||
package org.polytech.ryuk.gui;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.stb.STBImage;
|
||||
|
||||
public class Images {
|
||||
|
||||
public static int BACKGROUND;
|
||||
|
||||
private static int loadTexture(String fileName) {
|
||||
int[] width = new int[1];
|
||||
int[] height = new int[1];
|
||||
int[] channelCount = new int[1];
|
||||
|
||||
ByteBuffer pixels = STBImage.stbi_load(fileName, width, height, channelCount, 4);
|
||||
|
||||
int textureID = GL11.glGenTextures();
|
||||
GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureID);
|
||||
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
|
||||
GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1); // Not on WebGL/ES
|
||||
GL11.glPixelStorei(GL11.GL_UNPACK_SKIP_PIXELS, 0); // Not on WebGL/ES
|
||||
GL11.glPixelStorei(GL11.GL_UNPACK_SKIP_ROWS, 0); // Not on WebGL/ES
|
||||
GL11.glPixelStorei(GL11.GL_UNPACK_ROW_LENGTH, 0); // Not on WebGL/ES
|
||||
GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width[0], height[0], 0,
|
||||
GL11.GL_RGBA,
|
||||
GL11.GL_UNSIGNED_BYTE, pixels);
|
||||
GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
|
||||
|
||||
return textureID;
|
||||
}
|
||||
|
||||
public static void loadImages() {
|
||||
BACKGROUND = loadTexture("background.png");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,8 +1,8 @@
|
||||
package gui;
|
||||
package org.polytech.ryuk.gui;
|
||||
|
||||
import org.polytech.ryuk.gui.menu.MainMenu;
|
||||
import org.polytech.ryuk.gui.menu.StateMachine;
|
||||
|
||||
import gui.menu.MainMenu;
|
||||
import gui.menu.StateMachine;
|
||||
import imgui.ImGui;
|
||||
import imgui.app.Application;
|
||||
import imgui.app.Configuration;
|
||||
|
||||
@@ -26,6 +26,12 @@ public class Main extends Application {
|
||||
Fonts.createFonts();
|
||||
stateMachine.pushState(new MainMenu(stateMachine));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void preRun() {
|
||||
super.preRun();
|
||||
Images.loadImages();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void process() {
|
||||
8
app/src/main/java/org/polytech/ryuk/gui/Options.java
Normal file
8
app/src/main/java/org/polytech/ryuk/gui/Options.java
Normal file
@@ -0,0 +1,8 @@
|
||||
package org.polytech.ryuk.gui;
|
||||
|
||||
public class Options {
|
||||
|
||||
public static Symbols Symboles = Symbols.Numbers;
|
||||
public static float BackgroundSpeed = 1.0f;
|
||||
|
||||
}
|
||||
@@ -1,15 +1,15 @@
|
||||
package gui;
|
||||
package org.polytech.ryuk.gui;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import sudoku.structure.Block;
|
||||
import sudoku.structure.Cell;
|
||||
import sudoku.structure.Coordinate;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Block;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.Coordinate;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class RenderableMultidoku {
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
package gui;
|
||||
package org.polytech.ryuk.gui;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.SudokuFactory;;
|
||||
import org.polytech.ryuk.sudoku.constraint.Constraint;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.SudokuFactory;;
|
||||
|
||||
public enum SudokuType {
|
||||
|
||||
83
app/src/main/java/org/polytech/ryuk/gui/Symbols.java
Normal file
83
app/src/main/java/org/polytech/ryuk/gui/Symbols.java
Normal file
@@ -0,0 +1,83 @@
|
||||
package org.polytech.ryuk.gui;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public enum Symbols {
|
||||
|
||||
Numbers("Nombres", getNumbers()),
|
||||
Letters("Lettres", getLetters()),
|
||||
Russian("Cyrilique", getRussian()),
|
||||
Emojis("Emojis (Console uniquement)", getEmojis());
|
||||
|
||||
String displayName;
|
||||
List<String> symbols;
|
||||
|
||||
private Symbols(String displayName, List<String> symbols) {
|
||||
this.symbols = symbols;
|
||||
this.displayName = displayName;
|
||||
}
|
||||
|
||||
public String getDisplayName() {
|
||||
return displayName;
|
||||
}
|
||||
|
||||
public List<String> getSymbols() {
|
||||
return symbols;
|
||||
}
|
||||
|
||||
private static List<String> getNumbers() {
|
||||
List<String> sym = new ArrayList<>();
|
||||
for (int i = 1; i <= 100; i++) {
|
||||
sym.add(Integer.toString(i));
|
||||
}
|
||||
return sym;
|
||||
}
|
||||
|
||||
private static List<String> getLetters() {
|
||||
List<String> sym = new ArrayList<>();
|
||||
for (int i = 0; i < 100; i++) {
|
||||
int currentOffset = i;
|
||||
String letter = "";
|
||||
while (currentOffset >= 26) {
|
||||
letter += Character.toString((char) ('A' + currentOffset % 26));
|
||||
currentOffset /= 26;
|
||||
currentOffset--;
|
||||
}
|
||||
letter += Character.toString((char) ('A' + currentOffset % 26));
|
||||
sym.add(new StringBuilder(letter).reverse().toString());
|
||||
}
|
||||
return sym;
|
||||
}
|
||||
|
||||
private static List<String> getRussian() {
|
||||
List<String> sym = new ArrayList<>();
|
||||
for (int i = 0; i < 100; i++) {
|
||||
sym.add(new String(Character.toChars(0X0400 + i)));
|
||||
}
|
||||
return sym;
|
||||
}
|
||||
|
||||
private static List<String> getEmojis() {
|
||||
List<String> sym = new ArrayList<>();
|
||||
for (int i = 0; i < 100; i++) {
|
||||
sym.add(new String(Character.toChars(0X1F600 + i)));
|
||||
}
|
||||
return sym;
|
||||
}
|
||||
|
||||
private static final String[] symbolNames;
|
||||
|
||||
static {
|
||||
Symbols[] symbols = Symbols.values();
|
||||
symbolNames = new String[symbols.length];
|
||||
for (int i = 0; i < symbols.length; i++) {
|
||||
symbolNames[i] = symbols[i].getDisplayName();
|
||||
}
|
||||
}
|
||||
|
||||
public static String[] getSymbolsNames() {
|
||||
return symbolNames;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package gui.menu;
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import imgui.ImGui;
|
||||
|
||||
@@ -1,11 +1,12 @@
|
||||
package gui.menu;
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.UnknownHostException;
|
||||
|
||||
import org.polytech.ryuk.network.client.Client;
|
||||
import org.polytech.ryuk.network.server.Server;
|
||||
|
||||
import imgui.ImGui;
|
||||
import network.client.Client;
|
||||
import network.server.Server;
|
||||
|
||||
public class ConnexionStatusView extends BaseView {
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import org.polytech.ryuk.game.Player;
|
||||
import org.polytech.ryuk.gui.ColorGenerator;
|
||||
import org.polytech.ryuk.gui.widget.SudokuRenderer;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.ImVec4;
|
||||
|
||||
public class EndGameView extends BaseView {
|
||||
|
||||
private final Player winner;
|
||||
private float time = 0;
|
||||
|
||||
private static final ImVec4 YELLOW = new ImVec4(1, 1, 0, 1);
|
||||
|
||||
private final SudokuRenderer sudokuRenderer;
|
||||
|
||||
public EndGameView(StateMachine stateMachine, MultiDoku resolved, Player winner) {
|
||||
super(stateMachine);
|
||||
this.winner = winner;
|
||||
this.sudokuRenderer = new SudokuRenderer(resolved);
|
||||
}
|
||||
|
||||
private ImVec4 getPseudoColor() {
|
||||
time += ImGui.getIO().getDeltaTime();
|
||||
float factor = (float) Math.cos(time);
|
||||
var color = ColorGenerator.hslToRgb(factor * factor, 0.9f, 0.4f);
|
||||
return new ImVec4(color.r, color.g, color.b, 1.0f);
|
||||
}
|
||||
|
||||
private void renderWinText() {
|
||||
String winText = " a gagné !";
|
||||
String text = winner.getPseudo() + winText;
|
||||
float textWidth = ImGui.calcTextSizeX(text);
|
||||
ImGui.setCursorPosX(ImGui.getIO().getDisplaySizeX() / 2.0f - textWidth / 2.0f);
|
||||
ImGui.textColored(getPseudoColor(), winner.getPseudo());
|
||||
ImGui.sameLine();
|
||||
ImGui.textColored(YELLOW, winText);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void render() {
|
||||
renderWinText();
|
||||
this.sudokuRenderer.render();
|
||||
renderReturnButton();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package gui.menu;
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.ImVec2;
|
||||
@@ -1,4 +1,4 @@
|
||||
package gui.menu;
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import org.polytech.ryuk.game.Player;
|
||||
import org.polytech.ryuk.gui.widget.LeaderboardRenderer;
|
||||
import org.polytech.ryuk.gui.widget.MultiPlayerCompleteProgress;
|
||||
import org.polytech.ryuk.gui.widget.SudokuRenderer;
|
||||
import org.polytech.ryuk.gui.widget.TimerRenderer;
|
||||
import org.polytech.ryuk.network.client.Client;
|
||||
import org.polytech.ryuk.network.server.Server;
|
||||
import org.polytech.ryuk.sudoku.solver.BacktrackingSolver;
|
||||
import org.polytech.ryuk.sudoku.solver.Solver;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
import imgui.ImGui;
|
||||
|
||||
public class MultiPlayerDokuView extends BaseView {
|
||||
|
||||
private final Client client;
|
||||
private final Server server;
|
||||
private final SudokuRenderer sudokuRenderer;
|
||||
private final LeaderboardRenderer leaderboardRenderer;
|
||||
private final TimerRenderer timerRenderer;
|
||||
private final MultiPlayerCompleteProgress completeProgress;
|
||||
|
||||
public MultiPlayerDokuView(StateMachine stateMachine, Client client, Server server) {
|
||||
super(stateMachine);
|
||||
this.client = client;
|
||||
this.server = server;
|
||||
this.sudokuRenderer = new SudokuRenderer(this.client.getGame().getDoku());
|
||||
this.leaderboardRenderer = new LeaderboardRenderer(client.getGame(), client.getPlayer());
|
||||
this.sudokuRenderer.onCellChange.connect(this::onCellChange);
|
||||
this.client.onDisconnect.connect(this::onDisconnect);
|
||||
this.client.onGameEnd.connect(this::onGameEnd);
|
||||
this.timerRenderer = new TimerRenderer(this.client.getGame().getStartTime(), this.client.getGame().getGameDuration());
|
||||
this.completeProgress = new MultiPlayerCompleteProgress(this.client.getGame());
|
||||
}
|
||||
|
||||
private void onGameEnd(Player winner) {
|
||||
MultiDoku doku = this.client.getGame().getDoku();
|
||||
doku.clearMutableCells();
|
||||
Solver solver = new BacktrackingSolver();
|
||||
solver.solve(doku);
|
||||
this.stateMachine.overrideState(new EndGameView(stateMachine, doku, winner));
|
||||
}
|
||||
|
||||
private void onCellChange(Cell cell) {
|
||||
this.client.sendCellChange(cell);
|
||||
}
|
||||
|
||||
public void onDisconnect() {
|
||||
if (server == null) {
|
||||
closeMenu();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void render() {
|
||||
this.timerRenderer.render();
|
||||
this.leaderboardRenderer.render();
|
||||
this.completeProgress.render();
|
||||
this.sudokuRenderer.render();
|
||||
if (ImGui.button("Quitter")) {
|
||||
this.client.stop();
|
||||
this.closeMenu(3);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,24 +1,31 @@
|
||||
package gui.menu;
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import java.util.Arrays;
|
||||
import org.polytech.ryuk.game.Player;
|
||||
import org.polytech.ryuk.gui.widget.SudokuSelector;
|
||||
import org.polytech.ryuk.network.client.Client;
|
||||
import org.polytech.ryuk.network.server.Server;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
import game.Player;
|
||||
import imgui.ImGui;
|
||||
import network.client.Client;
|
||||
import network.server.Server;
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.SudokuFactory;
|
||||
import imgui.type.ImInt;
|
||||
|
||||
public class MultiPlayerView extends BaseView {
|
||||
|
||||
private final Client client;
|
||||
private final Server server;
|
||||
|
||||
private final SudokuSelector selector;
|
||||
|
||||
private ImInt gameDurationMinutes = new ImInt(10);
|
||||
|
||||
private MultiDoku doku = null;
|
||||
|
||||
public MultiPlayerView(StateMachine stateMachine, Client client, Server server) {
|
||||
super(stateMachine);
|
||||
this.client = client;
|
||||
this.server = server;
|
||||
this.selector = new SudokuSelector(false, "Sélectionner le sudoku");
|
||||
this.selector.onSelect.connect(this::onSelected);
|
||||
this.client.onDisconnect.connect(this::onDisconnect);
|
||||
this.client.onGameStarted
|
||||
.connect(() -> this.stateMachine.pushState(new MultiPlayerDokuView(stateMachine, client, server)));
|
||||
@@ -34,26 +41,40 @@ public class MultiPlayerView extends BaseView {
|
||||
this.stateMachine.popState();
|
||||
}
|
||||
|
||||
private void onSelected(MultiDoku doku) {
|
||||
this.doku = doku;
|
||||
}
|
||||
|
||||
public void renderGameStatus() {
|
||||
if (this.server == null) {
|
||||
ImGui.text("En attente de l'administrateur du serveur ...");
|
||||
} else {
|
||||
renderTimer();
|
||||
ImGui.beginDisabled(this.doku == null);
|
||||
if (ImGui.button("Démarrer")) {
|
||||
// temp
|
||||
MultiDoku doku = SudokuFactory.createBasicXShapedMultidoku(3, Arrays.asList(Constraint.Diagonal));
|
||||
this.server.startGame(doku);
|
||||
this.server.startGame(this.doku, this.gameDurationMinutes.get() * 60);
|
||||
}
|
||||
ImGui.endDisabled();
|
||||
selector.render();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void render() {
|
||||
private void renderPlayers() {
|
||||
ImGui.text("Joueurs :");
|
||||
{
|
||||
for (Player player : this.client.getGame().getPlayers().values()) {
|
||||
ImGui.bulletText(player.getPseudo());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void renderTimer() {
|
||||
ImGui.inputInt("Temps de la partie (minutes)", gameDurationMinutes);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void render() {
|
||||
renderPlayers();
|
||||
renderGameStatus();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import org.polytech.ryuk.gui.Options;
|
||||
import org.polytech.ryuk.gui.Symbols;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.type.ImInt;
|
||||
|
||||
public class OptionsMenu extends BaseView {
|
||||
|
||||
private ImInt currentValue = new ImInt();
|
||||
private float backgroundSpeed[] = new float[]{Options.BackgroundSpeed};
|
||||
|
||||
public OptionsMenu(StateMachine stateMachine) {
|
||||
super(stateMachine);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void render() {
|
||||
ImGui.text("Options");
|
||||
if(ImGui.combo("Jeu de symboles", currentValue, Symbols.getSymbolsNames())){
|
||||
Options.Symboles = Symbols.values()[currentValue.get()];
|
||||
}
|
||||
if(ImGui.sliderFloat("Vitesse d'animation de l'arrière plan", backgroundSpeed, 0.0f, 10.0f)){
|
||||
Options.BackgroundSpeed = backgroundSpeed[0];
|
||||
}
|
||||
renderReturnButton();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,6 +1,8 @@
|
||||
package gui.menu;
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import org.polytech.ryuk.gui.widget.SudokuSelector;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
import gui.SudokuSelector;
|
||||
import imgui.ImGui;
|
||||
|
||||
public class SoloMenu extends BaseView {
|
||||
@@ -9,12 +11,12 @@ public class SoloMenu extends BaseView {
|
||||
|
||||
public SoloMenu(StateMachine stateMachine) {
|
||||
super(stateMachine);
|
||||
this.sudokuSelector = new SudokuSelector(true);
|
||||
this.sudokuSelector = new SudokuSelector(true, "Résoudre le sudoku");
|
||||
this.sudokuSelector.onSelect.connect(this::pushSudokuState);
|
||||
}
|
||||
|
||||
private void pushSudokuState() {
|
||||
this.stateMachine.pushState(new SudokuView(stateMachine, this.sudokuSelector.getDoku()));
|
||||
private void pushSudokuState(MultiDoku doku) {
|
||||
this.stateMachine.pushState(new SudokuView(stateMachine, doku));
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -1,7 +1,9 @@
|
||||
package gui.menu;
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import java.util.Stack;
|
||||
|
||||
import org.polytech.ryuk.gui.AnimatedBackground;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.ImVec2;
|
||||
import imgui.flag.ImGuiKey;
|
||||
@@ -10,9 +12,11 @@ import imgui.flag.ImGuiWindowFlags;
|
||||
public class StateMachine {
|
||||
|
||||
private final Stack<BaseView> menus;
|
||||
private final AnimatedBackground background;
|
||||
|
||||
public StateMachine() {
|
||||
this.menus = new Stack<>();
|
||||
this.background = new AnimatedBackground();
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
@@ -26,6 +30,11 @@ public class StateMachine {
|
||||
menus.add(menu);
|
||||
}
|
||||
|
||||
public void overrideState(BaseView menu) {
|
||||
menus.getLast().cleanResources();
|
||||
menus.set(menus.size() - 1, menu);
|
||||
}
|
||||
|
||||
public void popState() {
|
||||
menus.getLast().cleanResources();
|
||||
menus.pop();
|
||||
@@ -39,6 +48,7 @@ public class StateMachine {
|
||||
|
||||
public void render() {
|
||||
var displaySize = ImGui.getIO().getDisplaySize();
|
||||
this.background.render();
|
||||
ImGui.setNextWindowPos(new ImVec2(0.0f, 0.0f));
|
||||
ImGui.setNextWindowSize(displaySize);
|
||||
ImGui.begin("##Main Window", null, ImGuiWindowFlags.NoDecoration | ImGuiWindowFlags.NoMove
|
||||
@@ -1,14 +1,17 @@
|
||||
package gui.menu;
|
||||
package org.polytech.ryuk.gui.menu;
|
||||
|
||||
import java.util.Random;
|
||||
import java.util.concurrent.CancellationException;
|
||||
|
||||
import gui.SudokuRenderer;
|
||||
import org.polytech.ryuk.gui.widget.SudokuRenderer;
|
||||
import org.polytech.ryuk.sudoku.io.SudokuSerializer;
|
||||
import org.polytech.ryuk.sudoku.solver.BacktrackingSolver;
|
||||
import org.polytech.ryuk.sudoku.solver.HumanSolver;
|
||||
import org.polytech.ryuk.sudoku.solver.MixedSolver;
|
||||
import org.polytech.ryuk.sudoku.solver.Solver;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.ImGuiStyle;
|
||||
import sudoku.io.SudokuSerializer;
|
||||
import sudoku.solver.Solver;
|
||||
import sudoku.structure.MultiDoku;
|
||||
|
||||
public class SudokuView extends BaseView {
|
||||
|
||||
@@ -66,34 +69,52 @@ public class SudokuView extends BaseView {
|
||||
stopResolve();
|
||||
}
|
||||
|
||||
private void startSolve(Solver solver) {
|
||||
resolveThread = new Thread(() -> {
|
||||
try {
|
||||
solver.solve(this.doku);
|
||||
} catch (CancellationException e) {
|
||||
System.out.println("The user is bored !");
|
||||
}
|
||||
stopResolve();
|
||||
});
|
||||
}
|
||||
|
||||
private void renderSolvePopup() {
|
||||
if (ImGui.beginPopup("solve")) {
|
||||
if (ImGui.button("Résoudre avec backtrace")) {
|
||||
startSolve(new BacktrackingSolver());
|
||||
ImGui.closeCurrentPopup();
|
||||
}
|
||||
if (ImGui.button("Résoudre avec déduction")) {
|
||||
startSolve(new HumanSolver());
|
||||
ImGui.closeCurrentPopup();
|
||||
}
|
||||
if (ImGui.button("Résoudre avec déduction et backtrace")) {
|
||||
startSolve(new MixedSolver());
|
||||
ImGui.closeCurrentPopup();
|
||||
}
|
||||
ImGui.endPopup();
|
||||
}
|
||||
}
|
||||
|
||||
private void renderSolveButton() {
|
||||
if (resolveThread != null)
|
||||
ImGui.beginDisabled();
|
||||
|
||||
boolean beginSolve = false;
|
||||
|
||||
if (!resolved && centeredButton("Résoudre")) {
|
||||
beginSolve = true;
|
||||
if (!this.resolved && centeredButton("Résoudre")) {
|
||||
// beginSolve = true;
|
||||
ImGui.openPopup("solve");
|
||||
}
|
||||
|
||||
if (resolveThread != null)
|
||||
ImGui.endDisabled();
|
||||
|
||||
if (beginSolve) {
|
||||
resolveThread = new Thread(() -> {
|
||||
try {
|
||||
Random rand = new Random();
|
||||
Solver.randomSolve(doku, rand);
|
||||
Thread.sleep(200);
|
||||
} catch (CancellationException | InterruptedException e) {
|
||||
System.out.println("The user is bored !");
|
||||
}
|
||||
stopResolve();
|
||||
});
|
||||
}
|
||||
|
||||
if (resolved) {
|
||||
if (this.resolved) {
|
||||
ImGui.text("Bravo !");
|
||||
}
|
||||
|
||||
renderSolvePopup();
|
||||
}
|
||||
|
||||
private void renderSaveButton() {
|
||||
@@ -0,0 +1,74 @@
|
||||
package org.polytech.ryuk.gui.widget;
|
||||
|
||||
import org.polytech.ryuk.game.Game;
|
||||
import org.polytech.ryuk.game.Player;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.ImVec2;
|
||||
import imgui.ImVec4;
|
||||
import imgui.flag.ImGuiCol;
|
||||
import imgui.flag.ImGuiStyleVar;
|
||||
|
||||
public class LeaderboardRenderer {
|
||||
|
||||
private final Game game;
|
||||
private final Player currentPlayer;
|
||||
|
||||
private final float cellHeight = 75;
|
||||
private final ImVec2 cellSize = new ImVec2(12 * cellHeight, cellHeight);
|
||||
private final ImVec2 rankSize = new ImVec2(cellHeight, cellHeight);
|
||||
private final ImVec2 scoreSize = rankSize;
|
||||
private final ImVec2 nameSize = new ImVec2(cellSize.x - cellHeight * 2.0f, cellHeight);
|
||||
private final ImVec4 cellColorPlayer = new ImVec4(0.20f, 0.67f, 1.0f, 0.5f);
|
||||
private final ImVec4 cellColorEnemy = new ImVec4(1.0f, 0.0f, 0.0f, 0.5f);
|
||||
private final int maxPlayersShowed = 2;
|
||||
|
||||
private final int emptyCellCount;
|
||||
|
||||
public LeaderboardRenderer(Game game, Player player) {
|
||||
this.game = game;
|
||||
this.currentPlayer = player;
|
||||
this.emptyCellCount = game.getDoku().getEmptyCells().size();
|
||||
}
|
||||
|
||||
private void renderRank(int rank) {
|
||||
ImGui.button(Integer.toString(rank), rankSize);
|
||||
}
|
||||
|
||||
private void renderName(String name) {
|
||||
ImGui.button(name, nameSize);
|
||||
}
|
||||
|
||||
private void renderScore(int score) {
|
||||
ImGui.button(Integer.toString(score), scoreSize);
|
||||
}
|
||||
|
||||
private void renderCell(Player player, int rank, ImVec4 color) {
|
||||
ImGui.pushStyleColor(ImGuiCol.Button, color);
|
||||
ImGui.pushStyleColor(ImGuiCol.ButtonHovered, color);
|
||||
ImGui.pushStyleColor(ImGuiCol.ButtonActive, color);
|
||||
ImGui.beginChild(player.getPseudo() + "##" + player.getId(), cellSize);
|
||||
renderRank(rank);
|
||||
ImGui.sameLine();
|
||||
renderName(player.getPseudo());
|
||||
ImGui.sameLine();
|
||||
renderScore(emptyCellCount - player.getRemainingCells());
|
||||
ImGui.endChild();
|
||||
ImGui.popStyleColor(3);
|
||||
}
|
||||
|
||||
public void render() {
|
||||
var displaySize = ImGui.getIO().getDisplaySize();
|
||||
ImGui.setCursorPosX(displaySize.x / 2.0f - cellSize.x / 2.0f);
|
||||
ImGui.beginChild("Leaderboard", new ImVec2(cellSize.x + 15.0f, cellHeight * maxPlayersShowed));
|
||||
ImGui.pushStyleVar(ImGuiStyleVar.ItemSpacing, new ImVec2());
|
||||
ImGui.pushStyleVar(ImGuiStyleVar.FrameBorderSize, 3.0f);
|
||||
for (int i = 0; i < game.getLeaderboard().size(); i++) {
|
||||
Player player = game.getLeaderboard().get(i);
|
||||
renderCell(player, i + 1, player == currentPlayer ? cellColorPlayer : cellColorEnemy);
|
||||
}
|
||||
ImGui.popStyleVar(2);
|
||||
ImGui.endChild();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package org.polytech.ryuk.gui.widget;
|
||||
|
||||
import org.polytech.ryuk.game.Game;
|
||||
import org.polytech.ryuk.game.Player;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.ImVec2;
|
||||
|
||||
public class MultiPlayerCompleteProgress {
|
||||
|
||||
private final Game game;
|
||||
private final int emptyCellCount;
|
||||
private final ImVec2 progressSize = new ImVec2(700, 50);
|
||||
private final SmoothProgressBar progressBar;
|
||||
|
||||
public MultiPlayerCompleteProgress(Game game) {
|
||||
this.game = game;
|
||||
this.emptyCellCount = game.getDoku().getEmptyCells().size();
|
||||
this.progressBar = new SmoothProgressBar();
|
||||
}
|
||||
|
||||
public void render() {
|
||||
Player firstPlayer = game.getLeaderboard().getFirst();
|
||||
ImGui.setCursorPosX(ImGui.getIO().getDisplaySizeX() / 2.0f - progressSize.x / 2.0f);
|
||||
String progressText = firstPlayer.getPseudo() + " - " + (emptyCellCount - firstPlayer.getRemainingCells()) + "/" + emptyCellCount;
|
||||
this.progressBar.render(progressText, progressSize, 1.0f - firstPlayer.getRemainingCells() / (float) emptyCellCount);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
package org.polytech.ryuk.gui.widget;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.ImVec2;
|
||||
|
||||
public class SmoothProgressBar {
|
||||
|
||||
private float lastProgress = 0;
|
||||
private final float speed = 2.0f;
|
||||
private final float clipConstant = 0.001f;
|
||||
|
||||
public void render(String label, ImVec2 size, float progress) {
|
||||
float delta = progress - lastProgress;
|
||||
if (Math.abs(delta) < clipConstant)
|
||||
lastProgress = progress;
|
||||
else
|
||||
lastProgress = lastProgress + delta * ImGui.getIO().getDeltaTime() * speed;
|
||||
ImGui.progressBar(lastProgress, size, label);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package gui;
|
||||
package org.polytech.ryuk.gui.widget;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
@@ -6,18 +6,25 @@ import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import common.Signal;
|
||||
import gui.ColorGenerator.Color;
|
||||
import org.polytech.ryuk.common.ConsumerSignal;
|
||||
import org.polytech.ryuk.common.Signal;
|
||||
import org.polytech.ryuk.gui.ColorGenerator;
|
||||
import org.polytech.ryuk.gui.ColorGenerator.Color;
|
||||
import org.polytech.ryuk.gui.Fonts;
|
||||
import org.polytech.ryuk.gui.Options;
|
||||
import org.polytech.ryuk.gui.RenderableMultidoku;
|
||||
import org.polytech.ryuk.gui.Symbols;
|
||||
import org.polytech.ryuk.sudoku.constraint.Constraint;
|
||||
import org.polytech.ryuk.sudoku.structure.Block;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.ImVec2;
|
||||
import imgui.ImVec4;
|
||||
import imgui.flag.ImGuiCol;
|
||||
import imgui.flag.ImGuiStyleVar;
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.structure.Block;
|
||||
import sudoku.structure.Cell;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.Sudoku;
|
||||
|
||||
public class SudokuRenderer {
|
||||
|
||||
@@ -33,6 +40,7 @@ public class SudokuRenderer {
|
||||
private final Set<Cell> diagonals = new HashSet<>();
|
||||
|
||||
public final Signal onResolve = new Signal();
|
||||
public final ConsumerSignal<Cell> onCellChange = new ConsumerSignal<>();
|
||||
|
||||
public SudokuRenderer(MultiDoku doku) {
|
||||
this.doku = RenderableMultidoku.fromMultidoku(doku);
|
||||
@@ -72,11 +80,13 @@ public class SudokuRenderer {
|
||||
if (currentCell.getSymbolIndex() == i) {
|
||||
if (ImGui.button("X", cellSize)) {
|
||||
currentCell.setSymbolIndex(Cell.NOSYMBOL);
|
||||
this.onCellChange.emit(currentCell);
|
||||
ImGui.closeCurrentPopup();
|
||||
}
|
||||
} else {
|
||||
if (ImGui.button(Integer.toString(i + 1), cellSize)) {
|
||||
currentCell.trySetValue(i);
|
||||
if (ImGui.button(Options.Symboles.getSymbols().get(i), cellSize)) {
|
||||
if (currentCell.trySetValue(i))
|
||||
this.onCellChange.emit(currentCell);
|
||||
if (this.doku.getDoku().isSolved())
|
||||
this.onResolve.emit();
|
||||
ImGui.closeCurrentPopup();
|
||||
@@ -88,6 +98,9 @@ public class SudokuRenderer {
|
||||
}
|
||||
|
||||
public void render() {
|
||||
if (Options.Symboles == Symbols.Russian) {
|
||||
ImGui.pushFont(Fonts.ARIAL);
|
||||
}
|
||||
final float sudokuViewWidth = cellSize.x * doku.getWidth();
|
||||
final float displayWidth = ImGui.getIO().getDisplaySizeX();
|
||||
float offsetX = displayWidth / 2.0f - sudokuViewWidth / 2.0f;
|
||||
@@ -95,7 +108,7 @@ public class SudokuRenderer {
|
||||
if (offsetX > 0) {
|
||||
ImGui.setCursorPosX(offsetX);
|
||||
}
|
||||
ImGui.beginChild(1, new ImVec2(cellSize.x * doku.getWidth(), cellSize.y * doku.getHeight()));
|
||||
ImGui.beginChild("sudokuChild", new ImVec2(cellSize.x * doku.getWidth(), cellSize.y * doku.getHeight()));
|
||||
|
||||
ImGui.pushStyleVar(ImGuiStyleVar.FrameBorderSize, 2.0f);
|
||||
ImGui.pushStyleVar(ImGuiStyleVar.ItemSpacing, new ImVec2(0.0f, 0.0f));
|
||||
@@ -123,7 +136,7 @@ public class SudokuRenderer {
|
||||
ImGui.pushStyleColor(ImGuiCol.Button, new ImVec4(blockColor.r, blockColor.g, blockColor.b, 1.0f));
|
||||
String cellText = "";
|
||||
if (symbol != -1)
|
||||
cellText += Integer.toString(symbol + 1);
|
||||
cellText += Options.Symboles.getSymbols().get(symbol);
|
||||
if (ImGui.button(cellText + "##" + index, cellSize) && cell.isMutable()) {
|
||||
ImGui.openPopup("editPopup");
|
||||
currentCell = cell;
|
||||
@@ -135,6 +148,9 @@ public class SudokuRenderer {
|
||||
ImGui.popStyleVar(2);
|
||||
renderPopup();
|
||||
ImGui.endChild();
|
||||
if (Options.Symboles == Symbols.Russian) {
|
||||
ImGui.popFont();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,22 +1,24 @@
|
||||
package gui;
|
||||
package org.polytech.ryuk.gui.widget;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import common.Signal;
|
||||
import org.polytech.ryuk.common.ConsumerSignal;
|
||||
import org.polytech.ryuk.gui.SudokuType;
|
||||
import org.polytech.ryuk.sudoku.constraint.Constraint;
|
||||
import org.polytech.ryuk.sudoku.structure.Difficulty;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.SudokuFactory;
|
||||
|
||||
import imgui.ImGui;
|
||||
import imgui.extension.imguifiledialog.ImGuiFileDialog;
|
||||
import imgui.extension.imguifiledialog.flag.ImGuiFileDialogFlags;
|
||||
import imgui.type.ImBoolean;
|
||||
import imgui.type.ImInt;
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.structure.Difficulty;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.SudokuFactory;
|
||||
|
||||
public class SudokuSelector {
|
||||
|
||||
public final Signal onSelect = new Signal();
|
||||
public final ConsumerSignal<MultiDoku> onSelect = new ConsumerSignal<>();
|
||||
private MultiDoku doku;
|
||||
|
||||
private final boolean canGenEmptyGrid;
|
||||
@@ -26,16 +28,16 @@ public class SudokuSelector {
|
||||
private final ImInt difficulty = new ImInt(Difficulty.Medium.ordinal());
|
||||
private final List<ImBoolean> contraints = new ArrayList<>();
|
||||
|
||||
private static final String[] sudokuTypes = { "Carré", "Rectangle", "Multidoku" };
|
||||
private static final int SQUARE = 0, RECTANGLE = 1, MULTIDOKU = 2;
|
||||
|
||||
private final ImInt sudokuSize = new ImInt(3);
|
||||
|
||||
private final ImInt sudokuWidth = new ImInt(3);
|
||||
private final ImInt sudokuHeight = new ImInt(3);
|
||||
|
||||
public SudokuSelector(boolean canGenEmptyGrid) {
|
||||
private final String confirmMessage;
|
||||
|
||||
public SudokuSelector(boolean canGenEmptyGrid, String confirmMessage) {
|
||||
this.canGenEmptyGrid = canGenEmptyGrid;
|
||||
this.confirmMessage = confirmMessage;
|
||||
initConstraints();
|
||||
}
|
||||
|
||||
@@ -63,7 +65,7 @@ public class SudokuSelector {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
this.onSelect.emit();
|
||||
this.onSelect.emit(this.doku);
|
||||
}
|
||||
|
||||
public void renderFileDialog() {
|
||||
@@ -75,7 +77,7 @@ public class SudokuSelector {
|
||||
String filePath = entry.getValue();
|
||||
this.doku = SudokuFactory.fromfile(filePath);
|
||||
if (this.doku != null)
|
||||
this.onSelect.emit();
|
||||
this.onSelect.emit(this.doku);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
@@ -98,7 +100,7 @@ public class SudokuSelector {
|
||||
switch (currentType.getMakerParamCount()) {
|
||||
case 1:
|
||||
ImGui.inputInt("Taille", sudokuSize);
|
||||
if (ImGui.button("Résoudre un sudoku")) {
|
||||
if (ImGui.button(confirmMessage)) {
|
||||
selectSudoku(currentType.createDoku(getConstraints(), sudokuSize.get()), false);
|
||||
}
|
||||
if (canGenEmptyGrid && ImGui.button("Générer une grille vide")) {
|
||||
@@ -109,7 +111,7 @@ public class SudokuSelector {
|
||||
case 2:
|
||||
ImGui.inputInt("Largeur", sudokuHeight);
|
||||
ImGui.inputInt("Longueur", sudokuWidth);
|
||||
if (ImGui.button("Résoudre un sudoku")) {
|
||||
if (ImGui.button(confirmMessage)) {
|
||||
selectSudoku(currentType.createDoku(getConstraints(), sudokuWidth.get(), sudokuHeight.get()),
|
||||
false);
|
||||
}
|
||||
@@ -129,8 +131,4 @@ public class SudokuSelector {
|
||||
renderFileDialog();
|
||||
}
|
||||
|
||||
public MultiDoku getDoku() {
|
||||
return doku;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package org.polytech.ryuk.gui.widget;
|
||||
|
||||
import java.time.Instant;
|
||||
|
||||
import imgui.ImGui;
|
||||
|
||||
public class TimerRenderer {
|
||||
|
||||
private final long endTime;
|
||||
|
||||
public TimerRenderer(Instant startTime, long duration) {
|
||||
this.endTime = startTime.getEpochSecond() + duration;
|
||||
}
|
||||
|
||||
private long getTimeRemaining() {
|
||||
long currentTime = Instant.now().getEpochSecond();
|
||||
return endTime - currentTime;
|
||||
}
|
||||
|
||||
public void render() {
|
||||
long seconds = getTimeRemaining();
|
||||
long minutes = seconds / 60;
|
||||
String text = String.format("%02d:%02d", minutes, seconds % 60);
|
||||
var textSize = ImGui.calcTextSize(text);
|
||||
ImGui.setCursorPosX(ImGui.getIO().getDisplaySizeX() / 2.0f - textSize.x / 2.0f);
|
||||
ImGui.text(text);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,11 +1,11 @@
|
||||
package network;
|
||||
package org.polytech.ryuk.network;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.net.Socket;
|
||||
|
||||
import network.protocol.Packet;
|
||||
import network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
|
||||
public abstract class Connexion implements PacketVisitor {
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
package network;
|
||||
package org.polytech.ryuk.network;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectInputStream;
|
||||
|
||||
import network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
|
||||
public class ConnexionThread extends Thread {
|
||||
|
||||
@@ -22,7 +22,7 @@ public class ConnexionThread extends Thread {
|
||||
// System.out.println(objectInputStream.available());
|
||||
Object o = objectInputStream.readObject();
|
||||
if (o instanceof Packet packet) {
|
||||
connexion.visitPacket(packet);
|
||||
connexion.visit(packet);
|
||||
}
|
||||
} catch (ClassNotFoundException | IOException e) {
|
||||
e.printStackTrace();
|
||||
@@ -1,13 +1,18 @@
|
||||
package network.client;
|
||||
package org.polytech.ryuk.network.client;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.UnknownHostException;
|
||||
import java.util.Random;
|
||||
|
||||
import common.Signal;
|
||||
import game.Game;
|
||||
import game.Player;
|
||||
import network.protocol.packets.LoginPacket;
|
||||
import org.polytech.ryuk.common.ConsumerSignal;
|
||||
import org.polytech.ryuk.common.Signal;
|
||||
import org.polytech.ryuk.game.Game;
|
||||
import org.polytech.ryuk.game.Player;
|
||||
import org.polytech.ryuk.network.protocol.packets.ChangeCellPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.LoginPacket;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class Client {
|
||||
private final ClientConnexion clientConnection;
|
||||
@@ -17,6 +22,9 @@ public class Client {
|
||||
public final Signal onDisconnect = new Signal();
|
||||
public final Signal onClosed = new Signal();
|
||||
public final Signal onGameStarted = new Signal();
|
||||
public final ConsumerSignal<Player> onGameEnd = new ConsumerSignal<>();
|
||||
|
||||
Player player;
|
||||
|
||||
String disconnectReason = null;
|
||||
|
||||
@@ -54,4 +62,20 @@ public class Client {
|
||||
stop();
|
||||
}
|
||||
|
||||
public void sendCellChange(Cell cell) {
|
||||
MultiDoku doku = getGame().getDoku();
|
||||
for (int sudokuIndex = 0; sudokuIndex < doku.getNbSubGrids(); sudokuIndex++) {
|
||||
Sudoku sudoku = doku.getSubGrid(sudokuIndex);
|
||||
int cellIndex = sudoku.getCells().indexOf(cell);
|
||||
if (cellIndex != -1) {
|
||||
this.clientConnection.sendPacket(new ChangeCellPacket(sudokuIndex, cellIndex, cell.getSymbolIndex()));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Player getPlayer() {
|
||||
return player;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
package org.polytech.ryuk.network.client;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.Socket;
|
||||
import java.net.UnknownHostException;
|
||||
|
||||
import org.polytech.ryuk.game.Player;
|
||||
import org.polytech.ryuk.network.Connexion;
|
||||
import org.polytech.ryuk.network.protocol.packets.ChangeCellPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.ConnexionInfoPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.DisconnectPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.EndGamePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.KeepAlivePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.LoginPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.PlayerJoinPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.PlayerLeavePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.StartGamePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.UpdatePlayerScorePacket;
|
||||
import org.polytech.ryuk.sudoku.io.SudokuSerializer;
|
||||
|
||||
public class ClientConnexion extends Connexion {
|
||||
|
||||
private final Client client;
|
||||
|
||||
public ClientConnexion(String address, short port, Client client) throws UnknownHostException, IOException {
|
||||
super(new Socket(address, port));
|
||||
this.client = client;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
if (!this.isClosed()) {
|
||||
super.close();
|
||||
client.onDisconnect.emit();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(ConnexionInfoPacket packet) {
|
||||
this.client.player = this.client.getGame().getPlayerById(packet.getConnectionId());
|
||||
client.onConnect.emit();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(KeepAlivePacket packet) {
|
||||
// we just send the packet back to the server
|
||||
sendPacket(packet);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(DisconnectPacket packet) {
|
||||
this.client.disconnectReason = packet.getReason();
|
||||
close();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(LoginPacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketLogin'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(PlayerJoinPacket packet) {
|
||||
this.client.addPlayer(packet.getPlayer());
|
||||
System.out.println("[Client] " + packet.getPlayer().getPseudo() + " joined the game !");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(PlayerLeavePacket packet) {
|
||||
this.client.getGame().removePlayer(packet.getPlayer());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(StartGamePacket packet) {
|
||||
this.client.getGame().startGame(SudokuSerializer.deserializeSudoku(packet.getSerializedSudoku()),
|
||||
packet.getInstant(), packet.getGameDuration());
|
||||
this.client.onGameStarted.emit();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(EndGamePacket packet) {
|
||||
Player winner = this.client.getGame().getLeaderboard().getFirst();
|
||||
this.client.getGame().stopGame();
|
||||
this.client.onGameEnd.emit(winner);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(UpdatePlayerScorePacket packet) {
|
||||
Player player = this.client.getGame().getPlayerById(packet.getPlayerId());
|
||||
assert (player != null);
|
||||
this.client.getGame().setPlayerRemainingCells(player, packet.getCellsLeft());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(ChangeCellPacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketChangeCell'");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package network.protocol;
|
||||
package org.polytech.ryuk.network.protocol;
|
||||
|
||||
import java.io.Serializable;
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
package org.polytech.ryuk.network.protocol;
|
||||
|
||||
import org.polytech.ryuk.network.protocol.packets.ChangeCellPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.ConnexionInfoPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.DisconnectPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.EndGamePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.KeepAlivePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.LoginPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.PlayerJoinPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.PlayerLeavePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.StartGamePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.UpdatePlayerScorePacket;
|
||||
|
||||
public interface PacketVisitor {
|
||||
|
||||
default void visit(Packet packet) {
|
||||
packet.accept(this);
|
||||
}
|
||||
|
||||
void visitPacket(ConnexionInfoPacket packet);
|
||||
void visitPacket(DisconnectPacket packet);
|
||||
void visitPacket(KeepAlivePacket packet);
|
||||
void visitPacket(LoginPacket packet);
|
||||
void visitPacket(PlayerJoinPacket packet);
|
||||
void visitPacket(PlayerLeavePacket packet);
|
||||
void visitPacket(StartGamePacket packet);
|
||||
void visitPacket(EndGamePacket packet);
|
||||
void visitPacket(UpdatePlayerScorePacket packet);
|
||||
void visitPacket(ChangeCellPacket packet);
|
||||
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
package org.polytech.ryuk.network.protocol;
|
||||
|
||||
public enum Packets {
|
||||
|
||||
ConnectionInfo, KeepAlive, Disconnect, Login, PlayerJoin, PlayerLeave, StartGame, ChangeCell, EndGame, UpdatePlayerScore
|
||||
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class ChangeCellPacket extends Packet {
|
||||
|
||||
static private final long serialVersionUID = Packets.ChangeCell.ordinal();
|
||||
|
||||
private final int sudokuIndex;
|
||||
private final int cellIndex;
|
||||
private final int newValue;
|
||||
|
||||
public ChangeCellPacket(int sudokuIndex, int cellIndex, int newValue) {
|
||||
this.sudokuIndex = sudokuIndex;
|
||||
this.cellIndex = cellIndex;
|
||||
this.newValue = newValue;
|
||||
}
|
||||
|
||||
public int getSudokuIndex() {
|
||||
return sudokuIndex;
|
||||
}
|
||||
|
||||
public int getCellIndex() {
|
||||
return cellIndex;
|
||||
}
|
||||
|
||||
public int getNewValue() {
|
||||
return newValue;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(PacketVisitor packetVisitor) {
|
||||
packetVisitor.visitPacket(this);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,8 +1,8 @@
|
||||
package network.protocol.packets;
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import network.protocol.Packet;
|
||||
import network.protocol.PacketVisitor;
|
||||
import network.protocol.Packets;
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class ConnexionInfoPacket extends Packet {
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package network.protocol.packets;
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import network.protocol.Packet;
|
||||
import network.protocol.PacketVisitor;
|
||||
import network.protocol.Packets;
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class DisconnectPacket extends Packet {
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class EndGamePacket extends Packet {
|
||||
|
||||
static private final long serialVersionUID = Packets.EndGame.ordinal();
|
||||
|
||||
public EndGamePacket() { }
|
||||
|
||||
@Override
|
||||
public void accept(PacketVisitor packetVisitor) {
|
||||
packetVisitor.visitPacket(this);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,8 +1,8 @@
|
||||
package network.protocol.packets;
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import network.protocol.Packet;
|
||||
import network.protocol.PacketVisitor;
|
||||
import network.protocol.Packets;
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class KeepAlivePacket extends Packet {
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package network.protocol.packets;
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import network.protocol.Packet;
|
||||
import network.protocol.PacketVisitor;
|
||||
import network.protocol.Packets;
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class LoginPacket extends Packet {
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
package network.protocol.packets;
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import game.Player;
|
||||
import network.protocol.Packet;
|
||||
import network.protocol.PacketVisitor;
|
||||
import network.protocol.Packets;
|
||||
import org.polytech.ryuk.game.Player;
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class PlayerJoinPacket extends Packet{
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package network.protocol.packets;
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import network.protocol.Packet;
|
||||
import network.protocol.PacketVisitor;
|
||||
import network.protocol.Packets;
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class PlayerLeavePacket extends Packet{
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import java.time.Instant;
|
||||
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class StartGamePacket extends Packet {
|
||||
|
||||
static private final long serialVersionUID = Packets.StartGame.ordinal();
|
||||
|
||||
private final String serializedSudoku;
|
||||
// used to resume game
|
||||
private final Instant instant;
|
||||
private final long gameDuration;
|
||||
|
||||
public StartGamePacket(String serializedSudoku, Instant instant, long gameDuration) {
|
||||
this.serializedSudoku = serializedSudoku;
|
||||
this.instant = instant;
|
||||
this.gameDuration = gameDuration;
|
||||
}
|
||||
|
||||
public String getSerializedSudoku() {
|
||||
return serializedSudoku;
|
||||
}
|
||||
|
||||
public Instant getInstant() {
|
||||
return instant;
|
||||
}
|
||||
|
||||
public long getGameDuration() {
|
||||
return gameDuration;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(PacketVisitor packetVisitor) {
|
||||
packetVisitor.visitPacket(this);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
package org.polytech.ryuk.network.protocol.packets;
|
||||
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.PacketVisitor;
|
||||
import org.polytech.ryuk.network.protocol.Packets;
|
||||
|
||||
public class UpdatePlayerScorePacket extends Packet {
|
||||
|
||||
static private final long serialVersionUID = Packets.UpdatePlayerScore.ordinal();
|
||||
|
||||
private final int playerId;
|
||||
private final int cellsLeft;
|
||||
|
||||
public UpdatePlayerScorePacket(int playerId, int cellsLeft) {
|
||||
this.playerId = playerId;
|
||||
this.cellsLeft = cellsLeft;
|
||||
}
|
||||
|
||||
public int getPlayerId() {
|
||||
return playerId;
|
||||
}
|
||||
|
||||
public int getCellsLeft() {
|
||||
return cellsLeft;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void accept(PacketVisitor packetVisitor) {
|
||||
packetVisitor.visitPacket(this);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,8 +1,8 @@
|
||||
package network.server;
|
||||
package org.polytech.ryuk.network.server;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
import network.protocol.packets.KeepAlivePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.KeepAlivePacket;
|
||||
|
||||
public class KeepAliveHandler {
|
||||
|
||||
@@ -1,16 +1,19 @@
|
||||
package network.server;
|
||||
package org.polytech.ryuk.network.server;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.ServerSocket;
|
||||
import java.time.Instant;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import game.Game;
|
||||
import game.Player;
|
||||
import network.protocol.Packet;
|
||||
import network.protocol.packets.StartGamePacket;
|
||||
import sudoku.io.SudokuSerializer;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.game.Game;
|
||||
import org.polytech.ryuk.game.Game.GameState;
|
||||
import org.polytech.ryuk.game.Player;
|
||||
import org.polytech.ryuk.network.protocol.Packet;
|
||||
import org.polytech.ryuk.network.protocol.packets.EndGamePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.StartGamePacket;
|
||||
import org.polytech.ryuk.sudoku.io.SudokuSerializer;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
public class Server {
|
||||
|
||||
@@ -37,7 +40,16 @@ public class Server {
|
||||
}
|
||||
}
|
||||
|
||||
public void update() {
|
||||
private void checkTimer() {
|
||||
if (getGame() == null || getGame().getGameState() != GameState.GameGoing)
|
||||
return;
|
||||
long now = Instant.now().getEpochSecond();
|
||||
long end = getGame().getStartTime().getEpochSecond() + getGame().getGameDuration();
|
||||
if (now > end)
|
||||
stopGame();
|
||||
}
|
||||
|
||||
private void checkConnexions() {
|
||||
for (var it = connexions.iterator(); it.hasNext();) {
|
||||
ServerConnexion connexion = it.next();
|
||||
if (!connexion.update()) {
|
||||
@@ -48,6 +60,11 @@ public class Server {
|
||||
}
|
||||
}
|
||||
|
||||
public void update() {
|
||||
checkTimer();
|
||||
checkConnexions();
|
||||
}
|
||||
|
||||
public void stop() {
|
||||
this.acceptThread.cancel();
|
||||
this.logicThread.cancel();
|
||||
@@ -68,9 +85,19 @@ public class Server {
|
||||
return game;
|
||||
}
|
||||
|
||||
public void startGame(MultiDoku doku) {
|
||||
this.game.startGame(doku);
|
||||
broadcastPacket(new StartGamePacket(SudokuSerializer.serializeSudoku(doku).toString()));
|
||||
public void startGame(MultiDoku doku, long gameDuration) {
|
||||
Instant now = Instant.now();
|
||||
this.game.startGame(doku, now, gameDuration);
|
||||
for (ServerConnexion connexion : this.connexions) {
|
||||
connexion.setSudoku(doku.clone());
|
||||
}
|
||||
broadcastPacket(new StartGamePacket(SudokuSerializer.serializeSudoku(doku).toString(), now, gameDuration));
|
||||
}
|
||||
|
||||
public void stopGame() {
|
||||
// we don't need to specify the winner since it has to be the first
|
||||
broadcastPacket(new EndGamePacket());
|
||||
getGame().stopGame();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package network.server;
|
||||
package org.polytech.ryuk.network.server;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.Socket;
|
||||
@@ -0,0 +1,167 @@
|
||||
package org.polytech.ryuk.network.server;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.Socket;
|
||||
|
||||
import org.polytech.ryuk.game.Game;
|
||||
import org.polytech.ryuk.game.Game.GameState;
|
||||
import org.polytech.ryuk.game.Player;
|
||||
import org.polytech.ryuk.network.Connexion;
|
||||
import org.polytech.ryuk.network.protocol.packets.ChangeCellPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.ConnexionInfoPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.DisconnectPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.EndGamePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.KeepAlivePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.LoginPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.PlayerJoinPacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.PlayerLeavePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.StartGamePacket;
|
||||
import org.polytech.ryuk.network.protocol.packets.UpdatePlayerScorePacket;
|
||||
import org.polytech.ryuk.sudoku.io.SudokuSerializer;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
public class ServerConnexion extends Connexion {
|
||||
|
||||
private final Server server;
|
||||
private final KeepAliveHandler keepAliveHandler;
|
||||
private boolean shouldClose = false;
|
||||
private Player player = null;
|
||||
private MultiDoku doku;
|
||||
|
||||
public ServerConnexion(Socket socket, Server server) throws IOException {
|
||||
super(socket);
|
||||
this.server = server;
|
||||
this.keepAliveHandler = new KeepAliveHandler(this);
|
||||
}
|
||||
|
||||
public boolean update() {
|
||||
if (shouldClose || isClosed())
|
||||
return false;
|
||||
return this.keepAliveHandler.update();
|
||||
}
|
||||
|
||||
public void nukeConnection() {
|
||||
if (player != null) {
|
||||
sendPacket(new DisconnectPacket("Le serveur a été fermé !"));
|
||||
this.server.broadcastPacket(new PlayerLeavePacket(player.getId()));
|
||||
this.server.getGame().removePlayer(player.getId());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public synchronized void close() {
|
||||
if (shouldClose)
|
||||
return;
|
||||
super.close();
|
||||
shouldClose = true;
|
||||
System.out.println("[Server] Closing connexion !");
|
||||
}
|
||||
|
||||
private void finishLogin() {
|
||||
// send players that have already joined (excluding this one)
|
||||
for (Player p : this.server.getGame().getPlayers().values()) {
|
||||
if (p.getId() != player.getId()) {
|
||||
sendPacket(new PlayerJoinPacket(p));
|
||||
sendPacket(new UpdatePlayerScorePacket(p.getId(), p.getRemainingCells()));
|
||||
}
|
||||
}
|
||||
|
||||
this.server.broadcastPacket(new PlayerJoinPacket(player));
|
||||
sendPacket(new ConnexionInfoPacket(player.getId()));
|
||||
|
||||
Game game = this.server.getGame();
|
||||
|
||||
if (game.getGameState() == GameState.GameGoing) {
|
||||
setSudoku(game.getDoku().clone());
|
||||
sendPacket(
|
||||
new StartGamePacket(SudokuSerializer.serializeSudoku(game.getDoku()).toString(),
|
||||
game.getStartTime(), game.getGameDuration()));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(KeepAlivePacket packet) {
|
||||
this.keepAliveHandler.recievedKeepAlive(packet.getKeepAliveId());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(DisconnectPacket packet) {
|
||||
close();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(LoginPacket packet) {
|
||||
if (this.player != null)
|
||||
return;
|
||||
this.player = this.server.addPlayer(packet.getPseudo());
|
||||
finishLogin();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(ConnexionInfoPacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketConnexionInfo'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(PlayerJoinPacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketPlayerJoin'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(PlayerLeavePacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketPlayerLeave'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(StartGamePacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacketStartGame'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(EndGamePacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacket'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(UpdatePlayerScorePacket packet) {
|
||||
throw new UnsupportedOperationException("Unimplemented method 'visitPacket'");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPacket(ChangeCellPacket packet) {
|
||||
Cell cell = this.doku.getSubGrid(packet.getSudokuIndex()).getCell(packet.getCellIndex());
|
||||
if (cell.getSymbolIndex() == Cell.NOSYMBOL && packet.getNewValue() == Cell.NOSYMBOL)
|
||||
return;
|
||||
if (cell.getSymbolIndex() != Cell.NOSYMBOL && packet.getNewValue() != Cell.NOSYMBOL) {
|
||||
cell.trySetValue(packet.getNewValue());
|
||||
return;
|
||||
}
|
||||
if (cell.getSymbolIndex() != Cell.NOSYMBOL && packet.getNewValue() == Cell.NOSYMBOL) {
|
||||
cell.empty();
|
||||
this.server.getGame().setPlayerRemainingCells(player, player.getRemainingCells() + 1);
|
||||
this.server.broadcastPacket(new UpdatePlayerScorePacket(player.getId(), player.getRemainingCells()));
|
||||
return;
|
||||
}
|
||||
// on rajoute un chiffre à la grille
|
||||
if (cell.trySetValue(packet.getNewValue())) {
|
||||
this.server.getGame().setPlayerRemainingCells(player, player.getRemainingCells() - 1);
|
||||
this.server.broadcastPacket(new UpdatePlayerScorePacket(player.getId(), player.getRemainingCells()));
|
||||
}
|
||||
checkWin();
|
||||
}
|
||||
|
||||
private void checkWin() {
|
||||
if (this.player.getRemainingCells() == 0) {
|
||||
this.server.stopGame();
|
||||
}
|
||||
}
|
||||
|
||||
public void setSudoku(MultiDoku doku) {
|
||||
this.doku = doku;
|
||||
assert (player != null);
|
||||
this.server.getGame().setPlayerRemainingCells(player, this.doku.getEmptyCells().size());
|
||||
this.server.broadcastPacket(new UpdatePlayerScorePacket(player.getId(), player.getRemainingCells()));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package network.server;
|
||||
package org.polytech.ryuk.network.server;
|
||||
|
||||
public class ServerLogicThread extends Thread {
|
||||
|
||||
@@ -19,7 +19,7 @@ public class ServerLogicThread extends Thread {
|
||||
try {
|
||||
Thread.sleep(50);
|
||||
} catch (InterruptedException e) {
|
||||
// e.printStackTrace();
|
||||
e.printStackTrace();
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -1,9 +1,9 @@
|
||||
/*
|
||||
* This Java source file was generated by the Gradle 'init' task.
|
||||
*/
|
||||
package sudoku;
|
||||
package org.polytech.ryuk.sudoku;
|
||||
|
||||
import sudoku.io.ConsoleInterface;
|
||||
import org.polytech.ryuk.sudoku.io.ConsoleInterface;
|
||||
|
||||
public class Main {
|
||||
public String getGreeting() {
|
||||
@@ -1,7 +1,7 @@
|
||||
package sudoku.constraint;
|
||||
package org.polytech.ryuk.sudoku.constraint;
|
||||
|
||||
import sudoku.structure.Block;
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Block;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class BlockConstraint implements IConstraint{
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
package sudoku.constraint;
|
||||
package org.polytech.ryuk.sudoku.constraint;
|
||||
|
||||
import sudoku.structure.Cell;
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class ColumnConstraint implements IConstraint {
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package sudoku.constraint;
|
||||
package org.polytech.ryuk.sudoku.constraint;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public enum Constraint {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
package sudoku.constraint;
|
||||
package org.polytech.ryuk.sudoku.constraint;
|
||||
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class DiagonalConstraint implements IConstraint {
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
package sudoku.constraint;
|
||||
package org.polytech.ryuk.sudoku.constraint;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public interface IConstraint {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
package sudoku.constraint;
|
||||
package org.polytech.ryuk.sudoku.constraint;
|
||||
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class LineConstraint implements IConstraint {
|
||||
|
||||
@@ -1,17 +1,16 @@
|
||||
package sudoku.io;
|
||||
|
||||
import sudoku.constraint.*;
|
||||
import sudoku.solver.Solver;
|
||||
import sudoku.structure.Difficulty;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.Sudoku;
|
||||
import sudoku.structure.SudokuFactory;
|
||||
package org.polytech.ryuk.sudoku.io;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
import java.util.Scanner;
|
||||
|
||||
import org.polytech.ryuk.sudoku.constraint.Constraint;
|
||||
import org.polytech.ryuk.sudoku.solver.RandomSolver;
|
||||
import org.polytech.ryuk.sudoku.structure.Difficulty;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.SudokuFactory;
|
||||
|
||||
public class ConsoleInterface {
|
||||
public Scanner reader = new Scanner(System.in);
|
||||
|
||||
@@ -133,7 +132,7 @@ public class ConsoleInterface {
|
||||
}
|
||||
|
||||
private void generateFullDoku(MultiDoku doku) {
|
||||
Solver.randomSolve(doku, new Random());
|
||||
new RandomSolver().solve(doku);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
package org.polytech.ryuk.sudoku.io;
|
||||
|
||||
public class SudokuFile {
|
||||
|
||||
|
||||
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
package sudoku.io;
|
||||
package org.polytech.ryuk.sudoku.io;
|
||||
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class SudokuPrinter {
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
package sudoku.io;
|
||||
package org.polytech.ryuk.sudoku.io;
|
||||
|
||||
public class SudokuSave {
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
package sudoku.io;
|
||||
package org.polytech.ryuk.sudoku.io;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileWriter;
|
||||
@@ -10,12 +10,11 @@ import java.util.List;
|
||||
|
||||
import org.json.JSONArray;
|
||||
import org.json.JSONObject;
|
||||
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.structure.Block;
|
||||
import sudoku.structure.Cell;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.constraint.Constraint;
|
||||
import org.polytech.ryuk.sudoku.structure.Block;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class SudokuSerializer {
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
package org.polytech.ryuk.sudoku.solver;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CancellationException;
|
||||
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
public class BacktrackingSolver implements Solver {
|
||||
|
||||
/**
|
||||
* Résout le MultiDoku passé en paramètre, avec backtracking.
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku à résoudre.
|
||||
* @return boolean, valant true si le MultiDoku est résolu, false sinon.
|
||||
*/
|
||||
@Override
|
||||
public boolean solve(MultiDoku doku) {
|
||||
if (Thread.interrupted())
|
||||
throw new CancellationException("User wants to stop the solver");
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
Cell cellToFill = doku.getFirstEmptyCell();
|
||||
if (cellToFill == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
|
||||
if (possibleSymbols.isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (int symbol : possibleSymbols) {
|
||||
|
||||
cellToFill.setSymbolIndex(symbol);
|
||||
if (this.solve(doku)) {
|
||||
return true;
|
||||
} else {
|
||||
cellToFill.setSymbolIndex(Cell.NOSYMBOL);
|
||||
}
|
||||
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package org.polytech.ryuk.sudoku.solver;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CancellationException;
|
||||
import java.util.logging.Level;
|
||||
|
||||
import org.polytech.ryuk.sudoku.io.SudokuPrinter;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class HumanSolver implements Solver {
|
||||
|
||||
/**
|
||||
* Résout le MultiDoku passé en paramètre, avec règles de déduction.
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku à résoudre.
|
||||
* @return boolean, valant true si le MultiDoku est résolu, false sinon.
|
||||
*/
|
||||
@Override
|
||||
public boolean solve(MultiDoku doku) {
|
||||
if (Thread.interrupted())
|
||||
throw new CancellationException("User wants to stop the solver");
|
||||
|
||||
Sudoku sudoku = doku.getSubGrid(0);
|
||||
logger.log(Level.FINE,
|
||||
'\n' + SudokuPrinter.toStringRectangleSudoku(sudoku,
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getBlockWidth(),
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getSize() / sudoku.getBlockWidth()));
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
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());
|
||||
|
||||
return this.solve(doku);
|
||||
}
|
||||
|
||||
return doku.isSolved();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
package org.polytech.ryuk.sudoku.solver;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
import java.util.concurrent.CancellationException;
|
||||
import java.util.logging.Level;
|
||||
|
||||
import org.polytech.ryuk.sudoku.io.SudokuPrinter;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class MixedSolver implements Solver{
|
||||
|
||||
/**
|
||||
* Résout le MultiDoku passé en paramètre, avec règles de déduction et
|
||||
* backtracking.
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku à résoudre.
|
||||
* @return boolean, valant true si le MultiDoku est résolu, false sinon.
|
||||
*/
|
||||
@Override
|
||||
public boolean solve(MultiDoku doku) {
|
||||
Random rand = new Random();
|
||||
|
||||
if (Thread.interrupted()) {
|
||||
throw new CancellationException("User wants to stop the solver");
|
||||
}
|
||||
|
||||
Sudoku sudoku = doku.getSubGrid(0);
|
||||
logger.log(Level.FINE,
|
||||
'\n' + SudokuPrinter.toStringRectangleSudoku(
|
||||
sudoku,
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getBlockWidth(),
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getSize() / sudoku.getBlockWidth()));
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
Cell cellToFill = doku.getFirstEmptyCell();
|
||||
if (cellToFill == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
|
||||
|
||||
if (possibleSymbols.size() == 1) {
|
||||
cellToFill.setSymbolIndex(possibleSymbols.getFirst());
|
||||
if (this.solve(doku)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
while (!possibleSymbols.isEmpty()) {
|
||||
int nextPossibleSymbolIndex = rand.nextInt(possibleSymbols.size());
|
||||
int nextSymbol = possibleSymbols.get(nextPossibleSymbolIndex);
|
||||
|
||||
cellToFill.setSymbolIndex(nextSymbol);
|
||||
if (this.solve(doku)) {
|
||||
return true;
|
||||
}
|
||||
cellToFill.setSymbolIndex(Cell.NOSYMBOL);
|
||||
possibleSymbols.remove(nextPossibleSymbolIndex);
|
||||
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
package org.polytech.ryuk.sudoku.solver;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
import java.util.concurrent.CancellationException;
|
||||
import java.util.logging.Level;
|
||||
|
||||
import org.polytech.ryuk.sudoku.io.SudokuPrinter;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
public class RandomSolver implements Solver {
|
||||
|
||||
/**
|
||||
* Résout, si possible, le multidoku passé en paramètre
|
||||
* en testant toutes les possibilités, de manière aléatoire, avec un algorithme
|
||||
* de backtracking.
|
||||
*
|
||||
* @param doku Multidoku, à résoudre
|
||||
* @param rand Random, pour tester aléatoirement les symboles
|
||||
* @return boolean, true s'il est résolu ou false s'il ne l'est pas.
|
||||
*/
|
||||
@Override
|
||||
public boolean solve(MultiDoku doku) {
|
||||
Random rand = new Random();
|
||||
|
||||
if (Thread.interrupted())
|
||||
throw new CancellationException("User wants to stop the solver");
|
||||
|
||||
Sudoku sudoku = doku.getSubGrid(0);
|
||||
logger.log(Level.FINE,
|
||||
'\n' + SudokuPrinter.toStringRectangleSudoku(sudoku,
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getBlockWidth(),
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getSize() / sudoku.getBlockWidth()));
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
Cell cellToFill = doku.getFirstEmptyCell();
|
||||
if (cellToFill == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
|
||||
|
||||
while (!possibleSymbols.isEmpty()) {
|
||||
int nextPossibleSymbolIndex = rand.nextInt(possibleSymbols.size());
|
||||
int nextSymbol = possibleSymbols.get(nextPossibleSymbolIndex);
|
||||
|
||||
cellToFill.setSymbolIndex(nextSymbol);
|
||||
if (this.solve(doku)) {
|
||||
return true;
|
||||
}
|
||||
cellToFill.setSymbolIndex(Cell.NOSYMBOL);
|
||||
possibleSymbols.remove(nextPossibleSymbolIndex);
|
||||
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package org.polytech.ryuk.sudoku.solver;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
|
||||
public interface Solver {
|
||||
|
||||
/**
|
||||
* Log du Solver, qui garde trace des actions réalisées.
|
||||
*/
|
||||
public static final Logger logger = Logger.getLogger("SolverLogger");
|
||||
|
||||
boolean solve(MultiDoku doku);
|
||||
|
||||
/**
|
||||
* Compte le nombre de solutions possibles au MultiDoku passé en paramètres.
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku dont on veut le nombre de solutions.
|
||||
* @return int, nombre de solutions possibles.
|
||||
*/
|
||||
default int countSolution(MultiDoku doku) {
|
||||
int result = 0;
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
Cell cellToFill = doku.getFirstEmptyCell();
|
||||
assert (cellToFill != null);
|
||||
|
||||
List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
|
||||
|
||||
for (int symbol : possibleSymbols) {
|
||||
doku.getStateManager().pushState();
|
||||
cellToFill.setSymbolIndex(symbol);
|
||||
if (solve(doku)) {
|
||||
result++;
|
||||
}
|
||||
doku.getStateManager().popState();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,10 +1,9 @@
|
||||
package sudoku.solver;
|
||||
package org.polytech.ryuk.sudoku.solver;
|
||||
|
||||
import java.util.concurrent.CancellationException;
|
||||
|
||||
import sudoku.structure.Coordinate;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
|
||||
/**
|
||||
* Class de test non utilisé
|
||||
@@ -1,4 +1,4 @@
|
||||
package sudoku.structure;
|
||||
package org.polytech.ryuk.sudoku.structure;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
@@ -1,4 +1,4 @@
|
||||
package sudoku.structure;
|
||||
package org.polytech.ryuk.sudoku.structure;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
@@ -126,6 +126,8 @@ public class Cell {
|
||||
}
|
||||
|
||||
public boolean trySetValue(int newValue) {
|
||||
if (!isMutable())
|
||||
return false;
|
||||
if (!canHaveValue(newValue))
|
||||
return false;
|
||||
setSymbolIndex(newValue);
|
||||
@@ -1,4 +1,4 @@
|
||||
package sudoku.structure;
|
||||
package org.polytech.ryuk.sudoku.structure;
|
||||
|
||||
/**
|
||||
* Représente les coordonnées d'une Cell
|
||||
@@ -1,4 +1,4 @@
|
||||
package sudoku.structure;
|
||||
package org.polytech.ryuk.sudoku.structure;
|
||||
|
||||
//TODO: melvyn va passer par là
|
||||
public enum Difficulty {
|
||||
@@ -1,8 +1,12 @@
|
||||
package sudoku.structure;
|
||||
package org.polytech.ryuk.sudoku.structure;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
import java.util.Set;
|
||||
|
||||
import sudoku.io.SudokuSerializer;
|
||||
import org.polytech.ryuk.sudoku.io.SudokuSerializer;
|
||||
|
||||
/**
|
||||
* @class MultiDoku
|
||||
@@ -178,4 +182,18 @@ public class MultiDoku {
|
||||
int randomIndex = rand.nextInt(emptyCells.size());
|
||||
return emptyCells.get(randomIndex);
|
||||
}
|
||||
|
||||
public void clearMutableCells() {
|
||||
for (Sudoku s : getSubGrids()) {
|
||||
for (Cell cell : s.getCells()) {
|
||||
if (cell.isMutable())
|
||||
cell.clearCurrentSymbol();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public MultiDoku clone() {
|
||||
//TODO: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah
|
||||
return SudokuSerializer.deserializeSudoku(SudokuSerializer.serializeSudoku(this));
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package sudoku.structure;
|
||||
package org.polytech.ryuk.sudoku.structure;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
@@ -1,13 +1,10 @@
|
||||
package sudoku.structure;
|
||||
|
||||
import sudoku.constraint.BlockConstraint;
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.constraint.IConstraint;
|
||||
import sudoku.io.SudokuPrinter;
|
||||
package org.polytech.ryuk.sudoku.structure;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.polytech.ryuk.sudoku.constraint.Constraint;
|
||||
|
||||
/**
|
||||
* @class Sudoku
|
||||
* @brief Représent un Sudoku
|
||||
@@ -1,4 +1,4 @@
|
||||
package sudoku.structure;
|
||||
package org.polytech.ryuk.sudoku.structure;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
@@ -9,10 +9,10 @@ import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Random;
|
||||
|
||||
import sudoku.io.SudokuSerializer;
|
||||
|
||||
import sudoku.constraint.Constraint;
|
||||
import sudoku.solver.Solver;
|
||||
import org.polytech.ryuk.sudoku.constraint.Constraint;
|
||||
import org.polytech.ryuk.sudoku.io.SudokuSerializer;
|
||||
import org.polytech.ryuk.sudoku.solver.RandomSolver;
|
||||
import org.polytech.ryuk.sudoku.solver.Solver;
|
||||
|
||||
public class SudokuFactory {
|
||||
|
||||
@@ -116,7 +116,7 @@ public class SudokuFactory {
|
||||
* @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) throws Exception {
|
||||
public static boolean newDokuFromFilledOne(MultiDoku doku, int nbCellsToEmpty, Solver solver) throws Exception {
|
||||
|
||||
if (nbCellsToEmpty >= doku.getCells().size()) {
|
||||
throw new Exception();
|
||||
@@ -134,9 +134,9 @@ public class SudokuFactory {
|
||||
|
||||
int oldSymbol = cellToEmpty.empty();
|
||||
|
||||
int nbDokuSultions = Solver.countSolution(doku);
|
||||
int nbDokuSultions = solver.countSolution(doku);
|
||||
if (nbDokuSultions == 1) {
|
||||
if (newDokuFromFilledOne(doku, --nbCellsToEmpty)) {
|
||||
if (newDokuFromFilledOne(doku, --nbCellsToEmpty, solver)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -145,7 +145,7 @@ public class SudokuFactory {
|
||||
cellsThatCanBeEmptied.remove(cellToEmpty);
|
||||
}
|
||||
|
||||
return newDokuFromFilledOne(doku, --nbCellsToEmpty);
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -181,21 +181,22 @@ public class SudokuFactory {
|
||||
* @param sudoku2 Sudoku, second sudoku à connecter.
|
||||
* @param offset Coordinate, décalage entre les deux Sudokus.
|
||||
*/
|
||||
private static void linkSquareSudokus(Sudoku sudoku1, Sudoku sudoku2, Coordinate offset) {
|
||||
private static void linkRectangleSudokus(Sudoku sudoku1, Sudoku sudoku2, Coordinate offset) {
|
||||
int blockWidth = sudoku1.getBlockWidth();
|
||||
for (int dx = 0; dx < blockWidth; dx++) {
|
||||
int blockHeight = sudoku1.getSize() / blockWidth;
|
||||
for (int dx = 0; dx < blockHeight; dx++) {
|
||||
for (int dy = 0; dy < blockWidth; dy++) {
|
||||
int block1X = dx + offset.getX();
|
||||
int block1Y = dy + offset.getY();
|
||||
int block2X = dx;
|
||||
int block2Y = dy;
|
||||
|
||||
if ((block1X < blockWidth) && (block1X >= 0) && (block1Y >= 0) && (block1Y < blockWidth)) {
|
||||
Block block1 = sudoku1.getBlocks().get(block1Y * blockWidth + block1X);
|
||||
Block block2 = sudoku2.getBlocks().get(block2Y * blockWidth + block2X);
|
||||
if ((block1X < blockHeight) && (block1X >= 0) && (block1Y >= 0) && (block1Y < blockWidth)) {
|
||||
Block block1 = sudoku1.getBlocks().get(block1Y * blockHeight + block1X);
|
||||
Block block2 = sudoku2.getBlocks().get(block2Y * blockHeight + block2X);
|
||||
|
||||
// on remplace le bloc
|
||||
sudoku2.getBlocks().set(block2Y * blockWidth + block2X, block1);
|
||||
sudoku2.getBlocks().set(block2Y * blockHeight + block2X, block1);
|
||||
block1.getSudokus().add(sudoku2);
|
||||
|
||||
// on remplace les cellules
|
||||
@@ -231,10 +232,10 @@ public class SudokuFactory {
|
||||
Sudoku sudoku4 = createSquareSudoku(size, constraints);
|
||||
Sudoku sudoku5 = createSquareSudoku(size, constraints);
|
||||
|
||||
linkSquareSudokus(sudoku1, sudoku2, new Coordinate(1 - size, 1 - size));
|
||||
linkSquareSudokus(sudoku1, sudoku3, new Coordinate(size - 1, 1 - size));
|
||||
linkSquareSudokus(sudoku1, sudoku4, new Coordinate(1 - size, size - 1));
|
||||
linkSquareSudokus(sudoku1, sudoku5, new Coordinate(size - 1, size - 1));
|
||||
linkRectangleSudokus(sudoku1, sudoku2, new Coordinate(1 - size, 1 - size));
|
||||
linkRectangleSudokus(sudoku1, sudoku3, new Coordinate(size - 1, 1 - size));
|
||||
linkRectangleSudokus(sudoku1, sudoku4, new Coordinate(1 - size, size - 1));
|
||||
linkRectangleSudokus(sudoku1, sudoku5, new Coordinate(size - 1, size - 1));
|
||||
|
||||
return new MultiDoku(Arrays.asList(sudoku1, sudoku2, sudoku3, sudoku4, sudoku5));
|
||||
}
|
||||
@@ -263,21 +264,19 @@ public class SudokuFactory {
|
||||
Sudoku sudoku4 = createRectangleSudoku(width, height, constraints);
|
||||
Sudoku sudoku5 = createRectangleSudoku(width, height, constraints);
|
||||
|
||||
linkSquareSudokus(sudoku1, sudoku2, new Coordinate(1 - width, 1 - height));
|
||||
linkSquareSudokus(sudoku1, sudoku3, new Coordinate(width - 1, 1 - height));
|
||||
linkSquareSudokus(sudoku1, sudoku4, new Coordinate(1 - width, height - 1));
|
||||
linkSquareSudokus(sudoku1, sudoku5, new Coordinate(width - 1, height - 1));
|
||||
linkRectangleSudokus(sudoku1, sudoku2, new Coordinate(1 - height, 1 - width));
|
||||
linkRectangleSudokus(sudoku1, sudoku3, new Coordinate(height - 1, 1 - width));
|
||||
linkRectangleSudokus(sudoku1, sudoku4, new Coordinate(1 - height, width - 1));
|
||||
linkRectangleSudokus(sudoku1, sudoku5, new Coordinate(height - 1, width - 1));
|
||||
|
||||
return new MultiDoku(Arrays.asList(sudoku1, sudoku2, sudoku3, sudoku4, sudoku5));
|
||||
}
|
||||
|
||||
public static void fillDoku(MultiDoku doku, Difficulty difficulty) throws Exception {
|
||||
Solver.randomSolve(doku, random);
|
||||
Solver solver = new RandomSolver();
|
||||
solver.solve(doku);
|
||||
int nbCellsToEmpty = (int) (difficulty.getFactor() * doku.getNbCells());
|
||||
boolean successfull = newDokuFromFilledOne(doku, nbCellsToEmpty);
|
||||
if (!successfull) {
|
||||
throw new Exception("Canno't create this doku with this difficulty");
|
||||
}
|
||||
boolean successfull = newDokuFromFilledOne(doku, nbCellsToEmpty, solver);
|
||||
doku.setFilledCellsImmutable();
|
||||
}
|
||||
|
||||
@@ -1,7 +0,0 @@
|
||||
package sudoku.io;
|
||||
|
||||
public class SudokuFile {
|
||||
|
||||
|
||||
|
||||
}
|
||||
@@ -1,236 +0,0 @@
|
||||
package sudoku.solver;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
import java.util.concurrent.CancellationException;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import sudoku.io.SudokuPrinter;
|
||||
import sudoku.structure.Cell;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.Sudoku;
|
||||
|
||||
public class Solver {
|
||||
|
||||
/**
|
||||
* Log du Solver, qui garde trace des actions réalisées.
|
||||
*/
|
||||
private static final Logger logger = Logger.getLogger("SolverLogger");
|
||||
|
||||
/**
|
||||
* Résout, si possible, le multidoku passé en paramètre
|
||||
* en testant toutes les possibilités, de manière aléatoire, avec un algorithme
|
||||
* de backtracking.
|
||||
*
|
||||
* @param doku Multidoku, à résoudre
|
||||
* @param rand Random, pour tester aléatoirement les symboles
|
||||
* @return boolean, true s'il est résolu ou false s'il ne l'est pas.
|
||||
*/
|
||||
public static boolean randomSolve(MultiDoku doku, Random rand) {
|
||||
if (Thread.interrupted())
|
||||
throw new CancellationException("User wants to stop the solver");
|
||||
|
||||
Sudoku sudoku = doku.getSubGrid(0);
|
||||
logger.log(Level.FINE,
|
||||
'\n' + SudokuPrinter.toStringRectangleSudoku(sudoku,
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getBlockWidth(),
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getSize() / sudoku.getBlockWidth()));
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
Cell cellToFill = doku.getFirstEmptyCell();
|
||||
if (cellToFill == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
|
||||
|
||||
while (!possibleSymbols.isEmpty()) {
|
||||
int nextPossibleSymbolIndex = rand.nextInt(possibleSymbols.size());
|
||||
int nextSymbol = possibleSymbols.get(nextPossibleSymbolIndex);
|
||||
|
||||
cellToFill.setSymbolIndex(nextSymbol);
|
||||
if (Solver.randomSolve(doku, rand)) {
|
||||
return true;
|
||||
}
|
||||
cellToFill.setSymbolIndex(Cell.NOSYMBOL);
|
||||
possibleSymbols.remove(nextPossibleSymbolIndex);
|
||||
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compte le nombre de solutions possibles au MultiDoku passé en paramètres.
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku dont on veut le nombre de solutions.
|
||||
* @return int, nombre de solutions possibles.
|
||||
*/
|
||||
public static int countSolution(MultiDoku doku) {
|
||||
int result = 0;
|
||||
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
Cell cellToFill = doku.getFirstEmptyCell();
|
||||
assert(cellToFill != null);
|
||||
|
||||
List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
|
||||
|
||||
for (int symbol : possibleSymbols) {
|
||||
doku.getStateManager().pushState();
|
||||
cellToFill.setSymbolIndex(symbol);
|
||||
if (Solver.solve(doku)) {
|
||||
result++;
|
||||
}
|
||||
doku.getStateManager().popState();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Résout le MultiDoku passé en paramètre, avec backtracking.
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku à résoudre.
|
||||
* @return boolean, valant true si le MultiDoku est résolu, false sinon.
|
||||
*/
|
||||
public static boolean solve(MultiDoku doku) {
|
||||
if (Thread.interrupted())
|
||||
throw new CancellationException("User wants to stop the solver");
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
Cell cellToFill = doku.getFirstEmptyCell();
|
||||
if (cellToFill == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
|
||||
if (possibleSymbols.isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (int symbol : possibleSymbols) {
|
||||
|
||||
cellToFill.setSymbolIndex(symbol);
|
||||
if (Solver.solve(doku)) {
|
||||
return true;
|
||||
} else {
|
||||
cellToFill.setSymbolIndex(Cell.NOSYMBOL);
|
||||
}
|
||||
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Résout le MultiDoku passé en paramètre, avec règles de déduction.
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku à résoudre.
|
||||
* @return boolean, valant true si le MultiDoku est résolu, false sinon.
|
||||
*/
|
||||
public static boolean humanSolve(MultiDoku doku) {
|
||||
if (Thread.interrupted())
|
||||
throw new CancellationException("User wants to stop the solver");
|
||||
|
||||
Sudoku sudoku = doku.getSubGrid(0);
|
||||
logger.log(Level.FINE,
|
||||
'\n' + SudokuPrinter.toStringRectangleSudoku(sudoku,
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getBlockWidth(),
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getSize() / sudoku.getBlockWidth()));
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
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());
|
||||
|
||||
return Solver.humanSolve(doku);
|
||||
}
|
||||
|
||||
return doku.isSolved();
|
||||
}
|
||||
|
||||
/**
|
||||
* Résout le MultiDoku passé en paramètre, avec règles de déduction et backtracking.
|
||||
*
|
||||
* @param doku MultiDoku, MultiDoku à résoudre.
|
||||
* @param rand Random, pour tester aléatoirement les symboles, lors du backtracking.
|
||||
* @return boolean, valant true si le MultiDoku est résolu, false sinon.
|
||||
*/
|
||||
public static boolean mixedSolve(MultiDoku doku, Random rand) {
|
||||
if (Thread.interrupted()) {
|
||||
throw new CancellationException("User wants to stop the solver");
|
||||
}
|
||||
|
||||
Sudoku sudoku = doku.getSubGrid(0);
|
||||
logger.log(Level.FINE,
|
||||
'\n' + SudokuPrinter.toStringRectangleSudoku(
|
||||
sudoku,
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getBlockWidth(),
|
||||
sudoku.getBlockWidth() == 0 ? sudoku.getSize() : sudoku.getSize() / sudoku.getBlockWidth())
|
||||
);
|
||||
|
||||
if (doku.isSolved()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
List<Cell> cellsToFill = doku.getEmptyCells();
|
||||
if (cellsToFill.isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
//Règles de déduction
|
||||
for (Cell cellToFill : cellsToFill) {
|
||||
|
||||
List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
|
||||
if (possibleSymbols.size() != 1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
cellToFill.setSymbolIndex(possibleSymbols.getFirst());
|
||||
|
||||
return Solver.mixedSolve(doku, rand);
|
||||
}
|
||||
|
||||
//Si ça ne marche pas
|
||||
//On fait du backtracking
|
||||
Cell cellToFill = doku.getRandomEmptyCell(rand);
|
||||
List<Integer> possibleSymbols = cellToFill.getPossibleSymbols();
|
||||
|
||||
while (!possibleSymbols.isEmpty()) {
|
||||
int nextPossibleSymbolIndex = rand.nextInt(possibleSymbols.size());
|
||||
int nextSymbol = possibleSymbols.get(nextPossibleSymbolIndex);
|
||||
|
||||
cellToFill.setSymbolIndex(nextSymbol);
|
||||
if (Solver.mixedSolve(doku, rand)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
cellToFill.setSymbolIndex(Cell.NOSYMBOL);
|
||||
possibleSymbols.remove(nextPossibleSymbolIndex);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
/*
|
||||
* This Java source file was generated by the Gradle 'init' task.
|
||||
*/
|
||||
package sudoku;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class AppTest {
|
||||
@Test void appHasAGreeting() {
|
||||
Main classUnderTest = new Main();
|
||||
assertNotNull(classUnderTest.getGreeting(), "app should have a greeting");
|
||||
}
|
||||
}
|
||||
@@ -8,18 +8,17 @@ import java.util.Random;
|
||||
|
||||
import org.json.JSONObject;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import sudoku.io.SudokuSerializer;
|
||||
import sudoku.solver.Solver;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.SudokuFactory;
|
||||
import org.polytech.ryuk.sudoku.io.SudokuSerializer;
|
||||
import org.polytech.ryuk.sudoku.solver.RandomSolver;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.SudokuFactory;
|
||||
|
||||
public class SudokuSerializerTest {
|
||||
|
||||
void testSerializeWithSize(int blockWidth, int blockHeight) {
|
||||
var sudoku = SudokuFactory.createBasicEmptyRectangleDoku(blockWidth, blockHeight,
|
||||
SudokuFactory.DEFAULT_CONSTRAINTS);
|
||||
Solver.randomSolve(sudoku, new Random());
|
||||
new RandomSolver().solve(sudoku);
|
||||
JSONObject data = SudokuSerializer.serializeSudoku(sudoku);
|
||||
MultiDoku multiDoku = SudokuSerializer.deserializeSudoku(data);
|
||||
assertTrue(data.toString().equals(SudokuSerializer.serializeSudoku(multiDoku).toString()));
|
||||
@@ -28,14 +27,15 @@ public class SudokuSerializerTest {
|
||||
void testSaveWithSize(int blockWidth, int blockHeight) {
|
||||
MultiDoku doku = SudokuFactory.createBasicEmptyRectangleDoku(blockWidth, blockHeight,
|
||||
SudokuFactory.DEFAULT_CONSTRAINTS);
|
||||
Solver.randomSolve(doku, new Random());
|
||||
new RandomSolver().solve(doku);
|
||||
String savePath = SudokuSerializer.saveMultiDoku(doku);
|
||||
MultiDoku otherDoku = null;
|
||||
try {
|
||||
otherDoku = SudokuFactory.fromfile(savePath);
|
||||
assert (otherDoku != null);
|
||||
|
||||
assertEquals(SudokuSerializer.serializeSudoku(doku).toString(), SudokuSerializer.serializeSudoku(otherDoku).toString());
|
||||
assertEquals(SudokuSerializer.serializeSudoku(doku).toString(),
|
||||
SudokuSerializer.serializeSudoku(otherDoku).toString());
|
||||
// clean file after test
|
||||
File fileToDelete = new File(savePath);
|
||||
fileToDelete.delete();
|
||||
@@ -47,7 +47,7 @@ public class SudokuSerializerTest {
|
||||
|
||||
void testSerializeX(int size) {
|
||||
var sudoku = SudokuFactory.createBasicXShapedMultidoku(size, SudokuFactory.DEFAULT_CONSTRAINTS);
|
||||
Solver.randomSolve(sudoku, new Random());
|
||||
new RandomSolver().solve(sudoku);
|
||||
JSONObject data = SudokuSerializer.serializeSudoku(sudoku);
|
||||
MultiDoku multiDoku = SudokuSerializer.deserializeSudoku(data);
|
||||
|
||||
|
||||
@@ -1,18 +1,19 @@
|
||||
package sudoku.solver;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import sudoku.io.SudokuPrinter;
|
||||
import sudoku.io.SudokuSerializer;
|
||||
import sudoku.structure.Cell;
|
||||
import sudoku.structure.MultiDoku;
|
||||
import sudoku.structure.Sudoku;
|
||||
import sudoku.structure.SudokuFactory;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.polytech.ryuk.sudoku.io.SudokuPrinter;
|
||||
import org.polytech.ryuk.sudoku.io.SudokuSerializer;
|
||||
import org.polytech.ryuk.sudoku.solver.RandomSolver;
|
||||
import org.polytech.ryuk.sudoku.structure.Cell;
|
||||
import org.polytech.ryuk.sudoku.structure.MultiDoku;
|
||||
import org.polytech.ryuk.sudoku.structure.Sudoku;
|
||||
import org.polytech.ryuk.sudoku.structure.SudokuFactory;
|
||||
|
||||
class SolverTest {
|
||||
|
||||
@Test
|
||||
@@ -57,7 +58,7 @@ class SolverTest {
|
||||
|
||||
assert (dokuResult.isSolved());
|
||||
|
||||
Solver.randomSolve(dokuToTest, rand);
|
||||
new RandomSolver().solve(dokuToTest);
|
||||
|
||||
System.out.println("\n****************************\nDoku solved");
|
||||
SudokuPrinter.printRectangleSudoku(dokuToTest.getSubGrid(0), 3, 3);
|
||||
@@ -89,13 +90,13 @@ class SolverTest {
|
||||
5, ns, ns, ns, 3, 1, 0, ns, ns);
|
||||
sudokuToTest2.setImmutableCellsSymbol(immutableCells2);
|
||||
|
||||
boolean isSolved = Solver.randomSolve(dokuToTest2, rand);
|
||||
boolean isSolved = new RandomSolver().solve(dokuToTest2);
|
||||
|
||||
assert (!isSolved);
|
||||
|
||||
MultiDoku dokuToTest3 = SudokuFactory.createBasicEmptySquareDoku(3, SudokuFactory.DEFAULT_CONSTRAINTS);
|
||||
|
||||
Solver.randomSolve(dokuToTest3, rand);
|
||||
new RandomSolver().solve(dokuToTest3);
|
||||
|
||||
SudokuPrinter.printRectangleSudoku(dokuToTest3.getSubGrid(0), 3, 3);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user