[1, 2단계 - 체스] 져니(이지원) 미션 제출합니다.

README.md

@@ -1,7 +1,183 @@
-# java-chess
+# 🪜 체스 게임 구현 미션
 
-체스 미션 저장소
+## Pair: 져니 [⛄️](http://github.com/cl8d), 제나 [❤️](https://github.com/yenawee)
 
-## 우아한테크코스 코드리뷰
+## ✔ 기능 요구사항
 
-- [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+### ChessBoard
+
+- [x] 체스판을 초기화한다.
+    - [x] 체스 말의 위치에 대한 정보를 관리한다.
+- [x] 해당 위치에 체스말이 존재하는지 확인한다.
+- [x] 특정 위치에 존재하는 체스말을 반환한다.
+- [x] 특정 위치에 존재하는 체스말을 제거한다.
+- [x] 특정 위치에 체스말을 둔다.
+- [x] 특정 말의 종류에 따라서 시작 위치에서 종료 위치로 이동 가능한지 판단한다.
+
+### ChessGame
+
+- [x] 체스 게임을 진행한다.
+
+### CampType
+
+- [x] 사용자의 진영을 관리한다.
+    - [x] 입력받은 위치의 열이 소문자면 WHITE, 대문자면 BLACK 진영으로 나눈다.
+- [x] 플레이할 진영을 번갈아가며 반환한다.
+
+### Piece
+
+- [x] 체스말이 어떤 진영에 속하는지 관리한다.
+- [x] 두 개의 체스말이 동일한 진영에 속하는지 판단한다.
+- [x] 체스말이 입력받은 진영에 속하는지 판단한다.
+- [x] 체스말이 시작 위치에서 도착 위치로 이동 가능한지 판단한다.
+- [x] 체스말이 공격 가능한지 판단한다.
+
+### PieceType
+
+- [x] 체스말의 종류를 관리한다.
+- [x] 특정 체스말이 시작 위치에서 종료 위치까지 이동 가능한지 판단한다.
+
+### Position
+
+- [x] 체스판 위의 위치 정보를 저장한다.
+- [x] 목표 위치를 반환한다.
+- [x] 위치가 입력받은 제한값을 넘어가는지 판단한다.
+- [x] 목표 위치로 이동하기 위한 단위 벡터를 계산한다.
+- [x] 입력받은 위치를 복사한 새로운 위치를 반환한다.
+- [x] 현재 위치와 입력받은 위치의 rank의 차이를 계산한다.
+- [x] 현재 위치와 입력받은 위치의 file의 차이를 계산한다.
+- [x] 현재 위치의 rank가 입력받은 위치의 rank보다 큰지 판단한다.
+- [x] 현재 위치의 rank과 입력받은 위치의 rank가 동일한지 판단한다.
+- [x] 현재 위치와 입력받은 위치가 동일한지 판단한다.
+
+### Direction
+
+- [x] 체스말이 이동하는 방향으로 관리한다.
+- [x] 모든 방향에 대해서 반환한다.
+- [x] 상하좌우에 대해서 반환한다.
+- [x] 상하좌우의 대각선에 대해서 반환한다.
+
+### Movable
+
+- [x] 체스말의 움직임을 관리한다.
+- [x] 체스말이 공격 가능한지 판단한다.
+
+### Location
+
+- [x] 이동 가능한 모든 위치에 대해 관리한다.
+- [x] 이동 가능한 위치에 새로운 정보를 추가한다.
+- [x] 이동 가능한 위치에 입력받은 위치가 포함되어 있는지 확인한다.
+
+### Move
+
+- [x] 입력받은 위치로 이동시킨다.
+- [x] 체스말이 이동 가능한 위치를 전부 반환한다.
+
+### QueenMove
+
+- [x] 입력받은 위치에 대해서 퀸이 이동 가능한지 판단한다.
+
+### RookMove
+
+- [x] 입력받은 위치에 대해서 룩이 이동 가능한지 판단한다.
+
+### BishopMove
+
+- [x] 입력받은 위치에 대해서 비숍이 이동 가능한지 판단한다.
+
+### KingMove
+
+- [x] 입력받은 위치에 대해서 킹이 이동 가능한지 판단한다.
+
+### KnightMove
+
+- [x] 입력받은 위치에 대해서 나이트가 이동 가능한지 판단한다.
+
+### PawnMove
+
+- [x] 입력받은 출발 위치의 행보다 도착 위치의 행이 더 크면 UP 방향, 아니면 DOWN 방향으로 이동할 수 있는지 판단한다.
+
+### PositionConverter
+
+- [x] 입력받은 source, target 위치를 가로, 세로 값으로 분리한다.
+    - [x] 가로값은 왼쪽부터 0~7 세로값은 아래부터 0~7으로 변환한다.
+- [x] 사용자가 입력한 위치를 검증한다.
+    - [x] 입력받은 위치 명령어의 길이가 2인지 확인한다.
+    - [x] 첫 번째 글자가 a~h, 두 번째 글자가 1~8인지 확인한다.
+
+### InputView
+
+- [x] 명령어를 입력받는다.
+
+### Command
+
+- [x] 사용자가 입력한 명령어에 대해서 관리한다.
+- [x] 사용자가 입력한 명령어가 start, move, end인지 검증한다.
+- [x] 사용자가 입력한 명령어가 start인지 확인한다.
+- [x] 사용자가 입력한 명령어가 end인지 확인한다.
+- [x] 사용자가 입력한 명령어가 move일 때 올바른 명령어 길이로 들어오는지 확인한다.
+
+### CommandType
+
+- [x] 명령어의 종류에 대해서 관리한다. (start, move, end)
+
+### Status
+
+- [x] 사용자가 입력한 명령어에 따라 게임의 상태를 확인한다.
+- [x] 현재 게임이 실행 중인지 판단한다.
+
+### EndController
+
+- [x] 사용자가 입력한 명령어가 End가 아니라면 예외를 발생시킨다.
+- [x] 현재 게임이 실행 중인지 판단한다.
+
+### MoveController
+
+- [x] 사용자가 입력한 명령어가 Start라면 예외를 발생시키고, End라면 종료한다.
+- [x] 사용자가 입력한 체스말을 시작 지점에서 끝 지점으로 이동시키고, 차례를 변경한다.
+- [x] 현재 게임이 실행 중인지 판단한다.
+
+### StartController
+
+- [x] 사용자가 입력한 명령어가 Move라면 예외를 발생시키고, End라면 종료한다.
+- [x] 현재 게임이 실행 중인지 판단한다.
+
+### PieceName
+
+- [x] 체스말의 종류에 따라 체스말의 이름으로 변환한다.
+
+### OutputView
+
+- [x] 게임 안내 메시지를 출력한다.
+- [x] 체스판에 있는 체스말을 출력하고, 비어있는 곳은 .으로 출력한다.
+- source에 있는 말이 target으로 이동된 체스판을 출력한다.
+
+---
+
+## ✔ 프로그래밍 요구사항
+
+- 자바 코드 컨벤션을 지키면서 프로그래밍한다.
+    - 기본적으로 Java Style Guide을 원칙으로 한다.
+- indent(인덴트, 들여쓰기) depth를 2를 넘지 않도록 구현한다. 1까지만 허용한다.
+    - 예를 들어 while문 안에 if문이 있으면 들여쓰기는 2이다.
+    - 힌트: indent(인덴트, 들여쓰기) depth를 줄이는 좋은 방법은 함수(또는 메서드)를 분리하면 된다.
+- 3항 연산자를 쓰지 않는다.
+- else 예약어를 쓰지 않는다.
+    - else 예약어를 쓰지 말라고 하니 switch/case로 구현하는 경우가 있는데 switch/case도 허용하지 않는다.
+    - 힌트: if문에서 값을 반환하는 방식으로 구현하면 else 예약어를 사용하지 않아도 된다.
+- 모든 기능을 TDD로 구현해 단위 테스트가 존재해야 한다. 단, UI(System.out, System.in) 로직은 제외
+    - 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 구분한다.
+    - UI 로직을 InputView, ResultView와 같은 클래스를 추가해 분리한다.
+- 함수(또는 메서드)의 길이가 10라인을 넘어가지 않도록 구현한다.
+    - 함수(또는 메소드)가 한 가지 일만 하도록 최대한 작게 만들어라.
+- 배열 대신 컬렉션을 사용한다.
+- 모든 원시 값과 문자열을 포장한다
+- 줄여 쓰지 않는다(축약 금지).
+- 일급 컬렉션을 쓴다.
+- 모든 엔티티를 작게 유지한다.
+- 3개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않는다.
+- 도메인의 의존성을 최소한으로 구현한다.
+- 한 줄에 점을 하나만 찍는다.
+- 게터/세터/프로퍼티를 쓰지 않는다.
+- 모든 객체지향 생활 체조 원칙을 잘 지키며 구현한다.
+- 프로그래밍 체크리스트의 원칙을 지키면서 프로그래밍 한다.

src/main/java/chess/ChessApplication.java

@@ -0,0 +1,10 @@
+package chess;
+
+import chess.controller.ChessHandler;
+
+public final class ChessApplication {
+    public static void main(String[] args) {
+        final ChessHandler chessHandler = new ChessHandler();
+        chessHandler.run();
+    }
+}

src/main/java/chess/controller/ChessHandler.java

@@ -0,0 +1,40 @@
+package chess.controller;
+
+import chess.controller.dto.BoardDto;
+import chess.controller.status.StartController;
+import chess.controller.status.Status;
+import chess.domain.chess.ChessGame;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+import java.util.List;
+
+public final class ChessHandler {
+
+    public void run() {
+        OutputView.printStartMessage();
+        final ChessGame chessGame = new ChessGame();
+        start(chessGame);
+    }
+
+    private void start(final ChessGame chessGame) {
+        Status gameStatus = new StartController(chessGame);
+        while (gameStatus.isRun()) {
+            gameStatus = play(chessGame, gameStatus);
+        }
+    }
+
+    private Status play(final ChessGame chessGame, Status gameStatus) {
+        try {
+            List<String> commands = InputView.getCommand();
+            final Command command = Command.findCommand(commands);
+            gameStatus = gameStatus.checkCommand(command,
+                    () -> OutputView.printBoard(BoardDto.from(chessGame.getChessBoard())));
+            return gameStatus;
+        } catch (IllegalArgumentException e) {
+            OutputView.print(e.getMessage());
+            return play(chessGame, gameStatus);
+        }
+    }
+}
+

src/main/java/chess/controller/Command.java

@@ -0,0 +1,46 @@
+package chess.controller;
+
+import java.util.Arrays;
+import java.util.List;
+
+public final class Command {
+    private static final int COMMAND_INDEX = 0;
+    private static final int MOVE_COMMAND_SIZE = 3;
+    private static final String COMMAND_ERROR_MESSAGE = "잘못된 명령어 입력입니다.";
+
+    private final CommandType type;
+    private final List<String> commands;
+
+    public Command(final CommandType type, final List<String> commands) {
+        this.type = type;
+        this.commands = commands;
+    }
+
+    public static Command findCommand(final List<String> commands) {
+        final CommandType type = Arrays.stream(CommandType.values())
+                .filter(e -> e.name().equalsIgnoreCase(commands.get(COMMAND_INDEX)))
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException(COMMAND_ERROR_MESSAGE));
+        return new Command(type, commands);
+    }
+
+    public boolean isStart() {
+        return type == CommandType.START;
+    }
+
+    public boolean isMove() {
+        return type == CommandType.MOVE;
+    }
+
+    public boolean isEnd() {
+        return type == CommandType.END;
+    }
+
+    public boolean isCorrectWhenMove() {
+        return commands.size() == MOVE_COMMAND_SIZE;
+    }
+
+    public List<String> getCommands() {
+        return List.copyOf(commands);
+    }
+}

src/main/java/chess/controller/CommandType.java

@@ -0,0 +1,5 @@
+package chess.controller;
+
+public enum CommandType {
+    START, MOVE, END
+}

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

@@ -0,0 +1,30 @@
+package chess.controller.dto;
+
+import chess.domain.piece.Piece;
+import chess.domain.piece.Position;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public final class BoardDto {
+
+    private final Map<PositionDto, PieceDto> board;
+
+    private BoardDto(final Map<PositionDto, PieceDto> board) {
+        this.board = board;
+    }
+
+    public static BoardDto from(final Map<Position, Piece> board) {
+        final Map<PositionDto, PieceDto> boardDto = new HashMap<>();
+        for (Position position : board.keySet()) {
+            boardDto.put(PositionDto.from(position.getRank(), position.getFile()),
+                    PieceDto.from(board.get(position)));
+        }
+        return new BoardDto(boardDto);
+    }
+
+    public Map<PositionDto, PieceDto> getBoard() {
+        return Collections.unmodifiableMap(board);
+    }
+}

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

@@ -0,0 +1,27 @@
+package chess.controller.dto;
+
+import chess.domain.chess.CampType;
+import chess.domain.piece.Piece;
+import chess.domain.piece.PieceType;
+
+public final class PieceDto {
+    private final PieceType pieceType;
+    private final CampType campType;
+
+    private PieceDto(final PieceType pieceType, final CampType campType) {
+        this.pieceType = pieceType;
+        this.campType = campType;
+    }
+
+    public static PieceDto from(final Piece piece) {
+        return new PieceDto(piece.getPieceType(), piece.getCampType());
+    }
+
+    public boolean isSameCamp(final CampType campType) {
+        return this.campType == campType;
+    }
+
+    public PieceType getPieceType() {
+        return pieceType;
+    }
+}

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

@@ -0,0 +1,31 @@
+package chess.controller.dto;
+
+import java.util.Objects;
+
+public final class PositionDto {
+
+    private final int rank;
+    private final int file;
+
+    private PositionDto(final int rank, final int file) {
+        this.rank = rank;
+        this.file = file;
+    }
+
+    public static PositionDto from(final int rank, final int file) {
+        return new PositionDto(rank, file);
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        final PositionDto that = (PositionDto) o;
+        return rank == that.rank && file == that.file;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(rank, file);
+    }
+}

src/main/java/chess/controller/status/EndController.java

@@ -0,0 +1,15 @@
+package chess.controller.status;
+
+import chess.controller.Command;
+
+public final class EndController implements Status {
+    @Override
+    public Status checkCommand(final Command command, final Runnable runnable) {
+        throw new IllegalArgumentException("게임이 끝났습니다.");
+    }
+
+    @Override
+    public boolean isRun() {
+        return false;
+    }
+}