doc, fin

Reviewed-on: #12

.gitattributes

@@ -3,7 +3,7 @@
 #
 # Linux start script should use lf
 /gradlew        text eol=lf
-
 # These are Windows script files and should use crlf
 *.bat           text eol=crlf
-
+*.glb filter=lfs diff=lfs merge=lfs -text
+*.fbx filter=lfs diff=lfs merge=lfs -text

.github/workflows/build.yml

@@ -0,0 +1,25 @@
+name: Linux arm64
+run-name: Build And Test
+
+on: [push]
+
+jobs:
+  Build:
+    runs-on: ubuntu-latest
+    steps: 
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '21'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+     
+      - name: Build with Gradle
+        run: ./gradlew assemble
+
+      - name: Test
+        run: ./gradlew test

.gitignore

@@ -6,4 +6,7 @@ build
 
 app/bin
 
-.vscode
+.vscode
+
+*.wav
+imgui.ini

app/build.gradle

@@ -16,8 +16,10 @@ repositories {
     mavenCentral()
 }
 
+def os = "linux";
 def lwjgl_version = "3.3.6"
-def lwjgl_natives = "natives-linux"
+def lwjgl_natives = "natives-$os"
+def imgui_version = "1.87.0"
 
 dependencies {
     // Use JUnit Jupiter for testing.
@@ -26,11 +28,17 @@ dependencies {
     implementation "org.lwjgl:lwjgl:$lwjgl_version"
     implementation "org.lwjgl:lwjgl-opengl:$lwjgl_version"
     implementation "org.lwjgl:lwjgl-glfw:$lwjgl_version"
+    implementation "org.lwjgl:lwjgl-assimp:$lwjgl_version"
     implementation "org.joml:joml:1.10.8"
 
     implementation "org.lwjgl:lwjgl::$lwjgl_natives"
     implementation "org.lwjgl:lwjgl-opengl::$lwjgl_natives"
     implementation "org.lwjgl:lwjgl-glfw::$lwjgl_natives"
+    implementation "org.lwjgl:lwjgl-assimp::$lwjgl_natives"
+
+    implementation "io.github.spair:imgui-java-binding:$imgui_version"
+    implementation "io.github.spair:imgui-java-natives-$os:$imgui_version"
+    implementation "io.github.spair:imgui-java-app:$imgui_version"
 }
 
 application {
@@ -45,6 +53,10 @@ jar {
     }
 }
 
+run {
+    standardInput = System.in
+}
+
 tasks.named('test') {
     // Use JUnit Platform for unit tests.
     useJUnitPlatform()

app/src/main/java/chess/App.java

@@ -1,8 +1,17 @@
 package chess;
 
+import java.util.Scanner;
+
 import chess.view.consolerender.Colors;
 
-import java.util.Scanner;
+/**
+ * Main class of the chess game. Asks the user for the version to use and runs the according main.
+ * @author Grenier Lilas
+ * @author Pribylski Simon
+ * @see ConsoleMain
+ * @see SwingMain
+ * @see OpenGLMain 
+ */
 
 public class App {
     public static void main(String[] args) {
@@ -10,14 +19,21 @@ public class App {
         System.out.println("""
                 Pick the version to use:
                     1 - Console
-                    2 - Window.""");
-        switch (new Scanner(System.in).nextLine()) {
+                    2 - Window
+                    3 - 3D.""");
+        Scanner scan = new Scanner(System.in);
+        String line = scan.nextLine();
+        scan.close();
+        switch (line) {
             case "1", "Console", "console":
                 ConsoleMain.main(args);
                 break;
             case "2", "Window", "window":
                 SwingMain.main(args);
                 break;
+            case "3", "3D", "3d":
+                OpenGLMain.main(args);
+                break;
             default:
                 System.out.println("Invalid input");
                 break;

app/src/main/java/chess/ConsoleMain.java

@@ -3,28 +3,22 @@
  */
 package chess;
 
+/**
+ * Main class for the console version of the game. 
+ */
 import chess.controller.CommandExecutor;
 import chess.controller.commands.NewGameCommand;
-import chess.model.ChessBoard;
 import chess.model.Game;
-import chess.simulator.PromoteTest;
 import chess.view.consolerender.Console;
 
 public class ConsoleMain {
     public static void main(String[] args) {
-        Game game = new Game(new ChessBoard());
+        Game game = new Game();
         CommandExecutor commandExecutor = new CommandExecutor(game);
 
-        PromoteTest promoteTest = new PromoteTest(commandExecutor);
-        commandExecutor.addListener(promoteTest);
-
         Console console = new Console(commandExecutor);
         commandExecutor.addListener(console);
         
-        promoteTest.onComplete.connect(() -> {
-            console.setCaptureInput(true);
-        });
-
         commandExecutor.executeCommand(new NewGameCommand());
     }
 }

app/src/main/java/chess/OpenGLMain.java

@@ -1,33 +1,29 @@
 package chess;
 
-import chess.ai.DumbAI;
 import chess.controller.CommandExecutor;
 import chess.controller.commands.NewGameCommand;
-import chess.controller.event.GameAdaptator;
-import chess.model.ChessBoard;
-import chess.model.Color;
 import chess.model.Game;
-import chess.pgn.PgnExport;
-import chess.view.render.Window;
+import chess.pgn.PgnFileSimulator;
+import chess.view.DDDrender.DDDView;
 
+/**
+ * Main class for the 3D Window version of the game.
+ */
 public class OpenGLMain {
-
-    public static void main(String[] args) {
-        Game game = new Game(new ChessBoard());
+	public static void main(String[] args) {
+        Game game = new Game();
         CommandExecutor commandExecutor = new CommandExecutor(game);
 
-        Window window = new Window(commandExecutor);
-        commandExecutor.addListener(window);
-
-        // DumbAI ai = new DumbAI(commandExecutor, Color.Black);
-        // commandExecutor.addListener(ai);
-
-        // DumbAI ai2 = new DumbAI(commandExecutor, Color.White);
-        // commandExecutor.addListener(ai2);
+        PgnFileSimulator fileSimulator = new PgnFileSimulator(commandExecutor, "games/PromoteTest.pgn");
+        
+        DDDView ddd = new DDDView(commandExecutor);
 
+        commandExecutor.addListener(ddd);
+        commandExecutor.addListener(fileSimulator);
+        
         commandExecutor.executeCommand(new NewGameCommand());
 
-        window.run();
+        ddd.run();
+        commandExecutor.close();
     }
-
 }

app/src/main/java/chess/SwingMain.java

@@ -1,36 +1,48 @@
 package chess;
 
-import chess.ai.DumbAI;
+import chess.ai.ais.AlphaBetaAI;
+import chess.ai.alphabeta.AlphaBetaConsolePrinter;
 import chess.controller.CommandExecutor;
 import chess.controller.commands.NewGameCommand;
-import chess.controller.event.GameAdaptator;
-import chess.model.ChessBoard;
+import chess.controller.event.GameAdapter;
 import chess.model.Color;
 import chess.model.Game;
 import chess.pgn.PgnExport;
+import chess.view.audio.GameAudio;
 import chess.view.simplerender.Window;
 
+/**
+ * Main class for the 2D window version of the game.
+ */
 public class SwingMain {
 	public static void main(String[] args) {
-        Game game = new Game(new ChessBoard());
+        Game game = new Game();
         CommandExecutor commandExecutor = new CommandExecutor(game);
 
-        Window window = new Window(commandExecutor, false);
+        Window window = new Window(commandExecutor, true);
         commandExecutor.addListener(window);
 
-        DumbAI ai = new DumbAI(commandExecutor, Color.Black);
+        AlphaBetaAI ai = new AlphaBetaAI(commandExecutor, Color.Black, 5);
         commandExecutor.addListener(ai);
 
-        DumbAI ai2 = new DumbAI(commandExecutor, Color.White);
-        commandExecutor.addListener(ai2);
+        AlphaBetaConsolePrinter aiResults = new AlphaBetaConsolePrinter(ai);
+        aiResults.connect();
 
-        commandExecutor.addListener(new GameAdaptator(){
+        // AI ai2 = new AlphaBetaAI(commandExecutor, Color.White, 5);
+        // commandExecutor.addListener(ai2);
+
+        // Window window2 = new Window(ai2.getSimulation(), false);
+        // ai2.getSimulation().addListener(window2);
+
+        commandExecutor.addListener(new GameAdapter(){
             @Override
             public void onGameEnd() {
                 System.out.println(PgnExport.exportGame(game));
             }
         });
 
+        commandExecutor.addListener(new GameAudio());
+
         commandExecutor.executeCommand(new NewGameCommand());
     }
 }

app/src/main/java/chess/ai/AI.java

@@ -0,0 +1,41 @@
+package chess.ai;
+
+import java.util.List;
+
+import chess.ai.actions.AIAction;
+import chess.ai.actions.AIActions;
+import chess.controller.CommandExecutor;
+import chess.controller.event.GameAdapter;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Piece;
+
+/**
+ * Abstract class, used to code bots. 
+ */
+public abstract class AI extends GameAdapter implements AIActions {
+
+	protected final CommandExecutor commandExecutor;
+	protected final Color color;
+
+	public AI(CommandExecutor commandExecutor, Color color) {
+		this.commandExecutor = commandExecutor;
+		this.color = color;
+	}
+
+	protected abstract void play();
+
+	@Override
+	public void onPlayerTurn(Color color, boolean undone) {
+		if (this.color != color || undone)
+			return;
+
+		play();
+	}
+
+	@Override
+	public CommandExecutor getCommandExecutor() {
+		return this.commandExecutor;
+	}
+
+}

app/src/main/java/chess/ai/DumbAI.java

@@ -1,102 +0,0 @@
-package chess.ai;
-
-import java.util.List;
-import java.util.Random;
-
-import chess.controller.Command;
-import chess.controller.CommandExecutor;
-import chess.controller.commands.CastlingCommand;
-import chess.controller.commands.GetAllowedCastlingsCommand;
-import chess.controller.commands.GetPieceAtCommand;
-import chess.controller.commands.GetPlayerMovesCommand;
-import chess.controller.commands.MoveCommand;
-import chess.controller.commands.PromoteCommand;
-import chess.controller.commands.GetAllowedCastlingsCommand.CastlingResult;
-import chess.controller.commands.PromoteCommand.PromoteType;
-import chess.controller.event.GameAdaptator;
-import chess.model.Color;
-import chess.model.Coordinate;
-import chess.model.Move;
-import chess.model.Piece;
-
-public class DumbAI extends GameAdaptator {
-
-	private final Color player;
-	private final CommandExecutor commandExecutor;
-	private final Random random = new Random();
-
-	public DumbAI(CommandExecutor commandExecutor, Color color) {
-		this.player = color;
-		this.commandExecutor = commandExecutor;
-	}
-
-	@Override
-	public void onPlayerTurn(Color color) {
-		if (color != player)
-			return;
-
-		GetPlayerMovesCommand cmd = new GetPlayerMovesCommand();
-		sendCommand(cmd);
-
-		GetAllowedCastlingsCommand cmd2 = new GetAllowedCastlingsCommand();
-		sendCommand(cmd2);
-
-		CastlingResult castlings = cmd2.getCastlingResult();
-		List<Move> moves = cmd.getMoves();
-
-		switch (castlings) {
-			case Both: {
-				int randomMove = this.random.nextInt(moves.size() + 2);
-				if (randomMove < moves.size() - 2)
-					break;
-				this.commandExecutor.executeCommand(new CastlingCommand(randomMove == moves.size()));
-				return;
-			}
-
-			case Small: {
-				int randomMove = this.random.nextInt(moves.size() + 1);
-				if (randomMove != moves.size())
-					break;
-				this.commandExecutor.executeCommand(new CastlingCommand(false));
-				return;
-
-			}
-
-			case Big: {
-				int randomMove = this.random.nextInt(moves.size() + 1);
-				if (randomMove != moves.size())
-					break;
-				this.commandExecutor.executeCommand(new CastlingCommand(true));
-				return;
-			}
-
-			default:
-				break;
-		}
-
-		int randomMove = this.random.nextInt(moves.size());
-		this.commandExecutor.executeCommand(new MoveCommand(moves.get(randomMove)));
-
-	}
-
-	@Override
-	public void onPromotePawn(Coordinate pieceCoords) {
-		Piece pawn = pieceAt(pieceCoords);
-		if (pawn.getColor() != this.player)
-			return;
-
-		int promote = this.random.nextInt(PromoteType.values().length);
-		this.commandExecutor.executeCommand(new PromoteCommand(PromoteType.values()[promote]));
-	}
-
-	private Piece pieceAt(Coordinate coordinate) {
-		GetPieceAtCommand command = new GetPieceAtCommand(coordinate);
-		sendCommand(command);
-		return command.getPiece();
-	}
-
-	private void sendCommand(Command command) {
-		this.commandExecutor.executeCommand(command);
-	}
-
-}

app/src/main/java/chess/ai/GameSimulation.java

@@ -0,0 +1,83 @@
+package chess.ai;
+
+import java.util.List;
+
+import chess.ai.actions.AIAction;
+import chess.ai.actions.AIActions;
+import chess.controller.CommandExecutor;
+import chess.controller.CommandSender;
+import chess.controller.commands.PromoteCommand.PromoteType;
+import chess.controller.event.EmptyGameDispatcher;
+import chess.controller.event.GameAdapter;
+import chess.model.ChessBoard;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Game;
+import chess.model.Move;
+import chess.model.LightGame;
+
+
+/**
+ *  Emulates the moves of a bot on a secondary board.
+ */
+public class GameSimulation extends GameAdapter implements AIActions {
+
+	private final CommandExecutor simulation;
+	private final Game gameSimulation;
+
+	public GameSimulation() {
+		this.gameSimulation = new LightGame();
+		this.simulation = new CommandExecutor(gameSimulation, new EmptyGameDispatcher());
+	}
+
+	@Override
+	public void onPawnPromoted(PromoteType promotion, Coordinate coordinate) {
+		sendPawnPromotion(promotion);
+	}
+
+	@Override
+	public void onCastling(boolean bigCastling, Move kingMove, Move rookMove) {
+		if (bigCastling)
+			sendBigCastling();
+		else
+			sendCastling();
+	}
+
+	@Override
+	public void onMove(Move move, boolean captured) {
+		sendMove(move);
+	}
+
+	@Override
+	public void onGameStart() {
+		sendStartGame();
+	}
+
+	@Override
+	public void onPlayerTurn(Color color, boolean undone) {
+		if (undone)
+			sendUndo();
+	}
+
+	@Override
+	public CommandExecutor getCommandExecutor() {
+		return simulation;
+	}
+
+	public Game getGame() {
+		return gameSimulation;
+	}
+
+	public ChessBoard getBoard() {
+		return this.gameSimulation.getBoard();
+	}
+
+	public Color getPlayerTurn() {
+		return this.gameSimulation.getPlayerTurn();
+	}
+
+	public void close() {
+		this.simulation.close();
+	}
+
+}

app/src/main/java/chess/ai/PieceCost.java

@@ -0,0 +1,71 @@
+package chess.ai;
+
+import chess.model.Color;
+import chess.model.Piece;
+import chess.model.PieceVisitor;
+import chess.model.pieces.Bishop;
+import chess.model.pieces.King;
+import chess.model.pieces.Knight;
+import chess.model.pieces.Pawn;
+import chess.model.pieces.Queen;
+import chess.model.pieces.Rook;
+
+/**
+ * Evaluate the cost of pieces for AI algorithm.
+ */
+
+public class PieceCost implements PieceVisitor<Float> {
+
+	private final Color player;
+
+	public static final float BISHOP = 30;
+	public static final float KING = 900;
+	public static final float KNIGHT = 30;
+	public static final float PAWN = 10;
+	public static final float QUEEN = 90;
+	public static final float ROOK = 50;
+
+	public PieceCost(Color color) {
+		this.player = color;
+	}
+
+	public float getCost(Piece piece) {
+		if (piece == null)
+			return 0;
+		float cost = visit(piece);
+		if (piece.getColor() != player)
+			cost = -cost;
+		return cost;
+	}
+
+	@Override
+	public Float visitPiece(Bishop bishop) {
+		return BISHOP;
+	}
+
+	@Override
+	public Float visitPiece(King king) {
+		return KING;
+	}
+
+	@Override
+	public Float visitPiece(Knight knight) {
+		return KNIGHT;
+	}
+
+	@Override
+	public Float visitPiece(Pawn pawn) {
+		return PAWN;
+	}
+
+	@Override
+	public Float visitPiece(Queen queen) {
+		return QUEEN;
+	}
+
+	@Override
+	public Float visitPiece(Rook rook) {
+		return ROOK;
+	}
+
+}

app/src/main/java/chess/ai/PiecePosCost.java

@@ -0,0 +1,133 @@
+package chess.ai;
+
+import java.util.Arrays;
+import java.util.List;
+
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Piece;
+import chess.model.PieceVisitor;
+import chess.model.pieces.Bishop;
+import chess.model.pieces.King;
+import chess.model.pieces.Knight;
+import chess.model.pieces.Pawn;
+import chess.model.pieces.Queen;
+import chess.model.pieces.Rook;
+
+public class PiecePosCost implements PieceVisitor<List<Float>> {
+
+	/**
+	 * Evaluate the cost of position for AI algorithm.
+	 */
+
+	private final Color color;
+
+	private static final List<Float> BISHOP = Arrays.asList(
+			-2.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -2.0f, 
+			-1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f,
+			-1.0f, 0.0f, 0.5f, 1.0f, 1.0f, 0.5f, 0.0f, -1.0f,
+			-1.0f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, -1.0f,
+			-1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f,
+			-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f,
+			-1.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, -1.0f,
+			-2.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -2.0f);
+
+	private static final List<Float> KING = Arrays.asList(
+			-3.0f, -4.0f, -4.0f, -5.0f, -5.0f, -4.0f, -4.0f, -3.0f,
+			-3.0f, -4.0f, -4.0f, -5.0f, -5.0f, -4.0f, -4.0f, -3.0f,
+			-3.0f, -4.0f, -4.0f, -5.0f, -5.0f, -4.0f, -4.0f, -3.0f,
+			-3.0f, -4.0f, -4.0f, -5.0f, -5.0f, -4.0f, -4.0f, -3.0f,
+			-2.0f, -3.0f, -3.0f, -4.0f, -4.0f, -3.0f, -3.0f, -2.0f,
+			-1.0f, -2.0f, -2.0f, -2.0f, -2.0f, -2.0f, -2.0f, -1.0f,
+			2.0f, 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f, 2.0f,
+			2.0f, 3.0f, 1.0f, 0.0f, 0.0f, 1.0f, 3.0f, 2.0f);
+
+	private static final List<Float> KNIGHT = Arrays.asList(
+			-5.0f, -4.0f, -3.0f, -3.0f, -3.0f, -3.0f, -4.0f, -5.0f, 
+			-4.0f, -2.0f, 0.0f, 0.0f, 0.0f, 0.0f, -2.0f, -4.0f,
+			-3.0f, 0.0f, 1.0f, 1.5f, 1.5f, 1.0f, 0.0f, -3.0f,
+			-3.0f, 0.5f, 1.5f, 2.0f, 2.0f, 1.5f, 0.5f, -3.0f,
+			-3.0f, 0.0f, 1.5f, 2.0f, 2.0f, 1.5f, 0.0f, -3.0f,
+			-3.0f, 0.5f, 1.0f, 1.5f, 1.5f, 1.0f, 0.5f, -3.0f,
+			-4.0f, -2.0f, 0.0f, 0.5f, 0.5f, 0.0f, -2.0f, -4.0f,
+			-5.0f, -4.0f, -3.0f, -3.0f, -3.0f, -3.0f, -4.0f, -5.0f);
+
+	private static final List<Float> PAWN = Arrays.asList(
+			0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+			5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f, 5.0f,
+			1.0f, 1.0f, 2.0f, 3.0f, 3.0f, 2.0f, 1.0f, 1.0f,
+			0.5f, 0.5f, 1.0f, 2.5f, 2.5f, 1.0f, 0.5f, 0.5f,
+			0.0f, 0.0f, 1.0f, 2.0f, 2.0f, 1.0f, 0.0f, 0.0f,
+			0.5f, -0.5f, -1.0f, 0.0f, 0.0f, -1.0f, -0.5f, 0.5f,
+			0.5f, 1.0f, 1.0f, -2.0f, -2.0f, 1.0f, 1.0f, 0.5f,
+			0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+
+	private static final List<Float> QUEEN = Arrays.asList(
+			-2.0f, -1.0f, -1.0f, -0.5f, -0.5f, -1.0f, -1.0f, -2.0f,
+			-1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f,
+			-1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.5f, 0.0f, -1.0f,
+			-0.5f, 0.0f, 0.5f, 0.5f, 0.5f, 0.5f, 0.0f, -0.5f,
+			0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.5f, 0.0f, -0.5f,
+			-1.0f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.0f, -1.0f,
+			-1.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f,
+			-2.0f, -1.0f, -1.0f, -0.5f, -0.5f, -1.0f, -1.0f, -2.0f);
+
+	private static final List<Float> ROOK = Arrays.asList(
+			0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+			0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.5f,
+			-0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f,
+			-0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f,
+			-0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f,
+			-0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f,
+			-0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f,
+			0.0f, 0.0f, 0.0f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f);
+
+	public PiecePosCost(Color color) {
+		this.color = color;
+	}
+
+	public float getEvaluation(Piece piece, Coordinate coordinate) {
+		if (piece == null)
+			return 0;
+		List<Float> positions = visit(piece);
+		int x = piece.getColor() == Color.Black ? (Coordinate.VALUE_MAX - 1 - coordinate.getX()) : coordinate.getX();
+		int y = piece.getColor() == Color.Black ? (Coordinate.VALUE_MAX - 1 - coordinate.getY()) : coordinate.getY();
+		Coordinate newCoords = new Coordinate(x, y);
+		assert newCoords.isValid();
+		float result = positions.get(newCoords.toIndex());
+		if (piece.getColor() != color)
+			return -result;
+		return result;
+	}
+
+	@Override
+	public List<Float> visitPiece(Bishop bishop) {
+		return BISHOP;
+	}
+
+	@Override
+	public List<Float> visitPiece(King king) {
+		return KING;
+	}
+
+	@Override
+	public List<Float> visitPiece(Knight knight) {
+		return KNIGHT;
+	}
+
+	@Override
+	public List<Float> visitPiece(Pawn pawn) {
+		return PAWN;
+	}
+
+	@Override
+	public List<Float> visitPiece(Queen queen) {
+		return QUEEN;
+	}
+
+	@Override
+	public List<Float> visitPiece(Rook rook) {
+		return ROOK;
+	}
+
+}

app/src/main/java/chess/ai/actions/AIAction.java

@@ -0,0 +1,36 @@
+package chess.ai.actions;
+
+import chess.controller.CommandExecutor;
+import chess.controller.CommandSender;
+import chess.controller.commands.UndoCommand;
+
+/**
+ * Abstract class, manage the possible actions of a bot. 
+ */
+public abstract class AIAction implements CommandSender {
+
+	private final CommandExecutor commandExecutor;
+
+	public AIAction(CommandExecutor commandExecutor) {
+		this.commandExecutor = commandExecutor;
+	}
+
+	@Override
+	public CommandExecutor getCommandExecutor() {
+		return this.commandExecutor;
+	}
+
+	public void undoAction(CommandExecutor commandExecutor) {
+		sendCommand(new UndoCommand(), commandExecutor);
+	}
+
+	public void undoAction() {
+		undoAction(this.commandExecutor);
+	}
+
+	public void applyAction() {
+		applyAction(this.commandExecutor);
+	}
+
+	public abstract void applyAction(CommandExecutor commandExecutor);
+}

app/src/main/java/chess/ai/actions/AIActionCastling.java

@@ -0,0 +1,23 @@
+package chess.ai.actions;
+
+import chess.controller.CommandExecutor;
+import chess.controller.commands.CastlingCommand;
+
+/**
+ * Manage the transition between model and bots when it comes to Castling command.
+ */
+public class AIActionCastling extends AIAction{
+
+	private final boolean bigCastling;
+
+	public AIActionCastling(CommandExecutor commandExecutor, boolean bigCastling) {
+		super(commandExecutor);
+		this.bigCastling = bigCastling;
+	}
+
+	@Override
+	public void applyAction(CommandExecutor commandExecutor) {
+		sendCommand(new CastlingCommand(this.bigCastling), commandExecutor);
+	}
+	
+}

app/src/main/java/chess/ai/actions/AIActionMove.java

@@ -0,0 +1,28 @@
+package chess.ai.actions;
+
+import chess.controller.CommandExecutor;
+import chess.controller.commands.MoveCommand;
+import chess.model.Move;
+
+/**
+ * Manage the transition between model and bots when it comes to Move command.
+ */
+public class AIActionMove extends AIAction{
+
+	private final Move move;
+
+	public AIActionMove(CommandExecutor commandExecutor, Move move) {
+		super(commandExecutor);
+		this.move = move;
+	}
+
+	public Move getMove() {
+		return move;
+	}
+
+	@Override
+	public void applyAction(CommandExecutor commandExecutor) {
+		sendCommand(new MoveCommand(move), commandExecutor);
+	}
+	
+}

app/src/main/java/chess/ai/actions/AIActionMoveAndPromote.java

@@ -0,0 +1,29 @@
+package chess.ai.actions;
+
+import chess.controller.CommandExecutor;
+import chess.controller.commands.MoveCommand;
+import chess.controller.commands.PromoteCommand;
+import chess.controller.commands.PromoteCommand.PromoteType;
+import chess.model.Move;
+
+/**
+ * Manage the transition between model and bots when it comes to Move and Promotion command.
+ */
+public class AIActionMoveAndPromote extends AIAction{
+
+	private final Move move;
+	private final PromoteType promoteType;
+
+	public AIActionMoveAndPromote(CommandExecutor commandExecutor, Move move, PromoteType promoteType) {
+		super(commandExecutor);
+		this.move = move;
+		this.promoteType = promoteType;
+	}
+
+	@Override
+	public void applyAction(CommandExecutor commandExecutor) {
+		sendCommand(new MoveCommand(move), commandExecutor);
+		sendCommand(new PromoteCommand(promoteType), commandExecutor);
+	}
+	
+}

app/src/main/java/chess/ai/actions/AIActions.java

@@ -0,0 +1,69 @@
+package chess.ai.actions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import chess.controller.Command;
+import chess.controller.CommandSender;
+import chess.controller.Command.CommandResult;
+import chess.controller.CommandExecutor;
+import chess.controller.commands.GetAllowedCastlingsCommand;
+import chess.controller.commands.GetAllowedCastlingsCommand.CastlingResult;
+import chess.controller.commands.PromoteCommand.PromoteType;
+import chess.controller.commands.GetPieceAtCommand;
+import chess.controller.commands.GetPlayerMovesCommand;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Move;
+import chess.model.Piece;
+import chess.model.pieces.Pawn;
+
+
+/**
+ * Search and compiles the different actions possible to a bot.
+ */
+public interface AIActions extends CommandSender {
+
+	default List<AIAction> getAllowedActions() {
+		List<Move> moves = getPlayerMoves();
+		CastlingResult castlingResult = getAllowedCastlings();
+
+		List<AIAction> actions = new ArrayList<>(moves.size() + 10);
+
+		for (Move move : moves) {
+			Piece movingPiece = getPieceAt(move.getStart());
+			if (movingPiece instanceof Pawn) {
+				int enemyLineY = movingPiece.getColor() == Color.White ? 0 : 7;
+				if (move.getFinish().getY() == enemyLineY) {
+					PromoteType[] promotes = PromoteType.values();
+					for (PromoteType promote : promotes) {
+						actions.add(new AIActionMoveAndPromote(getCommandExecutor(), move, promote));
+					}
+					continue;
+				}
+			}
+			actions.add(new AIActionMove(getCommandExecutor(), move));
+		}
+
+		switch (castlingResult) {
+			case Both:
+				actions.add(new AIActionCastling(getCommandExecutor(), true));
+				actions.add(new AIActionCastling(getCommandExecutor(), false));
+				break;
+
+			case Small:
+				actions.add(new AIActionCastling(getCommandExecutor(), false));
+				break;
+
+			case Big:
+				actions.add(new AIActionCastling(getCommandExecutor(), true));
+				break;
+
+			case None:
+				break;
+		}
+
+		return actions;
+	}
+
+}

app/src/main/java/chess/ai/ais/AlphaBetaAI.java

@@ -0,0 +1,93 @@
+package chess.ai.ais;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import chess.ai.*;
+import chess.ai.actions.*;
+import chess.ai.alphabeta.*;
+import chess.controller.CommandExecutor;
+import chess.model.Color;
+import common.Signal1;
+
+/**
+ * Extends AI. Bot based on the alpha-beta method of resolution.
+ */
+
+public class AlphaBetaAI extends AI {
+
+	private final int searchDepth;
+
+	private static final float MAX_FLOAT = Float.MAX_VALUE;
+	private static final float MIN_FLOAT = -MAX_FLOAT;
+
+	private final ExecutorService threadPool;
+
+	public final Signal1<Integer> onStartEval = new Signal1<>();
+	public final Signal1<Float> onCompleteEval = new Signal1<>();
+	public final Signal1<Float> onProgress = new Signal1<>();
+
+	public AlphaBetaAI(CommandExecutor commandExecutor, Color color, int searchDepth) {
+		super(commandExecutor, color);
+		this.searchDepth = searchDepth;
+		int threadCount = Runtime.getRuntime().availableProcessors();
+		this.threadPool = Executors.newFixedThreadPool(threadCount,
+				new AlphaBetaThreadCreator(commandExecutor, color, threadCount));
+	}
+
+	private AIAction getBestMove() {
+		List<AIAction> actions = getAllowedActions();
+		List<Future<Float>> moveEvaluations = new ArrayList<>(actions.size());
+		float bestMoveValue = MIN_FLOAT;
+		AIAction bestMove = null;
+
+		this.onStartEval.emit(actions.size());
+
+		for (AIAction action : actions) {
+			moveEvaluations.add(this.threadPool.submit(() -> {
+				return AlphaBetaThreadCreator.getMoveValue(action, this.searchDepth);
+			}));
+		}
+
+		for (int i = 0; i < actions.size(); i++) {
+			this.onProgress.emit((float) i / (float) actions.size());
+			AIAction action = actions.get(i);
+
+			float value = MIN_FLOAT;
+			try {
+				value = moveEvaluations.get(i).get();
+			} catch (InterruptedException | ExecutionException e) {
+				e.printStackTrace();
+			}
+			if (value > bestMoveValue) {
+				bestMoveValue = value;
+				bestMove = action;
+			}
+		}
+
+		this.onCompleteEval.emit(bestMoveValue);
+
+		return bestMove;
+	}
+
+	@Override
+	public void onGameEnd() {
+		this.threadPool.close();
+	}
+
+	@Override
+	protected void play() {
+		AIAction move = getBestMove();
+		move.applyAction();
+	}
+
+	@Override
+	public CommandExecutor getCommandExecutor() {
+		return super.getCommandExecutor();
+	}
+
+}

app/src/main/java/chess/ai/ais/DumbAI.java

@@ -0,0 +1,32 @@
+package chess.ai.ais;
+
+import java.util.List;
+import java.util.Random;
+
+import chess.ai.*;
+import chess.ai.actions.AIAction;
+import chess.controller.CommandExecutor;
+import chess.model.Color;
+
+/**
+ * Bot, takes a random decision among his possible moves.
+ */
+
+public class DumbAI extends AI {
+
+	private final Random random = new Random();
+
+	public DumbAI(CommandExecutor commandExecutor, Color color) {
+		super(commandExecutor, color);
+	}
+
+	@Override
+	protected void play() {
+		List<AIAction> actions = getAllowedActions();
+
+		int randomAction = this.random.nextInt(actions.size());
+
+		actions.get(randomAction).applyAction();
+	}
+
+}

app/src/main/java/chess/ai/ais/HungryAI.java

@@ -0,0 +1,64 @@
+package chess.ai.ais;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import chess.ai.actions.AIAction;
+import chess.ai.actions.AIActionMove;
+import chess.controller.CommandExecutor;
+import chess.model.Color;
+import chess.model.Move;
+import chess.model.Piece;
+import chess.ai.*;
+import chess.ai.actions.*;
+import chess.ai.actions.AIActions;
+
+
+/**
+ * Bot, takes the optimal piece when possible, or make a random move if no piece can be taken during the turn. 
+ * @see PieceCost
+ * @see PiecePosCost
+ */
+
+public class HungryAI extends AI {
+
+	private final PieceCost pieceCost;
+	private final Random random;
+
+	public HungryAI(CommandExecutor commandExecutor, Color color) {
+		super(commandExecutor, color);
+		this.pieceCost = new PieceCost(color);
+		this.random = new Random();
+	}
+
+	private int getMoveCost(Move move) {
+		Piece piece = getPieceAt(move.getDeadPieceCoords());
+		return -(int) pieceCost.getCost(piece);
+	}
+
+	private List<AIAction> getBestMoves() {
+		List<AIAction> actions = getAllowedActions();
+		List<AIAction> bestMoves = new ArrayList<>();
+		int bestCost = 0;
+		for (AIAction action : actions) {
+			if (action instanceof AIActionMove move) {
+				int moveCost = getMoveCost(move.getMove());
+				if (moveCost == bestCost) {
+					bestMoves.add(move);
+				} else if (moveCost > bestCost) {
+					bestMoves.clear();
+					bestMoves.add(move);
+					bestCost = moveCost;
+				}
+			}
+		}
+		return bestMoves;
+	}
+
+	@Override
+	protected void play() {
+		List<AIAction> bestMoves = getBestMoves();
+		bestMoves.get(this.random.nextInt(bestMoves.size())).applyAction();
+	}
+}

app/src/main/java/chess/ai/alphabeta/AlphaBetaConsolePrinter.java

@@ -0,0 +1,32 @@
+package chess.ai.alphabeta;
+import chess.ai.ais.AlphaBetaAI;
+
+/**
+ * Print the action of an alpha-beta bot on the console.
+ * @see AlphaBetaAI
+ */
+public class AlphaBetaConsolePrinter {
+
+	private final AlphaBetaAI ai;
+	private long lastTime;
+
+	public void connect() {
+		ai.onStartEval.connect((moveCount) -> {
+			this.lastTime = System.currentTimeMillis();
+			System.out.println("Evaluating " + moveCount + " moves ...");
+		});
+
+		ai.onProgress.connect((progress) -> {
+			System.out.printf("Progress : %.2f %%    \r", progress * 100.0f);
+		});
+
+		ai.onCompleteEval.connect((bestMove) -> {
+			System.out.println("Best move : " + bestMove + "                 ");
+			System.out.println("Took " + (System.currentTimeMillis() - this.lastTime) + "ms");
+		});
+	}
+
+	public AlphaBetaConsolePrinter(AlphaBetaAI ai) {
+		this.ai = ai;
+	}
+}

app/src/main/java/chess/ai/alphabeta/AlphaBetaThread.java

@@ -0,0 +1,107 @@
+package chess.ai.alphabeta;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import chess.ai.GameSimulation;
+import chess.ai.PieceCost;
+import chess.ai.PiecePosCost;
+import chess.ai.actions.AIAction;
+import chess.model.ChessBoard;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Piece;
+
+/**
+ * Manage the threads for an alpha-beta bot. 
+ * @see AlphaBetaAI
+ */
+
+public class AlphaBetaThread extends Thread {
+
+	private final GameSimulation simulation;
+	private final PieceCost pieceCost;
+	private final PiecePosCost piecePosCost;
+
+	private static final int GREAT_MOVE = 9999;
+
+	private static final float MAX_FLOAT = Float.MAX_VALUE;
+	private static final float MIN_FLOAT = -MAX_FLOAT;
+
+	public AlphaBetaThread(Runnable task, GameSimulation simulation, Color color) {
+		super(task);
+		this.simulation = simulation;
+		this.pieceCost = new PieceCost(color);
+		this.piecePosCost = new PiecePosCost(color);
+	}
+
+	private float getEndGameEvaluation() {
+		Color currentTurn = this.simulation.getPlayerTurn();
+		if (this.simulation.getBoard().isKingInCheck(currentTurn))
+			return GREAT_MOVE;
+		return getBoardEvaluation() - PieceCost.PAWN;
+	}
+
+	private float getBoardEvaluation() {
+		final ChessBoard board = this.simulation.getBoard();
+		float result = 0;
+		for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
+			for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
+				Coordinate coordinate = new Coordinate(i, j);
+				Piece piece = board.pieceAt(coordinate);
+				result += pieceCost.getCost(piece) + piecePosCost.getEvaluation(piece, coordinate);
+			}
+		}
+		return result;
+	}
+
+	public float getMoveValue(AIAction move, int searchDepth) {
+		move.applyAction(this.simulation.getCommandExecutor());
+		float value = -negaMax(searchDepth - 1, MIN_FLOAT, MAX_FLOAT);
+		move.undoAction(this.simulation.getCommandExecutor());
+		return value;
+	}
+
+	private float negaMax(int depth, float alpha, float beta) {
+		float value = MIN_FLOAT;
+
+		List<AIAction> moves = this.simulation.getAllowedActions();
+
+		if (moves.isEmpty())
+			return -getEndGameEvaluation();
+
+		List<Entry<AIAction, Float>> movesCost = new ArrayList<>(moves.size());
+
+		for (AIAction move : moves) {
+			move.applyAction();
+			movesCost.add(Map.entry(move, -getBoardEvaluation()));
+			move.undoAction();
+		}
+
+		Collections.sort(movesCost, (first, second) -> {
+			return Float.compare(first.getValue(), second.getValue());
+		});
+
+		if (depth == 1)
+			return -movesCost.getFirst().getValue();
+
+		for (var moveEntry : movesCost) {
+			AIAction move = moveEntry.getKey();
+			move.applyAction();
+			value = Float.max(value, -negaMax(depth - 1, -beta, -alpha));
+			move.undoAction();
+			alpha = Float.max(alpha, value);
+			if (alpha >= beta)
+				return value;
+		}
+
+		return value;
+	}
+
+	public GameSimulation getSimulation() {
+		return simulation;
+	}
+}

app/src/main/java/chess/ai/alphabeta/AlphaBetaThreadCreator.java

@@ -0,0 +1,41 @@
+package chess.ai.alphabeta;
+
+import java.util.concurrent.ThreadFactory;
+
+import chess.ai.GameSimulation;
+import chess.ai.actions.AIAction;
+import chess.controller.CommandExecutor;
+import chess.model.Color;
+
+/**
+ * Create the threads for an alpha-beta bot.
+ * @see AlphaBetaAI
+ */
+public class AlphaBetaThreadCreator implements ThreadFactory{
+
+	private final Color color;
+	private final GameSimulation simulations[];
+	private int currentThread = 0;
+
+	public AlphaBetaThreadCreator(CommandExecutor commandExecutor, Color color, int threadCount) {
+		this.color = color;
+		simulations = new GameSimulation[threadCount];
+		for (int i = 0; i < threadCount; i++) {
+			simulations[i] = new GameSimulation();
+			commandExecutor.addListener(simulations[i]);
+		}
+	}
+
+	public static float getMoveValue(AIAction move, int searchDepth) {
+		AlphaBetaThread t = (AlphaBetaThread) Thread.currentThread();
+		return t.getMoveValue(move, searchDepth);
+	}
+
+	@Override
+	public Thread newThread(Runnable r) {
+		AlphaBetaThread t = new AlphaBetaThread(r, simulations[currentThread], color);
+		currentThread++;
+		return t;
+	}
+	
+}

app/src/main/java/chess/controller/Command.java

@@ -3,18 +3,22 @@ package chess.controller;
 import chess.controller.event.GameListener;
 import chess.model.Game;
 
+/**
+ * Abstract class, manage the execution and results of commands.
+ */
+
 public abstract class Command {
 
 	public enum CommandResult {
 		/**
-		 * The command was successfull. Should update display and switch player turn.
+		 * The command was successful. Should update display and switch player turn.
 		 */
 		Moved,
-		/** The command was successfull. Should not update anything */
+		/** The command was successful. Should not update anything */
 		NotMoved,
-		/** The command was successfull. Should only update display */
+		/** The command was successful. Should only update display */
 		ActionNeeded,
-		/** The command was not successfull */
+		/** The command was not successful */
 		NotAllowed;
 	}
 

app/src/main/java/chess/controller/CommandExecutor.java

@@ -1,12 +1,18 @@
 package chess.controller;
 
+import java.util.List;
+
 import chess.controller.Command.CommandResult;
 import chess.controller.commands.UndoCommand;
+import chess.controller.event.AsyncGameDispatcher;
 import chess.controller.event.GameDispatcher;
 import chess.controller.event.GameListener;
 import chess.model.Game;
 import chess.model.Game.GameStatus;
 
+/**
+ * Execute commands.
+ */
 public class CommandExecutor {
 
 	private Game game;
@@ -17,9 +23,9 @@ public class CommandExecutor {
 	}
 
 	public CommandExecutor(Game game) {
-		this(game, new GameDispatcher());
+		this(game, new AsyncGameDispatcher());
 	}
-	
+
 	public CommandExecutor(Game game, GameDispatcher dispatcher) {
 		this.game = game;
 		this.dispatcher = dispatcher;
@@ -41,6 +47,13 @@ public class CommandExecutor {
 		return result;
 	}
 
+	public void executeCommands(List<? extends Command> commands) {
+		for (Command command : commands) {
+			CommandResult result = executeCommand(command);
+			assert result != CommandResult.NotAllowed;
+		}
+	}
+
 	private void processResult(Command command, CommandResult result) {
 		switch (result) {
 			case NotAllowed:
@@ -52,19 +65,21 @@ public class CommandExecutor {
 				return;
 
 			case Moved:
+				boolean notifyPlayerTurn = true;
 				this.dispatcher.onBoardUpdate();
-				if (checkGameStatus()) {
+				if (!(command instanceof UndoCommand) && checkGameStatus()) {
 					this.dispatcher.onGameEnd();
-					return;
+					notifyPlayerTurn = false;
 				}
-				switchPlayerTurn();
+				switchPlayerTurn(command instanceof UndoCommand, notifyPlayerTurn);
 				return;
 		}
 	}
 
-	private void switchPlayerTurn() {
+	private void switchPlayerTurn(boolean undone, boolean notifyPlayerTurn) {
 		this.game.switchPlayerTurn();
-		this.dispatcher.onPlayerTurn(this.game.getPlayerTurn());
+		if (notifyPlayerTurn)
+			this.dispatcher.onPlayerTurn(this.game.getPlayerTurn(), undone);
 	}
 
 	/**
@@ -107,6 +122,6 @@ public class CommandExecutor {
 	}
 
 	public void close() {
-		this.dispatcher.stopService();
+		this.dispatcher.close();
 	}
 }

app/src/main/java/chess/controller/CommandSender.java

@@ -0,0 +1,116 @@
+package chess.controller;
+
+import java.util.List;
+
+import chess.controller.Command.CommandResult;
+import chess.controller.commands.CastlingCommand;
+import chess.controller.commands.GetAllowedCastlingsCommand;
+import chess.controller.commands.GetAllowedMovesPieceCommand;
+import chess.controller.commands.GetPieceAtCommand;
+import chess.controller.commands.GetPlayerMovesCommand;
+import chess.controller.commands.MoveCommand;
+import chess.controller.commands.NewGameCommand;
+import chess.controller.commands.PromoteCommand;
+import chess.controller.commands.SurrenderCommand;
+import chess.controller.commands.UndoCommand;
+import chess.controller.commands.GetAllowedCastlingsCommand.CastlingResult;
+import chess.controller.commands.PromoteCommand.PromoteType;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Move;
+import chess.model.Piece;
+
+/**
+ * Interface for sending commands to the game, make long string of commands easier.
+ */
+
+public interface CommandSender {
+
+	CommandExecutor getCommandExecutor();
+
+	default CommandResult sendCommand(Command cmd, CommandExecutor commandExecutor) {
+		CommandResult result = commandExecutor.executeCommand(cmd);
+		if (result == CommandResult.NotAllowed) {
+			// maybe do something
+		}
+		return result;
+	}
+
+	default CommandResult sendCommand(Command cmd) {
+		return sendCommand(cmd, getCommandExecutor());
+	}
+
+	// inputs
+
+	default CastlingResult getAllowedCastlings() {
+		GetAllowedCastlingsCommand cmd = new GetAllowedCastlingsCommand();
+		sendCommand(cmd);
+		return cmd.getCastlingResult();
+	}
+
+	default boolean canDoCastling() {
+		CastlingResult castlings = getAllowedCastlings();
+		return castlings == CastlingResult.Both || castlings == CastlingResult.Small;
+	}
+
+	default boolean canDoBigCastling() {
+		CastlingResult castlings = getAllowedCastlings();
+		return castlings == CastlingResult.Both || castlings == CastlingResult.Big;
+	}
+
+	default Piece getPieceAt(int x, int y) {
+		return getPieceAt(new Coordinate(x, y));
+	}
+
+	default Piece getPieceAt(Coordinate coordinate) {
+		GetPieceAtCommand cmd = new GetPieceAtCommand(coordinate);
+		sendCommand(cmd);
+		return cmd.getPiece();
+	}
+
+	default boolean isCellEmpty(int x, int y) {
+		return getPieceAt(x, y) == null;
+	}
+
+	default List<Move> getPlayerMoves() {
+		GetPlayerMovesCommand cmd = new GetPlayerMovesCommand();
+		sendCommand(cmd);
+		return cmd.getMoves();
+	}
+
+	default List<Coordinate> getPieceAllowedMoves(Coordinate piecePos) {
+		GetAllowedMovesPieceCommand cmd = new GetAllowedMovesPieceCommand(piecePos);
+		sendCommand(cmd);
+		return cmd.getDestinations();
+	}
+
+	// outputs
+
+	default CommandResult sendCastling() {
+		return sendCommand(new CastlingCommand(false));
+	}
+
+	default CommandResult sendBigCastling() {
+		return sendCommand(new CastlingCommand(true));
+	}
+
+	default CommandResult sendMove(Move move) {
+		return sendCommand(new MoveCommand(move));
+	}
+
+	default CommandResult sendStartGame() {
+		return sendCommand(new NewGameCommand());
+	}
+
+	default CommandResult sendPawnPromotion(PromoteType promote) {
+		return sendCommand(new PromoteCommand(promote));
+	}
+
+	default CommandResult sendSurrender(Color player) {
+		return sendCommand(new SurrenderCommand(player));
+	}
+
+	default CommandResult sendUndo() {
+		return sendCommand(new UndoCommand());
+	}
+}

app/src/main/java/chess/controller/PlayerCommand.java

@@ -3,6 +3,9 @@ package chess.controller;
 import chess.controller.event.GameListener;
 import chess.model.Game;
 
+/**
+ * Abstract class, manage commands given by the player, which are the commands that can be undone.
+ */
 public abstract class PlayerCommand extends Command{
 
 	public CommandResult undo(Game game, GameListener outputSystem) {

app/src/main/java/chess/controller/commands/CastlingCommand.java

@@ -8,6 +8,9 @@ import chess.model.Coordinate;
 import chess.model.Game;
 import chess.model.Move;
 
+/**
+ * Command to execute a Castling or Big Castling.
+ */
 public class CastlingCommand extends PlayerCommand {
 
 	private Move kingMove;
@@ -49,6 +52,10 @@ public class CastlingCommand extends PlayerCommand {
 		board.applyMove(this.kingMove);
 		board.applyMove(this.rookMove);
 
+		board.setLastMove(this.kingMove);
+
+		outputSystem.onCastling(this.bigCastling, kingMove, rookMove);
+
 		return CommandResult.Moved;
 	}
 

app/src/main/java/chess/controller/commands/GetAllowedCastlingsCommand.java

@@ -4,6 +4,9 @@ import chess.controller.Command;
 import chess.controller.event.GameListener;
 import chess.model.Game;
 
+/**
+ * Command to check the possible Castling.
+ */
 public class GetAllowedCastlingsCommand extends Command{
 
 	public enum CastlingResult {

app/src/main/java/chess/controller/commands/GetAllowedMovesPieceCommand.java

@@ -10,6 +10,9 @@ import chess.model.Coordinate;
 import chess.model.Game;
 import chess.model.Piece;
 
+/**
+ * Command to check the Castlings that are possible.
+ */
 public class GetAllowedMovesPieceCommand extends Command {
 
 	private final Coordinate start;
@@ -31,7 +34,7 @@ public class GetAllowedMovesPieceCommand extends Command {
 		if (piece.getColor() != game.getPlayerTurn())
 			return CommandResult.NotAllowed;
 
-		this.destinations = board.getAllowedMoves(start);
+		this.destinations = board.getPieceAllowedMoves(start);
 		return CommandResult.NotMoved;
 	}
 

app/src/main/java/chess/controller/commands/GetPieceAtCommand.java

@@ -6,6 +6,9 @@ import chess.model.Coordinate;
 import chess.model.Game;
 import chess.model.Piece;
 
+/**
+ * Command to check the possible moves for a given piece.
+ */
 public class GetPieceAtCommand extends Command{
 
 	private final Coordinate pieceCoords;

app/src/main/java/chess/controller/commands/GetPlayerMovesCommand.java

@@ -7,6 +7,11 @@ import chess.controller.event.GameListener;
 import chess.model.Game;
 import chess.model.Move;
 
+/**
+ * Command to get the possible moves of a player. Castling and Promotion not included.
+ * @see CastlingCommand
+ * @see PromoteCommand
+ */
 public class GetPlayerMovesCommand extends Command {
 
 	private List<Move> moves;

app/src/main/java/chess/controller/commands/MoveCommand.java

@@ -7,8 +7,13 @@ import chess.model.Coordinate;
 import chess.model.Game;
 import chess.model.Move;
 import chess.model.Piece;
-import chess.model.visitor.PiecePathChecker;
+import chess.model.rules.PiecePathChecker;
 
+/*
+ * Command to move a piece. Castling not included.
+ * 
+ * @see CastlingCommand 
+ */
 public class MoveCommand extends PlayerCommand {
 
 	private final Move move;
@@ -37,7 +42,6 @@ public class MoveCommand extends PlayerCommand {
 				return result;
 
 			case Moved:
-				outputSystem.onMove(this.move);
 				game.saveTraitPiecesPos();
 				return result;
 
@@ -53,7 +57,7 @@ public class MoveCommand extends PlayerCommand {
 		final ChessBoard board = game.getBoard();
 
 		// we must promote the pending pawn before
-		if (board.pawnShouldBePromoted())
+		if (game.pawnShouldBePromoted())
 			return CommandResult.NotAllowed;
 
 		Piece piece = board.pieceAt(move.getStart());
@@ -76,11 +80,14 @@ public class MoveCommand extends PlayerCommand {
 		}
 
 		if (tryPromote(game, outputSystem)) {
+			outputSystem.onMove(this.move, this.deadPiece != null);
 			return CommandResult.ActionNeeded;
 		}
 
 		board.setLastMove(this.move);
 
+		outputSystem.onMove(this.move, this.deadPiece != null);
+
 		return CommandResult.Moved;
 	}
 

app/src/main/java/chess/controller/commands/NewGameCommand.java

@@ -13,6 +13,9 @@ import chess.model.pieces.Pawn;
 import chess.model.pieces.Queen;
 import chess.model.pieces.Rook;
 
+/**
+ * Command to create a new game.
+ */
 public class NewGameCommand extends Command {
 	public CommandResult execute(Game game, GameListener outputSystem) {
 		final ChessBoard board = game.getBoard();
@@ -51,7 +54,7 @@ public class NewGameCommand extends Command {
 		game.reset();
 
 		outputSystem.onGameStart();
-		outputSystem.onPlayerTurn(game.getPlayerTurn());
+		outputSystem.onPlayerTurn(game.getPlayerTurn(), false);
 
 		return CommandResult.NotMoved;
 	}

app/src/main/java/chess/controller/commands/PromoteCommand.java

@@ -9,10 +9,13 @@ import chess.model.Game;
 import chess.model.Piece;
 import chess.model.pieces.Bishop;
 import chess.model.pieces.Knight;
+import chess.model.pieces.Pawn;
 import chess.model.pieces.Queen;
 import chess.model.pieces.Rook;
-import chess.model.visitor.PawnIdentifier;
 
+/*
+ * Command to promote a pawn.
+ */
 public class PromoteCommand extends PlayerCommand {
 
 	public enum PromoteType {
@@ -28,6 +31,7 @@ public class PromoteCommand extends PlayerCommand {
 
 	public PromoteCommand(PromoteType promoteType) {
 		this.promoteType = promoteType;
+		assert this.promoteType != null;
 		this.pieceCoords = null;
 		this.oldPawn = null;
 	}
@@ -42,7 +46,7 @@ public class PromoteCommand extends PlayerCommand {
 			return CommandResult.NotAllowed;
 
 		Piece pawn = board.pieceAt(this.pieceCoords);
-		if (!new PawnIdentifier(game.getPlayerTurn()).isPawn(pawn))
+		if (!(pawn instanceof Pawn))
 			return CommandResult.NotAllowed;
 
 		int destY = this.pieceCoords.getY();
@@ -55,6 +59,11 @@ public class PromoteCommand extends PlayerCommand {
 		this.oldPawn = pawn;
 		board.pieceComes(createPiece(this.promoteType, pawn.getColor()), this.pieceCoords);
 
+		outputSystem.onPawnPromoted(this.promoteType, this.pieceCoords);
+
+		// invalidate the last move cache
+		board.setLastMove(null);
+
 		return CommandResult.Moved;
 	}
 

app/src/main/java/chess/controller/commands/SurrenderCommand.java

@@ -5,6 +5,9 @@ import chess.controller.event.GameListener;
 import chess.model.Color;
 import chess.model.Game;
 
+/**
+ * Command to surrender a game.
+ */
 public class SurrenderCommand extends Command {
 
 	private final Color player;

app/src/main/java/chess/controller/commands/UndoCommand.java

@@ -5,6 +5,9 @@ import chess.controller.PlayerCommand;
 import chess.controller.event.GameListener;
 import chess.model.Game;
 
+/**
+ * Command to undo the last action.
+ */
 public class UndoCommand extends Command{
 
 	@Override

app/src/main/java/chess/controller/event/AsyncGameDispatcher.java

@@ -0,0 +1,116 @@
+package chess.controller.event;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Consumer;
+
+import chess.controller.commands.PromoteCommand.PromoteType;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Move;
+
+/**
+ * Create a thread in which the notifications such as Move Not Allowed, Check, Checkmate, Promotion, Surrender, etc. will be sent to update the players.
+ */
+public class AsyncGameDispatcher extends GameDispatcher {
+
+	private final List<GameListener> listeners;
+	private final ExecutorService executor;
+
+	public AsyncGameDispatcher() {
+		this.listeners = new ArrayList<>();
+		this.executor = Executors.newSingleThreadExecutor();
+	}
+
+	@Override
+	public void addListener(GameListener listener) {
+		this.listeners.add(listener);
+	}
+
+	private void asyncForEachCall(Consumer<GameListener> func) {
+		this.executor.execute(() -> this.listeners.forEach(func));
+	}
+
+	@Override
+	public void onPlayerTurn(Color color, boolean undone) {
+		asyncForEachCall((l) -> l.onPlayerTurn(color, undone));
+	}
+
+	@Override
+	public void onWin(Color color) {
+		asyncForEachCall((l) -> l.onWin(color));
+	}
+
+	@Override
+	public void onKingInCheck() {
+		asyncForEachCall((l) -> l.onKingInCheck());
+	}
+
+	@Override
+	public void onKingInMat() {
+		asyncForEachCall((l) -> l.onKingInMat());
+	}
+
+	@Override
+	public void onPatSituation() {
+		asyncForEachCall((l) -> l.onPatSituation());
+	}
+
+	@Override
+	public void onSurrender(Color color) {
+		asyncForEachCall((l) -> l.onSurrender(color));
+	}
+
+	@Override
+	public void onGameStart() {
+		asyncForEachCall((l) -> l.onGameStart());
+	}
+
+	@Override
+	public void onPromotePawn(Coordinate pieceCoords) {
+		asyncForEachCall((l) -> l.onPromotePawn(pieceCoords));
+	}
+
+	@Override
+	public void onBoardUpdate() {
+		asyncForEachCall((l) -> l.onBoardUpdate());
+	}
+
+	@Override
+	public void onGameEnd() {
+		asyncForEachCall((l) -> l.onGameEnd());
+	}
+
+	@Override
+	public void onMove(Move move, boolean captured) {
+		asyncForEachCall((l) -> l.onMove(move, captured));
+	}
+
+	@Override
+	public void onMoveNotAllowed(Move move) {
+		asyncForEachCall((l) -> l.onMoveNotAllowed(move));
+	}
+
+	@Override
+	public void onDraw() {
+		asyncForEachCall((l) -> l.onDraw());
+	}
+
+	@Override
+	public void onCastling(boolean bigCastling, Move kingMove, Move rookMove) {
+		asyncForEachCall((l) -> l.onCastling(bigCastling, kingMove, rookMove));		
+	}
+
+	@Override
+	public void onPawnPromoted(PromoteType promotion, Coordinate coordinate) {
+		asyncForEachCall((l) -> l.onPawnPromoted(promotion, coordinate));
+	}
+
+	@Override
+	public void close() {
+		this.executor.shutdown();
+	}
+
+}

app/src/main/java/chess/controller/event/EmptyGameDispatcher.java

@@ -1,9 +1,13 @@
 package chess.controller.event;
 
+import chess.controller.commands.PromoteCommand.PromoteType;
 import chess.model.Color;
 import chess.model.Coordinate;
 import chess.model.Move;
 
+/**
+ * Dispatcher for bots, does nothing. 
+ */
 public class EmptyGameDispatcher extends GameDispatcher {
 
 	@Override
@@ -31,7 +35,7 @@ public class EmptyGameDispatcher extends GameDispatcher {
 	}
 
 	@Override
-	public void onMove(Move move) {
+	public void onMove(Move move, boolean captured) {
 	}
 
 	@Override
@@ -43,7 +47,7 @@ public class EmptyGameDispatcher extends GameDispatcher {
 	}
 
 	@Override
-	public void onPlayerTurn(Color color) {
+	public void onPlayerTurn(Color color, boolean undone) {
 	}
 
 	@Override
@@ -57,5 +61,21 @@ public class EmptyGameDispatcher extends GameDispatcher {
 	@Override
 	public void onWin(Color winner) {
 	}
-	
+
+	@Override
+	public void onCastling(boolean bigCastling, Move kingMove, Move rookMove) {
+	}
+
+	@Override
+	public void onPawnPromoted(PromoteType promotion, Coordinate coordinate) {
+	}
+
+	@Override
+	public void addListener(GameListener listener) {
+	}
+
+	@Override
+	public void close() {
+	}
+
 }

app/src/main/java/chess/controller/event/GameAdapter.java

@@ -1,13 +1,18 @@
 package chess.controller.event;
 
+import chess.controller.commands.PromoteCommand.PromoteType;
 import chess.model.Color;
 import chess.model.Coordinate;
 import chess.model.Move;
 
-public abstract class GameAdaptator implements GameListener {
+/**
+ * Abstract class, provides default implementation of GameListener methods. 
+ * @see GameListener
+ */
+public abstract class GameAdapter implements GameListener {
 
 	@Override
-	public void onPlayerTurn(Color color) {}
+	public void onPlayerTurn(Color color, boolean undone) {}
 
 	@Override
 	public void onWin(Color color) {}
@@ -37,7 +42,7 @@ public abstract class GameAdaptator implements GameListener {
 	public void onGameEnd() {}
 
 	@Override
-	public void onMove(Move move) {}
+	public void onMove(Move move, boolean captured) {}
 
 	@Override
 	public void onMoveNotAllowed(Move move) {}
@@ -45,4 +50,10 @@ public abstract class GameAdaptator implements GameListener {
 	@Override
 	public void onDraw() {}
 
+	@Override
+	public void onCastling(boolean bigCastling, Move kingMove, Move rookMove) {}
+
+	@Override
+	public void onPawnPromoted(PromoteType promotion, Coordinate coordinate) {}
+
 }

app/src/main/java/chess/controller/event/GameDispatcher.java

@@ -1,100 +1,12 @@
 package chess.controller.event;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.function.Consumer;
+/**
+ * Abstract class, provides a dispatcher for game events.
+ */
+public abstract class GameDispatcher extends GameAdapter {
 
-import chess.model.Color;
-import chess.model.Coordinate;
-import chess.model.Move;
-
-public class GameDispatcher implements GameListener {
-
-	private final List<GameListener> listeners;
-	private final ExecutorService executor;
-
-	public GameDispatcher() {
-		this.listeners = new ArrayList<>();
-		this.executor = Executors.newSingleThreadExecutor();
-	}
-
-	public void addListener(GameListener listener) {
-		this.listeners.add(listener);
-	}
-
-	private void asyncForEachCall(Consumer<GameListener> func) {
-		this.executor.execute(() -> this.listeners.forEach(func));
-	}
-
-	@Override
-	public void onPlayerTurn(Color color) {
-		asyncForEachCall((l) -> l.onPlayerTurn(color));
-	}
-
-	@Override
-	public void onWin(Color color) {
-		asyncForEachCall((l) -> l.onWin(color));
-	}
-
-	@Override
-	public void onKingInCheck() {
-		asyncForEachCall((l) -> l.onKingInCheck());
-	}
-
-	@Override
-	public void onKingInMat() {
-		asyncForEachCall((l) -> l.onKingInMat());
-	}
-
-	@Override
-	public void onPatSituation() {
-		asyncForEachCall((l) -> l.onPatSituation());
-	}
-
-	@Override
-	public void onSurrender(Color color) {
-		asyncForEachCall((l) -> l.onSurrender(color));
-	}
-
-	@Override
-	public void onGameStart() {
-		asyncForEachCall((l) -> l.onGameStart());
-	}
-
-	@Override
-	public void onPromotePawn(Coordinate pieceCoords) {
-		asyncForEachCall((l) -> l.onPromotePawn(pieceCoords));
-	}
-
-	@Override
-	public void onBoardUpdate() {
-		asyncForEachCall((l) -> l.onBoardUpdate());
-	}
-
-	@Override
-	public void onGameEnd() {
-		asyncForEachCall((l) -> l.onGameEnd());
-	}
-
-	@Override
-	public void onMove(Move move) {
-		asyncForEachCall((l) -> l.onMove(move));
-	}
-
-	@Override
-	public void onMoveNotAllowed(Move move) {
-		asyncForEachCall((l) -> l.onMoveNotAllowed(move));
-	}
-
-	@Override
-	public void onDraw() {
-		asyncForEachCall((l) -> l.onDraw());
-	}
-
-	public void stopService() {
-		this.executor.shutdown();
-	}
+	public abstract void addListener(GameListener listener);
 
+	public abstract void close();
+	
 }

app/src/main/java/chess/controller/event/GameListener.java

@@ -1,9 +1,13 @@
 package chess.controller.event;
 
+import chess.controller.commands.PromoteCommand.PromoteType;
 import chess.model.Color;
 import chess.model.Coordinate;
 import chess.model.Move;
 
+/**
+ * Interface for events to listen.
+ */
 public interface GameListener {
 
 	/**
@@ -15,7 +19,7 @@ public interface GameListener {
 	 * Invoked when a draw occurs (same position is repeated three times)
 	 */
 	void onDraw();
-	
+
 	/**
 	 * Invoked when the game has ended (by a win or a draw)
 	 */
@@ -25,7 +29,7 @@ public interface GameListener {
 	 * Invoked when the game has started
 	 */
 	void onGameStart();
-	
+
 	/**
 	 * Invoked when a king is in check
 	 */
@@ -35,46 +39,71 @@ public interface GameListener {
 	 * Invoked when a checkmate occurs
 	 */
 	void onKingInMat();
-	
+
 	/**
 	 * Invoked when a valid move on the board occurs
+	 * 
 	 * @param move the move to be processed
+	 * @param captured whether the move is a result of a capture
 	 */
-	void onMove(Move move);
+	void onMove(Move move, boolean captured);
 
 	/**
 	 * Invoked when a sent move is not allowed
+	 * 
 	 * @param move the move to be processed
 	 */
 	void onMoveNotAllowed(Move move);
-	
+
 	/**
 	 * Invoked when a pat situation occurs
 	 */
 	void onPatSituation();
-	
+
 	/**
 	 * Invoked when it's the player turn
-	 * @param color the color of the player who should play
+	 * 
+	 * @param color  the color of the player who should play
+	 * @param undone true if it's a result of an undo command
 	 */
-	void onPlayerTurn(Color color);
-	
+	void onPlayerTurn(Color color, boolean undone);
+
 	/**
 	 * Invoked when a pawn should be promoted
+	 * 
 	 * @param pieceCoords the coordinates of the pawn
 	 */
 	void onPromotePawn(Coordinate pieceCoords);
-	
+
 	/**
 	 * Invoked when a players surrenders
+	 * 
 	 * @param coward the player who gave up
 	 */
 	void onSurrender(Color coward);
-	
+
 	/**
 	 * Invoked when a player wins (by checkmate or if the other one surrenders)
+	 * 
 	 * @param winner
 	 */
 	void onWin(Color winner);
 
+	/**
+	 * Invoked when a castling is done
+	 * 
+	 * @param bigCastling if it's queen side castling
+	 * @param kingMove the king's move
+	 * @param rookMove the rook's move
+	 */
+	void onCastling(boolean bigCastling, Move kingMove, Move rookMove);
+
+	/**
+	 * Invoked when a pawn is promoted
+	 * 
+	 * @param promotion the type of promotion
+	 * @param coordinate the coordinate of the old pawn
+	 */
+	void onPawnPromoted(PromoteType promotion, Coordinate coordinate);
+
 }

app/src/main/java/chess/model/ChessBoard.java

@@ -4,11 +4,17 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 
-import chess.model.visitor.KingIdentifier;
-import chess.model.visitor.PawnIdentifier;
-import chess.model.visitor.PiecePathChecker;
+import chess.model.pieces.King;
+import chess.model.pieces.Pawn;
+import chess.model.rules.PiecePathChecker;
 
+/**
+ * Chess board entity, composed of cells.
+ */
 public class ChessBoard {
+	/**
+	 * Cell of the chess board.
+	 */
 	public static class Cell {
 		private Piece piece;
 
@@ -31,6 +37,10 @@ public class ChessBoard {
 	private Move lastMove;
 	private Piece lastEjectedPiece;
 
+	private List<Move> cachedAllowedMoves = null;
+
+	private final Coordinate kingPos[];
+
 	public ChessBoard() {
 		this.cells = new Cell[Coordinate.VALUE_MAX][Coordinate.VALUE_MAX];
 		for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
@@ -41,8 +51,13 @@ public class ChessBoard {
 		this.lastVirtualMove = null;
 		this.lastMove = null;
 		this.lastEjectedPiece = null;
+		this.kingPos = new Coordinate[Color.values().length];
 	}
 
+	/**
+	 * Apply a move on the board.
+	 * @param move move to apply
+	 */
 	public void applyMove(Move move) {
 		assert move.isValid() : "Invalid move !";
 		Piece deadPiece = pieceAt(move.getDeadPieceCoords());
@@ -59,12 +74,20 @@ public class ChessBoard {
 		this.lastVirtualMove = move;
 	}
 
+	/**
+	 * Undo the last move
+	 */
 	public void undoLastMove() {
 		assert this.lastVirtualMove != null : "Can't undo at the beginning!";
 
 		undoMove(this.lastVirtualMove, this.lastEjectedPiece);
 	}
 
+	/**
+	 * Undo the specified move
+	 * @param move
+	 * @param deadPiece
+	 */
 	public void undoMove(Move move, Piece deadPiece) {
 		Piece movingPiece = pieceAt(move.getFinish());
 		pieceComes(movingPiece, move.getStart());
@@ -74,16 +97,29 @@ public class ChessBoard {
 		movingPiece.unMove();
 	}
 
+	/**
+	 * Check if the cell is empty
+	 * @param coordinate
+	 * @return true if the cell is empty
+	 */
 	public boolean isCellEmpty(Coordinate coordinate) {
 		return pieceAt(coordinate) == null;
 	}
 
+	/**
+	 * Return the piece at the given coordinates
+	 * @param coordinate
+	 * @return piece at the given coordinates, or null if the coordinates are invalid or the cell is empty
+	 */
 	public Piece pieceAt(Coordinate coordinate) {
 		if (!coordinate.isValid())
 			return null;
 		return cellAt(coordinate).getPiece();
 	}
 
+	/**
+	 * Nuke all pieces of the board
+	 */
 	public void clearBoard() {
 		for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
 			for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
@@ -92,33 +128,77 @@ public class ChessBoard {
 		}
 	}
 
+	/**
+	 * Get the cell at the given coordinates
+	 * @param coordinate
+	 * @return
+	 */
 	private Cell cellAt(Coordinate coordinate) {
 		return this.cells[coordinate.getX()][coordinate.getY()];
 	}
 
+	
+	/*
+	 * Set the piece at the given coordinate
+	 */
 	public void pieceComes(Piece piece, Coordinate coordinate) {
 		cellAt(coordinate).setPiece(piece);
+		if (piece instanceof King)
+			this.kingPos[piece.getColor().ordinal()] = coordinate;
 	}
 
+	/**
+	 * Remove the piece at the given coordiinates
+	 * @param coordinate
+	 */
 	public void pieceLeaves(Coordinate coordinate) {
 		cellAt(coordinate).setPiece(null);
 	}
 
+	/**
+	 * Find the king of the given color on the board
+	 * @param color
+	 * @return the coordinates of the king
+	 */
 	public Coordinate findKing(Color color) {
-		KingIdentifier kingIdentifier = new KingIdentifier(color);
-		for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
-			for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
-				Coordinate coordinate = new Coordinate(i, j);
-				Piece piece = pieceAt(coordinate);
-				if (kingIdentifier.isKing(piece)) {
-					return coordinate;
-				}
-			}
-		}
-		assert false : "No king found ?!";
-		return null;
+		return kingPos[color.ordinal()];
 	}
 
+	/**
+	 * Get the allowed starting positions for a piece to attack the given Coordinate. Useful for PGN trasnlation.
+	 * @param finish
+	 * @param color
+	 * @return coordinates of the pieces that could attack
+	 */
+	public List<Coordinate> getAllowedStarts(Coordinate finish, Color color) {
+		List<Coordinate> starts = new ArrayList<>();
+		for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
+			for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
+				Coordinate attackCoords = new Coordinate(i, j);
+				Piece attackPiece = pieceAt(attackCoords);
+				if (attackPiece == null || attackPiece.getColor() != color)
+					continue;
+
+				Move move = new Move(attackCoords, finish);
+				PiecePathChecker piecePathChecker = new PiecePathChecker(this,
+						move);
+				if (!piecePathChecker.isValid())
+					continue;
+
+				applyMove(move);
+				if (!isKingInCheck(color))
+					starts.add(attackCoords);
+				undoLastMove();
+			}
+		}
+		return starts;
+	}
+
+	/**
+	 * Check if the king of the given color is in check
+	 * @param color
+	 * @return true if the king is in check
+	 */
 	public boolean isKingInCheck(Color color) {
 		Coordinate kingPos = findKing(color);
 		assert kingPos.isValid() : "King position is invalid!";
@@ -127,7 +207,7 @@ public class ChessBoard {
 			for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
 				Coordinate attackCoords = new Coordinate(i, j);
 				Piece attackPiece = pieceAt(attackCoords);
-				if (attackPiece == null)
+				if (attackPiece == null || attackPiece.getColor() == color)
 					continue;
 
 				PiecePathChecker checker = new PiecePathChecker(this, new Move(attackCoords, kingPos));
@@ -138,11 +218,25 @@ public class ChessBoard {
 		return false;
 	}
 
+	/**
+	 * Check if the given player has allowed moves
+	 * @param player
+	 * @return true if the player can move
+	 */
 	public boolean hasAllowedMoves(Color player) {
 		return !getAllowedMoves(player).isEmpty();
 	}
 
+	/**
+	 * Get the allowed moves for the given player
+	 * @param player
+	 * @return
+	 */
 	public List<Move> getAllowedMoves(Color player) {
+		if (this.cachedAllowedMoves != null) {
+			return this.cachedAllowedMoves;
+		}
+
 		List<Move> result = new ArrayList<>();
 
 		for (int x = 0; x < Coordinate.VALUE_MAX; x++) {
@@ -159,6 +253,11 @@ public class ChessBoard {
 						Coordinate destination = new Coordinate(i, j);
 						Move move = new Move(start, destination);
 
+						Piece destPiece = pieceAt(destination);
+
+						if (destPiece != null && destPiece.getColor() == player)
+							continue;
+
 						PiecePathChecker piecePathChecker = new PiecePathChecker(this,
 								move);
 						if (!piecePathChecker.isValid())
@@ -172,10 +271,14 @@ public class ChessBoard {
 				}
 			}
 		}
+		this.cachedAllowedMoves = result;
 		return result;
 	}
 
-	public List<Coordinate> getAllowedMoves(Coordinate pieceCoords) {
+	/**
+	 * Get all the end positions possible of a piece
+	 */
+	public List<Coordinate> getPieceAllowedMoves(Coordinate pieceCoords) {
 		Piece piece = pieceAt(pieceCoords);
 		if (piece == null)
 			return null;
@@ -203,6 +306,13 @@ public class ChessBoard {
 		return result;
 	}
 
+	/**
+	 * Check if the given player can castle with the given rook
+	 * @param color
+	 * @param rookX
+	 * @param kingDirection
+	 * @return true if the player can Castle
+	 */
 	private boolean canCastle(Color color, int rookX, Direction kingDirection) {
 		if (isKingInCheck(color))
 			return false;
@@ -237,20 +347,32 @@ public class ChessBoard {
 		return obstacle == null;
 	}
 
+	/**
+	 * @return wether the player can perform a kingside castling.
+	 */
 	public boolean canSmallCastle(Color color) {
 		return canCastle(color, 7, Direction.Right);
 	}
 
+	/**
+	 * Check if the given player is allowed to execute a queenside castling.
+	 * @param color
+	 * @return
+	*/
 	public boolean canBigCastle(Color color) {
 		return canCastle(color, 0, Direction.Left);
 	}
 
+	/**
+	 * Check if there is a pawn to be promoted by the given player.
+	 * @return
+	*/
 	public boolean pawnShouldBePromoted() {
 		return pawnPromotePosition() != null;
 	}
 
 	/**
-	 * 
+	 * Check if there's a pawn in the adversary line on the board
 	 * @return Null if there is no pawn to promote
 	 */
 	public Coordinate pawnPromotePosition() {
@@ -261,18 +383,17 @@ public class ChessBoard {
 	}
 
 	/**
-	 * 
+	 * Check if there's a pawn of the given player in the adversary line on the board
 	 * @return Null if there is no pawn to promote
 	 */
 	private Coordinate pawnPromotePosition(Color color) {
 		int enemyLineY = color == Color.White ? 0 : 7;
-		PawnIdentifier identifier = new PawnIdentifier(color);
 
 		for (int x = 0; x < Coordinate.VALUE_MAX; x++) {
 			Coordinate pieceCoords = new Coordinate(x, enemyLineY);
 			Piece piece = pieceAt(pieceCoords);
 
-			if (identifier.isPawn(piece))
+			if (piece instanceof Pawn)
 				return pieceCoords;
 
 		}
@@ -280,6 +401,10 @@ public class ChessBoard {
 		return null;
 	}
 
+	/**
+	 * Hash according to the pieces position on the board
+	 * @return hash code
+	 */
 	@Override
 	public int hashCode() {
 		int result = 0;
@@ -294,16 +419,23 @@ public class ChessBoard {
 		return result;
 	}
 
+	/**
+	 * @return the last played move
+	 */
 	public Move getLastMove() {
 		return this.lastMove;
 	}
 
+	/**
+	 * Updates the last move of the board and invalidate the allowedMoves cache.
+	 */
 	public void setLastMove(Move lastMove) {
 		this.lastMove = lastMove;
+		this.cachedAllowedMoves = null;
 	}
 
 	@Override
-	public boolean equals(Object obj){
+	public boolean equals(Object obj) {
 		if (obj instanceof ChessBoard board)
 			return board.hashCode() == this.hashCode();
 		return false;

app/src/main/java/chess/model/Color.java

@@ -1,5 +1,8 @@
 package chess.model;
 
+/**
+ * Enumeration of colors for player - either black or white
+ */
 public enum Color {
 	White,
 	Black;

app/src/main/java/chess/model/Coordinate.java

@@ -2,6 +2,9 @@ package chess.model;
 
 import java.util.Objects;
 
+/**
+ * Coordinate of a cell on the chess board.
+ */
 public class Coordinate {
 	private final int x;
 	private final int y;

app/src/main/java/chess/model/Direction.java

@@ -1,5 +1,9 @@
 package chess.model;
 
+/**
+ * Enumation of the different directions from a cell in a chessboard, and how to navigate the cells.
+ */
+
 public enum Direction {
 
 	Unset(65),

app/src/main/java/chess/model/Game.java

@@ -8,6 +8,10 @@ import java.util.Stack;
 import chess.controller.PlayerCommand;
 import chess.controller.commands.MoveCommand;
 
+/**
+ * Game class that represents a chess game.
+ */
+
 public class Game {
 	private final ChessBoard board;
 	private Color playerTurn;
@@ -20,8 +24,8 @@ public class Game {
 		Draw, Check, CheckMate, OnGoing, Pat;
 	}
 
-	public Game(ChessBoard board) {
-		this.board = board;
+	public Game() {
+		this.board = new ChessBoard();
 		this.movesHistory = new Stack<>();
 		this.traitsPos = new HashMap<>();
 	}
@@ -34,19 +38,24 @@ public class Game {
 		return playerTurn;
 	}
 
+	/**
+	 * Reset the game
+	 */
 	public void reset() {
 		resetPlayerTurn();
 		this.traitsPos.clear();
 	}
 
+	/**
+	 * Reset the player turn.
+	 * Aka: white for the win
+	 */
 	public void resetPlayerTurn() {
 		this.playerTurn = Color.White;
 	}
 
 	/**
-	 * 
-	 * @param color the current player turn
-	 * @return true if a draw should be declared
+	 * Save the current board configuration
 	 */
 	public void saveTraitPiecesPos() {
 		int piecesHash = this.board.hashCode();
@@ -63,41 +72,58 @@ public class Game {
 	}
 
 	/**
-	 * 
-	 * @return true if a draw should occur
+	 * Switch player turn
 	 */
 	public void switchPlayerTurn() {
 		playerTurn = Color.getEnemy(playerTurn);
 	}
 
-	public GameStatus checkGameStatus() {
-		final Color enemy = Color.getEnemy(getPlayerTurn());
-
+	/**
+	 * Check the status of the game ofr the specified player
+	 * @return a GameStatus enum
+	 */
+	public GameStatus checkGameStatus(Color color) {
 		if (checkDraw())
 			return GameStatus.Draw;
 
-		if (this.board.isKingInCheck(enemy))
-			if (this.board.hasAllowedMoves(enemy))
+		if (this.board.isKingInCheck(color))
+			if (this.board.hasAllowedMoves(color))
 				return GameStatus.Check;
 			else
 				return GameStatus.CheckMate;
 
-		if (!board.hasAllowedMoves(enemy))
+		if (!board.hasAllowedMoves(color))
 			return GameStatus.Pat;
 
 		return GameStatus.OnGoing;
 	}
 
+	/**
+	 * Check the status of the gamere
+	 */
+	public GameStatus checkGameStatus() {
+		return checkGameStatus(Color.getEnemy(getPlayerTurn()));
+	}
+
+	/**
+	 * Add a player move (basic move, castling, ...) to the game history.
+	 */
 	public void addAction(PlayerCommand command) {
 		this.movesHistory.add(command);
 	}
 
+	/**
+	 * @return the last player action
+	 */
 	public PlayerCommand getLastAction() {
 		if (this.movesHistory.isEmpty())
 			return null;
 		return this.movesHistory.pop();
 	}
 
+	/**
+	 * Update the last board move ater an undo.
+	 */
 	public void updateLastMove() {
 		if (this.movesHistory.isEmpty())
 			return;
@@ -108,6 +134,9 @@ public class Game {
 		}
 	}
 
+	/**
+	 * Remove the board configuration occurence from the game history
+	 */
 	public void undoTraitPiecesPos() {
 		int piecesHash = this.board.hashCode();
 		Integer count = this.traitsPos.get(piecesHash);
@@ -119,4 +148,11 @@ public class Game {
 		return this.movesHistory;
 	}
 
+	/**
+	 * @return wether a pawn should be promoted
+	 */
+	public boolean pawnShouldBePromoted() {
+		return this.board.pawnShouldBePromoted();
+	}
+
 }

app/src/main/java/chess/model/LightGame.java

@@ -0,0 +1,26 @@
+package chess.model;
+
+/**
+ * Game where the most ressource-consuming functions are empty.
+ * Mostly used by bots.
+ * @see GameSimulation
+ */
+
+public class LightGame extends Game {
+
+	@Override
+	public GameStatus checkGameStatus(Color color) {
+		return GameStatus.OnGoing;
+	}
+
+	@Override
+	public void undoTraitPiecesPos() {
+		
+	}
+
+	@Override
+	public void saveTraitPiecesPos() {
+		
+	}
+
+}

app/src/main/java/chess/model/Move.java

@@ -1,5 +1,9 @@
 package chess.model;
 
+/**
+ * Chess move, composed of a starting position, a finishing position and the eventual enemy pieces taken during the move.
+ */
+
 public class Move {
 	private final Coordinate start;
 	private final Coordinate finish;
@@ -11,6 +15,10 @@ public class Move {
 		this.deadPieceCoords = finish;
 	}
 
+	/**
+	 * 
+	 * @return true if the move is valid, false otherwise
+	 */
 	public boolean isValid() {
 		return this.start.isValid() && this.finish.isValid() && !this.start.equals(this.finish);
 	}
@@ -23,6 +31,10 @@ public class Move {
 		return finish;
 	}
 
+	/**
+	 * Returns the number of cells traversed by the move.
+	 * @return int
+	 */
 	public int traversedCells() {
 		assert isValid() : "Move is invalid!";
 
@@ -41,6 +53,9 @@ public class Move {
 		return 0;
 	}
 
+	/**
+	 * @return the coordinates of the cell in the middle of the move
+	 */
 	public Coordinate getMiddle() {
 		return Coordinate.fromIndex((getStart().toIndex() + getFinish().toIndex()) / 2);
 	}

app/src/main/java/chess/model/Piece.java

@@ -1,5 +1,9 @@
 package chess.model;
 
+/**
+ * Piece of a game. Posesses a color and the number of time it has been moved.
+ */
+
 public abstract class Piece {
 
 	private final Color color;
@@ -28,7 +32,4 @@ public abstract class Piece {
 
 	public abstract <T> T accept(PieceVisitor<T> visitor);
 
-	@Override
-	public abstract boolean equals(Object other);
-
 }

app/src/main/java/chess/model/PieceVisitor.java

@@ -7,6 +7,10 @@ import chess.model.pieces.Pawn;
 import chess.model.pieces.Queen;
 import chess.model.pieces.Rook;
 
+/**
+ * Visitor interface for pieces.
+ */
+
 public interface PieceVisitor<T> {
 
 	default T visit(Piece piece) {

app/src/main/java/chess/model/pieces/Bishop.java

@@ -4,6 +4,9 @@ import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
+/**
+ * Bishop piece.
+ */
 public class Bishop extends Piece {
 
 	public Bishop(Color color) {
@@ -15,13 +18,4 @@ public class Bishop extends Piece {
 		return visitor.visitPiece(this);
 	}
 
-	@Override
-	public int hashCode() {
-		return 0;
-	}
-
-	public boolean equals(Object obj) {
-		return (obj instanceof Bishop && ((Bishop) obj).getColor() == this.getColor());
-	}
-
 }

app/src/main/java/chess/model/pieces/King.java

@@ -4,6 +4,9 @@ import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
+/**
+ * King piece.
+ */
 public class King extends Piece {
 
 	public King(Color color) {
@@ -14,13 +17,4 @@ public class King extends Piece {
 	public <T> T accept(PieceVisitor<T> visitor) {
 		return visitor.visitPiece(this);
 	}
-
-	@Override
-	public int hashCode() {
-		return 1;
-	}
-
-	public boolean equals(Object obj) {
-		return (obj instanceof King && ((King) obj).getColor() == this.getColor());
-	}
 }

app/src/main/java/chess/model/pieces/Knight.java

@@ -4,6 +4,9 @@ import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
+/**
+ * Knight piece.
+ */
 public class Knight extends Piece {
 
 	public Knight(Color color) {
@@ -15,12 +18,4 @@ public class Knight extends Piece {
 		return visitor.visitPiece(this);
 	}
 
-	@Override
-	public int hashCode() {
-		return 2;
-	}
-
-	public boolean equals(Object obj) {
-		return (obj instanceof Knight && ((Knight) obj).getColor() == this.getColor());
-	}
 }

app/src/main/java/chess/model/pieces/Pawn.java

@@ -4,6 +4,9 @@ import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
+/**
+ * Pawn piece.
+ */
 public class Pawn extends Piece {
 
 	public Pawn(Color color) {
@@ -19,12 +22,4 @@ public class Pawn extends Piece {
 		return getColor() == Color.White ? 1 : -1;
 	}
 
-	@Override
-	public int hashCode() {
-		return 3;
-	}
-
-	public boolean equals(Object obj) {
-		return (obj instanceof Pawn && ((Pawn) obj).getColor() == this.getColor());
-	}
 }

app/src/main/java/chess/model/pieces/Queen.java

@@ -4,6 +4,9 @@ import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
+/**
+ * Queen piece.
+ */
 public class Queen extends Piece {
 
 	public Queen(Color color) {
@@ -15,12 +18,5 @@ public class Queen extends Piece {
 		return visitor.visitPiece(this);
 	}
 
-	@Override
-	public int hashCode() {
-		return 4;
-	}
 
-	public boolean equals(Object obj) {
-		return (obj instanceof Queen && ((Queen) obj).getColor() == this.getColor());
-	}
 }

app/src/main/java/chess/model/pieces/Rook.java

@@ -4,6 +4,9 @@ import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
+/**
+ * Rook piece.
+ */
 public class Rook extends Piece {
 
 	public Rook(Color color) {
@@ -15,12 +18,4 @@ public class Rook extends Piece {
 		return visitor.visitPiece(this);
 	}
 
-	@Override
-	public int hashCode() {
-		return 5;
-	}
-
-	public boolean equals(Object other) {
-		return (other instanceof Rook && ((Rook) other).getColor() == this.getColor());
-	}
 }

app/src/main/java/chess/model/rules/PermissiveRuleChecker.java

@@ -1,4 +1,4 @@
-package chess.model.visitor;
+package chess.model.rules;
 
 import chess.model.Coordinate;
 import chess.model.Direction;
@@ -12,6 +12,10 @@ import chess.model.pieces.Pawn;
 import chess.model.pieces.Queen;
 import chess.model.pieces.Rook;
 
+/**
+ * Check if a move can be done.
+ */
+
 public class PermissiveRuleChecker implements PieceVisitor<Boolean> {
 
 	private final Move move;

app/src/main/java/chess/model/rules/PiecePathChecker.java

@@ -1,4 +1,4 @@
-package chess.model.visitor;
+package chess.model.rules;
 
 import chess.model.ChessBoard;
 import chess.model.Color;
@@ -14,6 +14,9 @@ import chess.model.pieces.Pawn;
 import chess.model.pieces.Queen;
 import chess.model.pieces.Rook;
 
+/**
+ * Check if there are pieces in the path of a move.
+ */
 public class PiecePathChecker implements PieceVisitor<Boolean> {
 
 	private final ChessBoard board;
@@ -104,10 +107,11 @@ public class PiecePathChecker implements PieceVisitor<Boolean> {
 		Coordinate middle = lastMove.getMiddle();
 
 		if (middle.equals(this.move.getFinish())
-				&& new PawnIdentifier(pieceToEat.getColor()).isPawn(pieceToEat)) {
+				&& pieceToEat instanceof Pawn) {
 			this.move.setDeadPieceCoords(lastMove.getFinish());
 			return true;
 		}
+
 		return false;
 	}
 

app/src/main/java/chess/model/visitor/KingIdentifier.java

@@ -1,52 +0,0 @@
-package chess.model.visitor;
-
-import chess.model.Color;
-import chess.model.Piece;
-import chess.model.PieceVisitor;
-import chess.model.pieces.*;
-
-public class KingIdentifier implements PieceVisitor<Boolean> {
-
-	private final Color color;
-
-	public KingIdentifier(Color color) {
-		this.color = color;
-	}
-
-	public boolean isKing(Piece piece) {
-		if (piece == null)
-			return false;
-		return visit(piece);
-	}
-
-	@Override
-	public Boolean visitPiece(Bishop bishop) {
-		return false;
-	}
-
-	@Override
-	public Boolean visitPiece(King king) {
-		return king.getColor() == color;
-	}
-
-	@Override
-	public Boolean visitPiece(Knight knight) {
-		return false;
-	}
-
-	@Override
-	public Boolean visitPiece(Pawn pawn) {
-		return false;
-	}
-
-	@Override
-	public Boolean visitPiece(Queen queen) {
-		return false;
-	}
-
-	@Override
-	public Boolean visitPiece(Rook rook) {
-		return false;
-	}
-
-}

app/src/main/java/chess/model/visitor/PawnIdentifier.java

@@ -1,52 +0,0 @@
-package chess.model.visitor;
-
-import chess.model.Color;
-import chess.model.Piece;
-import chess.model.PieceVisitor;
-import chess.model.pieces.*;
-
-public class PawnIdentifier implements PieceVisitor<Boolean> {
-
-	private final Color color;
-
-	public PawnIdentifier(Color color) {
-		this.color = color;
-	}
-
-	public boolean isPawn(Piece piece) {
-		if (piece == null)
-			return false;
-		return visit(piece);
-	}
-
-	@Override
-	public Boolean visitPiece(Bishop bishop) {
-		return false;
-	}
-
-	@Override
-	public Boolean visitPiece(King king) {
-		return false;
-	}
-
-	@Override
-	public Boolean visitPiece(Knight knight) {
-		return false;
-	}
-
-	@Override
-	public Boolean visitPiece(Pawn pawn) {
-		return pawn.getColor() == color;
-	}
-
-	@Override
-	public Boolean visitPiece(Queen queen) {
-		return false;
-	}
-
-	@Override
-	public Boolean visitPiece(Rook rook) {
-		return false;
-	}
-
-}

app/src/main/java/chess/pgn/PgnExport.java

@@ -4,6 +4,7 @@ import java.util.List;
 
 import chess.controller.CommandExecutor;
 import chess.controller.PlayerCommand;
+import chess.controller.Command.CommandResult;
 import chess.controller.commands.CastlingCommand;
 import chess.controller.commands.GetPieceAtCommand;
 import chess.controller.commands.GetPlayerMovesCommand;
@@ -11,7 +12,6 @@ import chess.controller.commands.MoveCommand;
 import chess.controller.commands.NewGameCommand;
 import chess.controller.commands.PromoteCommand;
 import chess.controller.event.EmptyGameDispatcher;
-import chess.model.ChessBoard;
 import chess.model.Color;
 import chess.model.Coordinate;
 import chess.model.Game;
@@ -19,29 +19,12 @@ import chess.model.Move;
 import chess.model.Piece;
 import chess.model.pieces.Pawn;
 
+/**
+ * Export a game to PGN format.
+ */
+
 public class PgnExport {
 
-	// public static void main(String[] args) {
-	// 	final Game game = new Game(new ChessBoard());
-	// 	final CommandExecutor commandExecutor = new CommandExecutor(game);
-
-	// 	DumbAI ai1 = new DumbAI(commandExecutor, Color.White);
-	// 	commandExecutor.addListener(ai1);
-
-	// 	DumbAI ai2 = new DumbAI(commandExecutor, Color.Black);
-	// 	commandExecutor.addListener(ai2);
-
-	// 	commandExecutor.addListener(new GameAdaptator() {
-	// 		@Override
-	// 		public void onGameEnd() {
-	// 			System.out.println(exportGame(game));
-	// 			commandExecutor.close();
-	// 		}
-	// 	});
-
-	// 	commandExecutor.executeCommand(new NewGameCommand());
-	// }
-
 	private static final PiecePgnName piecePgnName = new PiecePgnName();
 
 	private static Piece pieceAt(CommandExecutor commandExecutor, Coordinate coordinate) {
@@ -57,21 +40,27 @@ public class PgnExport {
 	}
 
 	private static String gameEnd(Game game) {
-		switch (game.checkGameStatus()) {
+		switch (game.checkGameStatus(game.getPlayerTurn())) {
 			case Draw:
 			case Pat:
 				return "1/2-1/2";
 
 			case CheckMate:
 				if (game.getPlayerTurn() == Color.White)
-					return "1-0";
-				return "0-1";
+					return "0-1";
+				return "1-0";
 
 			default:
 				return "";
 		}
 	}
 
+	/**
+	 * Resolve PGN ambiguity in the case of two pieces of the same type able to move on the same square.
+	 * @param cmdExec the command executor attached to the game
+	 * @param pieceMove move of the piece
+	 * @return the character that solves the eventual ambiguity, empty if no ambiguity to start with
+	 */
 	private static String resolveAmbiguity(CommandExecutor cmdExec, Move pieceMove) {
 		Piece movingPiece = pieceAt(cmdExec, pieceMove.getStart());
 
@@ -89,7 +78,7 @@ public class PgnExport {
 			Piece otherPiece = pieceAt(cmdExec, move.getStart());
 
 			// checking type of piece
-			if (otherPiece.hashCode() != movingPiece.hashCode())
+			if (!otherPiece.getClass().equals(movingPiece.getClass()))
 				continue;
 
 			String startPos = toString(pieceMove.getStart());
@@ -105,6 +94,12 @@ public class PgnExport {
 		return "";
 	}
 
+	/**
+	 * From a move, get the capture-part of the associated PGN string.
+	 * @param move the move
+	 * @param movingPiece the piece that is moving
+	 * @return the capture string of the PGN move
+	 */
 	private static String capture(MoveCommand move, Piece movingPiece) {
 		String result = "";
 		if (move.getDeadPiece() != null) {
@@ -138,7 +133,7 @@ public class PgnExport {
 	}
 
 	private static String checkCheckMate(Game game) {
-		switch (game.checkGameStatus()) {
+		switch (game.checkGameStatus(game.getPlayerTurn())) {
 			case CheckMate:
 				return "#";
 
@@ -150,7 +145,10 @@ public class PgnExport {
 		}
 	}
 
-	private static String printMove(PlayerCommand cmd, PlayerCommand nextCommand, Game virtualGame,
+	private record MoveResult(String move, CommandResult commandResult) {
+	}
+
+	private static MoveResult printMove(PlayerCommand cmd, PlayerCommand nextCommand, Game virtualGame,
 			CommandExecutor executor) {
 		String result = "";
 		if (cmd instanceof MoveCommand move) {
@@ -178,20 +176,19 @@ public class PgnExport {
 			result += castling(castlingCommand);
 		}
 
-		executor.executeCommand(cmd);
+		CommandResult commandResult = executor.executeCommand(cmd);
 
 		// check or checkmate
 		result += checkCheckMate(virtualGame);
 
 		result += " ";
 
-		return result;
+		return new MoveResult(result, commandResult);
 	}
 
 	public static String exportGame(Game game) {
 
-		ChessBoard board = new ChessBoard();
-		Game virtualGame = new Game(board);
+		Game virtualGame = new Game();
 
 		CommandExecutor executor = new CommandExecutor(virtualGame, new EmptyGameDispatcher());
 		executor.executeCommand(new NewGameCommand());
@@ -201,17 +198,33 @@ public class PgnExport {
 
 		int tour = 1;
 
+		String lastMove = null;
+
 		for (int i = 0; i < commands.size(); i++) {
 			PlayerCommand cmd = commands.get(i);
 			PlayerCommand nextCommand = null;
+
 			if (i != commands.size() - 1) {
 				nextCommand = commands.get(i + 1);
 			}
-			if (virtualGame.getPlayerTurn() == Color.White) {
+			MoveResult moveResult = printMove(cmd, nextCommand, virtualGame, executor);
+			if (moveResult.commandResult() == CommandResult.Moved && virtualGame.getPlayerTurn() == Color.Black) {
 				result += tour + ".";
 				tour++;
 			}
-			result += printMove(cmd, nextCommand, virtualGame, executor);
+			
+			if (moveResult.commandResult() == CommandResult.ActionNeeded) {
+				lastMove = moveResult.move();
+				continue;
+			}
+			
+			if (lastMove != null && moveResult.commandResult() == CommandResult.Moved){
+				result += lastMove;
+				lastMove = null;
+				continue;
+			}
+			result += moveResult.move();
+
 		}
 		return result + " " + gameEnd(virtualGame);
 	}

app/src/main/java/chess/pgn/PgnFileSimulator.java

@@ -0,0 +1,16 @@
+package chess.pgn;
+
+import chess.controller.CommandExecutor;
+import common.AssetManager;
+
+/**
+ * Apply moves from a pgn file at the start of a game.
+ */
+
+public class PgnFileSimulator extends PgnSimulator{
+
+	public PgnFileSimulator(CommandExecutor commandExecutor, String fileName) {
+		super(commandExecutor, AssetManager.getResourceAsString(fileName));
+	}
+	
+}

app/src/main/java/chess/pgn/PgnImport.java

@@ -0,0 +1,198 @@
+package chess.pgn;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import chess.controller.CommandExecutor;
+import chess.controller.PlayerCommand;
+import chess.controller.commands.CastlingCommand;
+import chess.controller.commands.MoveCommand;
+import chess.controller.commands.NewGameCommand;
+import chess.controller.commands.PromoteCommand;
+import chess.controller.commands.PromoteCommand.PromoteType;
+import chess.controller.event.EmptyGameDispatcher;
+import chess.model.ChessBoard;
+import chess.model.Coordinate;
+import chess.model.Game;
+import chess.model.Move;
+import chess.model.Piece;
+import chess.model.pieces.Bishop;
+import chess.model.pieces.King;
+import chess.model.pieces.Knight;
+import chess.model.pieces.Pawn;
+import chess.model.pieces.Queen;
+import chess.model.pieces.Rook;
+
+/**
+ * Import a game from PGN format.
+ */
+
+public class PgnImport {
+
+	private static final Map<String, Class<? extends Piece>> pieceMap = Map.of(
+			"K", King.class,
+			"Q", Queen.class,
+			"R", Rook.class,
+			"B", Bishop.class,
+			"N", Knight.class);
+
+	private static final Map<String, PromoteType> promoteMap = Map.of(
+			"Q", PromoteType.Queen,
+			"R", PromoteType.Rook,
+			"B", PromoteType.Bishop,
+			"N", PromoteType.Knight);
+
+	public static List<PlayerCommand> importGame(String pgnContent) {
+		String[] parts = pgnContent.split("\n\n");
+		// we just ignore headers
+		return getMoves(parts[parts.length - 1]);
+	}
+
+	private static final int COORDINATE_ANY = -1;
+
+	/**
+	 * Parse the moves from a PGN string.
+	 * @param unparsedMoves
+	 * @return
+	 */
+	private static List<PlayerCommand> getMoves(String unparsedMoves) {
+		String[] moves = unparsedMoves.replaceAll("\\{.*?\\}", "") // Remove comments
+				.replaceAll("\\n", " ") // Remove new lines
+				.split("[\\s.]+"); // Split by whitespace and dots (trimming it also)
+		
+		Game virtualGame = new Game();
+		CommandExecutor commandExecutor = new CommandExecutor(virtualGame, new EmptyGameDispatcher());
+		List<PlayerCommand> instructions = new ArrayList<>();
+		
+		commandExecutor.executeCommand(new NewGameCommand());
+
+		for (int i = 0; i < moves.length; i++) {
+			if (i % 3 == 0)
+				continue;
+
+			String move = moves[i];
+
+			if (move.equals("1-0") || move.equals("0-1") || move.equals("1/2-1/2")) {
+				break; // End of the game
+			}
+
+			List<PlayerCommand> cmds = parseMove(move, virtualGame);
+			commandExecutor.executeCommands(cmds);
+
+			instructions.addAll(cmds);
+		}
+		return instructions;
+	}
+
+	/**
+	 * Parse a move from the PGN format and plays it in the given game.
+	 * @param move
+	 * @param game
+	 * @return
+	 */
+	private static List<PlayerCommand> parseMove(String move, Game game) {
+		if (move.equals("O-O-O"))
+			return Arrays.asList(new CastlingCommand(true));
+		if (move.equals("O-O"))
+			return Arrays.asList(new CastlingCommand(false));
+
+		move = move.replaceAll("[x|#|\\+]", "");
+
+		PromoteCommand promoteCommand = null;
+
+		if (move.contains("=")) {
+			String promoteString = move.substring(move.length() - 1);
+			promoteCommand = new PromoteCommand(promoteMap.get(promoteString));
+			move = move.substring(0, move.length() - 2);
+		}
+
+		Class<? extends Piece> pieceType = pieceMap.get(move.substring(0, 1));
+
+		if (pieceType == null)
+			pieceType = Pawn.class;
+		else
+			move = move.substring(1);
+
+		assert move.length() == 3 || move.length() == 2;
+
+		Coordinate ambiguity = new Coordinate(COORDINATE_ANY, COORDINATE_ANY);
+
+		// ambiguity
+		if (move.length() == 3) {
+			ambiguity = getAmbiguityPattern(move.charAt(0));
+			move = move.substring(1);
+		}
+
+		Coordinate dest = stringToCoordinate(move);
+
+		Coordinate start = getStartCoord(dest, pieceType, ambiguity, game);
+
+		List<PlayerCommand> cmds = new ArrayList<>();
+		cmds.add(new MoveCommand(new Move(start, dest)));
+		if (promoteCommand != null)
+			cmds.add(promoteCommand);
+
+		return cmds;
+	}
+
+	/**
+	 * Get the start coordinate of a piece.
+	 * @param dest the end position of the moving piece
+	 * @param pieceType the type of the piece
+	 * @param ambiguity	coordinates of the moving piece, indicated with the constant COORDINATE_ANY.
+	 * @param game the game
+	 * @see COORDINATE_ANY
+	 * @see getAmbiguityPattern	 
+	 * @return the start coordinate of the piece
+	 */
+	private static Coordinate getStartCoord(Coordinate dest, Class<? extends Piece> pieceType, Coordinate ambiguity, Game game) {
+		final ChessBoard board = game.getBoard();
+
+		List<Coordinate> starts = board.getAllowedStarts(dest, game.getPlayerTurn());
+
+		assert !starts.isEmpty() : "No moves allowed!";
+
+		for (Coordinate start : starts) {
+			Piece piece = board.pieceAt(start);
+			if (piece.getClass().equals(pieceType) && coordPatternMatch(start, ambiguity))
+				return start;
+		}
+
+		assert false : "There is a small problem ...";
+
+		return null;
+	}
+
+	private static int getXCoord(char xPos) {
+		return xPos - 'a';
+	}
+
+	private static int getYCoord(char yPos) {
+		return Coordinate.VALUE_MAX - 1 - (yPos - '1');
+	}
+
+	private static boolean coordPatternMatch(Coordinate coord, Coordinate pattern) {
+		if (pattern.getX() != COORDINATE_ANY && coord.getX() != pattern.getX())
+			return false;
+
+		if (pattern.getY() != COORDINATE_ANY && coord.getY() != pattern.getY())
+			return false;
+
+		return true;
+	}
+
+	private static Coordinate getAmbiguityPattern(char amb) {
+		if (Character.isDigit(amb))
+			return new Coordinate(COORDINATE_ANY, getYCoord(amb));
+		return new Coordinate(getXCoord(amb), COORDINATE_ANY);
+	}
+
+	private static Coordinate stringToCoordinate(String coordinates) {
+		char xPos = coordinates.charAt(0);
+		char yPos = coordinates.charAt(1);
+
+		return new Coordinate(getXCoord(xPos), getYCoord(yPos));
+	}
+}

app/src/main/java/chess/pgn/PgnSimulator.java

@@ -0,0 +1,34 @@
+package chess.pgn;
+
+
+import java.util.List;
+
+import chess.controller.CommandExecutor;
+import chess.controller.PlayerCommand;
+import chess.controller.event.GameAdapter;
+import common.Signal0;
+
+/**
+ * Apply moves from a pgn string at the start of a game.
+ */
+
+public class PgnSimulator extends GameAdapter {
+
+	private final CommandExecutor commandExecutor;
+	private final String pgn;
+
+	public final Signal0 onComplete = new Signal0();
+
+	public PgnSimulator(CommandExecutor commandExecutor, String pgn) {
+		this.commandExecutor = commandExecutor;
+		this.pgn = pgn;
+	}
+
+	@Override
+	public void onGameStart() {
+		List<PlayerCommand> cmds = PgnImport.importGame(this.pgn);
+		this.commandExecutor.executeCommands(cmds);
+		this.onComplete.emit();
+	}
+	
+}

app/src/main/java/chess/pgn/PiecePgnName.java

@@ -8,6 +8,10 @@ import chess.model.pieces.Pawn;
 import chess.model.pieces.Queen;
 import chess.model.pieces.Rook;
 
+/**
+ * Visitor that returns the PGN name of a piece.
+ */
+
 public class PiecePgnName implements PieceVisitor<String> {
 
 	@Override

app/src/main/java/chess/simulator/CastlingTest.java

@@ -1,31 +0,0 @@
-package chess.simulator;
-
-import chess.controller.CommandExecutor;
-import chess.model.Coordinate;
-import chess.model.Move;
-
-import java.util.Arrays;
-import java.util.List;
-
-public class CastlingTest extends Simulator {
-    public CastlingTest(CommandExecutor commandExecutor) {
-        super(commandExecutor);
-    }
-
-    @Override
-    protected List<Move> getMoves() {
-        return Arrays.asList(
-                // white pawn
-                new Move(new Coordinate(6, 6), new Coordinate(6, 4)),
-                // black knight
-                new Move(new Coordinate(1, 0), new Coordinate(0, 2)),
-                // white bishop
-                new Move(new Coordinate(5, 7), new Coordinate(7, 5)),
-                // black pawn
-                new Move(new Coordinate(1, 1), new Coordinate(1, 2)),
-                // white knight
-                new Move(new Coordinate(6, 7), new Coordinate(5, 5)),
-                // black pawn, bis
-                new Move(new Coordinate(2, 1), new Coordinate(2, 2)));
-    }
-}

app/src/main/java/chess/simulator/FoolCheckMate.java

@@ -1,28 +0,0 @@
-package chess.simulator;
-
-import java.util.Arrays;
-import java.util.List;
-
-import chess.controller.CommandExecutor;
-import chess.model.Coordinate;
-import chess.model.Move;
-
-public class FoolCheckMate extends Simulator {
-
-	public FoolCheckMate(CommandExecutor commandExecutor) {
-		super(commandExecutor);
-	}
-
-	@Override
-	public List<Move> getMoves() {
-		return Arrays.asList(
-				// white pawn
-				new Move(new Coordinate(5, 6), new Coordinate(5, 5)),
-				// black pawn
-				new Move(new Coordinate(4, 1), new Coordinate(4, 3)),
-				// 2nd white pawn
-				new Move(new Coordinate(6, 6), new Coordinate(6, 4)),
-				// black queen
-				new Move(new Coordinate(3, 0), new Coordinate(7, 4)));
-	}
-}

app/src/main/java/chess/simulator/PromoteTest.java

@@ -1,40 +0,0 @@
-package chess.simulator;
-
-import java.util.Arrays;
-import java.util.List;
-
-import chess.controller.CommandExecutor;
-import chess.model.Coordinate;
-import chess.model.Move;
-
-public class PromoteTest extends Simulator{
-
-	public PromoteTest(CommandExecutor commandExecutor) {
-		super(commandExecutor);
-	}
-
-	@Override
-	protected List<Move> getMoves() {
-		return Arrays.asList(
-				// white pawn
-				new Move(new Coordinate(5, 6), new Coordinate(5, 4)),
-				// black pawn
-				new Move(new Coordinate(4, 1), new Coordinate(4, 3)),
-				// white pawn capture
-				new Move(new Coordinate(5, 4), new Coordinate(4, 3)),
-				// black king
-				new Move(new Coordinate(4, 0), new Coordinate(4, 1)),
-				// white pawn moves
-				new Move(new Coordinate(4, 3), new Coordinate(4, 2)),
-				// black king
-				new Move(new Coordinate(4, 1), new Coordinate(5, 2)),
-				// white pawn moves
-				new Move(new Coordinate(4, 2), new Coordinate(4, 1)),
-				// black king
-				new Move(new Coordinate(5, 2), new Coordinate(6, 2))
-				// white pawn moves
-				// new Move(new Coordinate(4, 1), new Coordinate(4, 0))
-				);
-	}
-	
-}

app/src/main/java/chess/simulator/Simulator.java

@@ -1,39 +0,0 @@
-package chess.simulator;
-
-import java.util.List;
-
-import chess.controller.CommandExecutor;
-import chess.controller.commands.MoveCommand;
-import chess.controller.event.GameAdaptator;
-import chess.model.Move;
-import common.Signal0;
-
-public abstract class Simulator extends GameAdaptator {
-
-	protected final CommandExecutor commandExecutor;
-
-	public final Signal0 onComplete = new Signal0();
-	private int currentMove = 0;
-
-	public Simulator(CommandExecutor commandExecutor) {
-		this.commandExecutor = commandExecutor;
-	}
-
-	@Override
-	public void onGameStart() {
-		for (Move move : getMoves()) {
-			this.commandExecutor.executeCommand(new MoveCommand(move));
-		}
-	}
-
-	@Override
-	public void onBoardUpdate() {
-		currentMove++;
-		if (currentMove == getMoves().size()) {
-			onComplete.emit();
-		}
-	}
-
-	protected abstract List<Move> getMoves();
-
-}

app/src/main/java/chess/view/DDDrender/Camera.java

@@ -0,0 +1,93 @@
+package chess.view.DDDrender;
+
+import org.joml.Matrix4f;
+import org.joml.Vector2f;
+import org.joml.Vector3f;
+import org.joml.Vector4f;
+
+/**
+ * 3D camera
+ */
+public class Camera {
+    public static final float fov = 70.0f;
+    public static final float zNear = 0.01f;
+    public static final float zFar = 1000.0f;
+
+    private static final Vector3f up = new Vector3f(0.0f, -1.0f, 0.0f);
+    private static final Vector3f center = new Vector3f(0.0f, 0.0f, 0.0f);
+
+    private final float distance = 1.5f;
+    private final float camHeight = 1.5f;
+
+    private float aspectRatio;
+    private float angle;
+
+    private Vector3f pos;
+
+    public Camera() {
+        this.pos = new Vector3f(0.0f, camHeight, 0.0f);
+        setRotateAngle((float) Math.PI);
+    }
+
+    public void move(float x, float y) {
+        this.pos.x += x;
+        this.pos.y += y;
+    }
+
+    public void setRotateAngle(float angle) {
+        this.angle = angle;
+        updatePostion();
+    }
+
+    private void updatePostion() {
+        final float finalX = (float) Math.sin(angle);
+        final float finalZ = (float) -Math.cos(angle);
+        this.pos.set(distance * finalX, this.pos.get(1), distance * finalZ);
+    }
+
+    public float getRotateAngle() {
+        return angle;
+    }
+
+    public Vector3f getPos() {
+        return pos;
+    }
+
+    public float getFov() {
+        return fov;
+    }
+
+    public void setAspectRatio(float aspectRatio) {
+        this.aspectRatio = aspectRatio;
+    }
+
+    public Matrix4f getPerspectiveMatrix() {
+        return new Matrix4f().perspective((float) (Math.toRadians(fov)), aspectRatio, zNear, zFar);
+    }
+
+    public Matrix4f getViewMatrix() {
+        return new Matrix4f().lookAt(pos, center, up);
+    }
+
+    /**
+     * Performs a ray casting to find the selected cell by the cursor
+     * @return the position of the cell in world coordinates
+     */
+    public Vector2f getCursorWorldFloorPos(Vector2f screenPos, int windowWidth, int windowHeight) {
+        float relativeX = (screenPos.x / (float) windowWidth * 2.0f) - 1.0f;
+        float relativeY = 1.0f - (screenPos.y / (float) windowHeight * 2.0f);
+
+        Vector4f rayClip = new Vector4f(relativeX, relativeY, -1.0f, 1.0f);
+
+        Vector4f rayEye = getPerspectiveMatrix().invert().transform(rayClip);
+
+        rayEye = new Vector4f(rayEye.x, rayEye.y, -1.0f, 0.0f);
+
+        Vector4f rayWorld = getViewMatrix().invert().transform(rayEye);
+
+        float lambda = -this.pos.y / rayWorld.y;
+
+        return new Vector2f(lambda * rayWorld.x + this.pos.x, lambda *
+                rayWorld.z + this.pos.z);
+    }
+}

app/src/main/java/chess/view/DDDrender/DDDModel.java

@@ -0,0 +1,30 @@
+package chess.view.DDDrender;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.List;
+
+import chess.view.DDDrender.opengl.VertexArray;
+
+/**
+ * OpenGL model.
+ */
+public class DDDModel implements Closeable {
+	private final List<VertexArray> vaos;
+
+	public DDDModel(List<VertexArray> vaos) {
+		this.vaos = vaos;
+	}
+
+	public List<VertexArray> getVaos() {
+		return vaos;
+	}
+
+	@Override
+	public void close() throws IOException {
+		for (VertexArray vertexArray : vaos) {
+			vertexArray.close();
+		}
+	}
+
+}

app/src/main/java/chess/view/DDDrender/DDDPlacement.java

@@ -0,0 +1,24 @@
+package chess.view.DDDrender;
+
+import org.joml.Vector2f;
+
+import chess.model.Coordinate;
+
+/**
+ * Helper functions to convert from 2D to 3D coordinates systems.
+ */
+public class DDDPlacement {
+	public static Vector2f coordinatesToVector(Coordinate coo) {
+		return coordinatesToVector(coo.getX(), coo.getY());
+	}
+
+	public static Vector2f coordinatesToVector(float x, float y) {
+		return new Vector2f(1.0f - 0.125f - x * 0.250f, 1.0f - 0.125f - y * 0.250f);
+	}
+
+	public static Coordinate vectorToCoordinates(Vector2f pos) {
+		int x = (int) ((1.0f - pos.x) * 4.0f);
+		int y = (int) ((1.0f - pos.y) * 4.0f);
+		return new Coordinate(x, y);
+	}
+}

app/src/main/java/chess/view/DDDrender/DDDView.java

@@ -0,0 +1,564 @@
+package chess.view.DDDrender;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+import chess.controller.commands.*;
+import chess.controller.commands.PromoteCommand.PromoteType;
+import imgui.ImGui;
+import imgui.ImVec2;
+import imgui.flag.ImGuiCond;
+import imgui.flag.ImGuiWindowFlags;
+import org.joml.Vector2f;
+import org.joml.Vector3f;
+
+import chess.controller.Command.CommandResult;
+import chess.controller.CommandExecutor;
+import chess.controller.CommandSender;
+import chess.controller.event.GameAdapter;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Move;
+import chess.model.Piece;
+import chess.view.DDDrender.world.BoardEntity;
+import chess.view.DDDrender.world.PieceEntity;
+import chess.view.DDDrender.world.World;
+
+public class DDDView extends GameAdapter implements CommandSender {
+
+    private static final Vector3f BLACK = new Vector3f(0.3f, 0.3f, 0.3f);
+    private static final Vector3f WHITE = new Vector3f(1.0f, 1.0f, 1.0f);
+    private static final Vector3f RED = new Vector3f(1.0f, 0.0f, 0.0f);
+    private static final Vector3f YELLOW = new Vector3f(1.0f, 1.0f, 0.0f);
+    private static final Vector3f BLUE = new Vector3f(0.0f, 0.0f, 1.0f);
+
+    private final CommandExecutor commandExecutor;
+    private final Window window;
+    private final World world;
+    private BoardEntity boardEntity;
+    private final Camera camera;
+    private Coordinate click = null;
+
+    private static final float animationTime = 0.5f; // in seconds
+    private static final int animationTurns = 1;
+
+    private float moveProgress = 0.0f;
+
+    private String waitingPopup = null;
+
+    public DDDView(CommandExecutor commandExecutor) {
+        this.commandExecutor = commandExecutor;
+        this.world = new World();
+        this.camera = new Camera();
+        this.window = new Window(new Renderer(), this.world, this.camera);
+    }
+
+    @Override
+    public CommandExecutor getCommandExecutor() {
+        return this.commandExecutor;
+    }
+
+    private void cancelClick() {
+        this.click = null;
+    }
+
+    private void setClick(Coordinate coordinate) {
+        this.click = coordinate;
+    }
+
+    /**
+     * Invoked when a cell is clicked. The first click selects the piece to move, the second click selects the destination.
+     * @param coordinate
+     */
+    private void onCellClick(Coordinate coordinate) {
+        if (this.click == null) { // case: first click
+            List<Coordinate> allowedMoves = getPieceAllowedMoves(coordinate);
+            if (allowedMoves.isEmpty()) { // case: no movement possible for piece
+                return;
+            }
+            setClick(coordinate);
+            previewMoves(coordinate);
+            return;
+        }
+        // case: second click
+        GetAllowedMovesPieceCommand movesCommand = new GetAllowedMovesPieceCommand(this.click);
+        if (sendCommand(movesCommand) == CommandResult.NotAllowed) { // case: invalid piece to move
+            cancelPreview(this.click);
+            cancelClick();
+            return;
+        }
+        List<Coordinate> allowedMoves = movesCommand.getDestinations();
+        if (allowedMoves.isEmpty()) { // case: no movement possible for piece
+            cancelPreview(this.click);
+            cancelClick();
+            return;
+        }
+        if (allowedMoves.contains(coordinate)) { // case: valid attempt to move
+            cancelPreview(this.click);
+            sendMove(new Move(click, coordinate));
+            cancelClick();
+            return;
+        }
+        if (coordinate != this.click) { // cases: invalid move, selecting another piece
+            cancelPreview(this.click);
+            previewMoves(coordinate);
+            setClick(coordinate);
+            return;
+        }
+        cancelClick(); // case: cancelling previous click
+    }
+
+    /**
+     * Show the possible moves of the piece at the given coordinates: the piece is highlighted in yellow, the allowed moves in red.
+     * @param coordinate
+     */
+    private void previewMoves(Coordinate coordinate) {
+        List<Coordinate> allowedMoves = getPieceAllowedMoves(coordinate);
+        if (allowedMoves.isEmpty())
+            return;
+        this.boardEntity.setCellColor(coordinate, RED);
+        this.world.getPiece(coordinate).setColor(RED);
+        for (Coordinate destCoord : allowedMoves) {
+            this.boardEntity.setCellColor(destCoord, YELLOW);
+        }
+    }
+
+    /**
+     * Invoked when a cell is hovered. The hovered cell is highlighted in red. If the cell contains a piece, its allowed moves are highlighted in red as well.
+     * @param coordinate
+     */
+    private void onCellEnter(Coordinate coordinate) {
+        if (this.click == null) {
+            // small test turning a cell red when hovered
+            this.boardEntity.setCellColor(coordinate, RED);
+
+            PieceEntity pEntity = this.world.getPiece(coordinate);
+            if (pEntity == null)
+                return;
+
+            pEntity.setColor(RED);
+            List<Coordinate> allowedMoves = getPieceAllowedMoves(coordinate);
+            if (allowedMoves.isEmpty())
+                return;
+            for (Coordinate destCoord : allowedMoves) {
+                this.boardEntity.setCellColor(destCoord, YELLOW);
+            }
+        }
+    }
+
+    /**
+     * Invoked when a cell is not hovered anymore, cancel that cell's preview.
+     * @param coordinate
+     */
+    private void onCellExit(Coordinate coordinate) {
+        if (this.click == null) {
+            this.boardEntity.resetCellColor(coordinate);
+            Piece p = getPieceAt(coordinate);
+            if (p == null)
+                return;
+
+            PieceEntity pEntity = this.world.getPiece(coordinate);
+            if (pEntity == null)
+                return;
+
+            pEntity.setColor(p.getColor() == Color.White ? WHITE : BLACK);
+            List<Coordinate> allowedMoves = getPieceAllowedMoves(coordinate);
+            if (allowedMoves.isEmpty())
+                return;
+            for (Coordinate destCoord : allowedMoves) {
+                this.boardEntity.resetCellColor(destCoord);
+            }
+        }
+    }
+
+    /**
+     * Cancel the preview of the moves for the given coordinates.
+     * @param coordinate
+     */
+    private void cancelPreview(Coordinate coordinate) {
+        this.boardEntity.resetCellColor(coordinate);
+        Piece p = getPieceAt(coordinate);
+        if (p == null)
+            return;
+        this.world.getPiece(coordinate).setColor(p.getColor() == Color.White ? WHITE : BLACK);
+        List<Coordinate> allowedMoves = getPieceAllowedMoves(coordinate);
+        if (allowedMoves.isEmpty())
+            return;
+        for (Coordinate destCoord : allowedMoves) {
+            this.boardEntity.resetCellColor(destCoord);
+        }
+    }
+
+    /**
+     * Start the game by initializing the board, creating the events, and starting the game loop.
+     */
+    @Override
+    public void onGameStart() {
+        this.window.scheduleTask(() -> {
+            try {
+                initBoard();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            // start listening to mouse events
+            this.window.OnCellClick.connect(this::onCellClick);
+            this.window.OnCellEnter.connect(this::onCellEnter);
+            this.window.OnCellExit.connect(this::onCellExit);
+            this.window.OnImGuiTopRender.connect(this::onHeaderRender);
+            this.window.OnImGuiBottomRender.connect(this::onFooterRender);
+
+            synchronized (this) {
+                notifyAll();
+            }
+        });
+
+        synchronized (this) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    private void onHeaderRender() {
+        ImGui.text("FPS : " + (int) ImGui.getIO().getFramerate());
+    }
+
+    /**
+     * Render the footer of the window.
+     */
+    private void onFooterRender() {
+        ImGui.beginDisabled(!canDoCastling());
+        if (ImGui.button("Roque")) {
+            sendCastling();
+        }
+        ImGui.endDisabled();
+        ImGui.sameLine();
+        ImGui.beginDisabled(!canDoBigCastling());
+        if (ImGui.button("Grand Roque")) {
+            sendBigCastling();
+        }
+        ImGui.endDisabled();
+        ImGui.sameLine();
+        if (ImGui.button("Annuler le coup précédent")) {
+            sendUndo();
+        }
+        openPopup();
+        renderPopups();
+    }
+
+    private void openPopup() {
+        if (waitingPopup != null) {
+            ImGui.openPopup(waitingPopup);
+            waitingPopup = null;
+        }
+    }
+
+    /**
+     * Create the 3D piece at the given coordinates
+     * @param piece the piece to create
+     * @param coordinate the coordinates of the piece
+     * @return the piece entity
+     * @throws IOException
+     */
+    private PieceEntity createDefault(Piece piece, Coordinate coordinate) throws IOException {
+        Vector2f pieceBoardPos = DDDPlacement.coordinatesToVector(coordinate);
+        Vector3f pieceWorldPos = new Vector3f(pieceBoardPos.x(), 0, pieceBoardPos.y());
+
+        return new PieceEntity(piece, pieceWorldPos,
+                piece.getColor() == Color.White ? WHITE : BLACK,
+                piece.getColor() == Color.White ? 0.0f : (float) Math.PI);
+    }
+
+    /**
+     * Create the 3D board and add the pieces.
+     * @throws IOException
+     */
+    private void initBoard() throws IOException {
+        for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
+            for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
+                Coordinate pos = new Coordinate(i, j);
+                Piece piece = getPieceAt(pos);
+                if (piece == null)
+                    continue;
+
+                this.world.addPiece(createDefault(piece, pos), pos);
+            }
+        }
+        this.boardEntity = new BoardEntity();
+        this.world.addEntity(this.boardEntity);
+    }
+
+    /**
+     * Calculate the position of the point at the t position on a Bezier curve spanning from the begin point to the end point and goign through the control point.
+     * @param begin  begin
+     * @param middle control point
+     * @param end    end
+     * @param t      between 0 and 1
+     * @return the point
+     */
+    private Vector3f bezierCurve(Vector3f begin, Vector3f middle, Vector3f end, float t) {
+        return begin.mul((1.0f - t) * (1.0f - t)).add(middle.mul(2.0f * t * (1.0f - t))).add(end.mul(t * t));
+    }
+
+    /**
+     * Move the piece on the board according to the given move. Called in a loop to animate the movement.
+     * @param progress the proportion of the animation already done
+     * @param piece
+     * @param move
+     */
+    private void pieceTick(float progress, PieceEntity piece, Move move) {
+        float height = 1; // how high the piece is raised
+        Vector2f pieceStartBoard = DDDPlacement.coordinatesToVector(move.getStart());
+        Vector2f pieceDestinationBoard = DDDPlacement.coordinatesToVector(move.getFinish());
+        Vector3f start = new Vector3f(pieceStartBoard.x(), 0, pieceStartBoard.y());
+        Vector3f top = new Vector3f(pieceDestinationBoard.x() - pieceStartBoard.x(), height,
+                pieceDestinationBoard.y() - pieceStartBoard.y());
+        Vector3f end = new Vector3f(pieceDestinationBoard.x(), 0, pieceDestinationBoard.y());
+
+        piece.setPosition(bezierCurve(start, top, end, progress));
+    }
+
+    /**
+     * Move the pieces on the board according to the given moves.
+     * @param moves
+     */
+    private void move3DPieces(List<Move> moves) {
+        final List<PieceEntity> pEntities = new ArrayList<>(moves.size());
+        final List<Consumer<Float>> consumers = new ArrayList<>(moves.size());
+
+        this.moveProgress = 0.0f;
+
+        for (Move move : moves) {
+            final PieceEntity pEntity = this.world.getPiece(move.getStart());
+            final Consumer<Float> moveConsumer = (delta) -> {
+                this.moveProgress += delta / animationTime / (float) moves.size();
+                pieceTick(this.moveProgress, pEntity, move);
+            };
+            pEntities.add(pEntity);
+            consumers.add(moveConsumer);
+            this.window.addRegularTask(moveConsumer);
+        }
+
+        try {
+            Thread.sleep((long) (animationTime * 1000.0f));
+        } catch (InterruptedException e) {
+        }
+
+        for (int i = 0; i < moves.size(); i++) {
+            final Move move = moves.get(i);
+            final Consumer<Float> moveConsumer = consumers.get(i);
+            final PieceEntity pEntity = pEntities.get(i);
+
+            this.window.removeRegularTask(moveConsumer);
+
+            Vector2f pieceDestBoardPos = DDDPlacement.coordinatesToVector(move.getFinish());
+            Vector3f pieceDestWorldPos = new Vector3f(pieceDestBoardPos.x(), 0, pieceDestBoardPos.y());
+
+            final PieceEntity pDead = this.world.getPiece(move.getDeadPieceCoords());
+            this.world.setPieceCoords(null, move.getDeadPieceCoords());
+
+            // we must do that on the rendering thread to avoid
+            // ConcurrentModificationException
+            this.window.scheduleTask(() -> this.world.ejectPiece(pDead));
+
+            pEntity.setPosition(pieceDestWorldPos);
+
+            this.world.movePiece(pEntity, move);
+        }
+
+    }
+
+    @Override
+    public void onMove(Move move, boolean captured) {
+        move3DPieces(List.of(move));
+    }
+
+    /**
+     * Rotate the camera. Calles in a loop to animate the rotation.
+     * @param delta the proportion of the animation already done
+     */
+    private void cameraTick(float delta) {
+        int oddAnimationTurn = (2 * (animationTurns - 1)) + 1;
+        final float angle = (float) Math.PI;
+        this.camera.setRotateAngle(this.camera.getRotateAngle() + angle * delta * oddAnimationTurn / animationTime);
+    }
+
+    /**
+     * Rotate the camera so the current player faces his enemy's pieces.
+     */
+    private void cameraRotate() {
+        float end = this.camera.getRotateAngle() + (float) Math.PI;
+        Consumer<Float> rotationConsumer = this::cameraTick;
+        this.window.addRegularTask(rotationConsumer);
+        try {
+            Thread.sleep((long) (animationTime * 1000.0f));
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        this.window.removeRegularTask(rotationConsumer);
+        this.camera.setRotateAngle(end);
+    }
+
+    @Override
+    public void onPlayerTurn(Color color, boolean undone) {
+        cameraRotate();
+    }
+
+    /**
+     * Run the game.
+     */
+    public void run() {
+        this.window.run();
+
+        // free OpenGL resources
+        try {
+            this.window.close();
+            this.world.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Render a popup with the given title and content.
+     * @param title
+     * @param content
+     */
+    private void renderPopup(String title, Runnable content) {
+        ImVec2 center = ImGui.getMainViewport().getCenter();
+        ImGui.setNextWindowPos(center, ImGuiCond.Appearing, new ImVec2(0.5f, 0.5f));
+        if (ImGui.beginPopupModal(title, null, ImGuiWindowFlags.AlwaysAutoResize | ImGuiWindowFlags.NoMove)) {
+            content.run();
+            if (ImGui.button("Close")) {
+                closeCurrentPopup();
+            }
+            ImGui.endPopup();
+        }
+    }
+
+    private void closeCurrentPopup() {
+        ImGui.closeCurrentPopup();
+        synchronized (this) {
+            notifyAll();
+        }
+    }
+
+    private void renderPopup(String title, String text) {
+        renderPopup(title, () -> ImGui.text(text));
+    }
+
+    /**
+     * Open the promotion dialog.
+     */
+    private void renderPromoteDialog() {
+        renderPopup("Promotion", () -> {
+            ImGui.text("Select the promotion type :");
+            for (PromoteType promoteType : PromoteType.values()) {
+                if (ImGui.button(promoteType.toString())) {
+                    sendPawnPromotion(promoteType);
+                    closeCurrentPopup();
+                }
+                ImGui.sameLine();
+            }
+            ImGui.newLine();
+        });
+    }
+
+    /**
+     * List of possible popups.
+     */
+    private void renderPopups() {
+        renderPopup("Check", "Your king is in check");
+        renderPopup("Checkmate", "Checkmate, it's a win!");
+        renderPromoteDialog();
+        renderPopup("Pat", "It's a pat!");
+        renderPopup("Tie", "It's a tie!");
+        renderPopup("White surrender", "The white player has surrendered!");
+        renderPopup("Black surrender", "The black player has surrendered!");
+        renderPopup("White victory", "The white player has won !");
+        renderPopup("Black victory", "The black player has won !");
+        renderPopup("End", "End of the game, thank you for playing!");
+    }
+
+    /**
+     * Open the popup identified by the given title and block the current thread until the popup is closed.
+     * @param title the title of the popup to open
+     */
+    private void openPopup(String title) {
+        this.waitingPopup = title;
+        // block the current thread until the popup is closed
+        synchronized (this) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    public void onKingInCheck() {
+        openPopup("Check");
+    }
+
+    @Override
+    public void onDraw() {
+        openPopup("Tie");
+    }
+
+    @Override
+    public void onKingInMat() {
+        openPopup("Checkmate");
+    }
+
+    @Override
+    public void onGameEnd() {
+        openPopup("End");
+        this.window.stop();
+    }
+
+    @Override
+    public void onWin(Color color) {
+        openPopup(color == Color.White ? "Black victory" : "White victory");
+    }
+
+    @Override
+    public void onPatSituation() {
+        openPopup("Pat");
+    }
+
+    @Override
+    public void onSurrender(Color color) {
+        openPopup(color == Color.White ? "White surrender" : "Black surrender");
+    }
+
+    @Override
+    public void onCastling(boolean bigCastling, Move kingMove, Move rookMove) {
+        move3DPieces(List.of(kingMove, rookMove));
+    }
+
+    @Override
+    public void onPromotePawn(Coordinate pieceCoords) {
+        openPopup("Promotion");
+    }
+
+    /**
+     * Update the view with the promoted piece
+     */
+    @Override
+    public void onPawnPromoted(PromoteType promotion, Coordinate coordinate) {
+        this.window.scheduleTask(() -> {
+            this.world.ejectPiece(this.world.getPiece(coordinate));
+            try {
+                this.world.addPiece(createDefault(getPieceAt(coordinate), coordinate), coordinate);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        });
+    }
+}

app/src/main/java/chess/view/DDDrender/Renderer.java

@@ -0,0 +1,80 @@
+package chess.view.DDDrender;
+
+import static org.lwjgl.opengl.GL11.GL_UNSIGNED_INT;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+import org.lwjgl.opengl.GL30;
+
+import chess.view.DDDrender.opengl.FrameBuffer;
+import chess.view.DDDrender.opengl.VertexArray;
+import chess.view.DDDrender.shader.BoardShader;
+import chess.view.DDDrender.shader.PieceShader;
+import chess.view.DDDrender.shader.ShaderProgram;
+
+/**
+ * Basic 3D renderer
+ */
+public class Renderer implements Closeable {
+	private BoardShader boardShader;
+	private PieceShader pieceShader;
+	private FrameBuffer frameBuffer;
+
+	public Renderer() {
+		this.boardShader = new BoardShader();
+		this.pieceShader = new PieceShader();
+	}
+
+	public void Init(float windowWidth, float widowHeight) {
+		boardShader.LoadShader();
+		pieceShader.LoadShader();
+
+		this.frameBuffer = new FrameBuffer((int) windowWidth, (int) (widowHeight * 8.0f / 10.0f));
+	}
+
+	public void Update(Camera cam) {
+		this.boardShader.Start();
+		this.boardShader.SetCamMatrix(cam);
+		this.pieceShader.Start();
+		this.pieceShader.SetCamMatrix(cam);
+	}
+
+	public void Render(DDDModel model, Vector3f color, Matrix4f transform) {
+		this.pieceShader.Start();
+		this.pieceShader.setModelColor(color);
+		this.pieceShader.setModelTransform(transform);
+		Render(model);
+	}
+
+	public void Render(DDDModel model) {
+		for (int i = 0; i < model.getVaos().size(); i++) {
+			VertexArray vao = model.getVaos().get(i);
+			RenderVao(this.pieceShader, vao);
+		}
+	}
+
+	public void RenderVao(ShaderProgram shader, VertexArray vertexArray) {
+		shader.Start();
+		vertexArray.Bind();
+		GL30.glDrawElements(GL30.GL_TRIANGLES, vertexArray.GetVertexCount(), GL_UNSIGNED_INT, 0);
+		vertexArray.Unbind();
+	}
+
+	public FrameBuffer getFrameBuffer() {
+		return frameBuffer;
+	}
+
+	public BoardShader getBoardShader() {
+		return boardShader;
+	}
+
+	@Override
+	public void close() throws IOException {
+		this.boardShader.close();
+		this.pieceShader.close();
+		this.frameBuffer.close();
+	}
+}

app/src/main/java/chess/view/DDDrender/Window.java

@@ -0,0 +1,363 @@
+package chess.view.DDDrender;
+
+import common.AssetManager;
+import common.Signal0;
+import org.joml.Vector2f;
+import org.lwjgl.*;
+import org.lwjgl.glfw.*;
+import org.lwjgl.opengl.*;
+import org.lwjgl.system.*;
+
+import chess.model.Coordinate;
+import chess.view.DDDrender.opengl.FrameBuffer;
+import chess.view.DDDrender.world.Entity;
+import chess.view.DDDrender.world.World;
+import common.Signal1;
+import imgui.ImFontConfig;
+import imgui.ImGui;
+import imgui.ImVec2;
+import imgui.flag.ImGuiWindowFlags;
+import imgui.gl3.ImGuiImplGl3;
+import imgui.glfw.ImGuiImplGlfw;
+import imgui.type.ImBoolean;
+import imgui.type.ImInt;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.nio.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.function.Consumer;
+
+import static org.lwjgl.glfw.Callbacks.*;
+import static org.lwjgl.glfw.GLFW.*;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.system.MemoryStack.*;
+import static org.lwjgl.system.MemoryUtil.*;
+
+/**
+ * GLFW window.
+ */
+public class Window implements Closeable {
+
+	// The window handle
+	private long window;       
+
+	private final ImGuiImplGl3 implGl3 = new ImGuiImplGl3();
+	private final ImGuiImplGlfw implGlfw = new ImGuiImplGlfw();
+
+	private Renderer renderer;
+	private final Camera cam;
+	private final World world;
+
+	private final Queue<Runnable> tasks;
+	private final List<Consumer<Float>> regularTasks;
+
+	private Coordinate lastCell = null;
+
+	public final Signal1<Coordinate> OnCellClick = new Signal1<>();
+	public final Signal1<Coordinate> OnCellEnter = new Signal1<>();
+	public final Signal1<Coordinate> OnCellExit = new Signal1<>();
+
+	public final Signal0 OnImGuiTopRender = new Signal0();
+	public final Signal0 OnImGuiBottomRender = new Signal0();
+
+	private ImInt detailLevel = new ImInt(10);
+	private ImBoolean pixelatedFrame = new ImBoolean(true);
+
+	private boolean shouldBeClosed = false;
+
+	public Window(Renderer renderer, World world, Camera camera) {
+		this.renderer = new Renderer();
+		this.cam = camera;
+		this.tasks = new ConcurrentLinkedDeque<>();
+		this.world = world;
+		this.regularTasks = new ArrayList<>();
+	}
+
+	/**
+	 * Add a task to be executed in the next frames.
+	 * @param task
+	 */
+	public synchronized void addRegularTask(Consumer<Float> task) {
+		this.regularTasks.add(task);
+	}
+
+	/**
+	 * Remove a task that had been set to be executed in the next frames.
+	 * @param task
+	 */
+	public synchronized void removeRegularTask(Consumer<Float> task) {this.regularTasks.remove(task);}
+
+	/**
+	 * Schedule a task to be executed in the next frame (3d thread).
+	 * @param runnable
+	 */
+	public synchronized void scheduleTask(Runnable runnable) {
+		this.tasks.add(runnable);
+	}
+
+	/**
+	 * Get the next task to be executed.
+	 * @return
+	 */
+	private synchronized Runnable getNextTask() {
+		return this.tasks.poll();
+	}
+
+	/**
+	 * Run the window.
+	 */
+	public void run() {
+		System.out.println("LWJGL " + Version.getVersion() + "!");
+
+		init();
+		loop();
+
+		// Free the window callbacks and destroy the window
+		glfwFreeCallbacks(window);
+		glfwDestroyWindow(window);
+
+		// Terminate GLFW and free the error callback
+		glfwTerminate();
+		glfwSetErrorCallback(null).free();
+
+		implGl3.shutdown();
+		implGlfw.shutdown();
+
+		ImGui.destroyContext();
+	}
+
+	/**
+	 * Set the configuration of ImGui
+	 */
+	private void initImGui() {
+		ImGui.setCurrentContext(ImGui.createContext());
+
+		implGl3.init("#version 330");
+		implGlfw.init(window, true);
+
+		ImFontConfig config = new ImFontConfig();
+		config.setFontDataOwnedByAtlas(false);
+		try {
+			ImGui.getIO().getFonts().addFontFromMemoryTTF(AssetManager.getResource("fonts/comic.ttf").readAllBytes(),
+					50.0f, config);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Initialize the window.
+	 */
+	private void init() {
+		// Setup an error callback. The default implementation
+		// will print the error message in System.err.
+		GLFWErrorCallback.createPrint(System.err).set();
+
+		// Initialize GLFW. Most GLFW functions will not work before doing this.
+		if (!glfwInit())
+			throw new IllegalStateException("Unable to initialize GLFW");
+
+		// Configure GLFW
+		glfwDefaultWindowHints(); // optional, the current window hints are already the default
+		glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // the window will stay hidden after creation
+		glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // the window will be resizable
+
+		// Create the window
+		window = glfwCreateWindow(1000, 1000, "3DChess", NULL, NULL);
+		if (window == NULL)
+			throw new RuntimeException("Failed to create the GLFW window");
+
+		// Get the thread stack and push a new frame
+		try (MemoryStack stack = stackPush()) {
+			IntBuffer pWidth = stack.mallocInt(1); // int*
+			IntBuffer pHeight = stack.mallocInt(1); // int*
+
+			// Get the window size passed to glfwCreateWindow
+			glfwGetWindowSize(window, pWidth, pHeight);
+
+			// Get the resolution of the primary monitor
+			GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
+
+			// Center the window
+			glfwSetWindowPos(
+					window,
+					(vidmode.width() - pWidth.get(0)) / 2,
+					(vidmode.height() - pHeight.get(0)) / 2);
+
+			glfwSetWindowSize(window, vidmode.width(), vidmode.height());
+			
+			// Make the OpenGL context current
+			glfwMakeContextCurrent(window);
+			
+			GL.createCapabilities();
+			
+			initImGui();
+			
+			renderer.Init(vidmode.width(), vidmode.height());
+		} // the stack frame is popped automatically
+
+		// Enable v-sync
+		glfwSwapInterval(1);
+
+		// Make the window visible
+		glfwShowWindow(window);
+	}
+
+	private void render(float delta, float aspectRatio) {
+		final FrameBuffer frameBuffer = this.renderer.getFrameBuffer();
+
+		cam.setAspectRatio(frameBuffer.getAspectRatio());
+		frameBuffer.Bind();
+		frameBuffer.Clear();
+		renderer.Update(cam);
+		renderWorld();
+		frameBuffer.Unbind();
+	}
+
+	private void renderWorld() {
+		for (Entity entity : this.world.getEntites()) {
+			entity.render(this.renderer);
+		}
+	}
+
+	/**
+	 * Execute the tasks in the queue.
+	 * @param delta time since the last frame
+	 */
+	private synchronized void executeTasks(float delta) {
+		Runnable task = getNextTask();
+		while (task != null) {
+			task.run();
+			task = getNextTask();
+		}
+		for (Consumer<Float> consumer : regularTasks) {
+			consumer.accept(delta);
+		}
+	}
+
+	/**
+	 * Check the cursor position to identify the cell under it.
+	 * @param cursorPosX position of cursor on the x axis
+	 * @param cursorPosY position of cursor on the y axis
+	 * @param windowWidth width of the window
+	 * @param windowHeight height of the window
+	 */
+	private void checkCursor(float cursorPosX, float cursorPosY, int windowWidth, int windowHeight) {
+		Vector2f cursorPos = this.cam.getCursorWorldFloorPos(new Vector2f(cursorPosX, cursorPosY), windowWidth,
+				windowHeight);
+		Coordinate selectedCell = DDDPlacement.vectorToCoordinates(cursorPos);
+		if (this.lastCell == null) {
+			this.lastCell = selectedCell;
+			if (selectedCell.isValid())
+				this.OnCellEnter.emit(selectedCell);
+		} else if (!this.lastCell.equals(selectedCell)) {
+			if (this.lastCell.isValid())
+				this.OnCellExit.emit(this.lastCell);
+			if (selectedCell.isValid())
+				this.OnCellEnter.emit(selectedCell);
+			this.lastCell = selectedCell;
+		}
+
+		if (ImGui.getIO().getMouseClicked(0)) {
+			if (this.lastCell != null && this.lastCell.isValid())
+				this.OnCellClick.emit(this.lastCell);
+		}
+	}
+
+	private void newFrame() {
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear the framebuffer
+
+		implGlfw.newFrame();
+		implGl3.newFrame();
+		ImGui.newFrame();
+	}
+
+	private void renderWindow() {
+		ImGui.showDemoWindow();
+
+		final FrameBuffer frameBuffer = this.renderer.getFrameBuffer();
+		final int frameWidth = (int) ImGui.getIO().getDisplaySizeX();
+		final int frameHeight = (int) (ImGui.getIO().getDisplaySizeY() * 8.0f / 10.0f);
+
+		ImGui.setNextWindowSize(ImGui.getIO().getDisplaySize());
+		ImGui.setNextWindowPos(new ImVec2());
+		ImGui.begin("Main Window", ImGuiWindowFlags.NoDecoration);
+		this.OnImGuiTopRender.emit();
+		ImVec2 mousePos = ImGui.getIO().getMousePos();
+		ImVec2 framePos = ImGui.getCursorScreenPos();
+		checkCursor(mousePos.x - framePos.x, frameHeight - (mousePos.y - framePos.y), frameWidth, frameHeight);
+		ImGui.image(frameBuffer.getRenderTexture(), new ImVec2(frameWidth, frameHeight));
+		this.OnImGuiBottomRender.emit();
+		if(ImGui.sliderInt("Niveau de détail", detailLevel.getData(), 1, 10)){
+			frameBuffer.Resize((int) ((float) frameWidth * detailLevel.get() / 10.0f), (int) ((float) frameHeight * detailLevel.get() / 10.0f));
+		}
+		if (ImGui.checkbox("Minecraft", pixelatedFrame)) {
+			frameBuffer.SetPixelScaling(pixelatedFrame.get());
+		}
+		ImGui.end();
+	}
+
+	/**
+	 * Keep on rendering until the user close the window.
+	 */
+	private void loop() {
+
+		// Set the clear color
+		glClearColor(0.4f, 0.4f, 0.6f, 1.0f);
+
+		glEnable(GL_DEPTH_TEST);
+
+		glEnable(GL_CULL_FACE);
+		glCullFace(GL_FRONT);
+		glFrontFace(GL_CW);
+
+		glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
+
+		int width[] = new int[1];
+		int height[] = new int[1];
+		glfwGetWindowSize(window, width, height);
+
+		// Run the rendering loop until the user has attempted to close
+		// the window or has pressed the ESCAPE key.
+		while (!shouldBeClosed && !glfwWindowShouldClose(window)) {
+
+			newFrame();
+
+			render(ImGui.getIO().getDeltaTime(), (float) width[0] / (float) height[0]);
+
+			renderWindow();
+			ImGui.render();
+			implGl3.renderDrawData(ImGui.getDrawData());
+
+			glfwSwapBuffers(window); // swap the color buffers
+
+			// Poll for window events. The key callback above will only be
+			// invoked during this call.
+			glfwPollEvents();
+
+			executeTasks(ImGui.getIO().getDeltaTime());
+
+			glfwGetWindowSize(window, width, height);
+			glViewport(0, 0, width[0], height[0]);
+
+		}
+	}
+
+	/**
+	 * Closes the window
+	 */
+	public void stop() {
+		shouldBeClosed = true;
+	}
+
+	@Override
+	public void close() throws IOException {
+		shouldBeClosed = true;
+		this.renderer.close();
+	}
+
+}

app/src/main/java/chess/view/DDDrender/loader/BoardModelLoader.java

@@ -0,0 +1,118 @@
+package chess.view.DDDrender.loader;
+
+import org.joml.Vector3f;
+
+import chess.view.DDDrender.opengl.ElementBuffer;
+import chess.view.DDDrender.opengl.VertexArray;
+import chess.view.DDDrender.opengl.VertexBuffer;
+
+public class BoardModelLoader {
+
+	private static final int BOARD_WIDTH = 8;
+	private static final int BOARD_HEIGHT = 8;
+	private static final int BOARD_SIZE = BOARD_WIDTH * BOARD_HEIGHT;
+	private static final int SQUARE_VERTEX_COUNT = 4;
+
+	private static final Vector3f WHITE = new Vector3f(1, 1, 1);
+	private static final Vector3f BLACK = new Vector3f(0, 0, 0);
+	
+	/**
+	 * Create the points to make a 3D board. 
+	 * Note of developers: "Trust me on this one, bro".
+	 * @return array of 3D points, corressponding to the cells composing the board
+	 */
+	private static float[] GetBoardPositions() {
+		float[] positions = new float[BOARD_SIZE * SQUARE_VERTEX_COUNT * 3];
+		for (int i = 0; i < BOARD_WIDTH; i++) {
+			for (int j = 0; j < BOARD_HEIGHT; j++) {
+				float x = i / (float) BOARD_WIDTH;
+				float dx = (i + 1) / (float) BOARD_WIDTH;
+				float z = j / (float) BOARD_HEIGHT;
+				float dz = (j + 1) / (float) BOARD_HEIGHT;
+
+				float trueX = 2 * x - 1;
+				float trueZ = 2 * z - 1;
+				float trueDX = 2 * dx - 1;
+				float trueDZ = 2 * dz - 1;
+
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3] = trueX;
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 1] = 0.0f;
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 2] = trueZ;
+
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 3] = trueDX;
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 4] = 0.0f;
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 5] = trueZ;
+
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 6] = trueX;
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 7] = 0.0f;
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 8] = trueDZ;
+
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 9] = trueDX;
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 10] = 0.0f;
+				positions[(BOARD_WIDTH * i + j) * SQUARE_VERTEX_COUNT * 3 + 11] = trueDZ;
+			}
+		}
+		return positions;
+	}
+
+	/**
+	 * Assign each cell of the bopard to a color. 
+	 * Note of developers: "Why are you even reading this ?"
+	 * @return array of colors, corresponding to the cells composing the board
+	 */
+	private static float[] GetBoardColors() {
+		float[] colors = new float[BOARD_SIZE * SQUARE_VERTEX_COUNT * 3];
+		for (int i = 0; i < BOARD_WIDTH; i++) {
+			for (int j = 0; j < BOARD_HEIGHT; j++) {
+				Vector3f color = (i + j) % 2 == 0 ? WHITE : BLACK;
+				int squareIndex = i * BOARD_WIDTH + j;
+				for (int k = 0; k < SQUARE_VERTEX_COUNT; k++) {
+					colors[squareIndex * SQUARE_VERTEX_COUNT * 3 + k * 3] = color.x;
+					colors[squareIndex * SQUARE_VERTEX_COUNT * 3 + k * 3 + 1] = color.y;
+					colors[squareIndex * SQUARE_VERTEX_COUNT * 3 + k * 3 + 2] = color.z;
+				}
+			}
+		}
+		return colors;
+	}
+
+	/**
+	 * Return which points compose each cell. 
+	 * Note of developers: "You should stop before you have an heart attack"
+	 * @return array of indicies, corresponding to the cells composing the board
+	 */
+	private static int[] GetBoardIndicies() {
+		int[] indices = new int[BOARD_SIZE * 6];
+		for (int i = 0; i < BOARD_SIZE; i++) {
+			indices[i * 6] = i * 4;
+			indices[i * 6 + 1] = i * 4 + 2;
+			indices[i * 6 + 2] = i * 4 + 1;
+			indices[i * 6 + 3] = i * 4 + 1;
+			indices[i * 6 + 4] = i * 4 + 2;
+			indices[i * 6 + 5] = i * 4 + 3;
+		}
+		return indices;
+	}
+
+	/**
+	 * Create an OpenGL VertexArrayObject (VAO) using all of the functions above for data.
+	 * Note of developers : "Stop annoying me and go read the doc of OpenGL yourself. Please?"
+	 * @return the VAO
+	 */
+	public static VertexArray GetBoardModel() {
+		ElementBuffer eBuffer = new ElementBuffer(GetBoardIndicies());
+		VertexArray vao = new VertexArray(eBuffer);
+
+		VertexBuffer positionBuffer = new VertexBuffer(GetBoardPositions(), 3);
+		positionBuffer.AddVertexAttribPointer(0, 3, 0);
+
+		VertexBuffer colorBuffer = new VertexBuffer(GetBoardColors(), 3);
+		colorBuffer.AddVertexAttribPointer(1, 3, 0);
+
+		vao.Bind();
+		vao.BindVertexBuffer(positionBuffer);
+		vao.BindVertexBuffer(colorBuffer);
+		vao.Unbind();
+		return vao;
+	}
+}

app/src/main/java/chess/view/DDDrender/loader/ModelLoader.java

@@ -0,0 +1,151 @@
+package chess.view.DDDrender.loader;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.lwjgl.assimp.AIFace.Buffer;
+import org.lwjgl.assimp.AIMesh;
+import org.lwjgl.assimp.AINode;
+import org.lwjgl.assimp.AIScene;
+import org.lwjgl.assimp.AIVector3D;
+import org.lwjgl.assimp.Assimp;
+import org.lwjgl.system.MemoryUtil;
+
+import chess.view.DDDrender.DDDModel;
+import chess.view.DDDrender.opengl.ElementBuffer;
+import chess.view.DDDrender.opengl.VertexArray;
+import chess.view.DDDrender.opengl.VertexBuffer;
+import common.AssetManager;
+
+public class ModelLoader {
+
+	private static final int VERTEX_SIZE = 3;
+	private static final int VERTEX_POSITION_INDEX = 0;
+	private static final int VERTEX_NORMAL_INDEX = 1;
+
+	/**
+	 * Note of developers: "Kill me please"
+	 */
+	private static float[] toFloatArray(List<Float> list) {
+		float[] result = new float[list.size()];
+		for (int i = 0; i < list.size(); i++) {
+			result[i] = list.get(i);
+		}
+		return result;
+	}
+
+	/**
+	 * Note of developers : "I'd rather write assembly code than watch this again"
+	 */
+	private static int[] toIntArray(List<Integer> list) {
+		int[] result = new int[list.size()];
+		for (int i = 0; i < list.size(); i++) {
+			result[i] = list.get(i);
+		}
+		return result;
+	}
+
+	/**
+	 * Process a mesh and create a vertex array object from it.
+	 * @param mesh the mesh to process
+	 * @param scene the model scene
+	 * @return
+	 */
+	private static VertexArray processMesh(AIMesh mesh, AIScene scene) {
+		List<Float> positions = new ArrayList<>();
+		List<Float> normals = new ArrayList<>();
+
+		List<Integer> indicies = new ArrayList<>();
+
+		Buffer faces = mesh.mFaces();
+		int faceNumber = mesh.mNumFaces();
+
+		for (int i = 0; i < faceNumber; i++) {
+			IntBuffer faceIndicies = faces.get(i).mIndices();
+			for (int j = 0; j < faceIndicies.capacity(); j++) {
+				indicies.add(faceIndicies.get(j));
+			}
+		}
+
+		int vertNumber = mesh.mNumVertices();
+		org.lwjgl.assimp.AIVector3D.Buffer vertecies = mesh.mVertices();
+		for (int i = 0; i < vertNumber; i++) {
+			AIVector3D vertex = vertecies.get(i);
+			positions.add(vertex.x());
+			positions.add(vertex.y());
+			positions.add(vertex.z());
+		}
+
+		org.lwjgl.assimp.AIVector3D.Buffer vertexNormals = mesh.mNormals();
+		for (int i = 0; i < vertNumber; i++) {
+			AIVector3D normal = vertexNormals.get(i);
+			normals.add(normal.x());
+			normals.add(normal.y());
+			normals.add(normal.z());
+		}
+
+		VertexBuffer positionVBO = new VertexBuffer(toFloatArray(positions), VERTEX_SIZE);
+		positionVBO.AddVertexAttribPointer(VERTEX_POSITION_INDEX, VERTEX_SIZE, 0);
+		VertexBuffer normalVBO = new VertexBuffer(toFloatArray(normals), VERTEX_SIZE);
+		normalVBO.AddVertexAttribPointer(VERTEX_NORMAL_INDEX, VERTEX_SIZE, 0);
+
+		VertexArray vao = new VertexArray(new ElementBuffer(toIntArray(indicies)));
+		vao.Bind();
+		vao.BindVertexBuffer(positionVBO);
+		vao.BindVertexBuffer(normalVBO);
+		vao.Unbind();
+		return vao;
+
+	}
+
+	/**
+	 * Recursively process a node and its children.
+	 * @param node
+	 * @param scene
+	 * @param meshes
+	 */
+	private static void processNode(AINode node, AIScene scene, List<VertexArray> meshes) {
+		for (int i = 0; i < node.mNumChildren(); i++) {
+			AINode child = AINode.create(node.mChildren().get(i));
+			processNode(child, scene, meshes);
+		}
+		for (int i = 0; i < node.mNumMeshes(); i++) {
+			AIMesh mesh = AIMesh.create(scene.mMeshes().get(node.mMeshes().get(i)));
+			meshes.add(processMesh(mesh, scene));
+		}
+	}
+
+	/**
+	 * Load a 3D model from a file (usually .fbx)
+	 */
+	public static DDDModel loadModel(String filename) throws IOException {
+		InputStream input = AssetManager.getResource(filename);
+		byte[] buffer = input.readAllBytes();
+		ByteBuffer data = MemoryUtil.memCalloc(buffer.length);
+		data.put(buffer);
+		data.flip();
+
+		AIScene scene = Assimp.aiImportFileFromMemory(
+				data,
+				Assimp.aiProcess_Triangulate | Assimp.aiProcess_PreTransformVertices | Assimp.aiProcess_GlobalScale
+						| Assimp.aiProcess_ValidateDataStructure,
+				"");
+
+		if (scene == null)
+			System.err.println(Assimp.aiGetErrorString());
+
+		List<VertexArray> vertecies = new ArrayList<>();
+
+		processNode(scene.mRootNode(), scene, vertecies);
+
+		MemoryUtil.memFree(data);
+
+		return new DDDModel(vertecies);
+
+	}
+
+}

app/src/main/java/chess/view/DDDrender/loader/Piece3DModel.java

@@ -0,0 +1,78 @@
+package chess.view.DDDrender.loader;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import chess.model.Color;
+import chess.model.Piece;
+import chess.model.PieceVisitor;
+import chess.model.pieces.Bishop;
+import chess.model.pieces.King;
+import chess.model.pieces.Knight;
+import chess.model.pieces.Pawn;
+import chess.model.pieces.Queen;
+import chess.model.pieces.Rook;
+import chess.view.DDDrender.DDDModel;
+
+/**
+ * Visitor that returns the 3d model of a piece.
+ */
+public class Piece3DModel implements PieceVisitor<String> {
+
+	private static final String basePath = "3d/";
+	private static final Map<String, DDDModel> cache = new HashMap<>();
+
+	public DDDModel getModel(Piece piece) throws IOException {
+		if (piece == null)
+			return null;
+
+		String path = basePath + colorToString(piece.getColor()) + "-" + visit(piece) + ".fbx";
+		return getModel(path);
+	}
+
+	private DDDModel getModel(String path) throws IOException {
+		DDDModel model = cache.get(path);
+		if (model != null)
+			return model;
+
+		model = ModelLoader.loadModel(path);
+		cache.put(path, model);
+		return model;
+	}
+
+	private String colorToString(Color color) {
+		return color == Color.Black ? "black" : "white";
+	}
+
+	@Override
+	public String visitPiece(Bishop bishop) {
+		return "bishop";
+	}
+
+	@Override
+	public String visitPiece(King king) {
+		return "king";
+	}
+
+	@Override
+	public String visitPiece(Knight knight) {
+		return "knight";
+	}
+
+	@Override
+	public String visitPiece(Pawn pawn) {
+		return "pawn";
+	}
+
+	@Override
+	public String visitPiece(Queen queen) {
+		return "queen";
+	}
+
+	@Override
+	public String visitPiece(Rook rook) {
+		return "rook";
+	}
+
+}

app/src/main/java/chess/view/DDDrender/opengl/ElementBuffer.java

@@ -1,10 +1,13 @@
-package chess.view.render;
+package chess.view.DDDrender.opengl;
+
+import java.io.Closeable;
+import java.io.IOException;
 
 import org.lwjgl.opengl.GL30;
 
-public class ElementBuffer {
-	private int id;
-	private int indiciesCount;
+public class ElementBuffer implements Closeable {
+	private final int id;
+	private final int indiciesCount;
 
 	public ElementBuffer(int[] indicies) {
 		this.indiciesCount = indicies.length;
@@ -15,10 +18,6 @@ public class ElementBuffer {
 		Unbind();
 	}
 
-	public void Destroy() {
-		GL30.glDeleteBuffers(this.id);
-	}
-
 	public void Bind() {
 		GL30.glBindBuffer(GL30.GL_ELEMENT_ARRAY_BUFFER, this.id);
 	}
@@ -30,4 +29,9 @@ public class ElementBuffer {
 	public int GetIndiciesCount() {
 		return this.indiciesCount;
 	}
+
+	@Override
+	public void close() throws IOException {
+		GL30.glDeleteBuffers(this.id);
+	}
 }

app/src/main/java/chess/view/DDDrender/opengl/FrameBuffer.java

@@ -0,0 +1,116 @@
+package chess.view.DDDrender.opengl;
+
+import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
+import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
+import static org.lwjgl.opengl.GL11.GL_DEPTH_COMPONENT;
+import static org.lwjgl.opengl.GL11.GL_RGB;
+import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
+import static org.lwjgl.opengl.GL11.GL_UNSIGNED_BYTE;
+import static org.lwjgl.opengl.GL11.glBindTexture;
+import static org.lwjgl.opengl.GL11.glClear;
+import static org.lwjgl.opengl.GL11.glTexImage2D;
+import static org.lwjgl.opengl.GL11.glViewport;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+import org.lwjgl.opengl.GL30;
+
+public class FrameBuffer implements Closeable {
+
+	private int fbo;
+	private int renderTexture;
+	private int depthBuffer;
+
+	private int width;
+	private int height;
+
+	public FrameBuffer(int width, int height) {
+		this.width = width;
+		this.height = height;
+		
+		// The frame buffer
+		this.fbo = GL30.glGenFramebuffers();
+		GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, fbo);
+
+		// The texture
+		this.renderTexture = GL30.glGenTextures();
+		glBindTexture(GL_TEXTURE_2D, renderTexture);
+
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
+
+		GL30.glTexParameteri(GL_TEXTURE_2D, GL30.GL_TEXTURE_MAG_FILTER, GL30.GL_NEAREST);
+		GL30.glTexParameteri(GL_TEXTURE_2D, GL30.GL_TEXTURE_MIN_FILTER, GL30.GL_NEAREST);
+
+		// The depth buffer
+		this.depthBuffer = GL30.glGenRenderbuffers();
+		GL30.glBindRenderbuffer(GL30.GL_RENDERBUFFER, depthBuffer);
+		GL30.glRenderbufferStorage(GL30.GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
+		GL30.glFramebufferRenderbuffer(GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_RENDERBUFFER,
+				depthBuffer);
+
+		// Set "renderedTexture" as our colour attachement #0
+		GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderTexture, 0);
+		// Set the list of draw buffers.
+		int[] drawBuffers = { GL30.GL_COLOR_ATTACHMENT0 };
+		GL30.glDrawBuffers(drawBuffers);
+	}
+
+	public void Bind() {
+		GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, this.fbo);
+		glViewport(0, 0, this.width, this.height);
+	}
+
+	public void Unbind() {
+		GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, 0);
+	}
+
+	public void Clear() {
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear the framebuffer
+	}
+	
+	public void Resize(int width, int height) {
+		this.width = width;
+		this.height = height;
+
+		GL30.glBindTexture(GL_TEXTURE_2D, this.renderTexture);
+
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, this.width, this.height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
+
+		GL30.glBindRenderbuffer(GL30.GL_RENDERBUFFER, this.depthBuffer);
+		GL30.glRenderbufferStorage(GL30.GL_RENDERBUFFER, GL_DEPTH_COMPONENT, this.width, this.height);
+	}
+
+	public void SetPixelScaling(boolean pixelated) {
+		glBindTexture(GL_TEXTURE_2D, renderTexture);
+
+		int method = pixelated ? GL30.GL_NEAREST : GL30.GL_LINEAR;
+
+		GL30.glTexParameteri(GL_TEXTURE_2D, GL30.GL_TEXTURE_MAG_FILTER, method);
+		GL30.glTexParameteri(GL_TEXTURE_2D, GL30.GL_TEXTURE_MIN_FILTER, method);
+	}
+
+	public float getAspectRatio() {
+		return (float) width / (float) height;
+	}
+
+	public int getWidth() {
+		return width;
+	}
+
+	public int getHeight() {
+		return height;
+	}
+
+	public int getRenderTexture() {
+		return renderTexture;
+	}
+
+	@Override
+	public void close() throws IOException {
+		GL30.glDeleteFramebuffers(this.fbo);
+		GL30.glDeleteRenderbuffers(this.depthBuffer);
+		GL30.glDeleteTextures(this.renderTexture);
+	}
+
+}

app/src/main/java/chess/view/DDDrender/opengl/VertexArray.java

@@ -1,14 +1,17 @@
-package chess.view.render;
+package chess.view.DDDrender.opengl;
 
+import java.io.Closeable;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
 import org.lwjgl.opengl.GL30;
 
-public class VertexArray {
-	private int id;
-	private ElementBuffer elementBuffer;
-	private List<VertexBuffer> vertexBuffers;
+public class VertexArray implements Closeable {
+
+	private final int id;
+	private final ElementBuffer elementBuffer;
+	private final List<VertexBuffer> vertexBuffers;
 
 	public VertexArray(ElementBuffer elementBuffer) {
 		this.id = GL30.glGenVertexArrays();
@@ -19,10 +22,6 @@ public class VertexArray {
 		Unbind();
 	}
 
-	public void Destroy() {
-		GL30.glDeleteBuffers(this.id);
-	}
-
 	public int GetVertexCount() {
 		return this.elementBuffer.GetIndiciesCount();
 	}
@@ -44,4 +43,17 @@ public class VertexArray {
 	private void BindElementArrayBuffer() {
 		this.elementBuffer.Bind();
 	}
+
+	public List<VertexBuffer> getVertexBuffers() {
+		return vertexBuffers;
+	}
+
+	@Override
+	public void close() throws IOException {
+		GL30.glDeleteBuffers(this.id);
+		for (VertexBuffer vertexBuffer : vertexBuffers) {
+			vertexBuffer.close();
+		}
+		elementBuffer.close();
+	}
 }

app/src/main/java/chess/view/DDDrender/opengl/VertexAttribPointer.java

@@ -1,4 +1,4 @@
-package chess.view.render;
+package chess.view.DDDrender.opengl;
 
 public record VertexAttribPointer(int index, int size, int offset) {
 	

app/src/main/java/chess/view/DDDrender/opengl/VertexBuffer.java

@@ -1,16 +1,18 @@
-package chess.view.render;
+package chess.view.DDDrender.opengl;
 
 import static org.lwjgl.opengl.GL11.GL_FLOAT;
 
+import java.io.Closeable;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
 import org.lwjgl.opengl.GL30;
 
-public class VertexBuffer {
-	private int id;
-	private int dataStride;
-	List<VertexAttribPointer> vertexAttribs;
+public class VertexBuffer implements Closeable {
+	private final int id;
+	private final int dataStride;
+	private final List<VertexAttribPointer> vertexAttribs;
 
 	public VertexBuffer(float[] data, int stride) {
 		this.id = GL30.glGenBuffers();
@@ -22,8 +24,10 @@ public class VertexBuffer {
 		Unbind();
 	}
 
-	public void Destroy() {
-		GL30.glDeleteBuffers(id);
+	public void UpdateData(int offset, float[] data) {
+		Bind();
+		GL30.glBufferSubData(GL30.GL_ARRAY_BUFFER, offset, data);
+		Unbind();
 	}
 
 	public void Bind() {
@@ -46,4 +50,9 @@ public class VertexBuffer {
 					this.dataStride * 4, vertexAttribPointer.offset());
 		}
 	}
+
+	@Override
+	public void close() throws IOException {
+		GL30.glDeleteBuffers(id);
+	}
 }

app/src/main/java/chess/view/DDDrender/shader/BoardShader.java

@@ -0,0 +1,102 @@
+package chess.view.DDDrender.shader;
+
+import chess.view.DDDrender.Camera;
+
+public class BoardShader extends ShaderProgram {
+
+	private static String vertexShader = """
+			#version 330
+
+			layout(location = 0) in vec3 position;
+			layout(location = 1) in vec3 color;
+
+			uniform mat4 viewMatrix;
+			uniform mat4 projectionMatrix;
+			uniform vec3 lightPosition = vec3(0, 10, 0);
+
+			flat out vec3 pass_color;
+
+			out vec3 toLightVector;
+			out vec3 toCameraVector;
+			out vec3 surfaceNormal;
+
+			void main(void){
+				const vec4 normal = vec4(0.0, 1.0, 0.0, 1.0);
+
+				gl_Position = projectionMatrix * viewMatrix * vec4(position, 1.0);
+
+				vec3 camPos = (inverse(viewMatrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+
+				toLightVector = lightPosition - position;
+
+				toCameraVector = camPos - position;
+				surfaceNormal = (normal).xyz;
+
+				pass_color = color;
+			}
+
+				""";
+
+	private static String fragmentShader = """
+			#version 330
+
+			flat in vec3 pass_color;
+
+			in vec3 toLightVector;
+			in vec3 toCameraVector;
+			in vec3 surfaceNormal;
+
+			layout(location = 0) out vec4 out_color;
+
+			void main(void){
+				const float shineDamper = 10.0;
+				const float reflectivity = 1.0;
+
+				float lightDistance = length(toLightVector);
+
+				const vec3 attenuation = vec3(0.2, 0.1, 0.0);
+				float attenuationFactor = attenuation.x + attenuation.y * lightDistance + attenuation.z * lightDistance * lightDistance;
+
+				vec3 unitNormal = normalize(surfaceNormal);
+				vec3 unitLightVector = normalize(toLightVector);
+				vec3 unitCamVector = normalize(toCameraVector);
+
+				vec3 lightDirection = -unitLightVector;
+				vec3 reflectedLightDirection = reflect(lightDirection, unitNormal);
+
+				float diffuse = max(0.2, dot(unitNormal, unitLightVector));
+
+				float specularFactor = max(0.0, dot(reflectedLightDirection, unitCamVector));
+				float specular = pow(specularFactor, shineDamper) * reflectivity;
+
+				float brightness = (diffuse + specular) / attenuationFactor;
+
+				out_color = brightness * vec4(pass_color, 1.0);
+				out_color.w = 1.0;
+
+			}
+
+				""";
+
+	private int location_ProjectionMatrix = 0;
+	private int location_ViewMatrix = 0;
+
+	public BoardShader() {
+
+	}
+
+	public void LoadShader() {
+		super.LoadProgram(vertexShader, fragmentShader);
+	}
+
+	@Override
+	protected void GetAllUniformLocation() {
+		location_ProjectionMatrix = GetUniformLocation("projectionMatrix");
+		location_ViewMatrix = GetUniformLocation("viewMatrix");
+	}
+
+	public void SetCamMatrix(Camera camera) {
+		LoadMat4(location_ProjectionMatrix, camera.getPerspectiveMatrix());
+		LoadMat4(location_ViewMatrix, camera.getViewMatrix());
+	}
+}

app/src/main/java/chess/view/DDDrender/shader/PieceShader.java

@@ -0,0 +1,116 @@
+package chess.view.DDDrender.shader;
+
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+
+import chess.view.DDDrender.Camera;
+
+public class PieceShader extends ShaderProgram {
+
+	private static String vertexShader = """
+			#version 330
+
+			layout(location = 0) in vec3 position;
+			layout(location = 1) in vec3 normal;
+
+			uniform mat4 projectionMatrix;
+			uniform mat4 viewMatrix;
+			uniform mat4 modelTransform;
+			uniform vec3 lightPosition = vec3(0, 10, 0);
+
+			out vec3 toLightVector;
+			out vec3 toCameraVector;
+			out vec3 surfaceNormal;
+
+			void main(void){
+
+				vec4 modelPos = modelTransform * vec4(position, 1.0);
+				vec4 globalNormal = modelTransform * vec4(normal, 1.0);
+
+				gl_Position = projectionMatrix * viewMatrix * modelPos;
+
+				vec3 camPos = (inverse(viewMatrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+
+				toLightVector = lightPosition - modelPos.xyz;
+
+				toCameraVector = camPos - position;
+				surfaceNormal = normalize(globalNormal.xyz);
+			}
+
+				""";
+
+	private static String fragmentShader = """
+			#version 330
+
+			in vec3 toLightVector;
+			in vec3 toCameraVector;
+			in vec3 surfaceNormal;
+
+			uniform vec3 modelColor;
+
+			layout(location = 0) out vec4 out_color;
+
+			void main(void){
+				const float shineDamper = 10.0;
+				const float reflectivity = 1.0;
+
+				float lightDistance = length(toLightVector);
+
+				const vec3 attenuation = vec3(0.2, 0.1, 0.0);
+				float attenuationFactor = attenuation.x + attenuation.y * lightDistance + attenuation.z * lightDistance * lightDistance;
+
+				vec3 unitNormal = normalize(surfaceNormal);
+				vec3 unitLightVector = normalize(toLightVector);
+				vec3 unitCamVector = normalize(toCameraVector);
+
+				vec3 lightDirection = -unitLightVector;
+				vec3 reflectedLightDirection = reflect(lightDirection, unitNormal);
+
+				float diffuse = max(0.2, dot(unitNormal, unitLightVector));
+
+				float specularFactor = max(0.0, dot(reflectedLightDirection, unitCamVector));
+				float specular = pow(specularFactor, shineDamper) * reflectivity;
+
+				float brightness = (diffuse + specular) / attenuationFactor;
+
+				out_color = brightness * vec4(modelColor, 1.0);
+				out_color.w = 1.0;
+
+			}
+
+				""";
+
+	private int location_ProjectionMatrix = 0;
+	private int location_ViewMatrix = 0;
+	private int location_ModelTransform = 0;
+	private int location_ModelColor = 0;
+
+	public PieceShader() {
+
+	}
+
+	public void LoadShader() {
+		super.LoadProgram(vertexShader, fragmentShader);
+	}
+
+	@Override
+	protected void GetAllUniformLocation() {
+		location_ProjectionMatrix = GetUniformLocation("projectionMatrix");
+		location_ViewMatrix = GetUniformLocation("viewMatrix");
+		location_ModelTransform = GetUniformLocation("modelTransform");
+		location_ModelColor = GetUniformLocation("modelColor");
+	}
+
+	public void SetCamMatrix(Camera camera) {
+		LoadMat4(location_ProjectionMatrix, camera.getPerspectiveMatrix());
+		LoadMat4(location_ViewMatrix, camera.getViewMatrix());
+	}
+
+	public void setModelTransform(Matrix4f mat) {
+		LoadMat4(location_ModelTransform, mat);
+	}
+
+	public void setModelColor(Vector3f color) {
+		LoadVector(location_ModelColor, color);
+	}
+}

app/src/main/java/chess/view/DDDrender/shader/ShaderProgram.java

@@ -1,5 +1,7 @@
-package chess.view.render.shader;
+package chess.view.DDDrender.shader;
 
+import java.io.Closeable;
+import java.io.IOException;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 
@@ -9,7 +11,7 @@ import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL30;
 import org.lwjgl.system.MemoryStack;
 
-public abstract class ShaderProgram {
+public abstract class ShaderProgram implements Closeable {
 	private int programId;
 	private int vertexShaderId;
 	private int fragmentShaderId;
@@ -28,6 +30,11 @@ public abstract class ShaderProgram {
 		GL30.glUseProgram(0);
 	}
 
+	/**
+	 * Load the shader program.
+	 * @param vertexSource the source code of the vertex shader.
+	 * @param fragmentSource the source code of the fragment shader.
+	 */
 	public void LoadProgram(String vertexSource, String fragmentSource) {
 		this.vertexShaderId = LoadShader(vertexSource, GL30.GL_VERTEX_SHADER);
 		this.fragmentShaderId = LoadShader(fragmentSource, GL30.GL_FRAGMENT_SHADER);
@@ -45,6 +52,12 @@ public abstract class ShaderProgram {
 		GetAllUniformLocation();
 	}
 
+	/**
+	 * Load a shader from source code.
+	 * @param source
+	 * @param type
+	 * @return
+	 */
 	private int LoadShader(String source, int type) {
 		int shaderId = GL30.glCreateShader(type);
 
@@ -56,8 +69,8 @@ public abstract class ShaderProgram {
 
 		if (compileSuccesful.get() != 1) {
 			System.out.println("Shader did not compile !");
+			System.err.println(GL30.glGetShaderInfoLog(shaderId));
 			return -1;
-
 		}
 
 		return shaderId;
@@ -68,7 +81,7 @@ public abstract class ShaderProgram {
 	protected int GetUniformLocation(String uniformName) {
 		int location = GL30.glGetUniformLocation(programId, uniformName);
 		if (location == -1) {
-			System.out.println("Uniform value not found !");
+			System.out.println("Uniform value \"" + uniformName + "\" not found !");
 		}
 		return location;
 	}
@@ -91,4 +104,11 @@ public abstract class ShaderProgram {
 			GL30.glUniformMatrix4fv(location, false, buffer);
 		}
 	}
+
+	@Override
+	public void close() throws IOException {
+		GL30.glDeleteShader(vertexShaderId);
+		GL30.glDeleteShader(fragmentShaderId);
+		GL30.glDeleteProgram(programId);
+	}
 }

app/src/main/java/chess/view/DDDrender/world/BoardEntity.java

@@ -0,0 +1,62 @@
+package chess.view.DDDrender.world;
+
+import java.io.IOException;
+
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+
+import chess.model.Coordinate;
+import chess.view.DDDrender.Renderer;
+import chess.view.DDDrender.loader.BoardModelLoader;
+import chess.view.DDDrender.opengl.VertexArray;
+import chess.view.DDDrender.opengl.VertexBuffer;
+
+/**
+ * Abstraction of the 3D model of the board.
+ */
+public class BoardEntity extends Entity {
+
+	private final VertexArray vao;
+	private final VertexBuffer colorVbo;
+
+	private static final Vector3f WHITE = new Vector3f(1, 1, 1);
+	private static final Vector3f BLACK = new Vector3f(0, 0, 0);
+
+	public BoardEntity() {
+		this.vao = BoardModelLoader.GetBoardModel();
+		this.colorVbo = this.vao.getVertexBuffers().get(1);
+	}
+
+	/**
+	 * Set the color of a cell.
+	 * @param coord the coordinate of the cell.
+	 * @param color the color of the cell in RGB format.
+	 */
+	public void setCellColor(Coordinate coord, Vector3f color) {
+		float[] data = { color.x, color.y, color.z, color.x, color.y, color.z, color.x, color.y, color.z, color.x,
+				color.y, color.z};
+		int cellNumber = (Coordinate.VALUE_MAX - 1 - coord.getX()) * Coordinate.VALUE_MAX + Coordinate.VALUE_MAX - 1 - coord.getY();
+		int offset = cellNumber * 4 * 4 * 3;
+		this.colorVbo.UpdateData(offset, data);
+	}
+
+	public void resetCellColor(Coordinate coord) {
+		setCellColor(coord, (coord.getX() + coord.getY()) % 2 == 0 ? WHITE : BLACK);
+	}
+
+	@Override
+	public void render(Renderer renderer) {
+		renderer.RenderVao(renderer.getBoardShader(), vao);
+	}
+
+	@Override
+	public void close() throws IOException {
+		vao.close();
+	}
+
+	@Override
+	public Matrix4f getTransform() {
+		return null;
+	}
+
+}

app/src/main/java/chess/view/DDDrender/world/Entity.java

@@ -0,0 +1,18 @@
+package chess.view.DDDrender.world;
+
+import java.io.Closeable;
+
+import org.joml.Matrix4f;
+
+import chess.view.DDDrender.Renderer;
+
+/**
+ * Abstract class for all entities in the 3D view.
+ */
+public abstract class Entity implements Closeable{
+
+	public abstract void render(Renderer renderer);
+
+	public abstract Matrix4f getTransform();
+
+}

app/src/main/java/chess/view/DDDrender/world/ModelEntity.java

@@ -0,0 +1,64 @@
+package chess.view.DDDrender.world;
+
+import java.io.IOException;
+
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+
+import chess.view.DDDrender.DDDModel;
+import chess.view.DDDrender.Renderer;
+
+/**
+ * Generic type for 3D model that can be rendered.
+ */
+public class ModelEntity extends Entity {
+
+	protected Vector3f position;
+	protected Vector3f color;
+	protected float rotation;
+	protected DDDModel model;
+
+	private Matrix4f transform;
+
+	public ModelEntity(DDDModel model, Vector3f position, Vector3f color, float rotation) {
+		this.position = position;
+		this.color = color;
+		this.rotation = rotation;
+		this.model = model;
+		updateTransform();
+	}
+
+	@Override
+	public void render(Renderer renderer) {
+		renderer.Render(model, color, transform);
+	}
+
+	public void setPosition(Vector3f position) {
+		this.position = position;
+		updateTransform();
+	}
+
+	public void setColor(Vector3f color) {
+		this.color = color;
+	}
+
+	public void setRotation(float rotation) {
+		this.rotation = rotation;
+		updateTransform();
+	}
+
+	@Override
+	public void close() throws IOException {
+		this.model.close();
+	}
+
+	private void updateTransform() {
+		this.transform = new Matrix4f().translate(this.position).rotate(this.rotation, new Vector3f(0, 1, 0));
+	}
+
+	@Override
+	public Matrix4f getTransform() {
+		return transform;
+	}
+
+}

app/src/main/java/chess/view/DDDrender/world/PieceEntity.java

@@ -0,0 +1,28 @@
+package chess.view.DDDrender.world;
+
+import java.io.IOException;
+
+import org.joml.Vector3f;
+
+import chess.model.Piece;
+import chess.view.DDDrender.loader.Piece3DModel;
+
+/**
+ * Model entity of a piece. Loads the correct model of the resources files for the kind of piece.
+ */
+public class PieceEntity extends ModelEntity {
+
+	private static final Piece3DModel modelLoader = new Piece3DModel();
+
+	private final Piece piece;
+
+	public PieceEntity(Piece piece, Vector3f position, Vector3f color, float rotation) throws IOException {
+		super(modelLoader.getModel(piece), position, color, rotation);
+		this.piece = piece;
+	}
+
+	public Piece getPiece() {
+		return piece;
+	}
+	
+}

app/src/main/java/chess/view/DDDrender/world/World.java

@@ -0,0 +1,75 @@
+package chess.view.DDDrender.world;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import chess.model.Coordinate;
+import chess.model.Move;
+import chess.model.Piece;
+
+/**
+ * Contains all 3D entities.
+ */
+public class World implements Closeable{
+	/** Renderable entity list */
+	private final List<Entity> entites;
+
+	/** provides fast access to 3d pieces */
+	private final PieceEntity[] pieces;
+
+	public World() {
+		this.entites = new ArrayList<>();
+		this.pieces = new PieceEntity[Coordinate.VALUE_MAX * Coordinate.VALUE_MAX];
+	}
+
+	public PieceEntity getEntity(Piece piece) {
+		for (Entity entity : entites) {
+			if (entity instanceof PieceEntity p) {
+				if (p.getPiece() == piece)
+					return p;
+			}
+		}
+		return null;
+	}
+
+	public void addPiece(PieceEntity entity, Coordinate coordinate) {
+		addEntity(entity);
+		setPieceCoords(entity, coordinate);
+	}
+
+	public void setPieceCoords(PieceEntity entity, Coordinate coordinate) {
+		pieces[coordinate.toIndex()] = entity;
+	}
+	
+	public void movePiece(PieceEntity entity, Move move) {
+		setPieceCoords(entity, move.getFinish());
+		setPieceCoords(null, move.getStart());
+	}
+
+	public void ejectPiece(PieceEntity entity) {
+		if (entity != null)
+			this.entites.remove(entity);
+	}
+
+	public PieceEntity getPiece(Coordinate coordinate) {
+		return pieces[coordinate.toIndex()];
+	}
+
+	public void addEntity(Entity entity) {
+		this.entites.add(entity);
+	}
+
+	public List<Entity> getEntites() {
+		return entites;
+	}
+
+	@Override
+	public void close() throws IOException {
+		for (Entity entity : entites) {
+			entity.close();
+		}
+	}
+
+}

app/src/main/java/chess/view/audio/AudioFiles.java

@@ -0,0 +1,67 @@
+package chess.view.audio;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import common.AssetManager;
+
+/**
+ * Manage audio files: download, save, and load them.
+ */
+
+public class AudioFiles {
+
+	private static final String baseURL = "https://images.chesscomfiles.com/chess-themes/sounds/_WAV_/default/";
+	private static final String[] files = { "game-start", "game-end", "capture", "castle", "move-self",
+			"move-check", "promote", "illegal" };
+	private static final String filesExtension = ".wav";
+	private static final String saveDir = "audio/";
+
+	public static boolean initFiles() {
+		createSaveDir();
+		for (String file : files) {
+			if (!initFile(file + filesExtension))
+				return false;
+		}
+		return true;
+	}
+
+	private static boolean downloadFile(String fileName) {
+		System.out.println("[GameAudio] missing " + fileName + " Downloading ...");
+		try (BufferedInputStream in = new BufferedInputStream(new URI(baseURL + fileName).toURL().openStream());
+				FileOutputStream fileOutputStream = new FileOutputStream(saveDir + fileName)) {
+			byte dataBuffer[] = new byte[1024];
+			int bytesRead;
+			while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
+				fileOutputStream.write(dataBuffer, 0, bytesRead);
+			}
+			return true;
+		} catch (IOException | URISyntaxException e) {
+			e.printStackTrace();
+			return false;
+		}
+	}
+
+	private static void createSaveDir() {
+		new File(saveDir).mkdir();
+	}
+
+	private static boolean initFile(String fileName) {
+		if (isFileDownloaded(saveDir + fileName))
+			return true;
+		return downloadFile(fileName);
+	}
+
+	private static boolean isFileDownloaded(String fileName) {
+		return AssetManager.getResource(fileName) != null;
+	}
+
+	public static InputStream getAudio(String audioName) {
+		return AssetManager.getResource(saveDir + audioName + filesExtension);
+	}
+}

app/src/main/java/chess/view/audio/AudioPlayer.java

@@ -0,0 +1,57 @@
+package chess.view.audio;
+
+import java.io.BufferedInputStream;
+import java.io.InputStream;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.Clip;
+
+/**
+ * Audio player class to play sound files.
+ */
+public class AudioPlayer {
+	
+	/**
+	 * Play a sound file.
+	 * @param audio the audio input stream to play
+	 */
+	public static void playSound(InputStream audio) {
+		new Thread(new Runnable() {
+			// The wrapper thread is unnecessary, unless it blocks on the
+			// Clip finishing; see comments.
+			public void run() {
+				try {
+					Clip clip = AudioSystem.getClip();
+					BufferedInputStream bufferedInputStream = new BufferedInputStream(audio);
+					AudioInputStream inputStream = AudioSystem.getAudioInputStream(bufferedInputStream);
+					clip.open(inputStream);
+					clip.start();
+				} catch (Exception e) {
+					System.err.println(e.getMessage());
+				}
+			}
+		}).start();
+	}
+
+	/**
+	 * Convert the given audio input stream to PCM format.
+	 * @param audioInputStream the audio input stream to convert
+	 * @return
+	 */
+	private static AudioInputStream convertToPCM(AudioInputStream audioInputStream) {
+		AudioFormat m_format = audioInputStream.getFormat();
+
+		if ((m_format.getEncoding() != AudioFormat.Encoding.PCM_SIGNED) &&
+				(m_format.getEncoding() != AudioFormat.Encoding.PCM_UNSIGNED)) {
+			AudioFormat targetFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
+					m_format.getSampleRate(), 16,
+					m_format.getChannels(), m_format.getChannels() * 2,
+					m_format.getSampleRate(), m_format.isBigEndian());
+			audioInputStream = AudioSystem.getAudioInputStream(targetFormat, audioInputStream);
+		}
+
+		return audioInputStream;
+	}
+}

app/src/main/java/chess/view/audio/GameAudio.java

@@ -0,0 +1,67 @@
+package chess.view.audio;
+
+import chess.controller.commands.PromoteCommand.PromoteType;
+import chess.controller.event.GameAdapter;
+import chess.model.Coordinate;
+import chess.model.Move;
+
+/**
+ * Class to handle audio events in the game.
+ */
+public class GameAudio extends GameAdapter {
+
+	private final boolean functional;
+
+	public GameAudio() {
+		this.functional = AudioFiles.initFiles();
+		if(!this.functional){
+			System.err.println("[GameAudio] Failed to initialize audio files. Aborting ...");
+		}
+	}
+
+	private void playSound(String soundName) {
+		if (!this.functional)
+			return;
+		AudioPlayer.playSound(AudioFiles.getAudio(soundName));
+	}
+
+	@Override
+	public void onGameStart() {
+		playSound("game-start");
+	}
+
+	@Override
+	public void onGameEnd() {
+		playSound("game-end");
+	}
+
+	@Override
+	public void onMoveNotAllowed(Move move) {
+		playSound("illegal");
+	}
+
+	@Override
+	public void onMove(Move move, boolean captured) {
+		if (captured) {
+			playSound("capture");
+			return;
+		}
+		playSound("move-self");
+	}
+
+	@Override
+	public void onKingInCheck() {
+		playSound("move-check");
+	}
+
+	@Override
+	public void onPawnPromoted(PromoteType promotion, Coordinate coordinate) {
+		playSound("promote");
+	}
+
+	@Override
+	public void onCastling(boolean bigCastling, Move kingMove, Move rookMove) {
+		playSound("castle");
+	}
+	
+}

app/src/main/java/chess/view/consolerender/Colors.java

@@ -1,5 +1,8 @@
 package chess.view.consolerender;
 
+/**
+ * Colors class for console output, contains ANSI escape codes.
+ */
 public class Colors {
     // Reset
     public static final String RESET = "\u001B[0m";  // Text Reset
@@ -15,24 +18,24 @@ public class Colors {
     public static final String CYAN     = "\033[38;2;0;255;255m";
 
     // Background
-    public static final String BLACK_BACKGROUND     = "\033[40m";  // BLACK
+    public static final String BLACK_BACKGROUND     = "\033[40m";
     public static final String LIGHT_GRAY_BACKGROUND = "\033[48;2;180;180;180m";
     public static final String DARK_GRAY_BACKGROUND = "\033[48;2;120;120;120m";
-    public static final String RED_BACKGROUND       = "\033[41m";    // RED
-    public static final String GREEN_BACKGROUND     = "\033[42m";  // GREEN
-    public static final String YELLOW_BACKGROUND    = "\033[43m"; // YELLOW
-    public static final String BLUE_BACKGROUND      = "\033[44m";   // BLUE
-    public static final String PURPLE_BACKGROUND    = "\033[45m"; // PURPLE
-    public static final String CYAN_BACKGROUND      = "\033[46m";   // CYAN
-    public static final String WHITE_BACKGROUND     = "\033[47m";  // WHITE
+    public static final String RED_BACKGROUND       = "\033[41m";
+    public static final String GREEN_BACKGROUND     = "\033[42m";
+    public static final String YELLOW_BACKGROUND    = "\033[43m";
+    public static final String BLUE_BACKGROUND      = "\033[44m";
+    public static final String PURPLE_BACKGROUND    = "\033[45m";
+    public static final String CYAN_BACKGROUND      = "\033[46m";
+    public static final String WHITE_BACKGROUND     = "\033[47m";
 
     // High Intensity backgrounds
-    public static final String BLACK_BACKGROUND_BRIGHT = "\033[0;100m";// BLACK
-    public static final String RED_BACKGROUND_BRIGHT = "\033[0;101m";// RED
-    public static final String GREEN_BACKGROUND_BRIGHT = "\033[0;102m";// GREEN
-    public static final String YELLOW_BACKGROUND_BRIGHT = "\033[0;103m";// YELLOW
-    public static final String BLUE_BACKGROUND_BRIGHT = "\033[0;104m";// BLUE
-    public static final String PURPLE_BACKGROUND_BRIGHT = "\033[0;105m"; // PURPLE
-    public static final String CYAN_BACKGROUND_BRIGHT = "\033[0;106m";  // CYAN
-    public static final String WHITE_BACKGROUND_BRIGHT = "\033[0;107m";   // WHITE
+    public static final String BLACK_BACKGROUND_BRIGHT = "\033[0;100m";
+    public static final String RED_BACKGROUND_BRIGHT = "\033[0;101m";
+    public static final String GREEN_BACKGROUND_BRIGHT = "\033[0;102m";
+    public static final String YELLOW_BACKGROUND_BRIGHT = "\033[0;103m";
+    public static final String BLUE_BACKGROUND_BRIGHT = "\033[0;104m";
+    public static final String PURPLE_BACKGROUND_BRIGHT = "\033[0;105m";
+    public static final String CYAN_BACKGROUND_BRIGHT = "\033[0;106m";
+    public static final String WHITE_BACKGROUND_BRIGHT = "\033[0;107m";
 }

app/src/main/java/chess/view/consolerender/Console.java

@@ -2,9 +2,10 @@ package chess.view.consolerender;
 
 import chess.controller.Command;
 import chess.controller.CommandExecutor;
+import chess.controller.CommandSender;
 import chess.controller.commands.*;
 import chess.controller.commands.PromoteCommand.PromoteType;
-import chess.controller.event.GameListener;
+import chess.controller.event.GameAdapter;
 import chess.model.Color;
 import chess.model.Coordinate;
 import chess.model.Move;
@@ -16,32 +17,33 @@ import java.util.Scanner;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
-public class Console implements GameListener {
+/** 
+ * Console renderer.
+ */
+
+public class Console extends GameAdapter implements CommandSender {
     private final Scanner scanner = new Scanner(System.in);
     private final CommandExecutor commandExecutor;
     private final ConsolePieceName consolePieceName = new ConsolePieceName();
-    private boolean captureInput = false;
+    private boolean captureInput;
     private final ExecutorService executor;
 
-    public Console(CommandExecutor commandExecutor) {
+    public Console(CommandExecutor commandExecutor, boolean captureInput) {
         this.commandExecutor = commandExecutor;
         this.executor = Executors.newSingleThreadExecutor();
+        this.captureInput = captureInput;
     }
 
-    private Piece pieceAt(int x, int y) {
-        return pieceAt(new Coordinate(x, y));
-    }
-
-    private Command.CommandResult sendCommand(Command command) {
-        return this.commandExecutor.executeCommand(command);
-    }
-
-    private Piece pieceAt(Coordinate coordinate) {
-        GetPieceAtCommand command = new GetPieceAtCommand(coordinate);
-        sendCommand(command);
-        return command.getPiece();
+    public Console(CommandExecutor commandExecutor) {
+        this(commandExecutor, true);
     }
 
+    /**
+     * Translate a string containing chess coordinates (such as "a1" or "d6") to coordinates.
+     * @param coordinates the string to translate
+     * @return the coordinates of the cell
+     * @throws Exception if the string is not valid
+     */
     public Coordinate stringToCoordinate(String coordinates) throws Exception {
         char xPos = coordinates.charAt(0);
         char yPos = coordinates.charAt(1);
@@ -60,8 +62,11 @@ public class Console implements GameListener {
         return new Coordinate(x, y);
     }
 
+    /**
+     * Open a dialog so the user can, during their turn, move a piece, show move previews, or surrender.
+     */
     @Override
-    public void onPlayerTurn(Color color) {
+    public void onPlayerTurn(Color color, boolean undone) {
         if (!captureInput)
             return;
         System.out.println(Colors.RED + "Player turn: " + color + Colors.RESET);
@@ -90,10 +95,15 @@ public class Console implements GameListener {
     }
 
     private boolean playerPickedSurrender(Color color) {
-        sendCommand(new SurrenderCommand(color));
+        sendSurrender(color);
         return true;
     }
 
+    /**
+     * Ask the user to pick a move
+     * @param color the color of the player
+     * @return true if there has been a move, false otherwise
+     */
     public boolean playerPickedMove(Color color) {
         try {
             System.out.println("Piece to move, or \"castling\" for a castling");
@@ -104,7 +114,7 @@ public class Console implements GameListener {
             Coordinate start = stringToCoordinate(answer);
             System.out.println("New position: ");
             Coordinate end = stringToCoordinate(scanner.nextLine());
-            Command.CommandResult result = sendCommand(new MoveCommand(new Move(start, end)));
+            Command.CommandResult result = sendMove(new Move(start, end));
 
             return switch (Objects.requireNonNull(result)) {
                 case Command.CommandResult.Moved, Command.CommandResult.ActionNeeded -> true;
@@ -117,16 +127,16 @@ public class Console implements GameListener {
         }
     }
 
+    /**
+     * Ask the user to pick a piece, and show its potential moves
+     * @param color
+     * @return
+     */
     private boolean playerPickedShowMoves(Color color) {
         try {
             System.out.println("Piece to examine: ");
             Coordinate piece = stringToCoordinate(scanner.nextLine());
-            GetAllowedMovesPieceCommand movesCommand = new GetAllowedMovesPieceCommand(piece);
-            if (sendCommand(movesCommand) == Command.CommandResult.NotAllowed) {
-                System.out.println("Not allowed.");
-                return false;
-            }
-            List<Coordinate> allowedMoves = movesCommand.getDestinations();
+            List<Coordinate> allowedMoves = getPieceAllowedMoves(piece);
             if (allowedMoves.isEmpty()) {
                 System.out.println("No moves allowed for this piece.");
                 return false;
@@ -177,6 +187,10 @@ public class Console implements GameListener {
         this.executor.shutdown();
     }
 
+    /**
+     * Open the dialog to promote a pawn.
+     * @param pieceCoords the coordinates of the pawn to promote
+     */
     @Override
     public void onPromotePawn(Coordinate pieceCoords) {
         System.out.println("The pawn on the " + pieceCoords + " coordinates needs to be promoted.");
@@ -196,7 +210,7 @@ public class Console implements GameListener {
                         default -> throw new Exception();
                     };
                     valid = true;
-                    sendCommand(new PromoteCommand(newPiece));
+                    sendPawnPromotion(newPiece);
                 } catch (Exception e) {
                     System.out.println("Invalid input!");
                 }
@@ -204,6 +218,9 @@ public class Console implements GameListener {
         });
     }
 
+    /**
+     * Update and print the board in the console.
+     */
     @Override
     public void onBoardUpdate() {
         if (!this.captureInput)
@@ -213,7 +230,7 @@ public class Console implements GameListener {
         for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
             string.append(8 - i).append(" ");
             for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
-                Piece p = pieceAt(j, i);
+                Piece p = getPieceAt(new Coordinate(j, i));
                 if ((i + j) % 2 == 0) {
                     string.append(Colors.LIGHT_GRAY_BACKGROUND);
                 } else {
@@ -231,6 +248,11 @@ public class Console implements GameListener {
         System.out.flush();
     }
 
+    /**
+     * Display the possible moves of a piece.
+     * @param piece
+     * @param moves
+     */
     public void displayMoves(Coordinate piece, List<Coordinate> moves) {
         StringBuilder string = new StringBuilder();
         string.append("   a  b  c  d  e  f  g  h \n");
@@ -238,7 +260,7 @@ public class Console implements GameListener {
             string.append(8 - i).append(" ");
             for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
                 Coordinate currentCell = new Coordinate(j, i);
-                Piece p = pieceAt(j, i);
+                Piece p = getPieceAt(new Coordinate(j, i));
                 if (moves.contains(currentCell)) {
                     string.append(Colors.YELLOW_BACKGROUND);
                 } else {
@@ -264,10 +286,6 @@ public class Console implements GameListener {
         System.out.println(string);
     }
 
-    @Override
-    public void onMove(Move move) {
-    }
-
     @Override
     public void onMoveNotAllowed(Move move) {
         System.out.println("Move not allowed.");
@@ -278,10 +296,12 @@ public class Console implements GameListener {
         System.out.println("Repeated positions!");
     }
 
+    /**
+     * Open different dialogs according to which castling is allowed.
+     * @return true if a castling was played, false otherwise
+     */
     private boolean onAskedCastling() {
-        GetAllowedCastlingsCommand cmd = new GetAllowedCastlingsCommand();
-        sendCommand(cmd);
-        return switch (cmd.getCastlingResult()) {
+        return switch (getAllowedCastlings()) {
             case Small -> onSmallCastling();
             case Big -> onBigCastling();
             case Both -> onBothCastling();
@@ -292,6 +312,10 @@ public class Console implements GameListener {
         };
     }
 
+    /**
+     * Ask the user to confirm a small castling.
+     * @return true if the castling was played, false otherwise
+     */
     private boolean onSmallCastling() {
         System.out.println("Small castling allowed. Confirm with \"y\":");
         String answer = scanner.nextLine();
@@ -302,6 +326,10 @@ public class Console implements GameListener {
         }
     }
 
+    /**
+     * Ask the user to confirm a big castling.
+     * @return true if the castling was played, false otherwise
+     */
     private boolean onBigCastling() {
         System.out.println("Big castling allowed. Confirm with \"y\":");
         String answer = scanner.nextLine();
@@ -312,6 +340,10 @@ public class Console implements GameListener {
         }
     }
 
+    /**
+     * Ask the user to pick a castling when both are allowed.
+     * @return true if a castling was played, false otherwise
+     */
     private boolean onBothCastling() {
         System.out.println("Both castlings allowed. Pick \"s\" to play a castling, \"b\" to play a big castling.");
         String answer = scanner.nextLine();
@@ -328,4 +360,10 @@ public class Console implements GameListener {
         this.captureInput = captureInput;
     }
 
+    @Override
+    public CommandExecutor getCommandExecutor() {
+        return this.commandExecutor;
+    }
+    
+
 }

app/src/main/java/chess/view/consolerender/ConsolePieceName.java

@@ -5,6 +5,10 @@ import chess.model.Piece;
 import chess.model.PieceVisitor;
 import chess.model.pieces.*;
 
+/**
+ * Manage appearance of pieces in the console.
+ */
+
 public class ConsolePieceName implements PieceVisitor<String> {
 
     public String getString(Piece piece){

app/src/main/java/chess/view/render/Camera.java

@@ -1,128 +0,0 @@
-package chess.view.render;
-
-import org.joml.Matrix4f;
-import org.joml.Vector3f;
-
-public class Camera {
-    public static final float fov = 70.0f;
-    // should be changed to match screen
-    public static final float aspect = 1.0f;
-    public static final float zNear = 0.01f;
-    public static final float zFar = 100.0f;
-
-    private Vector3f pos;
-
-    private float yaw = 0.0f;
-    private float pitch = 0.0f;
-
-    public Camera() {
-        this.pos = new Vector3f(0, 2.0f, 0);
-        setRotation(0.0f, -3.14150f / 2.0f);
-    }
-
-    public void move(float x, float y) {
-        this.pos.x += x;
-        this.pos.y += y;
-    }
-
-    public void rotate(float yaw, float pitch) {
-        this.yaw += yaw;
-        this.pitch += pitch;
-    }
-
-    public Vector3f getPos() {
-        return pos;
-    }
-
-    public float getYaw() {
-        return yaw;
-    }
-
-    public float getPitch() {
-        return pitch;
-    }
-
-    public float getFov() {
-        return fov;
-    }
-
-    public void setX(float x) {
-        this.pos.x = x;
-    }
-
-    public void setY(float y) {
-        this.pos.y = y;
-    }
-
-    public void setZ(float z) {
-        this.pos.z = z;
-    }
-
-    public void setYaw(float yaw) {
-        this.yaw = yaw;
-    }
-
-    public void setPitch(float pitch) {
-        this.pitch = pitch;
-    }
-
-    public void reset() {
-        resetPosition();
-        resetRotation();
-    }
-
-    public void resetPosition() {
-        pos = new Vector3f(0.0f, 0.0f, 0.0f);
-    }
-
-    public void resetRotation() {
-        yaw = 0.0f;
-        pitch = 0.0f;
-    }
-
-    public void moveForward(float distance) {
-        pos.x += distance * (float) Math.cos(yaw);
-        pos.y += distance * (float) Math.sin(yaw);
-    }
-
-    public void moveRight(float distance) {
-        pos.x += distance * (float) Math.cos(yaw);
-        pos.y += distance * (float) Math.sin(yaw);
-    }
-
-    public void moveUp(float distance) {
-        pos.z += distance;
-    }
-
-    public void moveDown(float distance) {
-        pos.z -= distance;
-    }
-
-    public void addYaw(float angle) {
-        yaw += angle;
-    }
-
-    public void addPitch(float angle) {
-        pitch += angle;
-    }
-
-    public void setPosition(Vector3f pos) {
-        this.pos = pos;
-    }
-
-    public void setRotation(float yaw, float pitch) {
-        this.yaw = yaw;
-        this.pitch = pitch;
-    }
-
-    public Matrix4f getMatrix() {
-        Vector3f forward = new Vector3f(
-                (float) (Math.cos(yaw) * Math.cos(pitch)),
-                (float) (Math.sin(pitch)),
-                (float) (Math.sin(yaw) * Math.cos(pitch)));
-
-        return new Matrix4f()
-                .perspective((float) (Math.toRadians(fov)), aspect, zNear, zFar)
-                .lookAt(pos, forward, new Vector3f(0.0f, 1.0f, 0.0f));
-    }
-}