[1,2단계 - 체스] 켈리(양성욱) 미션 제출합니다.

.gitmessage.txt

@@ -0,0 +1,4 @@
+
+
+Co-authored-by: Hyunguk Ryu <[email protected]>
+

docs/README.md

@@ -0,0 +1,63 @@
+## 프로그램 흐름
+
+- 사용자로부터 게임 시작 여부를 입력받는다.
+    - `start`를 입력받으면 게임을 생성하고 초기 체스판의 상태를 출력한다.
+    - `end`를 입력받으면 프로그램을 종료한다.
+- 기물 이동 여부를 입력받는다.
+    - `move b2 b4`와 같이 입력받으면 `b2`에 존재하는 기물을 `b4`로 이동시킨다.
+    - `end`를 입력받으면 프로그램을 종료한다.
+
+## 도메인별 기능
+
+### Piece
+
+- [x] 출발지 & 목적지 정보를 토대로 기물이 이동할 수 있는지 검사한다.
+- [x] 입력받은 색상을 토대로 자신의 적 여부를 반환한다.
+
+#### Rook
+
+- 상/하/좌/우 거리 제한 없이 이동 가능
+- 비었거나 적 기물이 존재하는 칸으로만 이동 가능
+- 이동 경로에 기물이 존재하면 이동 불가
+
+#### Bishop
+
+- 대각선 방향 거리 제한 없이 이동 가능
+- 비었거나 적 기물이 존재하는 칸으로만 이동 가능
+- 이동 경로에 기물이 존재하면 이동 불가
+
+#### Queen
+
+- 상/하/좌/우, 대각선 방향 거리 제한 없이 이동 가능
+- 비었거나 적 기물이 존재하는 칸으로만 이동 가능
+- 이동 경로에 기물이 존재하면 이동 불가
+
+#### King
+
+- 상/하/좌/우, 대각선 방향 중 한 칸만 이동 가능
+- 비었거나 적 기물이 존재하는 칸으로만 이동 가능
+
+#### Knight
+
+- 상/하/좌/우 중 한 칸 이동 후 전진 방향의 대각석으로 한 칸 이동 가능
+- 비었거나 적 기물이 존재하는 칸으로만 이동 가능
+- 이동 경로에 기물이 존재해도 이동 가능
+
+#### Pawn
+
+- 특정 조건에 따라 이동 선택
+    - 기본적으로 한 칸 전진 가능
+    - 출발지가 초기 위치일 경우 두 칸 전진 가능
+    - 전진 경로 혹은 목적지에 기물이 존재하면 이동 불가
+    - 전진 방향 대각선 한 칸에 적 기물이 존재시 이동 가능
+
+## Board
+
+- [x] 특정 색상의 기물 이동
+    - `출발지` == `도착지`인 경우 예외 처리
+    - 출발지에 기물이 존재하지 않으면 예외 처리
+    - 상대 색상의 기물을 이동시키려 할 시 예외 처리
+
+## ChessGame
+
+- [x] `흰색` 플레이어와 `검은색` 플레이어의 게임 순서 관리 및 `Board`에 기물 이동 요청 전달

src/main/java/Application.java

@@ -0,0 +1,12 @@
+import controller.GameController;
+import domain.game.ChessGame;
+import view.InputView;
+import view.OutputView;
+
+public class Application {
+    public static void main(String[] args) {
+        ChessGame chessGame = ChessGame.initGame();
+        GameController gameController = new GameController(new InputView(), new OutputView(), chessGame);
+        gameController.run();
+    }
+}

src/main/java/controller/GameController.java

@@ -0,0 +1,62 @@
+package controller;
+
+import domain.game.ChessGame;
+import domain.game.GameCommand;
+import domain.game.GameCommandType;
+import dto.BoardDto;
+import view.InputView;
+import view.OutputView;
+
+public class GameController {
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final ChessGame chessGame;
+
+    public GameController(final InputView inputView, final OutputView outputView, final ChessGame chessGame) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+        this.chessGame = chessGame;
+    }
+
+    public void run() {
+        initGame();
+
+        if (chessGame.isGameRunning()) {
+            gameStart();
+        }
+    }
+
+    private void initGame() {
+        try {
+            GameCommand gameCommand = inputCommand();
+            gameCommand.execute(chessGame);
+        } catch (Exception e) {
+            outputView.printErrorMessage(e.getMessage());
+            initGame();
+        }
+    }
+
+    private GameCommand inputCommand() {
+        String[] inputValues = inputView.inputCommand().split(" ");
+        return GameCommandType.of(inputValues);
+    }
+
+    private void gameStart() {
+        outputView.printWelcomeMessage();
+        while (chessGame.isGameRunning()) {
+            BoardDto boardDto = BoardDto.from(chessGame.piecePositions());
+            outputView.printBoard(boardDto);
+            playTurn();
+        }
+    }
+
+    private void playTurn() {
+        try {
+            GameCommand gameCommand = inputCommand();
+            gameCommand.execute(chessGame);
+        } catch (Exception e) {
+            outputView.printErrorMessage(e.getMessage());
+            playTurn();
+        }
+    }
+}

src/main/java/domain/board/Board.java

@@ -0,0 +1,52 @@
+package domain.board;
+
+import domain.piece.Piece;
+import domain.piece.PieceColor;
+
+import java.util.Collections;
+import java.util.Map;
+
+public class Board {
+    private final Map<Position, Piece> piecePositions;
+
+    public Board(final Map<Position, Piece> piecePositions) {
+        this.piecePositions = piecePositions;
+    }
+
+    public void movePiece(final PieceColor pieceColor, final Position source, final Position destination) {
+        validatePosition(pieceColor, source, destination);
+
+        Piece targetPiece = piecePositions.get(source);
+        targetPiece.move(source, destination, this);
+
+        piecePositions.put(destination, targetPiece);
+        piecePositions.remove(source);
+    }
+
+    private void validatePosition(final PieceColor pieceColor, final Position source, final Position destination) {
+        if (source.equals(destination)) {
+            throw new IllegalArgumentException("출발지와 목적지가 같을 수 없습니다.");
+        }
+
+        if (!piecePositions.containsKey(source)) {
+            throw new IllegalArgumentException("출발지에 기물이 존재하지 않습니다.");
+        }
+
+        if (!piecePositions.get(source).isTeam(pieceColor)) {
+            throw new IllegalArgumentException("상대방의 기물을 이동시킬 수 없습니다.");
+        }
+    }
+
+    public boolean existPiece(final Position position) {
+        return piecePositions.containsKey(position);
+    }
+
+    public boolean existTeamColor(final Position position, final PieceColor teamColor) {
+        return piecePositions.get(position).isTeam(teamColor);
+
+    }
+
+    public Map<Position, Piece> piecePositions() {
+        return Collections.unmodifiableMap(piecePositions);
+    }
+}

src/main/java/domain/board/BoardInitializer.java

@@ -0,0 +1,87 @@
+package domain.board;
+
+import domain.piece.*;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import static domain.board.File.D;
+import static domain.board.File.E;
+import static domain.board.File.A;
+import static domain.board.File.B;
+import static domain.board.File.C;
+import static domain.board.File.F;
+import static domain.board.File.G;
+import static domain.board.File.H;
+import static domain.board.Rank.ONE;
+import static domain.board.Rank.TWO;
+import static domain.board.Rank.SEVEN;
+import static domain.board.Rank.EIGHT;
+import static domain.piece.PieceColor.BLACK;
+import static domain.piece.PieceColor.WHITE;
+
+public class BoardInitializer {
+    public static Board initBoard() {
+        return new Board(new HashMap<>(initPieces()));
+    }
+
+    private static Map<Position, Piece> initPieces() {
+        final Map<Position, Piece> piecePositions = new HashMap<>();
+        initKing(piecePositions);
+        initQueen(piecePositions);
+        initBishop(piecePositions);
+        initKnight(piecePositions);
+        initRook(piecePositions);
+        initBlackPawns(piecePositions);
+        initWhitePawns(piecePositions);
+
+        return piecePositions;
+    }
+
+    private static void initKing(final Map<Position, Piece> piecePositions) {
+        piecePositions.put(position(E, ONE), new King(WHITE));
+        piecePositions.put(position(E, EIGHT), new King(BLACK));
+    }
+
+    private static void initQueen(final Map<Position, Piece> piecePositions) {
+        piecePositions.put(position(D, ONE), new Queen(WHITE));
+        piecePositions.put(position(D, EIGHT), new Queen(BLACK));
+    }
+
+    private static void initBishop(final Map<Position, Piece> piecePositions) {
+        piecePositions.put(position(C, ONE), new Bishop(WHITE));
+        piecePositions.put(position(F, ONE), new Bishop(WHITE));
+        piecePositions.put(position(C, EIGHT), new Bishop(BLACK));
+        piecePositions.put(position(F, EIGHT), new Bishop(BLACK));
+    }
+
+    private static void initKnight(final Map<Position, Piece> piecePositions) {
+        piecePositions.put(position(B, ONE), new Knight(WHITE));
+        piecePositions.put(position(G, ONE), new Knight(WHITE));
+        piecePositions.put(position(B, EIGHT), new Knight(BLACK));
+        piecePositions.put(position(G, EIGHT), new Knight(BLACK));
+    }
+
+    private static void initRook(final Map<Position, Piece> piecePositions) {
+        piecePositions.put(position(A, ONE), new Rook(WHITE));
+        piecePositions.put(position(H, ONE), new Rook(WHITE));
+        piecePositions.put(position(A, EIGHT), new Rook(BLACK));
+        piecePositions.put(position(H, EIGHT), new Rook(BLACK));
+
+    }
+
+    private static void initWhitePawns(final Map<Position, Piece> piecePositions) {
+        Arrays.stream(File.values())
+                .forEach(file -> piecePositions.put(position(file, TWO), new Pawn(WHITE)));
+    }
+
+    private static void initBlackPawns(final Map<Position, Piece> piecePositions) {
+        Arrays.stream(File.values())
+                .forEach(file -> piecePositions.put(position(file, SEVEN), new Pawn(BLACK)));
+    }
+
+    private static Position position(final File file, final Rank rank) {
+        return new Position(file, rank);
+    }
+}

src/main/java/domain/board/File.java

@@ -0,0 +1,38 @@
+package domain.board;
+
+import java.util.Arrays;
+
+public enum File {
+    A(0),
+    B(1),
+    C(2),
+    D(3),
+    E(4),
+    F(5),
+    G(6),
+    H(7);
+
+    private final int index;
+
+    File(final int index) {
+        this.index = index;
+    }
+
+    public static File of(final String value) {
+        return Arrays.stream(values())
+                .filter(file -> file.name().equals(value.toUpperCase()))
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 File 값입니다."));
+    }
+
+    public static File of(final int index) {
+        return Arrays.stream(values())
+                .filter(file -> file.getIndex() == index)
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 인덱스입니다."));
+    }
+
+    public int getIndex() {
+        return this.index;
+    }
+}

src/main/java/domain/board/Position.java

@@ -0,0 +1,40 @@
+package domain.board;
+
+import domain.piece.MovementDirection;
+
+public record Position(File file, Rank rank) {
+    private static final int POSITIONS_VALUES_SIZE = 2;
+    private static final int FILE_INDEX = 0;
+    private static final int RANK_INDEX = 1;
+
+    public static Position of(final String value) {
+        String[] positionValues = value.split("");
+        validatePositionValue(positionValues);
+
+        File file = File.of(positionValues[FILE_INDEX]);
+        Rank rank = Rank.of(positionValues[RANK_INDEX]);
+
+        return new Position(file, rank);
+    }
+
+    private static void validatePositionValue(final String[] values) {
+        if (values.length != POSITIONS_VALUES_SIZE) {
+            throw new IllegalArgumentException("잘못된 위치값입니다.");
+        }
+    }
+
+    public Position next(final MovementDirection movementDirection) {
+        File nextFile = File.of(this.columnIndex() + movementDirection.getColumnDistance());
+        Rank nextRank = Rank.of(this.rowIndex() + movementDirection.getRowDistance());
+
+        return new Position(nextFile, nextRank);
+    }
+
+    public int rowIndex() {
+        return rank.getIndex();
+    }
+
+    public int columnIndex() {
+        return file.getIndex();
+    }
+}