Step1 : 체스 게임 1단계 리뷰 요청 드립니다!

README.md

@@ -1 +1,101 @@
 # java-chess 게임
+
+## 구현해야할 목록
+
+- [x] 입력
+  - [x] 명령어 입력
+- [x] 출력
+  - [x] 시작 안내 문구 출력
+  - [x] 체스판 전체 출력
+  - [x] 점수와 결과 출력
+
+- [x] 체스게임(ChessGame)
+  - [x] 체스판
+  - [x] 현재 플레이어
+  - [x] 게임 시작&종료 상태 제어
+
+  - 기능
+    - [x] 명령어 검증 및 처리
+      - [x] start : 게임 실행
+      - [x] end : 게임 종료
+      - [x] move : 인자로 전달받은 source 위치에서 target 위치로 기물 이동
+
+- [x] 체스판(Board)
+  - [x] 체스판
+  - [x] 생성 시 32개의 기물 초기화
+
+  - 기능
+    - [x] 인자로 전달받은 위치에 기물이 있는지 확인
+      - [x] ERROR : 존재하지 않을 경우
+      - [x] 같은 색상 기물인지 확인
+        - [x] ERROR : 다른 색상일 경우
+      - [x] 시작과 도착 위치의 기물이 다른 색상인지 확인
+        - [x] ERROR : 같은 색상일 경우
+      - [x] source 위치에서 target 위치로 기물 이동
+        - [x] ERROR : source 위치에 기물이 없는 경우
+        - [x] ERROR : 자신의 기물이 아닌 경우
+        - [x] ERROR : source, target 위치의 기물 색상이 같을 경우
+        - [x] ERROR : source, target 위치가 같을 경우
+        - [x] ERROR : 이동 경로에 기물이 존재할 경우
+
+- [x] 기물(Piece)
+  - [x] 색상
+
+  - [x] 기물 위치(Position)
+    - [x] 파일
+    - [x] 랭크
+    - [x] 64개의 캐싱된 위치
+
+    - 기능
+      - [x] 전달받은 인자에 해당하는 위치 객체 반환
+
+  - [x] 기물 색상(Color)
+    - [x] 색상
+
+  - [x] 기물 이름 매퍼
+    - [x] 기물 종류에 따라 이름을 매핑
+
+- [x] 플레이어(Player)
+  - [x] 자신의 기물
+  - [x] 자신이 공격 가능한 범위
+
+  - 기능
+    - [x] 기물을 이동시킨다.
+    - [x] 기물의 이동 경로를 반환한다.
+    - [x] 입력받은 위치에 기물이 있는지 확인한다.
+
+## 이동 규칙
+
+- [x] 폰 (1 or 0.5)
+  - [x] 적 방향 직선 1칸 이동
+    - [x] ERROR : 직선 방향 2칸 이상일 경우
+    - [x] ERROR : 좌, 우 이동이 포함될 경우
+  - [x] 처음 이동 시에는 2칸 이동 가능
+    - [x] ERROR : 직선 방향 3칸 이상일 경우
+    - [x] ERROR : 좌, 우 이동이 포함될 경우
+
+  - [x] 공격 : 적 방향 좌, 우 대각선 1칸
+    - [x] ERROR : 직선 1칸 && 좌 또는 우 1칸이 아닐 경우
+
+- [x] 룩 (5)
+  - [x] 모든 직선 방향으로 원하는 만큼 이동 가능
+    - [x] ERROR : 룩 이동 패턴으로 이동할 수 없는 위치일 경우
+
+- [x] 나이트 (2.5)
+  - [x] 모든 직선 방향 1칸 + 이동한 직선 방향의 좌, 우 대각선 1칸으로 이동 가능
+    - [x] ERROR : 나이트 이동 패턴으로 이동할 수 없는 위치일 경우
+  - [x] 진행 방향이 가로막혀도 적, 아군 상관없이 뛰어넘을 수 있다.
+
+- [x] 비숍 (3)
+  - [x] 모든 대각선 방향으로 원하는 만큼 이동 가능
+    - [x] ERROR : 비숍 이동 패턴으로 이동할 수 없는 위치일 경우
+
+- [x] 퀸 (9)
+  - [x] 모든 방향 1칸 + α 이동 (모든 대각선 방향으로는 원하는 만큼 이동 가능)
+    - [x] ERROR : 퀸 이동 패턴으로 이동할 수 없는 위치일 경우
+
+- [x] 킹
+  - [x] 모든 방향 1칸 이동
+    - [x] ERROR : 킹 이동 패턴으로 이동할 수 없는 위치일 경우
+  - [x] 상대의 공격 범위로는 이동 불가능
+

build.gradle

@@ -18,4 +18,5 @@ dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.1'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.1'
     testCompile "org.assertj:assertj-core:3.14.0"
+    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.4.2'
 }

src/main/java/chess/ConsoleApplication.java

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

src/main/java/chess/controller/ChessController.java

@@ -0,0 +1,88 @@
+package chess.controller;
+
+import chess.controller.dto.BoardDto;
+import chess.domain.ChessGame;
+import chess.domain.board.Status;
+import chess.domain.command.CommandOptions;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+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() {
+        ChessGame chessGame = initialize();
+
+        while (chessGame.isRunning()) {
+            play(chessGame);
+        }
+
+        printResult(chessGame);
+    }
+
+    private ChessGame initialize() {
+        outputView.printGuide();
+        ChessGame chessGame = new ChessGame();
+        CommandOptions initialCommandOptions = CommandOptions.of(inputView.getCommand());
+        executeInitialCommand(initialCommandOptions, chessGame);
+
+        return chessGame;
+    }
+
+    private void executeInitialCommand(final CommandOptions commandOptions, final ChessGame chessGame) {
+        commandOptions.validateInitialCommand();
+
+        if (commandOptions.isEnd()) {
+            chessGame.end();
+        }
+    }
+
+    private void play(final ChessGame chessGame) {
+        try {
+            outputView.printTurn(chessGame.isWhiteTurn());
+            CommandOptions commandOptions = CommandOptions.of(inputView.getCommand());
+            executeCommand(chessGame, commandOptions);
+            printBoard(chessGame);
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    private void executeCommand(final ChessGame chessGame, final CommandOptions commandOptions) {
+        if (commandOptions.isEnd()) {
+            chessGame.end();
+            return;
+        }
+
+        if (commandOptions.isMove()) {
+            chessGame.move(commandOptions.getMoveOptions());
+            return;
+        }
+
+        if (commandOptions.isStatus()) {
+            printStatus(chessGame);
+        }
+    }
+
+    private void printBoard(final ChessGame chessGame) {
+        BoardDto boardDto = new BoardDto(chessGame.getBoard());
+        outputView.printBoard(boardDto);
+    }
+
+    private void printStatus(final ChessGame chessGame) {
+        Status status = chessGame.getStatus();
+        outputView.printStatus(status);
+    }
+
+    private void printResult(final ChessGame chessGame) {
+        printBoard(chessGame);
+        printStatus(chessGame);
+    }
+}

src/main/java/chess/controller/dto/BoardDto.java

@@ -0,0 +1,41 @@
+package chess.controller.dto;
+
+import chess.domain.board.Board;
+import chess.domain.board.File;
+import chess.domain.board.Rank;
+import chess.domain.piece.Piece;
+import chess.domain.piece.PieceResolver;
+import chess.domain.player.Position;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class BoardDto {
+    private List<PositionDto> positionDtos = new ArrayList<>();
+
+    public BoardDto(final Board board) {
+        Arrays.stream(Rank.values()).forEach(rank -> Arrays.stream(
+                File.values()).forEach(file -> addPositionDto(file, rank, board)));
+    }
+
+    private void addPositionDto(final File file, final Rank rank, final Board board) {
+        Position position = Position.from(file, rank);
+
+        if (board.isEmpty(position)) {
+            PositionDto positionDto = new PositionDto(position.getFile());
+            positionDtos.add(positionDto);
+            return;
+        }
+
+        Piece piece = board.findBy(position);
+        String name = PieceResolver.findNameBy(piece);
+        PositionDto positionDto = new PositionDto(position.getFile(), name);
+        positionDtos.add(positionDto);
+    }
+
+    public List<PositionDto> getPositionDtos() {
+        return Collections.unmodifiableList(positionDtos);
+    }
+}

src/main/java/chess/controller/dto/PositionDto.java

@@ -0,0 +1,28 @@
+package chess.controller.dto;
+
+import chess.domain.board.File;
+
+public class PositionDto {
+
+    private static final String DEFAULT_NAME = ".";
+
+    private final boolean isLastFile;
+    private final String name;
+
+    public PositionDto(final File file, final String name) {
+        this.isLastFile = (file == File.H);
+        this.name = name;
+    }
+
+    public PositionDto(final File file) {
+        this(file, DEFAULT_NAME);
+    }
+
+    public boolean isLastFile() {
+        return isLastFile;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/chess/domain/ChessGame.java

@@ -0,0 +1,44 @@
+package chess.domain;
+
+import chess.domain.board.Board;
+import chess.domain.board.Status;
+import chess.domain.command.MoveOptions;
+
+public class ChessGame {
+
+    private final Board board = new Board();
+    private boolean isRunning = true;
+    private boolean isWhiteTurn = true;
+
+    public ChessGame() {
+    }
+
+    public void move(final MoveOptions moveOptions) {
+        board.move(moveOptions, isWhiteTurn);
+        isWhiteTurn = !isWhiteTurn;
+
+        if (board.isEnd()) {
+            isRunning = false;
+        }
+    }
+
+    public void end() {
+        isRunning = false;
+    }
+
+    public Status getStatus() {
+        return board.getStatus();
+    }
+
+    public boolean isRunning() {
+        return isRunning;
+    }
+
+    public Board getBoard() {
+        return board;
+    }
+
+    public boolean isWhiteTurn() {
+        return isWhiteTurn;
+    }
+}