add screenshots

README.md

@@ -9,6 +9,14 @@ Une application de génération et résolution de MultiDoku.
 - Sudoku saves
 - Multiplayer
 
+## Screenshots 🖼
+
+[[screenshots/menu.png]]
+
+[[screenshots/solo.png]]
+
+[[screenshots/multi.png]]
+
 ## Develop ☝🤓
 
 **Pour plus de détails sur la conception et autres, regarder le 👉 [wiki](https://git.ale-pri.com/Ryuk/Sudoku/wiki)** 👈

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

@@ -71,24 +71,28 @@ public class SudokuRenderer {
 
 	private void renderPopup() {
 		if (ImGui.beginPopup("editPopup")) {
-			Block block = currentCell.getBlock();
+			if (currentCell == null)
-			int symbolCount = block.getCells().size();
+				ImGui.closeCurrentPopup();
-			for (int i = 0; i < symbolCount; i++) {
+			else {
-				if ((i + 1) % (int) (Math.sqrt(symbolCount)) != 1)
+				Block block = currentCell.getBlock();
-					ImGui.sameLine();
+				int symbolCount = block.getCells().size();
-				if (currentCell.getSymbolIndex() == i) {
+				for (int i = 0; i < symbolCount; i++) {
-					if (ImGui.button("X", cellSize)) {
+					if ((i + 1) % (int) (Math.sqrt(symbolCount)) != 1)
-						currentCell.setSymbolIndex(Cell.NOSYMBOL);
+						ImGui.sameLine();
-						this.onCellChange.emit(currentCell);
+					if (currentCell.getSymbolIndex() == i) {
-						ImGui.closeCurrentPopup();
+						if (ImGui.button("X", cellSize)) {
-					}
+							currentCell.setSymbolIndex(Cell.NOSYMBOL);
-				} else {
+							this.onCellChange.emit(currentCell);
-					if (ImGui.button(Options.Symboles.getSymbols().get(i), cellSize)) {
+							ImGui.closeCurrentPopup();
-						currentCell.setSymbolIndex(i);
+						}
-						this.onCellChange.emit(currentCell);
+					} else {
-						if (this.doku.getDoku().isSolved())
+						if (ImGui.button(Options.Symboles.getSymbols().get(i), cellSize)) {
-							this.onResolve.emit();
+							currentCell.setSymbolIndex(i);
-						ImGui.closeCurrentPopup();
+							this.onCellChange.emit(currentCell);
+							if (this.doku.getDoku().isSolved())
+								this.onResolve.emit();
+							ImGui.closeCurrentPopup();
+						}
 					}
 				}
 			}

app/src/main/java/network/Connexion.java

@@ -1,54 +1,40 @@
 package network;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
-import java.net.DatagramPacket;
+import java.net.Socket;
-import java.net.DatagramSocket;
-import java.net.InetSocketAddress;
 
 import network.protocol.Packet;
 import network.protocol.PacketVisitor;
 
 public abstract class Connexion implements PacketVisitor {
+	
+	final Socket socket;
+	private final ObjectOutputStream objectOutputStream;
+	private final ConnexionThread connexionThread;
 
-	protected final DatagramSocket socket;
+	public Connexion(Socket socket) throws IOException {
-	protected final InetSocketAddress address;
-
-	public Connexion(DatagramSocket socket, InetSocketAddress address) {
 		this.socket = socket;
-		this.address = address;
+		this.objectOutputStream = new ObjectOutputStream(this.socket.getOutputStream());
+		this.connexionThread = new ConnexionThread(this);
+		this.connexionThread.start();
 	}
 
-	public static record ReadInfo(Packet packet, InetSocketAddress address) {}
+	public boolean isClosed() {
-
+		return this.socket.isClosed();
-	public static ReadInfo readPacket(final DatagramSocket socket)
-			throws IOException, ClassNotFoundException {
-		byte[] buffer = new byte[65535];
-		DatagramPacket dataPacket = new DatagramPacket(buffer, buffer.length);
-		socket.receive(dataPacket);
-
-		InetSocketAddress address = new InetSocketAddress(dataPacket.getAddress(), dataPacket.getPort());
-
-		ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(dataPacket.getData()));
-		Packet packet = (Packet) ois.readObject();
-		return new ReadInfo(packet, address);
 	}
 
-	public void sendPacket(Packet packet) {
+	public synchronized void sendPacket(Packet packet) {
 		try {
-			ByteArrayOutputStream stream = new ByteArrayOutputStream();
+			objectOutputStream.writeObject(packet);
-			ObjectOutputStream oos = new ObjectOutputStream(stream);
+			objectOutputStream.flush();
-			oos.writeObject(packet);
-			oos.flush();
-			byte[] data = stream.toByteArray();
-			DatagramPacket dataPacket = new DatagramPacket(data, data.length, this.address.getAddress(),
-					this.address.getPort());
-			this.socket.send(dataPacket);
 		} catch (IOException e) {
-			e.printStackTrace();
+			System.err.println("Error while sending packet ! " + e.getLocalizedMessage());
+			close();
 		}
 	}
+
+	public void close() {
+		this.connexionThread.cancel();
+	}
 }

app/src/main/java/network/ConnexionThread.java

@@ -0,0 +1,44 @@
+package network;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
+import network.protocol.Packet;
+
+public class ConnexionThread extends Thread {
+
+	private final Connexion connexion;
+	private final ObjectInputStream objectInputStream;
+
+	public ConnexionThread(Connexion connexion) throws IOException {
+		this.connexion = connexion;
+		this.objectInputStream = new ObjectInputStream(this.connexion.socket.getInputStream());
+	}
+
+	@Override
+	public void run() {
+		while (!interrupted()) {
+			try {
+				// System.out.println(objectInputStream.available());
+				Object o = objectInputStream.readObject();
+				if (o instanceof Packet packet) {
+					connexion.visit(packet);
+				}
+			} catch (ClassNotFoundException | IOException e) {
+				e.printStackTrace();
+				this.connexion.close();
+				break;
+			}
+		}
+	}
+
+	public void cancel() {
+		try {
+			objectInputStream.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		interrupt();
+	}
+
+}

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

@@ -1,13 +1,11 @@
 package network.client;
 
 import java.io.IOException;
-import java.net.DatagramSocket;
+import java.net.Socket;
-import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
 
 import game.Player;
 import network.Connexion;
-import network.protocol.Packet;
 import network.protocol.packets.ChangeCellPacket;
 import network.protocol.packets.ConnexionInfoPacket;
 import network.protocol.packets.DisconnectPacket;
@@ -23,35 +21,18 @@ import sudoku.io.SudokuSerializer;
 public class ClientConnexion extends Connexion {
 
 	private final Client client;
-	private final Thread readThread;
 
 	public ClientConnexion(String address, short port, Client client) throws UnknownHostException, IOException {
-		super(new DatagramSocket(), new InetSocketAddress(address, port));
+		super(new Socket(address, port));
 		this.client = client;
-		this.readThread = new Thread(this::readPackets);
-		this.readThread.start();
-	}
-
-	private void readPackets() {
-		while (!Thread.interrupted()) {
-			try {
-				Packet packet = Connexion.readPacket(this.socket).packet();
-
-				visit(packet);
-			} catch (IOException e) {
-				e.printStackTrace();
-			} catch (ClassNotFoundException e) {
-				e.printStackTrace();
-			}
-		}
 	}
 
+	@Override
 	public void close() {
-		if (!this.socket.isClosed()) {
+		if (!this.isClosed()) {
+			super.close();
 			sendPacket(new DisconnectPacket(""));
 			client.onDisconnect.emit();
-			this.readThread.interrupt();
-			this.socket.close();
 		}
 	}
 

app/src/main/java/network/server/Server.java

@@ -1,15 +1,14 @@
 package network.server;
 
 import java.io.IOException;
-import java.net.DatagramSocket;
+import java.net.ServerSocket;
-import java.net.InetSocketAddress;
 import java.time.Instant;
-import java.util.HashMap;
+import java.util.ArrayList;
-import java.util.Map;
+import java.util.List;
 
 import game.Game;
-import game.Game.GameState;
 import game.Player;
+import game.Game.GameState;
 import network.protocol.Packet;
 import network.protocol.packets.EndGamePacket;
 import network.protocol.packets.StartGamePacket;
@@ -18,17 +17,17 @@ import sudoku.structure.MultiDoku;
 
 public class Server {
 
-	final DatagramSocket serverSocket;
+	final ServerSocket serverSocket;
-	final Map<InetSocketAddress, ServerConnexion> connexions;
+	final List<ServerConnexion> connexions;
-	private final ServerReadThread acceptThread;
+	private final ServerAcceptThread acceptThread;
 	private final ServerLogicThread logicThread;
 	private final Game game;
 	private int nextPlayerId = 0;
 
 	public Server(short port) throws IOException {
-		this.serverSocket = new DatagramSocket(port);
+		this.serverSocket = new ServerSocket(port);
-		this.connexions = new HashMap<>();
+		this.connexions = new ArrayList<>();
-		this.acceptThread = new ServerReadThread(this);
+		this.acceptThread = new ServerAcceptThread(this);
 		this.acceptThread.start();
 		this.logicThread = new ServerLogicThread(this);
 		this.logicThread.start();
@@ -36,7 +35,7 @@ public class Server {
 	}
 
 	public void broadcastPacket(Packet packet) {
-		for (ServerConnexion connexion : this.connexions.values()) {
+		for (ServerConnexion connexion : this.connexions) {
 			connexion.sendPacket(packet);
 		}
 	}
@@ -51,9 +50,8 @@ public class Server {
 	}
 
 	private void checkConnexions() {
-		for (var it = connexions.entrySet().iterator(); it.hasNext();) {
+		for (var it = connexions.iterator(); it.hasNext();) {
-			var entry = it.next();
+			ServerConnexion connexion = it.next();
-			ServerConnexion connexion = entry.getValue();
 			if (!connexion.update()) {
 				connexion.close();
 				connexion.nukeConnection();
@@ -70,10 +68,10 @@ public class Server {
 	public void stop() {
 		this.acceptThread.cancel();
 		this.logicThread.cancel();
-		for (ServerConnexion connexion : this.connexions.values()) {
+		for (ServerConnexion connexion : this.connexions) {
 			connexion.nukeConnection();
+			connexion.close();
 		}
-		this.serverSocket.close();
 	}
 
 	public Player addPlayer(String pseudo) {
@@ -90,7 +88,7 @@ public class Server {
 	public void startGame(MultiDoku doku, long gameDuration) {
 		Instant now = Instant.now();
 		this.game.startGame(doku, now, gameDuration);
-		for (ServerConnexion connexion : this.connexions.values()) {
+		for (ServerConnexion connexion : this.connexions) {
 			connexion.setSudoku(doku.clone());
 		}
 		broadcastPacket(new StartGamePacket(SudokuSerializer.serializeSudoku(doku).toString(), now, gameDuration));

app/src/main/java/network/server/ServerAcceptThread.java

@@ -0,0 +1,36 @@
+package network.server;
+
+import java.io.IOException;
+import java.net.Socket;
+
+public class ServerAcceptThread extends Thread {
+
+	private final Server server;
+
+	public ServerAcceptThread(Server server) {
+		this.server = server;
+	}
+
+	public void cancel() {
+		try {
+			this.server.serverSocket.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		interrupt();
+	}
+
+	@Override
+	public void run() {
+		try {
+			while(!interrupted()) {
+				Socket newConnection = this.server.serverSocket.accept();
+				ServerConnexion serverConnection = new ServerConnexion(newConnection, this.server);
+				this.server.connexions.add(serverConnection);
+			}
+		} catch(IOException e) {
+			// e.printStackTrace();
+		}
+	}
+
+}

app/src/main/java/network/server/ServerConnexion.java

@@ -1,11 +1,11 @@
 package network.server;
 
 import java.io.IOException;
-import java.net.InetSocketAddress;
+import java.net.Socket;
 
 import game.Game;
-import game.Game.GameState;
 import game.Player;
+import game.Game.GameState;
 import network.Connexion;
 import network.protocol.packets.ChangeCellPacket;
 import network.protocol.packets.ConnexionInfoPacket;
@@ -29,14 +29,14 @@ public class ServerConnexion extends Connexion {
 	private Player player = null;
 	private MultiDoku doku;
 
-	public ServerConnexion(InetSocketAddress remoteAddress, Server server) throws IOException {
+	public ServerConnexion(Socket socket, Server server) throws IOException {
-		super(server.serverSocket, remoteAddress);
+		super(socket);
 		this.server = server;
 		this.keepAliveHandler = new KeepAliveHandler(this);
 	}
 
 	public boolean update() {
-		if (shouldClose)
+		if (shouldClose || isClosed())
 			return false;
 		return this.keepAliveHandler.update();
 	}
@@ -49,6 +49,15 @@ public class ServerConnexion extends Connexion {
 		}
 	}
 
+	@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()) {
@@ -78,7 +87,7 @@ public class ServerConnexion extends Connexion {
 
 	@Override
 	public void visitPacket(DisconnectPacket packet) {
-		//TODO: close connexion
+		close();
 	}
 
 	@Override
@@ -155,8 +164,4 @@ public class ServerConnexion extends Connexion {
 		this.server.broadcastPacket(new UpdatePlayerScorePacket(player.getId(), player.getRemainingCells()));
 	}
 
-	public void close() {
-		this.shouldClose = true;
-	}
-
 }

app/src/main/java/network/server/ServerReadThread.java

@@ -1,43 +0,0 @@
-package network.server;
-
-import java.io.IOException;
-import java.net.InetSocketAddress;
-
-import network.Connexion;
-import network.protocol.Packet;
-
-public class ServerReadThread extends Thread {
-
-	private final Server server;
-
-	public ServerReadThread(Server server) {
-		this.server = server;
-	}
-
-	public void cancel() {
-		this.server.serverSocket.close();
-		interrupt();
-	}
-
-	@Override
-	public void run() {
-		try {
-			while (!interrupted()) {
-				Connexion.ReadInfo read = Connexion.readPacket(this.server.serverSocket);
-				Packet packet = read.packet();
-				InetSocketAddress address = read.address();
-				
-				if (!this.server.connexions.containsKey(address)) {
-					this.server.connexions.put(address, new ServerConnexion(address, server));
-				}
-
-				this.server.connexions.get(address).visit(packet);
-			}
-		} catch (IOException e) {
-			e.printStackTrace();
-		} catch (ClassNotFoundException e) {
-			e.printStackTrace();
-		}
-	}
-
-}