[체스 - 놀면뭐하니] 훌라(김성준) 제출합니다

README.md

@@ -5,3 +5,48 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 기존 코드
+
+Column
+A: 가장 왼쪽
+H: 가장 오른쪽
+
+Row
+EIGHT: 가장 위
+ONE: 가장 아래
+
+Position
+말의 움직임 가능 여부 확인 및 움직임
+
+## 장기말
+
+공통 내용
+- [ ] 각 말은 팀(Color)를 가지고 있다.
+- [ ] 도착지에 같은 팀이 있다면 이동할 수 없다.
+- [x] 장기판 말 밖으로 이동할 수 없다.
+
+비숍
+- [x] 대각선 원하는만큼
+- [ ] 뛰어넘기 불가
+
+왕
+- [x] 상하좌우 + 대각선
+
+나이트
+- [ ] 상하좌우 한 칸 + 진행 방향으로 대각선 한 칸
+- [ ] 뛰어넘기 가능
+
+폰
+- [x] 각 팀마다 진행방향으로 한칸 이동 가능
+- [x] 처음 이동에는 두 칸 이동 가능
+- [ ] 상대편 말을 잡을 경우 대각선 이동 가능
+
+퀸
+- [x] 상하좌우 원하는 만큼
+- [x] 대각선 원하는 만큼
+- [ ] 뛰어넘기 불가
+
+룩
+- [x] 상하좌우 원하는 만큼
+- [ ] 뛰어넘기 불가

src/main/java/chess/Application.java

@@ -0,0 +1,11 @@
+package chess;
+
+import chess.board.BoardManager;
+
+public class Application {
+
+    public static void main(String[] args) {
+        BoardManager manager = new BoardManager();
+        manager.move();
+    }
+}

src/main/java/chess/board/Board.java

@@ -0,0 +1,41 @@
+package chess.board;
+
+import chess.position.Position;
+import chess.piece.Piece;
+import chess.piece.Pieces;
+import java.util.List;
+import java.util.Set;
+
+public class Board {
+
+    private final Pieces pieces;
+
+    public Board(Pieces pieces) {
+        this.pieces = pieces;
+    }
+
+    public void move(Position current, Position destination) {
+        Piece pickedPiece = pieces.findByPosition(current);
+        int differenceX = destination.column().ordinal() - current.column().ordinal();
+        int differenceY = current.row().ordinal() - destination.row().ordinal();
+        if (pieces.existsByPosition(destination)) {
+            Piece targetPiece = pieces.findByPosition(destination);
+            if (pickedPiece.isSameColor(targetPiece)) {
+                throw new IllegalArgumentException("같은 팀이 있는 위치로는 이동할 수 없습니다.");
+            }
+        }
+
+        Set<Position> path = pickedPiece.calculatePath(differenceX, differenceY);
+        boolean existsPieceOnPath = path.stream()
+                .anyMatch(pieces::existsByPosition);
+        if (existsPieceOnPath) {
+            throw new IllegalArgumentException("경로 상에 말이 존재합니다");
+        }
+
+        pickedPiece.move(differenceX, differenceY);
+    }
+
+    public List<Piece> getPieces() {
+        return pieces.getPieces();
+    }
+}

src/main/java/chess/board/BoardFactory.java

@@ -0,0 +1,53 @@
+package chess.board;
+
+import chess.position.Color;
+import chess.position.Column;
+import chess.position.Position;
+import chess.position.Row;
+import chess.piece.Bishop;
+import chess.piece.King;
+import chess.piece.Knight;
+import chess.piece.Pawn;
+import chess.piece.Piece;
+import chess.piece.Pieces;
+import chess.piece.Queen;
+import chess.piece.Rook;
+import java.util.ArrayList;
+import java.util.List;
+
+public class BoardFactory {
+
+    private BoardFactory() {
+    }
+
+    public static Board init() {
+        List<Piece> initPieces = new ArrayList<>();
+        for (Column column : Column.values()) {
+            initPieces.add(new Pawn(Color.WHITE, new Position(column, Row.TWO)));
+            initPieces.add(new Pawn(Color.BLACK, new Position(column, Row.SEVEN)));
+        }
+        initPieces.add(new Rook(Color.WHITE, new Position(Column.A, Row.ONE)));
+        initPieces.add(new Rook(Color.WHITE, new Position(Column.H, Row.ONE)));
+        initPieces.add(new Rook(Color.BLACK, new Position(Column.A, Row.EIGHT)));
+        initPieces.add(new Rook(Color.BLACK, new Position(Column.H, Row.EIGHT)));
+
+        initPieces.add(new Knight(Color.WHITE, new Position(Column.B, Row.ONE)));
+        initPieces.add(new Knight(Color.WHITE, new Position(Column.G, Row.ONE)));
+        initPieces.add(new Knight(Color.BLACK, new Position(Column.B, Row.EIGHT)));
+        initPieces.add(new Knight(Color.BLACK, new Position(Column.G, Row.EIGHT)));
+
+        initPieces.add(new Bishop(Color.WHITE, new Position(Column.C, Row.ONE)));
+        initPieces.add(new Bishop(Color.WHITE, new Position(Column.F, Row.ONE)));
+        initPieces.add(new Bishop(Color.BLACK, new Position(Column.C, Row.EIGHT)));
+        initPieces.add(new Bishop(Color.BLACK, new Position(Column.F, Row.EIGHT)));
+
+        initPieces.add(new King(Color.WHITE, new Position(Column.D, Row.ONE)));
+        initPieces.add(new Queen(Color.WHITE, new Position(Column.E, Row.ONE)));
+
+        initPieces.add(new King(Color.BLACK, new Position(Column.D, Row.EIGHT)));
+        initPieces.add(new Queen(Color.BLACK, new Position(Column.E, Row.EIGHT)));
+
+        Pieces pieces = new Pieces(initPieces);
+        return new Board(pieces);
+    }
+}

src/main/java/chess/board/BoardManager.java

@@ -0,0 +1,34 @@
+package chess.board;
+
+import chess.position.Column;
+import chess.position.Position;
+import chess.position.Row;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class BoardManager {
+
+    public void move() {
+        Board board = BoardFactory.init();
+        while(true)
+        {
+            OutputView.printBoard(board);
+            String inputCurrentCoordinate = InputView.inputCurrentCoordinate();
+            if (inputCurrentCoordinate.equals("Q")) {
+                break;
+            }
+            String inputDestinationCoordinate = InputView.inputDestinationCoordinate();
+            Position currentPosition = parsePosition(inputCurrentCoordinate);
+            Position destinationPosition = parsePosition(inputDestinationCoordinate);
+            board.move(currentPosition, destinationPosition);
+        }
+    }
+
+    private Position parsePosition(String input) {
+        String[] coordinate = input.split("");
+        Column column = Column.valueOf(coordinate[0]);
+        int rowNumber = Integer.parseInt(coordinate[1]);
+        Row row = Row.values()[8 - rowNumber];
+        return new Position(column, row);
+    }
+}

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

@@ -1,5 +1,54 @@
 package chess.piece;
 
-public class Bishop {
+import chess.position.Color;
+import chess.position.Position;
+import java.util.HashSet;
+import java.util.Set;
 
+public class Bishop extends Piece {
+
+    public Bishop(final Color color, final Position position) {
+        super(color, position);
+    }
+
+    @Override
+    public void move(final int x, final int y) {
+        if (Math.abs(x) != Math.abs(y)) {
+            throw new IllegalArgumentException("대각선으로만 이동 가능합니다.");
+        }
+        boolean canMove = position.canMoveDiagonal(x, y);
+
+        if (canMove) {
+            position = position.moveDiagonal(x, y);
+            return;
+        }
+        throw new IllegalArgumentException("이동할 수 없습니다");
+    }
+
+    @Override
+    public Set<Position> calculatePath(final int x, final int y) {
+        Set<Position> path = new HashSet<>();
+        int step = Math.abs(x);
+        if (x > 0 && y > 0) {
+            for (int i = 0; i < step; i++) {
+                path.add(position.moveRightUp());
+            }
+        }
+        if (x > 0 && y < 0) {
+            for (int i = 0; i < step; i++) {
+                path.add(position.moveRightDown());
+            }
+        }
+        if (x < 0 && y > 0) {
+            for (int i = 0; i < step; i++) {
+                path.add(position.moveLeftUp());
+            }
+        }
+        if (x < 0 && y < 0) {
+            for (int i = 0; i < step; i++) {
+                path.add(position.moveLeftDown());
+            }
+        }
+        return path;
+    }
 }

src/main/java/chess/piece/King.java

@@ -1,5 +1,34 @@
 package chess.piece;
 
-public class King {
+import chess.position.Color;
+import chess.position.Position;
+import java.util.Set;
 
+public class King extends Piece {
+
+    public King(final Color color, final Position position) {
+        super(color, position);
+    }
+
+    @Override
+    public void move(final int x, final int y) {
+        if (x > 1 || y > 1) {
+            throw new IllegalArgumentException("한 칸만 이동 가능합니다");
+        }
+
+        boolean canMoveHorizontal = position.canMoveHorizontal(x);
+        boolean canMoveVertical = position.canMoveVertical(y);
+
+        if (canMoveHorizontal && canMoveVertical) {
+            position = position.moveHorizontal(x);
+            position = position.moveVertical(y);
+            return;
+        }
+        throw new IllegalArgumentException("움직일 수 없습니다.");
+    }
+
+    @Override
+    public Set<Position> calculatePath(int x, int y) {
+        return Set.of();
+    }
 }

src/main/java/chess/piece/Knight.java

@@ -1,5 +1,34 @@
 package chess.piece;
 
-public class Knight {
+import chess.position.Color;
+import chess.position.Position;
+import java.util.Set;
 
+public class Knight extends Piece {
+
+    public Knight(Color color, Position position) {
+        super(color, position);
+    }
+
+    @Override
+    public void move(final int x, final int y) {
+        boolean canMove = position.canMoveHorizontal(x) && position.canMoveVertical(y);
+
+        if (isMovingRule(x, y) && canMove) {
+            position = position.moveDiagonal(x, y);
+            return;
+        }
+        throw new IllegalArgumentException("이동할 수 없습니다.");
+    }
+
+    @Override
+    public Set<Position> calculatePath(int x, int y) {
+        return Set.of();
+    }
+
+    private boolean isMovingRule(final int x, final int y) {
+        int absX = Math.abs(x);
+        int absY = Math.abs(y);
+        return ((absX == 2 && absY == 1) || (absX == 1 && absY == 2));
+    }
 }

src/main/java/chess/piece/Pawn.java

@@ -1,5 +1,47 @@
 package chess.piece;
 
-public class Pawn {
+import chess.position.Color;
+import chess.position.Position;
+import chess.position.Row;
+import java.util.Set;
 
+public class Pawn extends Piece {
+
+    public Pawn(final Color color, final Position position) {
+        super(color, position);
+    }
+
+    @Override
+    public void move(final int x, final int y) {
+        boolean canMove = false;
+        if (color == Color.WHITE && y > 0 && y <= 2) {
+            canMove = position.canMoveUp();
+        }
+        if (color == Color.BLACK && y < 0 && y >= -2) {
+            canMove = position.canMoveDown();
+        }
+
+        boolean isNotFirstMove = true;
+        if (color == Color.WHITE && position.row() == Row.TWO) {
+            isNotFirstMove = false;
+        }
+        if (color == Color.BLACK && position.row() == Row.SEVEN) {
+            isNotFirstMove = false;
+        }
+
+        if (isNotFirstMove && y != 1) {
+            canMove = false;
+        }
+
+        if (canMove) {
+            position = position.moveVertical(y);
+            return;
+        }
+        throw new IllegalArgumentException("이동할 수 없습니다.");
+    }
+
+    @Override
+    public Set<Position> calculatePath(int x, int y) {
+        return Set.of();
+    }
 }