i failed you

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

@@ -0,0 +1,33 @@
+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;
+
+public class OpenGLMain {
+
+    public static void main(String[] args) {
+        Game game = new Game(new ChessBoard());
+        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);
+
+        commandExecutor.executeCommand(new NewGameCommand());
+
+        window.run();
+    }
+
+}

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

@@ -3,9 +3,11 @@ 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.simplerender.Window;
 
 public class SwingMain {
@@ -22,6 +24,13 @@ public class SwingMain {
         DumbAI ai2 = new DumbAI(commandExecutor, Color.White);
         commandExecutor.addListener(ai2);
 
+        commandExecutor.addListener(new GameAdaptator(){
+            @Override
+            public void onGameEnd() {
+                System.out.println(PgnExport.exportGame(game));
+            }
+        });
+
         commandExecutor.executeCommand(new NewGameCommand());
     }
 }

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

@@ -5,10 +5,13 @@ 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;
@@ -34,9 +37,46 @@ public class DumbAI extends GameAdaptator {
 
 		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
@@ -50,10 +90,10 @@ public class DumbAI extends GameAdaptator {
 	}
 
 	private Piece pieceAt(Coordinate coordinate) {
-        GetPieceAtCommand command = new GetPieceAtCommand(coordinate);
+		GetPieceAtCommand command = new GetPieceAtCommand(coordinate);
-        sendCommand(command);
+		sendCommand(command);
-        return command.getPiece();
+		return command.getPiece();
-    }
+	}
 
 	private void sendCommand(Command command) {
 		this.commandExecutor.executeCommand(command);

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

@@ -280,14 +280,15 @@ public class ChessBoard {
 		return null;
 	}
 
-	public int hashPlayerPieces(Color color) {
+	@Override
+	public int hashCode() {
 		int result = 0;
 		for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
 			for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
 				Piece piece = pieceAt(new Coordinate(i, j));
-				if (piece == null || piece.getColor() != color)
+				if (piece == null)
 					continue;
-				result = Objects.hash(result, new Coordinate(i, j), piece);
+				result = Objects.hash(result, piece.getColor(), new Coordinate(i, j), piece);
 			}
 		}
 		return result;
@@ -301,4 +302,11 @@ public class ChessBoard {
 		this.lastMove = lastMove;
 	}
 
+	@Override
+	public boolean equals(Object obj){
+		if (obj instanceof ChessBoard board)
+			return board.hashCode() == this.hashCode();
+		return false;
+	}
+
 }

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

@@ -12,7 +12,7 @@ public class Game {
 	private final ChessBoard board;
 	private Color playerTurn;
 	private final Stack<PlayerCommand> movesHistory;
-	private final Map<Color, Map<Integer, Integer>> traitsPos;
+	private final Map<Integer, Integer> traitsPos;
 
 	private static final int DRAW_REPETITONS = 3;
 
@@ -37,13 +37,6 @@ public class Game {
 	public void reset() {
 		resetPlayerTurn();
 		this.traitsPos.clear();
-		initPlayer(Color.Black);
-		initPlayer(Color.White);
-	}
-
-	private void initPlayer(Color color) {
-		this.traitsPos.put(color, new HashMap<>());
-		saveTraitPiecesPos(color);
 	}
 
 	public void resetPlayerTurn() {
@@ -55,32 +48,18 @@ public class Game {
 	 * @param color the current player turn
 	 * @return true if a draw should be declared
 	 */
-	private void saveTraitPiecesPos(Color color) {
-		int piecesHash = this.board.hashPlayerPieces(color);
-		Integer count = this.traitsPos.get(color).get(piecesHash);
-		this.traitsPos.get(color).put(piecesHash, count == null ? 1 : count + 1);
-	}
-
 	public void saveTraitPiecesPos() {
-		saveTraitPiecesPos(playerTurn);
+		int piecesHash = this.board.hashCode();
+		Integer count = this.traitsPos.get(piecesHash);
+		this.traitsPos.put(piecesHash, count == null ? 1 : count + 1);
 	}
 
-	/**
-	 * 
-	 * @param player the trait to check
-	 * @return true if a position is repeated DRAW_REPETITONS times
-	 */
-	private boolean checkDraw(Color player) {
-		return this.traitsPos.get(player).containsValue(DRAW_REPETITONS);
-	}
 
 	/**
 	 * @return whether the game is in a draw situation
 	 */
 	private boolean checkDraw() {
-		if (checkDraw(Color.White))
+		return this.traitsPos.containsValue(DRAW_REPETITONS);
-			return true;
-		return checkDraw(Color.Black);
 	}
 
 	/**
@@ -129,15 +108,11 @@ public class Game {
 		}
 	}
 
-	private void undoTraitPiecesPos(Color color) {
-		int piecesHash = this.board.hashPlayerPieces(color);
-		Integer count = this.traitsPos.get(color).get(piecesHash);
-		if (count != null)
-			this.traitsPos.get(color).put(piecesHash, count - 1);
-	}
-
 	public void undoTraitPiecesPos() {
-		undoTraitPiecesPos(Color.getEnemy(playerTurn));
+		int piecesHash = this.board.hashCode();
+		Integer count = this.traitsPos.get(piecesHash);
+		if (count != null)
+			this.traitsPos.put(piecesHash, count - 1);
 	}
 
 	public List<PlayerCommand> getMoves() {

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

@@ -28,4 +28,7 @@ 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/pieces/Bishop.java

@@ -20,4 +20,8 @@ public class Bishop extends Piece {
 		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

@@ -19,4 +19,8 @@ public class King extends Piece {
 	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

@@ -19,4 +19,8 @@ public class Knight extends Piece {
 	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

@@ -23,4 +23,8 @@ public class Pawn extends Piece {
 	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

@@ -19,4 +19,8 @@ public class Queen extends Piece {
 	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

@@ -19,4 +19,8 @@ public class Rook extends Piece {
 	public int hashCode() {
 		return 5;
 	}
+
+	public boolean equals(Object other) {
+		return (other instanceof Rook && ((Rook) other).getColor() == this.getColor());
+	}
 }

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

@@ -3,6 +3,7 @@ package chess.view.render;
 import org.joml.Vector3f;
 import org.lwjgl.opengl.*;
 
+import chess.model.Coordinate;
 import chess.view.render.shader.BoardShader;
 
 import static org.lwjgl.opengl.GL30.*;
@@ -59,16 +60,42 @@ public class Renderer {
 		return positions;
 	}
 
+	private Coordinate GetCellFromColor(Vector3f color) {
+		int offset = 1;
+
+		if (color.x > 0.5) {
+			color = new Vector3f(1.0f, 1.0f, 1.0f).sub(color);
+			offset = 0;
+		}
+
+		int r = (int) (color.x * 255.0f);
+		int g = (int) (color.y * 255.0f);
+		int b = (int) (color.z * 255.0f);
+
+		int index = (r + g + b) * 2 + offset;
+
+		return Coordinate.fromIndex(index);
+	}
+
+	private Vector3f GetCellColor(int x, int y) {
+		float index = (y * BOARD_WIDTH + x) / 2.0f;
+		float r = (int) (index / 3) / 255.0f;
+		float g = (int) ((index + 1) / 3) / 255.0f;
+		float b = (int) ((index + 2) / 3) / 255.0f;
+		if ((x + y) % 2 != 0) {
+			System.out.println(GetCellFromColor(new Vector3f(1.0f - r - 1.0f / 255.0f, 1.0f - g - 1.0f / 255.0f, 1.0f - b - 1.0f / 255.0f)));
+			return new Vector3f(1.0f - r - 1.0f / 255.0f, 1.0f - g - 1.0f / 255.0f, 1.0f - b - 1.0f / 255.0f);
+		} else {
+			System.out.println(GetCellFromColor(new Vector3f(r, g, b)));
+			return new Vector3f(r, g, b);
+		}
+	}
+
 	private 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++) {
-			for (int j = 0; j < BOARD_HEIGHT; j++) {
+			for (int i = 0; i < BOARD_WIDTH; i++) {
-				Vector3f color;
+				Vector3f color = GetCellColor(i, j);
-				if ((i + j) % 2 != 0) {
-					color = new Vector3f(1.0f, 1.0f, 1.0f);
-				} else {
-					color = new Vector3f(0.0f, 0.0f, 0.0f);
-				}
 				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;
@@ -109,6 +136,12 @@ public class Renderer {
 		this.vao.Unbind();
 	}
 
+	public Coordinate GetSelectedCell() {
+		float pixels[] = new float[3];
+		GL30.glReadPixels(500, 500, 1, 1, GL_RGB, GL_FLOAT, pixels);
+		return GetCellFromColor(new Vector3f(pixels[0], pixels[1], pixels[2]));
+	}
+
 	public void Render(Camera cam) {
 		this.shader.Start();
 		this.shader.SetCamMatrix(cam.getMatrix());

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

@@ -5,6 +5,12 @@ import org.lwjgl.glfw.*;
 import org.lwjgl.opengl.*;
 import org.lwjgl.system.*;
 
+import chess.controller.CommandExecutor;
+import chess.controller.event.GameListener;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Move;
+
 import java.nio.*;
 
 import static org.lwjgl.glfw.Callbacks.*;
@@ -13,17 +19,20 @@ import static org.lwjgl.opengl.GL11.*;
 import static org.lwjgl.system.MemoryStack.*;
 import static org.lwjgl.system.MemoryUtil.*;
 
-public class Window {
+public class Window implements GameListener{
 
 	// The window handle
 	private long window;
 
+	private final CommandExecutor commandExecutor;
+
 	private Renderer renderer;
 	private Camera cam;
 
-	public Window() {
+	public Window(CommandExecutor commandExecutor) {
 		this.renderer = new Renderer();
 		this.cam = new Camera();
+		this.commandExecutor = new CommandExecutor();
 	}
 
 	public void run() {
@@ -114,6 +123,8 @@ public class Window {
 
 			render();
 
+			System.out.println(this.renderer.GetSelectedCell());
+
 			glfwSwapBuffers(window); // swap the color buffers
 
 			// Poll for window events. The key callback above will only be
@@ -132,4 +143,82 @@ public class Window {
 		}
 	}
 
+	@Override
+	public void onBoardUpdate() {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onBoardUpdate'");
+	}
+
+	@Override
+	public void onDraw() {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onDraw'");
+	}
+
+	@Override
+	public void onGameEnd() {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onGameEnd'");
+	}
+
+	@Override
+	public void onGameStart() {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onGameStart'");
+	}
+
+	@Override
+	public void onKingInCheck() {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onKingInCheck'");
+	}
+
+	@Override
+	public void onKingInMat() {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onKingInMat'");
+	}
+
+	@Override
+	public void onMove(Move move) {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onMove'");
+	}
+
+	@Override
+	public void onMoveNotAllowed(Move move) {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onMoveNotAllowed'");
+	}
+
+	@Override
+	public void onPatSituation() {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onPatSituation'");
+	}
+
+	@Override
+	public void onPlayerTurn(Color color) {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onPlayerTurn'");
+	}
+
+	@Override
+	public void onPromotePawn(Coordinate pieceCoords) {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onPromotePawn'");
+	}
+
+	@Override
+	public void onSurrender(Color coward) {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onSurrender'");
+	}
+
+	@Override
+	public void onWin(Color winner) {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'onWin'");
+	}
+
 }

app/src/test/java/chess/AppTest.java

@@ -3,12 +3,57 @@
  */
 package chess;
 
+import chess.ai.DumbAI;
+import chess.controller.Command;
+import chess.controller.CommandExecutor;
+import chess.controller.commands.NewGameCommand;
+import chess.controller.commands.UndoCommand;
+import chess.controller.event.GameAdaptator;
+import chess.model.*;
+import chess.model.pieces.*;
+import chess.simulator.Simulator;
+import chess.view.simplerender.Window;
 import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import java.util.Objects;
 
 class AppTest {
-    @Test void appHasAGreeting() {
+    @Test void functionalRollback(){
-        // App classUnderTest = new App();
+        Game game = new Game(new ChessBoard());
-        // assertNotNull(classUnderTest.getGreeting(), "app should have a greeting");
+        CommandExecutor commandExecutor = new CommandExecutor(game);
+
+        DumbAI ai = new DumbAI(commandExecutor, Color.Black);
+        commandExecutor.addListener(ai);
+
+        DumbAI ai2 = new DumbAI(commandExecutor, Color.White);
+        commandExecutor.addListener(ai2);
+
+        commandExecutor.addListener(new GameAdaptator() {
+            @Override
+            public void onGameEnd() {
+
+                Command.CommandResult result;
+                do {
+                    result = commandExecutor.executeCommand(new UndoCommand());
+                } while (result != Command.CommandResult.NotAllowed);
+
+                Game initialGame = new Game(new ChessBoard());
+                CommandExecutor initialCommandExecutor = new CommandExecutor(initialGame);
+                commandExecutor.executeCommand(new NewGameCommand());
+
+                assert(game.getBoard().equals(initialGame.getBoard()));
+
+            }
+        });
+
+        commandExecutor.executeCommand(new NewGameCommand());
+
+    }
+
+    @Test void functionalRollbacks(){
+        for (int i=0; i<100; i++) {
+            functionalRollback();
+        }
     }
 }