체체체 스 구현

src/main/java/chess/Application.java

@@ -0,0 +1,17 @@
+package chess;
+
+import chess.Controller.ChessController;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class Application {
+
+    public static void main(String[] args) {
+
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+
+        ChessController chessController = new ChessController(inputView, outputView);
+        chessController.run();
+    }
+}

src/main/java/chess/ChessInitializer.java

@@ -0,0 +1,73 @@
+package chess;
+
+import static chess.domain.piece.Color.BLACK;
+import static chess.domain.piece.Color.WHITE;
+import static chess.domain.piece.Column.A;
+import static chess.domain.piece.Column.B;
+import static chess.domain.piece.Column.C;
+import static chess.domain.piece.Column.D;
+import static chess.domain.piece.Column.E;
+import static chess.domain.piece.Column.F;
+import static chess.domain.piece.Column.G;
+import static chess.domain.piece.Column.H;
+import static chess.domain.piece.Row.EIGHT;
+import static chess.domain.piece.Row.ONE;
+import static chess.domain.piece.Row.SEVEN;
+import static chess.domain.piece.Row.TWO;
+
+import chess.domain.piece.Bishop;
+import chess.domain.piece.King;
+import chess.domain.piece.Knight;
+import chess.domain.piece.Pawn;
+import chess.domain.piece.Piece;
+import chess.domain.piece.Position;
+import chess.domain.piece.Queen;
+import chess.domain.piece.Rook;
+import java.util.HashSet;
+import java.util.Set;
+
+public class ChessInitializer {
+
+    public static Set<Piece> initialize() {
+        Set<Piece> pieces = new HashSet<>();
+
+        pieces.add(new Rook(WHITE, new Position(A, ONE)));
+        pieces.add(new Knight(WHITE, new Position(B, ONE)));
+        pieces.add(new Bishop(WHITE, new Position(C, ONE)));
+        pieces.add(new Queen(WHITE, new Position(D, ONE)));
+        pieces.add(new King(WHITE, new Position(E, ONE)));
+        pieces.add(new Bishop(WHITE, new Position(F, ONE)));
+        pieces.add(new Knight(WHITE, new Position(G, ONE)));
+        pieces.add(new Rook(WHITE, new Position(H, ONE)));
+
+        pieces.add(new Pawn(WHITE, new Position(A, TWO)));
+        pieces.add(new Pawn(WHITE, new Position(B, TWO)));
+        pieces.add(new Pawn(WHITE, new Position(C, TWO)));
+        pieces.add(new Pawn(WHITE, new Position(D, TWO)));
+        pieces.add(new Pawn(WHITE, new Position(E, TWO)));
+        pieces.add(new Pawn(WHITE, new Position(F, TWO)));
+        pieces.add(new Pawn(WHITE, new Position(G, TWO)));
+        pieces.add(new Pawn(WHITE, new Position(H, TWO)));
+
+        pieces.add(new Rook(BLACK, new Position(A, EIGHT)));
+        pieces.add(new Knight(BLACK, new Position(B, EIGHT)));
+        pieces.add(new Bishop(BLACK, new Position(C, EIGHT)));
+        pieces.add(new Queen(BLACK, new Position(D, EIGHT)));
+        pieces.add(new King(BLACK, new Position(E, EIGHT)));
+        pieces.add(new Bishop(BLACK, new Position(F, EIGHT)));
+        pieces.add(new Knight(BLACK, new Position(G, EIGHT)));
+        pieces.add(new Rook(BLACK, new Position(H, EIGHT)));
+
+        pieces.add(new Pawn(BLACK, new Position(A, SEVEN)));
+        pieces.add(new Pawn(BLACK, new Position(B, SEVEN)));
+        pieces.add(new Pawn(BLACK, new Position(C, SEVEN)));
+        pieces.add(new Pawn(BLACK, new Position(D, SEVEN)));
+        pieces.add(new Pawn(BLACK, new Position(E, SEVEN)));
+        pieces.add(new Pawn(BLACK, new Position(F, SEVEN)));
+        pieces.add(new Pawn(BLACK, new Position(G, SEVEN)));
+        pieces.add(new Pawn(BLACK, new Position(H, SEVEN)));
+
+        return pieces;
+    }
+
+}

src/main/java/chess/Controller/ChessController.java

@@ -0,0 +1,37 @@
+package chess.Controller;
+
+import chess.domain.Board;
+import chess.view.InputView;
+import chess.view.OutputView;
+import java.util.List;
+
+public class ChessController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public ChessController(final InputView inputView, final OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        Board board = new Board();
+
+        while (true) {
+            try {
+                outputView.printChessBoard(board);
+                outputView.printTurn(board.getTurn());
+
+                List<String> pieceInput = inputView.inputMovePiece();
+                List<String> positionInput = inputView.inputMovePosition();
+                board.movePiece(pieceInput, positionInput);
+
+                board.changeTurn();
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            }
+
+        }
+    }
+}

src/main/java/chess/domain/Board.java

@@ -0,0 +1,44 @@
+package chess.domain;
+
+import chess.ChessInitializer;
+import chess.domain.piece.Column;
+import chess.domain.piece.Piece;
+import chess.domain.piece.Position;
+import chess.domain.piece.Row;
+import java.util.List;
+import java.util.Set;
+
+public class Board {
+
+    private final Pieces pieces;
+    private final Turn turn;
+
+    public Board() {
+        this.pieces = new Pieces(ChessInitializer.initialize());
+        this.turn = new Turn();
+    }
+
+    public void movePiece(final List<String> inputMovePiece, final List<String> inputMovePosition) {
+        Position wantMovePiecePosition = new Position(Row.findRowByNumber(inputMovePiece.get(1)),
+                Column.findColumnByAlphabet(inputMovePiece.get(0)));
+        Position wantMovePosition = new Position(Row.findRowByNumber(inputMovePosition.get(1)),
+                Column.findColumnByAlphabet(inputMovePosition.get(0)));
+        Piece piece = pieces.findPieceByPositionAndColor(wantMovePiecePosition, turn.getTurn());
+
+        pieces.validateMove(piece, wantMovePosition);
+        pieces.move(piece, wantMovePosition);
+    }
+
+    public Set<Piece> getPieces() {
+        return pieces.getPieces();
+    }
+
+    public Turn getTurn() {
+        return turn;
+    }
+
+    public void changeTurn() {
+        turn.changeTurn();
+    }
+
+}

src/main/java/chess/Movement.java → src/main/java/chess/domain/Movement.java

@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 public enum Movement {
     UP(0, 1),

src/main/java/chess/domain/Pieces.java

@@ -0,0 +1,73 @@
+package chess.domain;
+
+import chess.domain.piece.Color;
+import chess.domain.piece.Knight;
+import chess.domain.piece.Piece;
+import chess.domain.piece.Position;
+import java.util.List;
+import java.util.Set;
+
+public class Pieces {
+
+    private final Set<Piece> pieces;
+
+    public Pieces(final Set<Piece> pieces) {
+        this.pieces = pieces;
+    }
+
+    public Set<Piece> getPieces() {
+        return pieces;
+    }
+
+    public void validateMove(Piece piece, Position endPosition) {
+        if (piece.getClass() == Knight.class) {
+            return;
+        }
+        List<Position> route = piece.canMove(endPosition);
+        route.removeLast();
+        for (Position position : route) {
+            if (findPieceByPosition(position).samePosition(endPosition)) {
+                throw new IllegalArgumentException("경로에 기물이 존재합니다.");
+            }
+        }
+    }
+
+    public Piece findPieceByPosition(Position position) {
+        for (Piece piece : pieces) {
+            if (piece.samePosition(position)) {
+                return piece;
+            }
+        }
+        throw new IllegalArgumentException("기물이 해당 위치에 존재하지 않습니다.");
+    }
+
+    public Piece findPieceByPositionAndColor(Position position, Color color) {
+        for (Piece piece : pieces) {
+            if (piece.samePosition(position) && piece.isSameTeam(color)) {
+                return piece;
+            }
+        }
+        throw new IllegalArgumentException("기물이 해당 위치에 존재하지 않습니다.");
+    }
+
+    public boolean hasPieceInPosition(final Position position) {
+        for (Piece piece : pieces) {
+            if (piece.samePosition(position)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void move(final Piece piece, final Position wantMovePosition) {
+        if (hasPieceInPosition(wantMovePosition)) {
+            Piece findPiece = findPieceByPosition(wantMovePosition);
+            if (piece.isOtherTeam(findPiece)) {
+                pieces.remove(findPiece);
+            } else {
+                throw new IllegalArgumentException("같은 팀의 말은 잡지 못합니다.");
+            }
+        }
+        piece.move(wantMovePosition);
+    }
+}

src/main/java/chess/domain/Turn.java

@@ -0,0 +1,30 @@
+package chess.domain;
+
+import static chess.domain.piece.Color.BLACK;
+import static chess.domain.piece.Color.WHITE;
+
+import chess.domain.piece.Color;
+
+public class Turn {
+
+    private static final Color initialTurn = WHITE;
+
+    private Color turn;
+
+    public Turn() {
+        this.turn = initialTurn;
+    }
+
+    public Color getTurn() {
+        return turn;
+    }
+
+    public void changeTurn() {
+        if (turn == WHITE) {
+            turn = BLACK;
+            return;
+        }
+        turn = WHITE;
+
+    }
+}

src/main/java/chess/domain/piece/Bishop.java

@@ -0,0 +1,41 @@
+package chess.domain.piece;
+
+import static chess.domain.Movement.LEFT_DOWN;
+import static chess.domain.Movement.LEFT_UP;
+import static chess.domain.Movement.RIGHT_DOWN;
+import static chess.domain.Movement.RIGHT_UP;
+
+import chess.domain.Movement;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Bishop extends Piece {
+
+    private final static List<Movement> canMove = List.of(
+            RIGHT_UP, RIGHT_DOWN, LEFT_DOWN, LEFT_UP
+    );
+
+    public Bishop(final Color color, final Position position) {
+        super(color, position);
+    }
+
+    @Override
+    public List<Position> canMove(final Position endPosition) {
+        List<Position> positions = new ArrayList<>();
+        Position currentPosition = this.position;
+        for (Movement movement : canMove) {
+            positions.clear();
+            while (currentPosition.canMove(movement)) {
+                Position nextPosition = currentPosition.move(movement);
+                positions.add(nextPosition);
+                if (nextPosition.equals(endPosition)) {
+                    return positions;
+                }
+                currentPosition = nextPosition;
+            }
+        }
+        throw new IllegalArgumentException("갈 수 없는 곳입니다.");
+    }
+
+}
+

src/main/java/chess/Color.java → src/main/java/chess/domain/piece/Color.java

@@ -1,4 +1,4 @@
-package chess;
+package chess.domain.piece;
 
 public enum Color {
 

src/main/java/chess/Column.java → src/main/java/chess/domain/piece/Column.java

@@ -1,4 +1,4 @@
-package chess;
+package chess.domain.piece;
 
 public enum Column {
 
@@ -50,4 +50,35 @@ public Column moveRight(final int step) {
 
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
+
+    public static Column findColumnByAlphabet(String input) {
+
+        if (input.equals("A")) {
+            return A;
+        }
+        if (input.equals("B")) {
+            return B;
+        }
+        if (input.equals("C")) {
+            return C;
+        }
+        if (input.equals("D")) {
+            return D;
+        }
+        if (input.equals("E")) {
+            return E;
+        }
+        if (input.equals("F")) {
+            return F;
+        }
+        if (input.equals("G")) {
+            return G;
+        }
+        if (input.equals("H")) {
+            return H;
+        }
+
+        throw new IllegalArgumentException("위치가 올바르지 않습니다.");
+
+    }
 }