better gui interaction

.gitignore

@@ -4,4 +4,6 @@
 # Ignore Gradle build output directory
 build
 
-app/bin
+app/bin
+
+.vscode

app/build.gradle

@@ -17,7 +17,7 @@ repositories {
 }
 
 def lwjgl_version = "3.3.6"
-def lwjgl_natives = "natives-windows"
+def lwjgl_natives = "natives-linux"
 
 dependencies {
     // Use JUnit Jupiter for testing.

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

@@ -3,14 +3,22 @@
  */
 package chess;
 
-import chess.view.render2D.Window;
+import chess.io.CommandExecutor;
+import chess.io.commands.NewGameCommand;
+import chess.model.ChessBoard;
+import chess.model.Game;
+import chess.simplerender.Window;
 
 public class App {
-    public String getGreeting() {
-        return "Hello World!";
-    }
-
     public static void main(String[] args) {
-        Window.main(args);
+        CommandExecutor commandExecutor = new CommandExecutor();
+
+        Game game = new Game(new ChessBoard());
+        Window window = new Window(commandExecutor);
+
+        commandExecutor.setGame(game);
+        commandExecutor.setOutputSystem(window);
+
+        commandExecutor.executeCommand(new NewGameCommand());
     }
 }

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

@@ -1,29 +0,0 @@
-package chess.controller;
-
-import chess.model.Coordinates;
-import chess.model.Game;
-import chess.model.Move;
-import chess.view.render2D.Window;
-
-public class Controller {
-    private final Game game;
-    private final Window view;
-
-    public Controller(Game game, Window view) {
-        this.game = game;
-        this.view = view;
-    }
-
-    /**
-     *
-     * @param from Coordinates: old coordinates
-     * @param to Coordinates: new coordinates
-     */
-    public void sendMove(Coordinates from, Coordinates to) {
-        System.out.println("New move: " + from + " to " + to);
-        game.setMove(new Move(from, to));
-    }
-
-
-
-}

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

@@ -0,0 +1,7 @@
+package chess.io;
+
+import chess.model.Game;
+
+public abstract class Command {
+	public abstract CommandResult execute(Game game, OutputSystem outputSystem);
+}

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

@@ -0,0 +1,80 @@
+package chess.io;
+
+import chess.io.commands.MoveCommand;
+import chess.io.commands.PromoteCommand;
+import chess.model.Game;
+
+public class CommandExecutor {
+
+	private Game game;
+	private OutputSystem outputSystem;
+
+	public CommandExecutor() {
+		this.game = null;
+		this.outputSystem = null;
+	}
+
+	public CommandResult executeCommand(Command command) {
+		assert this.game != null : "No input game specified !";
+		assert this.outputSystem != null : "No output system specified !";
+
+		CommandResult result = command.execute(this.game, this.outputSystem);
+
+		// non player commands are not supposed to return move result
+		assert result != CommandResult.Moved || command instanceof PlayerCommand;
+
+		processResult(command, result);
+		return result;
+	}
+
+	private void processResult(Command command, CommandResult result) {
+		if (result != CommandResult.Moved)
+			return;
+
+		if (command instanceof MoveCommand move) {
+			boolean needsPromote = this.game.checkPromotion(move.getMove().getFinish());
+			if (this.game.checkGameStatus())
+				return;
+
+			if (!needsPromote)
+				this.game.switchPlayerTurn();
+		} else if (command instanceof PlayerCommand) {
+			this.game.switchPlayerTurn();
+		}
+	}
+
+	public void setOutputSystem(OutputSystem outputSystem) {
+		unbindListeners();
+		this.outputSystem = outputSystem;
+		bindListeners();
+	}
+
+	public void setGame(Game game) {
+		unbindListeners();
+		this.game = game;
+		bindListeners();
+	}
+
+	private void unbindListeners() {
+		if (this.game == null || this.outputSystem == null)
+			return;
+		this.game.OnCheck.disconnect(outputSystem::kingIsInCheck);
+		this.game.OnMat.disconnect(outputSystem::kingIsInMat);
+		this.game.OnPat.disconnect(outputSystem::patSituation);
+		this.game.OnPromote.disconnect(outputSystem::promotePawn);
+		this.game.OnWin.disconnect(outputSystem::winnerIs);
+		this.game.OnPlayerTurn.disconnect(outputSystem::playerTurn);
+	}
+
+	private void bindListeners() {
+		if (this.game == null || this.outputSystem == null)
+			return;
+		this.game.OnCheck.connect(outputSystem::kingIsInCheck);
+		this.game.OnMat.connect(outputSystem::kingIsInMat);
+		this.game.OnPat.connect(outputSystem::patSituation);
+		this.game.OnPromote.connect(outputSystem::promotePawn);
+		this.game.OnWin.connect(outputSystem::winnerIs);
+		this.game.OnPlayerTurn.connect(outputSystem::playerTurn);
+	}
+
+}

app/src/main/java/chess/io/CommandResult.java

@@ -0,0 +1,5 @@
+package chess.io;
+
+public enum CommandResult {
+	Moved, NotMoved, NotAllowed;
+}

app/src/main/java/chess/io/OutputSystem.java

@@ -0,0 +1,23 @@
+package chess.io;
+
+import chess.model.Color;
+import chess.model.Coordinate;
+
+public interface OutputSystem {
+
+	void playerTurn(Color color);
+
+	void winnerIs(Color color);
+
+	void kingIsInCheck();
+
+	void kingIsInMat();
+
+	void patSituation();
+
+	void hasSurrendered(Color color);
+
+	void gameStarted();
+
+	void promotePawn(Coordinate pieceCoords);
+}

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

@@ -0,0 +1,7 @@
+package chess.io;
+
+import chess.model.Game;
+
+public abstract class PlayerCommand extends Command{
+	public abstract void undo(Game game, OutputSystem outputSystem);
+}

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

@@ -0,0 +1,21 @@
+package chess.io.commands;
+
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.io.PlayerCommand;
+import chess.model.Game;
+
+public class CastlingCommand extends PlayerCommand{
+
+	@Override
+	public CommandResult execute(Game game, OutputSystem outputSystem) {
+		return CommandResult.NotAllowed;
+	}
+
+	@Override
+	public void undo(Game game, OutputSystem outputSystem) {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'undo'");
+	}
+	
+}

app/src/main/java/chess/io/commands/GetAllowedMovesCommand.java

@@ -0,0 +1,42 @@
+package chess.io.commands;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import chess.io.Command;
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.model.ChessBoard;
+import chess.model.Coordinate;
+import chess.model.Game;
+import chess.model.Piece;
+
+public class GetAllowedMovesCommand extends Command {
+
+	private final Coordinate start;
+	private List<Coordinate> destinations;
+
+	public GetAllowedMovesCommand(Coordinate start) {
+		this.start = start;
+		this.destinations = new ArrayList<>();
+	}
+
+	@Override
+	public CommandResult execute(Game game, OutputSystem outputSystem) {
+		final ChessBoard board = game.getBoard();
+		Piece piece = board.pieceAt(start);
+
+		if (piece == null)
+			return CommandResult.NotAllowed;
+
+		if (piece.getColor() != game.getPlayerTurn())
+			return CommandResult.NotAllowed;
+
+		this.destinations = board.getAllowedMoves(start);
+		return CommandResult.NotMoved;
+	}
+
+	public List<Coordinate> getDestinations() {
+		return destinations;
+	}
+}

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

@@ -0,0 +1,34 @@
+package chess.io.commands;
+
+import chess.io.Command;
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.model.Coordinate;
+import chess.model.Game;
+import chess.model.Piece;
+
+public class GetPieceAtCommand extends Command{
+
+	private final Coordinate pieceCoords;
+	private Piece piece;
+
+	public GetPieceAtCommand(Coordinate pieceCoords) {
+		this.pieceCoords = pieceCoords;
+		this.piece = null;
+	}
+
+	@Override
+	public CommandResult execute(Game game, OutputSystem outputSystem) {
+		if (!pieceCoords.isValid())
+			return CommandResult.NotAllowed;
+
+		this.piece = game.getBoard().pieceAt(pieceCoords);
+
+		return CommandResult.NotMoved;
+	}
+
+	public Piece getPiece() {
+		return piece;
+	}
+
+}

app/src/main/java/chess/io/commands/GrandCastlingCommand.java

@@ -0,0 +1,21 @@
+package chess.io.commands;
+
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.io.PlayerCommand;
+import chess.model.Game;
+
+public class GrandCastlingCommand extends PlayerCommand {
+
+	@Override
+	public CommandResult execute(Game game, OutputSystem outputSystem) {
+		return CommandResult.NotAllowed;
+	}
+
+	@Override
+	public void undo(Game game, OutputSystem outputSystem) {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException("Unimplemented method 'undo'");
+	}
+
+}

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

@@ -0,0 +1,57 @@
+package chess.io.commands;
+
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.io.PlayerCommand;
+import chess.model.ChessBoard;
+import chess.model.Game;
+import chess.model.Move;
+import chess.model.Piece;
+import chess.model.visitor.PiecePathChecker;
+
+public class MoveCommand extends PlayerCommand {
+	private final Move move;
+
+	public MoveCommand(Move move) {
+		this.move = move;
+	}
+
+	public Move getMove() {
+		return move;
+	}
+
+	@Override
+	public CommandResult execute(Game game, OutputSystem outputSystem) {
+		final ChessBoard board = game.getBoard();
+
+		// we must promote the pending pawn before
+		if (game.pawnShouldBePromoted())
+			return CommandResult.NotAllowed;
+
+		Piece piece = board.pieceAt(move.getStart());
+		if (piece == null)
+			return CommandResult.NotAllowed;
+
+		if (piece.getColor() != game.getPlayerTurn())
+			return CommandResult.NotAllowed;
+
+		boolean valid = new PiecePathChecker(board, move).isValid();
+		if (!valid)
+			return CommandResult.NotAllowed;
+
+		board.applyMove(move);
+
+		if (board.isKingInCheck(game.getPlayerTurn())) {
+			board.undoLastMove();
+			return CommandResult.NotAllowed;
+		}
+
+		return CommandResult.Moved;
+	}
+
+	@Override
+	public void undo(Game game, OutputSystem outputSystem) {
+		game.getBoard().undoLastMove();
+	}
+
+}

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

@@ -0,0 +1,56 @@
+package chess.io.commands;
+
+import chess.io.Command;
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.model.ChessBoard;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Game;
+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 NewGameCommand extends Command {
+	public CommandResult execute(Game game, OutputSystem outputSystem) {
+		ChessBoard board = game.getBoard();
+
+		for (int i = 0; i < 8; i++) {
+			board.pieceComes(new Pawn(Color.Black), new Coordinate(i, 1));
+			board.pieceComes(new Pawn(Color.White), new Coordinate(i, Coordinate.VALUE_MAX - 2));
+		}
+
+		board.pieceComes(new Rook(Color.Black), new Coordinate(0, 0));
+		board.pieceComes(new Rook(Color.Black), new Coordinate(Coordinate.VALUE_MAX - 1, 0));
+
+		board.pieceComes(new Rook(Color.White), new Coordinate(0, Coordinate.VALUE_MAX - 1));
+		board.pieceComes(new Rook(Color.White), new Coordinate(Coordinate.VALUE_MAX - 1, Coordinate.VALUE_MAX - 1));
+
+		board.pieceComes(new Knight(Color.Black), new Coordinate(1, 0));
+		board.pieceComes(new Knight(Color.Black), new Coordinate(Coordinate.VALUE_MAX - 2, 0));
+
+		board.pieceComes(new Knight(Color.White), new Coordinate(1, Coordinate.VALUE_MAX - 1));
+		board.pieceComes(new Knight(Color.White), new Coordinate(Coordinate.VALUE_MAX - 2, Coordinate.VALUE_MAX - 1));
+
+		board.pieceComes(new Bishop(Color.Black), new Coordinate(2, 0));
+		board.pieceComes(new Bishop(Color.Black), new Coordinate(Coordinate.VALUE_MAX - 3, 0));
+
+		board.pieceComes(new Bishop(Color.White), new Coordinate(2, Coordinate.VALUE_MAX - 1));
+		board.pieceComes(new Bishop(Color.White), new Coordinate(Coordinate.VALUE_MAX - 3, Coordinate.VALUE_MAX - 1));
+
+		board.pieceComes(new Queen(Color.Black), new Coordinate(3, 0));
+		board.pieceComes(new King(Color.Black), new Coordinate(4, 0));
+
+		board.pieceComes(new Queen(Color.White), new Coordinate(3, Coordinate.VALUE_MAX - 1));
+		board.pieceComes(new King(Color.White), new Coordinate(4, Coordinate.VALUE_MAX - 1));
+
+		game.resetPlayerTurn();
+
+		outputSystem.gameStarted();
+
+		return CommandResult.NotMoved;
+	}
+}

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

@@ -0,0 +1,87 @@
+package chess.io.commands;
+
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.io.PlayerCommand;
+import chess.model.ChessBoard;
+import chess.model.Color;
+import chess.model.Coordinate;
+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;
+
+public class PromoteCommand extends PlayerCommand {
+
+	public enum PromoteType {
+		Queen,
+		Rook,
+		Bishop,
+		Knight
+	}
+
+	private final PromoteType promoteType;
+	private final Coordinate pieceCoords;
+
+	public PromoteCommand(PromoteType promoteType, Coordinate pieceCoords) {
+		this.promoteType = promoteType;
+		this.pieceCoords = pieceCoords;
+	}
+
+	@Override
+	public CommandResult execute(Game game, OutputSystem outputSystem) {
+		final ChessBoard board = game.getBoard();
+
+		Piece pawn = board.pieceAt(this.pieceCoords);
+		if (pawn == null || !(pawn instanceof Pawn))
+			return CommandResult.NotAllowed;
+
+		int destY = this.pieceCoords.getY();
+
+		int enemyLine = pawn.getColor() == Color.White ? 0 : 7;
+
+		if (destY != enemyLine)
+			return CommandResult.NotAllowed;
+
+		board.pieceLeaves(this.pieceCoords);
+		board.pieceComes(createPiece(this.promoteType, pawn.getColor()), this.pieceCoords);
+
+		return CommandResult.Moved;
+	}
+
+	private Piece createPiece(PromoteType promoteType, Color color) {
+		switch (promoteType) {
+			case Queen:
+				return new Queen(color);
+
+			case Bishop:
+				return new Bishop(color);
+
+			case Knight:
+				return new Knight(color);
+
+			case Rook:
+				return new Rook(color);
+
+			default:
+				return null;
+		}
+	}
+
+	@Override
+	public void undo(Game game, OutputSystem outputSystem) {
+		final ChessBoard board = game.getBoard();
+
+		Piece promoted = board.pieceAt(this.pieceCoords);
+
+		assert promoted != null;
+
+		Color player = promoted.getColor();
+		board.pieceLeaves(this.pieceCoords);
+		board.pieceComes(new Pawn(player), this.pieceCoords);
+	}
+
+}

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

@@ -0,0 +1,24 @@
+package chess.io.commands;
+
+import chess.io.Command;
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.model.Color;
+import chess.model.Game;
+
+public class SurrenderCommand extends Command {
+
+	private final Color player;
+
+	public SurrenderCommand(Color player) {
+		this.player = player;
+	}
+
+	@Override
+	public CommandResult execute(Game game, OutputSystem outputSystem) {
+		outputSystem.hasSurrendered(player);
+		outputSystem.winnerIs(Color.getEnemy(player));
+		return CommandResult.NotMoved;
+	}
+	
+}

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

@@ -0,0 +1,16 @@
+package chess.io.commands;
+
+import chess.io.Command;
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.model.Game;
+
+public class UndoCommand extends Command{
+
+	@Override
+	public CommandResult execute(Game game, OutputSystem outputSystem) {
+		//TODO
+		return CommandResult.Moved;
+	}
+	
+}

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

@@ -1,17 +0,0 @@
-package chess.model;
-
-import java.util.ArrayList;
-
-public abstract class AccessibleCellsDecorator {
-    public AccessibleCellsDecorator base;
-    public ArrayList<Cell> cells;
-    protected abstract ArrayList<Cell> getAccessibleCells();
-    public AccessibleCellsDecorator(AccessibleCellsDecorator base) {
-        this.base = base;
-    }
-    public AccessibleCellsDecorator() {
-        this(null);
-    }
-
-
-}

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

@@ -1,81 +0,0 @@
-package chess.model;
-
-import chess.model.pieces.*;
-
-public class Board {
-    private final Cell[][] cells;
-    private static final int WHITE = 0;
-    private static final int BLACK = 1;
-
-    public Board(int size) {
-        cells = new Cell[size][size];
-        for (int y = 0; y < size; y++) {
-            for (int x = 0; x < size; x++) {
-                cells[y][x] = new Cell();
-            }
-        }
-        setPieces();
-    }
-
-    public Board() {
-        this(8);
-    }
-
-    public Cell getCell(Coordinates coordinates) {
-        return cells[coordinates.getX()][coordinates.getY()];
-    }
-
-    public int getSize() {
-        return cells.length;
-    }
-
-    public void setPieces() throws Error {
-        if (this.getSize() == 8) {
-            setPiecesSize8();
-        } else {
-            throw new Error("Oops. This isn't implemented yet.");
-        }
-    }
-
-    public void setPiecesSize8() {
-        for (int i = 0; i < 8; i++) {
-            cells[i][1].setPiece(new Pawn(BLACK, this, cells[i][1]));
-            cells[i][6].setPiece(new Pawn(WHITE, this, cells[i][6]));
-        }
-
-        for (int i = 0; i <= 7; i += 7) {
-            cells[i][0].setPiece(new Rook(BLACK, this, cells[i][0]));
-            cells[i][7].setPiece(new Rook(WHITE, this, cells[i][7]));
-        }
-        for (int i = 1; i <= 6; i += 5) {
-            cells[i][0].setPiece(new Knight(BLACK, this, cells[i][0]));
-            cells[i][7].setPiece(new Knight(WHITE, this, cells[i][7]));
-        }
-        for (int i = 2; i <= 5; i += 3) {
-            cells[i][0].setPiece(new Bishop(BLACK, this, cells[i][0]));
-            cells[i][7].setPiece(new Bishop(WHITE, this, cells[i][7]));
-        }
-        cells[3][0].setPiece(new Queen(BLACK, this, cells[3][0]));
-        cells[3][7].setPiece(new Queen(WHITE, this, cells[3][7]));
-        cells[4][0].setPiece(new King(BLACK, this, cells[4][0]));
-        cells[4][7].setPiece(new King(WHITE, this, cells[4][7]));
-    }
-
-    public Piece getPiece(Coordinates coordinates) {
-        return getCell(coordinates).getPiece();
-    }
-
-    public void movePiece(Move move) throws Error {
-        Piece movingPiece = getPiece(move.getStart());
-        Cell arrivalCell = getCell(move.getEnd());
-        getCell(move.getStart()).deletePiece();
-        arrivalCell.setPiece(movingPiece);
-        movingPiece.setPosition(arrivalCell);
-    }
-
-    public Cell getRelativePosition(Coordinates coordinates) {
-        // todo
-        return null;
-    }
-
-}

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

@@ -1,25 +0,0 @@
-package chess.model;
-
-public class Cell {
-    private Piece piece = null;
-
-    public Cell(Piece piece) {
-        this.piece = piece;
-    }
-
-    public Cell(){
-        this.piece = null;
-    }
-
-    public void setPiece(Piece piece) {
-        this.piece = piece;
-    }
-
-    public void deletePiece() {
-        this.piece = null;
-    }
-
-    public Piece getPiece() {
-        return piece;
-    }
-}

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

@@ -0,0 +1,188 @@
+package chess.model;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+import chess.model.visitor.KingIdentifier;
+import chess.model.visitor.PiecePathChecker;
+
+public class ChessBoard {
+	public static class Cell {
+		private Piece piece;
+
+		public Cell() {
+			this.piece = null;
+		}
+
+		public Piece getPiece() {
+			return piece;
+		}
+
+		public void setPiece(Piece piece) {
+			this.piece = piece;
+		}
+
+	}
+
+	private final Cell[][] cells;
+	private final Stack<Move> moves;
+	private final Stack<Piece> ejectedPieces;
+
+	public ChessBoard() {
+		this.cells = new Cell[Coordinate.VALUE_MAX][Coordinate.VALUE_MAX];
+		for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
+			for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
+				this.cells[i][j] = new Cell();
+			}
+		}
+		this.moves = new Stack<>();
+		this.ejectedPieces = new Stack<>();
+	}
+
+	public void applyMove(Move move) {
+		assert (move.isValid());
+		Piece deadPiece = pieceAt(move.getFinish());
+		if (deadPiece != null) {
+			deadPiece.eject(this.moves.size());
+			this.ejectedPieces.add(deadPiece);
+		}
+		Piece movingPiece = pieceAt(move.getStart());
+		pieceComes(movingPiece, move.getFinish());
+		pieceLeaves(move.getStart());
+		movingPiece.move();
+		this.moves.add(move);
+	}
+
+	public void undoLastMove() {
+		assert !this.moves.empty() : "Can't undo at the beginning!";
+
+		Move move = this.moves.pop();
+
+		Piece movingPiece = pieceAt(move.getFinish());
+		pieceComes(movingPiece, move.getStart());
+		pieceLeaves(move.getFinish());
+		movingPiece.unMove();
+
+		if (this.ejectedPieces.empty())
+			return;
+
+		Piece piece = this.ejectedPieces.lastElement();
+		if (piece.getEjectedMoveNumber() != this.moves.size())
+			return;
+
+		pieceComes(piece, move.getFinish());
+		piece.eject(-1);
+	}
+
+	public boolean isCellEmpty(Coordinate coordinate) {
+		return pieceAt(coordinate) == null;
+	}
+
+	public Piece pieceAt(Coordinate coordinate) {
+		if (!coordinate.isValid())
+			return null;
+		return cellAt(coordinate).getPiece();
+	}
+
+	public void clearBoard() {
+		for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
+			for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
+				pieceLeaves(new Coordinate(i, j));
+			}
+		}
+	}
+
+	private Cell cellAt(Coordinate coordinate) {
+		return this.cells[coordinate.getX()][coordinate.getY()];
+	}
+
+	public void pieceComes(Piece piece, Coordinate coordinate) {
+		cellAt(coordinate).setPiece(piece);
+	}
+
+	public void pieceLeaves(Coordinate coordinate) {
+		cellAt(coordinate).setPiece(null);
+	}
+
+	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 (piece != null && kingIdentifier.visit(piece)) {
+					return coordinate;
+				}
+			}
+		}
+		assert false : "No king found ?!";
+		return null;
+	}
+
+	public boolean isKingInCheck(Color color) {
+		Coordinate kingPos = findKing(color);
+		assert kingPos.isValid() : "King position is invalid!";
+
+		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)
+					continue;
+
+				PiecePathChecker checker = new PiecePathChecker(this, new Move(attackCoords, kingPos));
+				if (checker.isValid())
+					return true;
+			}
+		}
+		return false;
+	}
+
+	public boolean hasAllowedMoves(Color player) {
+		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)
+					continue;
+
+				if (attackPiece.getColor() != player)
+					continue;
+
+				if (!getAllowedMoves(attackCoords).isEmpty())
+					return true;
+			}
+		}
+		return false;
+	}
+
+	public List<Coordinate> getAllowedMoves(Coordinate pieceCoords) {
+		Piece piece = pieceAt(pieceCoords);
+		if (piece == null)
+			return null;
+
+		Color player = piece.getColor();
+
+		List<Coordinate> result = new ArrayList<>();
+
+		for (int i = 0; i < Coordinate.VALUE_MAX; i++) {
+			for (int j = 0; j < Coordinate.VALUE_MAX; j++) {
+				Coordinate destination = new Coordinate(i, j);
+				Move move = new Move(pieceCoords, destination);
+
+				PiecePathChecker piecePathChecker = new PiecePathChecker(this,
+						move);
+				if (!piecePathChecker.isValid())
+					continue;
+
+				applyMove(move);
+				if (!isKingInCheck(player))
+					result.add(destination);
+				undoLastMove();
+			}
+		}
+		return result;
+	}
+
+}

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

@@ -0,0 +1,10 @@
+package chess.model;
+
+public enum Color {
+	White,
+	Black;
+
+	public static Color getEnemy(Color color) {
+		return color == White ? Black : White;
+	}
+}

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

@@ -0,0 +1,41 @@
+package chess.model;
+
+public class Coordinate {
+	private final int x;
+	private final int y;
+
+	public static int VALUE_MAX = 8;
+
+	public Coordinate(int x, int y) {
+		this.x = x;
+		this.y = y;
+	}
+
+	public int getX() {
+		return x;
+	}
+
+	public int getY() {
+		return y;
+	}
+
+	public boolean isValid() {
+		return 0 <= this.x && this.x < VALUE_MAX && 0 <= this.y && this.y < VALUE_MAX;
+	}
+
+	public static Coordinate fromIndex(int index) {
+		return new Coordinate(index % VALUE_MAX, index / VALUE_MAX);
+	}
+
+	public int toIndex() {
+		return this.y * VALUE_MAX + this.x;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof Coordinate coo) {
+			return this.x == coo.x && this.y == coo.y;
+		}
+		return false;
+	}
+}

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

@@ -1,22 +0,0 @@
-package chess.model;
-
-public class Coordinates {
-    private int x;
-    private int y;
-
-    public Coordinates(int x, int y) {
-        this.x = x;
-        this.y = y;
-    }
-    public int getX() {
-        return this.x;
-    }
-
-    public int getY() {
-        return this.y;
-    }
-
-    public String toString() {
-        return "(" + this.x + ", " + this.y + ")";
-    }
-}

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

@@ -0,0 +1,54 @@
+package chess.model;
+
+public enum Direction {
+
+	Unset(65),
+	Front(-8), Back(8), Left(-1), Right(1),
+	FrontLeft(-9), FrontRight(-7), BackLeft(7), BackRight(9);
+
+	private final int indexOffset;
+
+	Direction(int indexOffset) {
+		this.indexOffset = indexOffset;
+	}
+
+	public int getIndexOffset() {
+		return indexOffset;
+	}
+
+	public static Direction fromInt(int direction) {
+		for (Direction dir : Direction.values()) {
+			if (dir.getIndexOffset() == direction)
+				return dir;
+		}
+		return null;
+	}
+
+	public static Direction findDirection(Move move) {
+		assert move.isValid() : "Move is invalid!";
+		int diffX = move.getFinish().getX() - move.getStart().getX();
+		int diffY = move.getFinish().getY() - move.getStart().getY();
+
+		if (diffX == 0 && diffY < 0)
+			return Direction.Front;
+		if (diffX == 0 && diffY > 0)
+			return Direction.Back;
+
+		if (diffX < 0 && diffY == 0)
+			return Direction.Left;
+		if (diffX > 0 && diffY == 0)
+			return Direction.Right;
+
+		if (diffX < 0 && -diffX == diffY)
+			return Direction.BackLeft;
+		if (diffX > 0 && diffX == diffY)
+			return Direction.BackRight;
+
+		if (diffY < 0 && diffX == diffY)
+			return Direction.FrontLeft;
+		if (diffX > 0 && diffX == -diffY)
+			return Direction.FrontRight;
+
+		return Direction.Unset;
+	}
+}

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

@@ -1,87 +1,99 @@
 package chess.model;
 
-import java.util.ArrayList;
-import java.util.Observable;
+import chess.model.pieces.Pawn;
+import common.Signal0;
+import common.Signal1;
 
-public class Game extends Observable implements Runnable  {
-    private final Board board;
-    private Move move;
-    private final ArrayList<Player> players = new ArrayList<>();
+public class Game {
+	private final ChessBoard board;
+	private Color playerTurn;
 
-    public Game(int size) {
-        this.board = new Board(size);
-        this.setChanged();
-        this.notifyObservers();
-    }
-    public Game() {
-        this(8);
-    }
+	public final Signal1<Coordinate> OnPromote = new Signal1<>();
+	public final Signal1<Color> OnWin = new Signal1<>();
+	public final Signal1<Color> OnPlayerTurn = new Signal1<>();
 
-    public int getSize(){
-        return board.getSize();
-    }
-    public Board getBoard() {
-        return board;
-    }
-    public Move getMove() {
-        return move;
-    }
+	public final Signal0 OnCheck = new Signal0();
+	public final Signal0 OnMat = new Signal0();
+	public final Signal0 OnPat = new Signal0();
 
-    public void setMove(Move m){
-        this.move = m;
-        synchronized (this) {
-            this.notify();
-        }
-    }
+	public Game(ChessBoard board) {
+		this.board = board;
+	}
 
-    public boolean gameDone(){
-        // todo
-        return false;
-    }
+	public ChessBoard getBoard() {
+		return board;
+	}
 
-    public Player getNextPlayer(){
-        return players.getFirst();
-    }
+	public Color getPlayerTurn() {
+		return playerTurn;
+	}
 
-    public void updatePlayersList(){
-        Player player = players.getFirst();
-        players.remove(player);
-        players.add(player);
-    }
+	public void resetPlayerTurn() {
+		this.playerTurn = Color.White;
+		this.OnPlayerTurn.emit(playerTurn);
+	}
 
-    public void playGame() {
-        players.add(new Player(this));
-        players.add(new Player(this));
-        while (!gameDone()){
-            Move m = getNextPlayer().getMove();
-            while (!applyMove(m)){
-                m = getNextPlayer().getMove();
-            }
-            updatePlayersList();
-            setChanged();
-            notifyObservers();
-        }
-    }
+	public void switchPlayerTurn() {
+		playerTurn = Color.getEnemy(playerTurn);
+		this.OnPlayerTurn.emit(playerTurn);
+	}
 
-    @Override
-    public void run(){
-        playGame();
-    }
+	public boolean checkPromotion(Coordinate pieceCoords) {
 
-    public boolean applyMove(Move m){
-        if (board.getCell(m.getStart()).getPiece() == null){
-            return false;
-        }
-        try {
-            move(m);
-        }
-        catch (Exception e) {
-            return false;
-        }
-        return true;
-    }
+		Piece piece = getBoard().pieceAt(pieceCoords);
+
+		if (piece == null || !(piece instanceof Pawn))
+			return false;
+
+		int destY = pieceCoords.getY();
+
+		int enemyLine = piece.getColor() == Color.White ? 0 : 7;
+
+		if (destY != enemyLine)
+			return false;
+
+		this.OnPromote.emit(pieceCoords);
+		return true;
+	}
+
+	/**
+	 * 
+	 * @return true if game should end
+	 */
+	public boolean checkGameStatus() {
+		final Color enemy = Color.getEnemy(getPlayerTurn());
+
+		if (this.board.isKingInCheck(enemy)) {
+			if (this.board.hasAllowedMoves(enemy)) {
+				this.OnCheck.emit();
+			} else {
+				this.OnMat.emit();
+				this.OnWin.emit(getPlayerTurn());
+				return true;
+			}
+		} else if (!board.hasAllowedMoves(enemy)) {
+			this.OnPat.emit();
+			return true;
+		}
+
+		return false;
+	}
+
+	public boolean pawnShouldBePromoted() {
+		if (pawnShouldBePromoted(Color.White))
+			return true;
+		return pawnShouldBePromoted(Color.Black);
+	}
+
+	private boolean pawnShouldBePromoted(Color color) {
+		int enemyLineY = color == Color.White ? 0 : 7;
+
+		for (int x = 0; x < Coordinate.VALUE_MAX; x++) {
+			if (checkPromotion(new Coordinate(x, enemyLineY)))
+				return true;
+		}
+
+		return false;
+	}
 
-    public void move(Move move) throws Exception{
-        board.movePiece(move);
-    }
 }

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

@@ -1,15 +0,0 @@
-package chess.model;
-
-import java.util.Observable;
-
-public class Model2D extends Observable {
-    public int x;
-    public int y;
-
-    public void set(int i, int j){
-        this.x = i;
-        this.y = j;
-        setChanged();
-        notifyObservers();
-    }
-}

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

@@ -1,26 +1,42 @@
 package chess.model;
 
 public class Move {
-    private Coordinates start;
-    private Coordinates end;
+	private final Coordinate start;
+	private final Coordinate finish;
 
-    public Move(Coordinates start, Coordinates end) {
-        this.start = start;
-        this.end = end;
-    }
+	public Move(Coordinate start, Coordinate finish) {
+		this.start = start;
+		this.finish = finish;
+	}
 
-    public Coordinates getEnd() {
-        return end;
-    }
+	public boolean isValid() {
+		return this.start.isValid() && this.finish.isValid() && !this.start.equals(this.finish);
+	}
 
-    public Coordinates getStart() {
-        return start;
-    }
+	public Coordinate getStart() {
+		return start;
+	}
 
-    public void updateMove(Coordinates start, Coordinates end) {
-        this.start = start;
-        this.end = end;
-    }
+	public Coordinate getFinish() {
+		return finish;
+	}
 
+	public int traversedCells() {
+		assert isValid() : "Move is invalid!";
+
+		int diffX = getFinish().getX() - getStart().getX();
+		int diffY = getFinish().getY() - getStart().getY();
+
+		assert Math.abs(diffX) < Coordinate.VALUE_MAX : "Move is too big!";
+		assert Math.abs(diffX) < Coordinate.VALUE_MAX : "Move is too big!";
+
+		if (diffX == 0)
+			return Math.abs(diffY);
+		if (diffY == 0)
+			return Math.abs(diffX);
+		if (Math.abs(diffX) == Math.abs(diffY))
+			return Math.abs(diffX);
+		return 0;
+	}
 
 }

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

@@ -1,27 +1,45 @@
 package chess.model;
 
-import chess.view.render2D.Pieces;
-
 public abstract class Piece {
-    public final int color;
-    public AccessibleCellsDecorator decorator;
-    public final Board board;
-    public Cell position;
 
-    public Piece(int color, Board board, Cell position) {
-        this.color = color;
-        this.board = board;
-        this.position = position;
-    }
+	private final Color color;
+	private int moved;
+	private int ejectedMoveNumber;
 
-    public int getColor() {
-        return color;
-    }
+	public Piece(Color color) {
+		this.color = color;
+		this.moved = 0;
+		this.ejectedMoveNumber = -1;
+	}
 
-    public void setPosition(Cell cell) {
-        this.position = cell;
-    }
+	public void move() {
+		this.moved++;
+	}
 
-    public abstract void accept(PieceVisitor pv);
+	public Color getColor() {
+		return color;
+	}
+
+	public boolean hasMoved() {
+		return moved > 0;
+	}
+
+	public void unMove() {
+		this.moved--;
+	}
+
+	public boolean isEjected() {
+		return this.ejectedMoveNumber != -1;
+	}
+
+	public int getEjectedMoveNumber() {
+		return ejectedMoveNumber;
+	}
+
+	public void eject(int moveNumber) {
+		this.ejectedMoveNumber = moveNumber;
+	}
+
+	public abstract <T> T accept(PieceVisitor<T> visitor);
 
 }

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

@@ -1,17 +1,28 @@
 package chess.model;
 
-import chess.model.pieces.*;
+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 interface PieceVisitor{
-    default void visit(Piece p) {
-        p.accept(this);
-    }
+public interface PieceVisitor<T> {
 
-    void visitPiece(Bishop p);
-    void visitPiece(Knight p);
-    void visitPiece(Pawn p);
-    void visitPiece(Queen p);
-    void visitPiece(King p);
-    void visitPiece(Rook p);
+	default T visit(Piece piece) {
+		return piece.accept(this);
+	}
+
+	T visitPiece(Bishop bishop);
+
+	T visitPiece(King king);
+
+	T visitPiece(Knight knight);
+
+	T visitPiece(Pawn pawn);
+
+	T visitPiece(Queen queen);
+
+	T visitPiece(Rook rook);
 
 }

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

@@ -1,21 +0,0 @@
-package chess.model;
-
-public class Player {
-    private final Game game;
-
-    public Player(Game game) {
-        this.game = game;
-    }
-
-    public Move getMove(){
-        synchronized(game){
-            try {
-                game.wait();
-            }
-            catch (Exception e) {
-                System.out.println(e.getMessage());
-            }
-        }
-        return game.getMove();
-    }
-}

app/src/main/java/chess/model/decorators/DiagonalDecorator.java

@@ -1,21 +0,0 @@
-package chess.model.decorators;
-
-import chess.model.AccessibleCellsDecorator;
-import chess.model.Cell;
-
-import java.util.ArrayList;
-
-public class DiagonalDecorator extends AccessibleCellsDecorator {
-    public DiagonalDecorator(AccessibleCellsDecorator base) {
-        super(base);
-    }
-
-    public DiagonalDecorator(){
-        super();
-    }
-
-    @Override
-    protected ArrayList<Cell> getAccessibleCells() {
-        return null;
-    }
-}

app/src/main/java/chess/model/decorators/LineDecorator.java

@@ -1,22 +0,0 @@
-package chess.model.decorators;
-
-import chess.model.AccessibleCellsDecorator;
-import chess.model.Cell;
-
-import java.util.ArrayList;
-
-public class LineDecorator extends AccessibleCellsDecorator {
-    public LineDecorator(AccessibleCellsDecorator base) {
-        super(base);
-    }
-
-    public LineDecorator(){
-        super();
-    }
-
-    @Override
-    protected ArrayList<Cell> getAccessibleCells() {
-
-        return null;
-    }
-}

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

@@ -1,17 +1,18 @@
 package chess.model.pieces;
 
-import chess.model.Board;
-import chess.model.Cell;
+import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
 public class Bishop extends Piece {
-    public Bishop(final int color, Board board, Cell cell) {
-        super(color, board, cell);
-    }
 
-    @Override
-    public void accept(PieceVisitor pv) {
-        pv.visitPiece(this);
-    }
+	public Bishop(Color color) {
+		super(color);
+	}
+
+	@Override
+	public <T> T accept(PieceVisitor<T> visitor) {
+		return visitor.visitPiece(this);
+	}
+
 }

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

@@ -1,17 +1,17 @@
 package chess.model.pieces;
 
-import chess.model.Board;
-import chess.model.Cell;
+import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
 public class King extends Piece {
-    public King(final int color, Board board, Cell cell) {
-        super(color, board, cell);
-    }
 
-    @Override
-    public void accept(PieceVisitor pv) {
-        pv.visitPiece(this);
-    }
+	public King(Color color) {
+		super(color);
+	}
+
+	@Override
+	public <T> T accept(PieceVisitor<T> visitor) {
+		return visitor.visitPiece(this);
+	}
 }

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

@@ -1,17 +1,17 @@
 package chess.model.pieces;
 
-import chess.model.Board;
-import chess.model.Cell;
+import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
 public class Knight extends Piece {
-    public Knight(final int color, Board board, Cell cell) {
-        super(color, board, cell);
-    }
 
-    @Override
-    public void accept(PieceVisitor pv) {
-        pv.visitPiece(this);
-    }
+	public Knight(Color color) {
+		super(color);
+	}
+
+	@Override
+	public <T> T accept(PieceVisitor<T> visitor) {
+		return visitor.visitPiece(this);
+	}
 }

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

@@ -1,17 +1,21 @@
 package chess.model.pieces;
 
-import chess.model.Board;
-import chess.model.Cell;
+import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
 
 public class Pawn extends Piece {
-    public Pawn(final int color, Board board, Cell cell) {
-        super(color, board, cell);
-    }
 
-    @Override
-    public void accept(PieceVisitor pv) {
-        pv.visitPiece(this);
-    }
+	public Pawn(Color color) {
+		super(color);
+	}
+
+	@Override
+	public <T> T accept(PieceVisitor<T> visitor) {
+		return visitor.visitPiece(this);
+	}
+
+	public int multiplier() {
+		return getColor() == Color.White ? 1 : -1;
+	}
 }

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

@@ -1,16 +1,17 @@
 package chess.model.pieces;
 
-import chess.model.*;
-import chess.model.decorators.DiagonalDecorator;
-import chess.model.decorators.LineDecorator;
+import chess.model.Color;
+import chess.model.Piece;
+import chess.model.PieceVisitor;
 
 public class Queen extends Piece {
-    public Queen(final int color, Board board, Cell cell) {
-        super(color, board, cell);
-    }
 
-    @Override
-    public void accept(PieceVisitor pv) {
-        pv.visitPiece(this);
-    }
+	public Queen(Color color) {
+		super(color);
+	}
+
+	@Override
+	public <T> T accept(PieceVisitor<T> visitor) {
+		return visitor.visitPiece(this);
+	}
 }

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

@@ -1,21 +1,17 @@
 package chess.model.pieces;
 
-import chess.model.Board;
-import chess.model.Cell;
+import chess.model.Color;
 import chess.model.Piece;
 import chess.model.PieceVisitor;
-import chess.model.decorators.DiagonalDecorator;
-import chess.model.decorators.LineDecorator;
 
 public class Rook extends Piece {
-    public Rook(final int color, Board board, Cell cell) {
-        super(color, board, cell);
-        this.decorator = new LineDecorator();
-        // todo
-    }
 
-    @Override
-    public void accept(PieceVisitor pv) {
-        pv.visitPiece(this);
-    }
+	public Rook(Color color) {
+		super(color);
+	}
+
+	@Override
+	public <T> T accept(PieceVisitor<T> visitor) {
+		return visitor.visitPiece(this);
+	}
 }

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

@@ -0,0 +1,45 @@
+package chess.model.visitor;
+
+import chess.model.Color;
+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;
+	}
+
+	@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/PermissiveRuleChecker.java

@@ -0,0 +1,119 @@
+package chess.model.visitor;
+
+import chess.model.Coordinate;
+import chess.model.Direction;
+import chess.model.Move;
+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 PermissiveRuleChecker implements PieceVisitor<Boolean> {
+
+	private final Move move;
+
+	public PermissiveRuleChecker(Move move) {
+		this.move = move;
+		assert move.isValid() : "Move is invalid!";
+	}
+
+	public boolean isValidFor(Piece piece) {
+		return visit(piece);
+	}
+
+	@Override
+	public Boolean visitPiece(Bishop bishop) {
+		Direction moveDirection = Direction.findDirection(this.move);
+
+		switch (moveDirection) {
+			case FrontLeft:
+			case BackLeft:
+			case FrontRight:
+			case BackRight:
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+	@Override
+	public Boolean visitPiece(King king) {
+		return this.move.traversedCells() == 1;
+	}
+
+	@Override
+	public Boolean visitPiece(Knight knight) {
+		Coordinate piecePos = move.getStart();
+		final Coordinate[] positions = {
+				new Coordinate(piecePos.getX() - 1, piecePos.getY() - 2),
+				new Coordinate(piecePos.getX() - 1, piecePos.getY() + 2),
+				new Coordinate(piecePos.getX() + 1, piecePos.getY() - 2),
+				new Coordinate(piecePos.getX() + 1, piecePos.getY() + 2),
+				new Coordinate(piecePos.getX() + 2, piecePos.getY() - 1),
+				new Coordinate(piecePos.getX() + 2, piecePos.getY() + 1),
+				new Coordinate(piecePos.getX() - 2, piecePos.getY() - 1),
+				new Coordinate(piecePos.getX() - 2, piecePos.getY() + 1),
+		};
+
+		for (int i = 0; i < positions.length; i++) {
+			if (this.move.getFinish().equals(positions[i]))
+				return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public Boolean visitPiece(Pawn pawn) {
+		Direction moveDirection = Direction.findDirection(this.move);
+		int directionIndexOffset = moveDirection.getIndexOffset();
+		int distance = this.move.traversedCells();
+
+		// Revoke moving backwards
+		if (directionIndexOffset * pawn.multiplier() > 0)
+			return false;
+
+		// Allowing straight moves
+		if (Math.abs(directionIndexOffset) == Math.abs(Direction.Front.getIndexOffset())) {
+			if (pawn.hasMoved())
+				return distance == 1;
+			return distance == 1 || distance == 2;
+		}
+
+		// Allowing small diagonal moves
+		if (directionIndexOffset * pawn.multiplier() == Direction.FrontLeft.getIndexOffset()
+				|| directionIndexOffset * pawn.multiplier() == Direction.FrontRight.getIndexOffset()) {
+			return distance == 1;
+		}
+
+		return false;
+	}
+
+	@Override
+	public Boolean visitPiece(Queen queen) {
+		Direction moveDirection = Direction.findDirection(this.move);
+		return moveDirection != Direction.Unset;
+	}
+
+	@Override
+	public Boolean visitPiece(Rook rook) {
+		Direction moveDirection = Direction.findDirection(this.move);
+
+		switch (moveDirection) {
+			case Front:
+			case Back:
+			case Left:
+			case Right:
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+}

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

@@ -0,0 +1,119 @@
+package chess.model.visitor;
+
+import chess.model.ChessBoard;
+import chess.model.Color;
+import chess.model.Coordinate;
+import chess.model.Direction;
+import chess.model.Move;
+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 PiecePathChecker implements PieceVisitor<Boolean> {
+
+	private final ChessBoard board;
+	private final Move move;
+
+	public PiecePathChecker(ChessBoard board, Move move) {
+		this.move = move;
+		this.board = board;
+	}
+
+	public boolean isValid() {
+		if (this.move.getStart().equals(this.move.getFinish()))
+			return false;
+		Piece piece = this.board.pieceAt(move.getStart());
+		if (piece == null)
+			return false;
+		return visit(piece);
+	}
+
+	@Override
+	public Boolean visitPiece(Bishop bishop) {
+		if (!new PermissiveRuleChecker(this.move).isValidFor(bishop))
+			return false;
+		return testPath(bishop.getColor());
+	}
+
+	@Override
+	public Boolean visitPiece(King king) {
+		if (!new PermissiveRuleChecker(this.move).isValidFor(king))
+			return false;
+
+		Piece destPiece = board.pieceAt(this.move.getFinish());
+		if (destPiece == null)
+			return true;
+		return destPiece.getColor() != king.getColor();
+	}
+
+	@Override
+	public Boolean visitPiece(Knight knight) {
+		if (!new PermissiveRuleChecker(this.move).isValidFor(knight))
+			return false;
+
+		Piece destPiece = board.pieceAt(this.move.getFinish());
+		if (destPiece == null)
+			return true;
+		return destPiece.getColor() != knight.getColor();
+	}
+
+	@Override
+	public Boolean visitPiece(Pawn pawn) {
+		if (!new PermissiveRuleChecker(this.move).isValidFor(pawn))
+			return false;
+
+		Direction moveDirection = Direction.fromInt(Direction.findDirection(move).getIndexOffset() * pawn.multiplier());
+
+		if (moveDirection == Direction.Front)
+			return testPath(pawn.getColor()) && this.board.pieceAt(this.move.getFinish()) == null;
+
+		assert moveDirection == Direction.FrontLeft || moveDirection == Direction.FrontRight;
+
+		Piece destPiece = this.board.pieceAt(this.move.getFinish());
+		if (destPiece == null)
+			return false;
+
+		return destPiece.getColor() != pawn.getColor();
+	}
+
+	@Override
+	public Boolean visitPiece(Queen queen) {
+		if (!new PermissiveRuleChecker(this.move).isValidFor(queen))
+			return false;
+		return testPath(queen.getColor());
+	}
+
+	@Override
+	public Boolean visitPiece(Rook rook) {
+		if (!new PermissiveRuleChecker(this.move).isValidFor(rook))
+			return false;
+		return testPath(rook.getColor());
+	}
+
+	private boolean testPath(Color color) {
+		Direction moveDirection = Direction.findDirection(this.move);
+		int distance = this.move.traversedCells();
+		int stepIndex = move.getStart().toIndex();
+
+		for (int step = 0; step < distance; step++) {
+			stepIndex += moveDirection.getIndexOffset();
+
+			if (Coordinate.fromIndex(stepIndex).equals(move.getFinish())) {
+				Piece pieceDest = this.board.pieceAt(move.getFinish());
+				if (pieceDest == null)
+					return true;
+				return pieceDest.getColor() != color;
+			}
+
+			if (!this.board.isCellEmpty(Coordinate.fromIndex(stepIndex)))
+				return false;
+		}
+
+		return false;
+	}
+}

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

@@ -1,4 +1,4 @@
-package chess.view.render3D;
+package chess.render;
 
 import org.joml.Matrix4f;
 import org.joml.Vector3f;

app/src/main/java/chess/render/ElementBuffer.java

@@ -1,4 +1,4 @@
-package chess.view.render3D;
+package chess.render;
 
 import org.lwjgl.opengl.GL30;
 

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

@@ -1,10 +1,10 @@
-package chess.view.render3D;
+package chess.render;
 
 import org.joml.Vector3f;
 import org.lwjgl.opengl.*;
 
 import static org.lwjgl.opengl.GL30.*;
-import chess.view.render3D.shader.BoardShader;
+import chess.render.shader.BoardShader;
 
 public class Renderer {
 	private BoardShader shader;

app/src/main/java/chess/render/VertexArray.java

@@ -1,4 +1,4 @@
-package chess.view.render3D;
+package chess.render;
 
 import java.util.ArrayList;
 import java.util.List;

app/src/main/java/chess/render/VertexAttribPointer.java

@@ -0,0 +1,5 @@
+package chess.render;
+
+public record VertexAttribPointer(int index, int size, int offset) {
+	
+}

app/src/main/java/chess/render/VertexBuffer.java

@@ -1,4 +1,4 @@
-package chess.view.render3D;
+package chess.render;
 
 import static org.lwjgl.opengl.GL11.GL_FLOAT;
 
@@ -41,9 +41,9 @@ public class VertexBuffer {
 
 	public void BindVertexAttribs() {
 		for (VertexAttribPointer vertexAttribPointer : vertexAttribs) {
-			GL30.glEnableVertexAttribArray(vertexAttribPointer.index);
-			GL30.glVertexAttribPointer(vertexAttribPointer.index, vertexAttribPointer.size, GL_FLOAT, false,
-					this.dataStride * 4, vertexAttribPointer.offset);
+			GL30.glEnableVertexAttribArray(vertexAttribPointer.index());
+			GL30.glVertexAttribPointer(vertexAttribPointer.index(), vertexAttribPointer.size(), GL_FLOAT, false,
+					this.dataStride * 4, vertexAttribPointer.offset());
 		}
 	}
 }

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

@@ -1,4 +1,4 @@
-package chess.view.render3D;
+package chess.render;
 
 import org.lwjgl.*;
 import org.lwjgl.glfw.*;
@@ -56,7 +56,7 @@ public class Window {
 		glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // the window will be resizable
 
 		// Create the window
-		window = glfwCreateWindow(1000, 1000, "Chess4J", NULL, NULL);
+		window = glfwCreateWindow(1000, 1000, "3DChess", NULL, NULL);
 		if (window == NULL)
 			throw new RuntimeException("Failed to create the GLFW window");
 

app/src/main/java/chess/render/shader/BoardShader.java

@@ -1,4 +1,4 @@
-package chess.view.render3D.shader;
+package chess.render.shader;
 
 import org.joml.Matrix4f;
 
@@ -12,7 +12,7 @@ public class BoardShader extends ShaderProgram {
 
 			uniform mat4 camMatrix;
 
-			out vec3 pass_color;
+			flat out vec3 pass_color;
 
 			void main(void){
 				gl_Position = camMatrix * vec4(position, 1.0);
@@ -23,7 +23,7 @@ public class BoardShader extends ShaderProgram {
 	private static String fragmentShader = """
 			#version 330
 
-			in vec3 pass_color;
+			flat in vec3 pass_color;
 
 			out vec4 out_color;
 

app/src/main/java/chess/render/shader/ShaderProgram.java

@@ -1,4 +1,4 @@
-package chess.view.render3D.shader;
+package chess.render.shader;
 
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;

app/src/main/java/chess/simplerender/PieceIcon.java

@@ -0,0 +1,75 @@
+package chess.simplerender;
+
+import java.awt.Image;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.swing.Icon;
+import javax.swing.ImageIcon;
+
+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;
+
+public class PieceIcon implements PieceVisitor<String> {
+
+	private static final String basePath = "app/src/main/resources/pieces2D/";
+	private static final Map<String, Icon> cache = new HashMap<>();
+
+	public Icon getIcon(Piece piece) {
+		if (piece == null)
+			return null;
+		String path = basePath + colorToString(piece.getColor()) + "-" + visit(piece) + ".png";
+		return getIcon(path);
+	}
+	
+	private Icon getIcon(String path) {
+		Icon image = cache.get(path);
+		if (image != null)
+			return image;
+		image = new ImageIcon(new ImageIcon(path).getImage().getScaledInstance(100,100, Image.SCALE_SMOOTH)); 
+		cache.put(path, image);
+		return image;
+	}
+
+	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/simplerender/Window.java

@@ -0,0 +1,244 @@
+package chess.simplerender;
+
+import java.awt.Color;
+import java.awt.GridLayout;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.List;
+
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.SwingUtilities;
+
+import chess.io.Command;
+import chess.io.CommandExecutor;
+import chess.io.CommandResult;
+import chess.io.OutputSystem;
+import chess.io.commands.GetAllowedMovesCommand;
+import chess.io.commands.GetPieceAtCommand;
+import chess.io.commands.MoveCommand;
+import chess.io.commands.PromoteCommand;
+import chess.io.commands.PromoteCommand.PromoteType;
+import chess.model.Coordinate;
+import chess.model.Move;
+import chess.model.Piece;
+
+public class Window extends JFrame implements OutputSystem {
+
+	private final JLabel cells[][];
+	private final JLabel displayText;
+	private final CommandExecutor commandExecutor;
+
+	private Coordinate lastClick = null;
+
+	public Window(CommandExecutor commandExecutor) {
+		this.cells = new JLabel[8][8];
+		this.displayText = new JLabel();
+		this.commandExecutor = commandExecutor;
+		setSize(800, 870);
+		setVisible(true);
+		setLocationRelativeTo(null);
+		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
+	}
+
+	private CommandResult sendCommand(Command command) {
+		CommandResult result = this.commandExecutor.executeCommand(command);
+		if (result == CommandResult.Moved) {
+			updateBoard();
+		}
+		return result;
+	}
+
+	private Color getCellColor(int x, int y) {
+		return ((x + y) % 2 == 1) ? Color.BLACK : Color.WHITE;
+	}
+
+	private void buildBoard() {
+		JPanel content = new JPanel();
+		JPanel grid = new JPanel(new GridLayout(8, 8));
+
+		content.add(this.displayText);
+		content.add(grid);
+
+		setContentPane(content);
+
+		for (int y = 0; y < 8; y++) {
+			for (int x = 0; x < 8; x++) {
+				JLabel label = new JLabel();
+				label.setOpaque(true);
+				label.setBackground(getCellColor(x, y));
+				this.cells[x][y] = label;
+
+				final int xx = x;
+				final int yy = y;
+
+				label.addMouseListener(new MouseAdapter() {
+					@Override
+					public void mousePressed(MouseEvent e) {
+						onCellClicked(xx, yy);
+					}
+
+				});
+				grid.add(label);
+			}
+		}
+		updateBoard();
+	}
+
+	private boolean isCellEmpty(int x, int y) {
+		return pieceAt(x, y) == null;
+	}
+
+	private Piece pieceAt(int x, int y) {
+		GetPieceAtCommand command = new GetPieceAtCommand(new Coordinate(x, y));
+		sendCommand(command);
+		return command.getPiece();
+	}
+
+	private void updateBoard() {
+		PieceIcon pieceIcon = new PieceIcon();
+		for (int y = 0; y < 8; y++) {
+			for (int x = 0; x < 8; x++) {
+				JLabel cell = this.cells[x][y];
+				cell.setIcon(pieceIcon.getIcon(pieceAt(x, y)));
+			}
+		}
+	}
+
+	private boolean previewMoves(int x, int y) {
+		GetAllowedMovesCommand movesCommand = new GetAllowedMovesCommand(new Coordinate(x, y));
+		if (sendCommand(movesCommand) == CommandResult.NotAllowed)
+			return false;
+
+		List<Coordinate> allowedMoves = movesCommand.getDestinations();
+		if (allowedMoves.isEmpty())
+			return false;
+
+		for (Coordinate destCoord : allowedMoves) {
+			JLabel cell = this.cells[destCoord.getX()][destCoord.getY()];
+			cell.setBackground(Color.CYAN);
+		}
+		return true;
+	}
+
+	private void drawInvalid(Move move) {
+		JLabel from = this.cells[move.getStart().getX()][move.getStart().getY()];
+		JLabel to = this.cells[move.getFinish().getX()][move.getFinish().getY()];
+		from.setBackground(Color.RED);
+		to.setBackground(Color.RED);
+	}
+
+	private void clearMoves() {
+		for (int y = 0; y < 8; y++) {
+			for (int x = 0; x < 8; x++) {
+				JLabel cell = this.cells[x][y];
+				cell.setBackground(getCellColor(x, y));
+			}
+		}
+	}
+
+	private void onCellClicked(int x, int y) {
+		clearMoves();
+		if (this.lastClick == null) {
+			if (isCellEmpty(x, y))
+				return;
+			if (!previewMoves(x, y))
+				return;
+			this.lastClick = new Coordinate(x, y);
+			return;
+		}
+		if (!this.lastClick.equals(new Coordinate(x, y))) {
+			Move move = new Move(lastClick, new Coordinate(x, y));
+			if (sendCommand(new MoveCommand(move)) == CommandResult.NotAllowed) {
+				drawInvalid(move);
+			}
+		}
+		this.lastClick = null;
+	}
+
+	@Override
+	public void playerTurn(chess.model.Color color) {
+		this.displayText.setText("C'est au tour de " + color);
+	}
+
+	@Override
+	public void winnerIs(chess.model.Color color) {
+		SwingUtilities.invokeLater(() -> {
+			JOptionPane.showMessageDialog(this, "Victoire de " + color);
+			this.dispose();
+		});
+	}
+
+	@Override
+	public void kingIsInCheck() {
+		SwingUtilities.invokeLater(() -> {
+			JOptionPane.showMessageDialog(this, "Échec !");
+		});
+	}
+
+	@Override
+	public void kingIsInMat() {
+		SwingUtilities.invokeLater(() -> {
+			JOptionPane.showMessageDialog(this, "Échec et mat !");
+		});
+	}
+
+	@Override
+	public void patSituation() {
+		SwingUtilities.invokeLater(() -> {
+			JOptionPane.showMessageDialog(this, "Pat. Égalité !");
+		});
+	}
+
+	@Override
+	public void hasSurrendered(chess.model.Color color) {
+		SwingUtilities.invokeLater(() -> {
+			JOptionPane.showMessageDialog(this, "Abandon de " + color);
+		});
+	}
+
+	@Override
+	public void gameStarted() {
+		buildBoard();
+	}
+
+	@Override
+	public void promotePawn(Coordinate pieceCoords) {
+		SwingUtilities.invokeLater(() -> {
+			String result = null;
+
+			Object[] possibilities = new Object[PromoteType.values().length];
+			int i = 0;
+			for (PromoteType type : PromoteType.values()) {
+				possibilities[i] = type.name();
+				i++;
+			}
+
+			while (result == null || result.isEmpty()) {
+				result = (String) JOptionPane.showInputDialog(
+						this,
+						"Choose the type of piece to upgrade the pawn",
+						"Promote Dialog",
+						JOptionPane.PLAIN_MESSAGE,
+						null,
+						possibilities,
+						possibilities[0]);
+			}
+
+			PromoteType choosedType = null;
+
+			for (PromoteType type : PromoteType.values()) {
+				if (type.name().equals(result)) {
+					choosedType = type;
+					break;
+				}
+			}
+
+			if (choosedType != null)
+				sendCommand(new PromoteCommand(choosedType, pieceCoords));
+		});
+	}
+
+}

app/src/main/java/chess/view/render2D/PieceFileName.java

@@ -1,61 +0,0 @@
-package chess.view.render2D;
-
-import chess.model.Piece;
-import chess.model.PieceVisitor;
-import chess.model.pieces.*;
-
-public class PieceFileName implements PieceVisitor {
-
-    private String pieceName;
-    private static final String BASE = "app/src/main/resources/pieces2D/";
-
-    PieceFileName(Piece piece) {
-        visit(piece);
-        pieceName = colorToString(piece.getColor()) +"-"+ pieceName;
-    }
-
-    private String colorToString(int color) {
-        switch (color) {
-            case 0:
-                return "white";
-            case 1:
-                return "black";
-            default:
-                return "";
-        }
-    }
-
-    @Override
-    public void visitPiece(Bishop p) {
-        this.pieceName = "bishop";
-    }
-
-    @Override
-    public void visitPiece(Knight p) {
-        this.pieceName = "knight";
-    }
-
-    @Override
-    public void visitPiece(Pawn p) {
-        this.pieceName = "pawn";
-    }
-
-    @Override
-    public void visitPiece(Queen p) {
-        this.pieceName = "queen";
-    }
-
-    @Override
-    public void visitPiece(King p) {
-        this.pieceName = "king";
-    }
-
-    @Override
-    public void visitPiece(Rook p) {
-        this.pieceName = "rook";
-    }
-
-    public String getFileName() {
-        return BASE + pieceName + ".png";
-    }
-}

app/src/main/java/chess/view/render2D/Pieces.java

@@ -1,23 +0,0 @@
-package chess.view.render2D;
-
-import javax.swing.*;
-import java.awt.*;
-
-public enum Pieces {
-    WHITE_KING,
-    WHITE_QUEEN,
-    WHITE_KNIGHT,
-    WHITE_BISHOP,
-    WHITE_ROOK,
-    WHITE_PAWN,
-    BLACK_KING,
-    BLACK_QUEEN,
-    BLACK_KNIGHT,
-    BLACK_BISHOP,
-    BLACK_ROOK,
-    BLACK_PAWN;
-
-    public static ImageIcon getIcon(String path) {
-        return new ImageIcon(new ImageIcon(path).getImage().getScaledInstance(100,100, Image.SCALE_SMOOTH));
-    }
-}

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

@@ -1,105 +0,0 @@
-package chess.view.render2D;
-
-import chess.controller.Controller;
-import chess.model.Coordinates;
-import chess.model.Game;
-import chess.model.Piece;
-
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.util.Observable;
-import java.util.Observer;
-
-public class Window extends JFrame implements Observer {
-    private final Game game;
-    private final Controller controller;
-    private final JLabel[][] tab;
-    private static final String path = "app/src/main/resources/pieces2D/";
-    Coordinates mouseClick = null;
-    Coordinates mouseRelease = null;
-
-    public Window(Game game) {
-        this.game = game;
-        game.addObserver(this);
-        this.controller = new Controller(game, this);
-        tab = new JLabel[game.getSize()][game.getSize()];
-        build();
-        showBoard();
-    }
-
-    public static void main(String[] args){
-        Game game = new Game();
-        Thread gameThread = new Thread(game);
-        gameThread.start();
-        Window f = new Window(game);
-        f.setVisible(true);
-    }
-
-    /**
-     * Create a playing grid with alternating black & white cells
-     */
-    private void build(){
-        JPanel jp = new JPanel(new GridLayout(game.getSize(), game.getSize()));
-        setContentPane(jp);
-        setTitle("Let's play chess!");
-        for (int y = 0; y < game.getSize(); y++){
-            for (int x = 0; x < game.getSize(); x++){
-                JLabel jl = new JLabel();
-                jl.setOpaque(true);
-                if (((y+x)%2)!=0) {
-                    jl.setBackground(Color.BLACK);
-                }
-                final int yy = y;
-                final int xx = x;
-
-                jl.addMouseListener(new MouseAdapter() {
-                    public void mousePressed(MouseEvent e) {
-                        if (mouseClick == null) {
-                            mouseClick = new Coordinates(xx, yy);
-                        }
-                        else {
-                            mouseRelease = new Coordinates(xx, yy);
-                            if (!mouseClick.equals(mouseRelease)) {
-                                controller.sendMove(mouseClick, mouseRelease);
-                                update();
-                            }
-                            mouseClick = null;
-                            mouseRelease = null;
-                        }
-                    }
-                });
-                this.tab[x][y]=jl;
-                jp.add(jl);
-            }
-        }
-        setSize(800,800);
-    }
-
-    public void showBoard(){
-        for (int y = 0; y < game.getSize(); y++){
-            for (int x = 0; x < game.getSize(); x++){
-                Piece p = game.getBoard().getCell(new Coordinates(x,y)).getPiece();
-                if (p != null){
-                    this.tab[x][y].setIcon(Pieces.getIcon(new PieceFileName(p).getFileName()));
-                }
-                else
-                {
-                    this.tab[x][y].setIcon(null);
-                }
-            }
-        }
-    }
-
-   public void update() {
-       // todo
-       showBoard();
-    }
-
-
-    @Override
-    public void update(Observable o, Object arg) {
-        update();
-    }
-}

app/src/main/java/chess/view/render3D/VertexAttribPointer.java

@@ -1,13 +0,0 @@
-package chess.view.render3D;
-
-public class VertexAttribPointer {
-	public int index;
-	public int size;
-	public int offset;
-
-	public VertexAttribPointer(int index, int size, int offset) {
-		this.index = index;
-		this.size = size;
-		this.offset = offset;
-	}
-}

app/src/main/java/common/Signal0.java

@@ -0,0 +1,26 @@
+package common;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Signal0 {
+	private final List<Runnable> handlers;
+
+	public Signal0() {
+		this.handlers = new ArrayList<>();
+	}
+
+	public void connect(Runnable handler) {
+		this.handlers.add(handler);
+	}
+
+	public void disconnect(Runnable handler) {
+		this.handlers.remove(handler);
+	}
+
+	public void emit() {
+		for (Runnable handler : this.handlers) {
+			handler.run();
+		}
+	}
+}

app/src/main/java/common/Signal1.java

@@ -0,0 +1,27 @@
+package common;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+public class Signal1<T> {
+	private final List<Consumer<T>> handlers;
+
+	public Signal1() {
+		this.handlers = new ArrayList<>();
+	}
+
+	public void connect(Consumer<T> handler) {
+		this.handlers.add(handler);
+	}
+
+	public void disconnect(Consumer<T> handler) {
+		this.handlers.remove(handler);
+	}
+
+	public void emit(T arg) {
+		for (Consumer<T> handler : this.handlers) {
+			handler.accept(arg);
+		}
+	}
+}

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

@@ -8,7 +8,7 @@ import static org.junit.jupiter.api.Assertions.*;
 
 class AppTest {
     @Test void appHasAGreeting() {
-        App classUnderTest = new App();
-        assertNotNull(classUnderTest.getGreeting(), "app should have a greeting");
+        // App classUnderTest = new App();
+        // assertNotNull(classUnderTest.getGreeting(), "app should have a greeting");
     }
 }