[1, 2단계 - 체스] 페드로(류형욱) 미션 제출합니다.

.gitignore

@@ -30,3 +30,6 @@ out/
 
 ### VS Code ###
 .vscode/
+
+### Docker ###
+/docker/

.gitmessage.txt

@@ -0,0 +1,4 @@
+
+
+Co-authored-by: Hyunguk Ryu <hw0603@naver.com>
+

docs/README.md

@@ -0,0 +1,52 @@
+## 기능 흐름
+
+- [x] 사용자로부터 게임 시작 여부 입력
+    - [x] `start`를 입력받으면 체스판을 초기화한다.
+    - [x] `end`를 입력받으면 프로그램을 종료한다.
+    - [x] `move`와 출발지/목적지 정보를 입력받으면 기물 이동을 시도한다.
+- [x] 체스판을 초기화한다.
+- [x] 체스판을 출력한다.
+- [x] 체스 기물을 이동시킨다.
+    - [x] 이동이 가능 여부를 확인한다.
+    - [x] 기물 위치를 업데이트한다.
+
+## 도메인별 기능
+
+### Vector
+- [x] 행, 열의 두 정수 성분을 가지고, 단위벡터로서 이동의 방향성을 나타낸다.
+- [x] 출발지, 도착지의 위치 정보를 받아서 해당 방향으로 이동하기 위한 최적의 벡터 객체를 생성한다.
+
+### Position
+- [x] `Rank`, `File`의 쌍을 가지고 한 칸의 위치를 표현한다.
+
+### Piece
+- [x] 타입이 다른 기물들과 자신을 구별할 수 있는`PieceType`을 가진다.
+- [x] 이동 가능한 위치인지 여부를 확인한다.
+- [x] 모든 말은 체스보드 안에서만 움직일 수 있다.
+- [x] 목적지까지 가는 경로에 다른 기물이 존재하면 이동할 수 없다.
+    - 록
+        - [x] 동서남북 방향으로 직진할 수 있다.
+    - 비숍
+        - [x] 대각선 방향으로 직진할 수 있다.
+    - 퀸
+        - [x] 동서남북, 혹은 대각선 방향으로 직진할 수 있다.
+    - 킹
+        - [x] 동서남북, 혹은 대각선 방향으로 1칸만 이동할 수 있다.
+    - 나이트
+        - [x] 동서남북 방향으로 한 칸 전진 후, 전진한 방향에서 대각선으로 한 칸 이동할 수 있다.
+        - [x] 다른 말을 뛰어넘을 수 있다.
+    - 폰
+        - [x] 한 칸만 앞으로 전진만 할 수 있다.
+        - [x] 다른 말을 공격하는 경우 대각선 방향으로 한 칸만 이동할 수 있다.
+        - [x] 최초로 이동할 경우 한 칸 또는 두 칸 이동할 수 있다.
+
+### Board
+- [x] 체스의 규칙에 맞게 각 기물들을 시작 위치로 배치한다.
+- [x] 기물의 도착지에 현재 이동하는 기물과 같은 색의 기물이 존재하면 이동할 수 없다.
+- [x] 도착지에 다른 색의 기물이 존재하는 경우, 해당 기물을 제거하고 배치한다.
+
+### InputView
+- [x] `start` 명령과 `end`, `move` 명령을 입력받는다.
+
+### OutputView
+- [x] 현재 체스판의 상태를 출력한다.

src/main/java/Application.java

@@ -0,0 +1,13 @@
+import controller.ChessController;
+import view.InputView;
+import 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/controller/ChessController.java

@@ -0,0 +1,66 @@
+package controller;
+
+import domain.GameCommand;
+import domain.game.Board;
+import domain.game.BoardInitializer;
+import domain.game.Turn;
+import dto.BoardDto;
+import dto.RequestDto;
+import java.util.function.Supplier;
+import view.InputView;
+import 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() {
+        outputView.printWelcomeMessage();
+        GameCommand command = readUserInput(inputView::inputGameStart);
+        if (command.isStart()) {
+            startGame();
+        }
+    }
+
+    private <T> T readUserInput(Supplier<T> inputSupplier) {
+        while (true) {
+            try {
+                return inputSupplier.get();
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            }
+        }
+    }
+
+    private void startGame() {
+        Board board = BoardInitializer.init();
+        printStatus(board);
+
+        Turn turn = new Turn();
+        RequestDto requestDto = readUserInput(inputView::inputGameCommand);
+        while (requestDto.command().isContinuable()) {
+            doTurn(board, turn, requestDto);
+            printStatus(board);
+            requestDto = readUserInput(inputView::inputGameCommand);
+        }
+    }
+
+    private void doTurn(Board board, Turn turn, RequestDto requestDto) {
+        try {
+            board.movePiece(turn.current(), requestDto.source(), requestDto.destination());
+            turn.next();
+        } catch (IllegalArgumentException e) {
+            System.out.println("[오류] " + e.getMessage());
+        }
+    }
+
+    private void printStatus(Board board) {
+        BoardDto boardDto = BoardDto.from(board);
+        outputView.printBoard(boardDto);
+    }
+}

src/main/java/domain/GameCommand.java

@@ -0,0 +1,13 @@
+package domain;
+
+public enum GameCommand {
+    START, MOVE, END;
+
+    public boolean isContinuable() {
+        return this != END;
+    }
+
+    public boolean isStart() {
+        return this == START;
+    }
+}

src/main/java/domain/game/Board.java

@@ -0,0 +1,78 @@
+package domain.game;
+
+import domain.position.Position;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class Board {
+    private final Map<Position, Piece> chessBoard;
+
+    public Board(final Map<Position, Piece> chessBoard) {
+        this.chessBoard = chessBoard;
+    }
+
+    public Map<Position, Piece> getChessBoard() {
+        return Collections.unmodifiableMap(chessBoard);
+    }
+
+    public void movePiece(final TeamColor teamColor, final Position source, final Position destination) {
+        validateMoveRequest(teamColor, source, destination);
+
+        boolean caughtEnemy = isPieceExist(destination);
+        Piece piece = chessBoard.get(source);
+        chessBoard.put(destination, piece);
+        chessBoard.remove(source);
+    }
+
+    private void validateMoveRequest(TeamColor teamColor, Position source, Position destination) {
+        validateEmpty(source);
+        validateColor(teamColor, source);
+        Piece piece = chessBoard.get(source);
+        validateReachability(source, destination, piece);
+        validateDestinationPiece(teamColor, destination);
+    }
+
+    private void validateEmpty(final Position source) {
+        if (!chessBoard.containsKey(source)) {
+            throw new IllegalArgumentException("해당 위치에 기물이 없습니다.");
+        }
+    }
+
+    private void validateColor(final TeamColor teamColor, final Position source) {
+        if (!chessBoard.get(source).hasColor(teamColor)) {
+            throw new IllegalArgumentException("차례가 맞지 않습니다.");
+        }
+    }
+
+    private void validateReachability(Position source, Position destination, Piece piece) {
+        if (source.equals(destination)) {
+            throw new IllegalArgumentException("출발지와 도착지가 동일합니다.");
+        }
+        if (!piece.isMovable(source, destination, generatePiecePositions(source))) {
+            throw new IllegalArgumentException("이동 위치까지 이동할 수 없습니다.");
+        }
+    }
+
+    private Set<Position> generatePiecePositions(final Position excluded) {
+        return chessBoard.keySet().stream()
+                .filter(key -> !key.equals(excluded))
+                .collect(Collectors.toSet());
+    }
+
+    private void validateDestinationPiece(TeamColor teamColor, Position destination) {
+        if (isAllyPieceExistOnDestination(teamColor, destination)) {
+            throw new IllegalArgumentException("이동 위치에 아군 기물이 존재합니다.");
+        }
+    }
+
+    private boolean isAllyPieceExistOnDestination(TeamColor teamColor, Position destination) {
+        return isPieceExist(destination) && (chessBoard.get(destination).hasColor(teamColor));
+    }
+
+    private boolean isPieceExist(Position position) {
+        return chessBoard.containsKey(position);
+    }
+}

src/main/java/domain/game/BoardInitializer.java

@@ -0,0 +1,42 @@
+package domain.game;
+
+import domain.position.File;
+import domain.position.Position;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static domain.game.PieceType.*;
+import static domain.position.File.*;
+import static domain.position.Rank.*;
+
+public class BoardInitializer {
+    private BoardInitializer() {
+    }
+
+    private static final Map<PieceType, List<Position>> pieceInitialPositions = Map.ofEntries(
+            Map.entry(BLACK_PAWN, Arrays.stream(File.values()).map(file -> Position.of(file, SEVEN)).toList()),
+            Map.entry(BLACK_ROOK, List.of(Position.of(A, EIGHT), Position.of(H, EIGHT))),
+            Map.entry(BLACK_KNIGHT, List.of(Position.of(B, EIGHT), Position.of(G, EIGHT))),
+            Map.entry(BLACK_BISHOP, List.of(Position.of(C, EIGHT), Position.of(F, EIGHT))),
+            Map.entry(BLACK_QUEEN, List.of(Position.of(D, EIGHT))),
+            Map.entry(BLACK_KING, List.of(Position.of(E, EIGHT))),
+            Map.entry(WHITE_PAWN, Arrays.stream(File.values()).map(file -> Position.of(file, TWO)).toList()),
+            Map.entry(WHITE_ROOK, List.of(Position.of(A, ONE), Position.of(H, ONE))),
+            Map.entry(WHITE_KNIGHT, List.of(Position.of(B, ONE), Position.of(G, ONE))),
+            Map.entry(WHITE_BISHOP, List.of(Position.of(C, ONE), Position.of(F, ONE))),
+            Map.entry(WHITE_QUEEN, List.of(Position.of(D, ONE))),
+            Map.entry(WHITE_KING, List.of(Position.of(E, ONE)))
+    );
+
+    public static Board init() {
+        Map<Position, Piece> positions = pieceInitialPositions.entrySet().stream()
+                .flatMap(entry -> entry.getValue().stream()
+                        .map(position -> Map.entry(position, PieceFactory.create(entry.getKey()))))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        return new Board(positions);
+    }
+}

src/main/java/domain/game/Piece.java

@@ -0,0 +1,28 @@
+package domain.game;
+
+import domain.position.Position;
+import domain.strategy.MoveStrategy;
+
+import java.util.Set;
+
+public class Piece {
+    private final PieceType pieceType;
+    private final MoveStrategy moveStrategy;
+
+    public Piece(final PieceType pieceType, final MoveStrategy moveStrategy) {
+        this.pieceType = pieceType;
+        this.moveStrategy = moveStrategy;
+    }
+
+    public PieceType getPieceType() {
+        return pieceType;
+    }
+
+    public boolean hasColor(final TeamColor teamColor) {
+        return teamColor.contains(pieceType);
+    }
+
+    public boolean isMovable(final Position source, final Position destination, final Set<Position> piecePositions) {
+        return moveStrategy.isMovable(source, destination, piecePositions);
+    }
+}

src/main/java/domain/game/PieceFactory.java

@@ -0,0 +1,45 @@
+package domain.game;
+
+import domain.position.UnitVector;
+import domain.strategy.BlackPawnMoveStrategy;
+import domain.strategy.ContinuousMoveStrategy;
+import domain.strategy.KnightMoveStrategy;
+import domain.strategy.MoveStrategy;
+import domain.strategy.WhitePawnMoveStrategy;
+import java.util.Map;
+
+import static domain.game.PieceType.*;
+
+public class PieceFactory {
+    private PieceFactory() {
+    }
+
+    private static final int MAXIMUM_MOVE_BOUND = 8;
+    private static final int KING_MAXIMUM_MOVE_BOUND = 1;
+    private static final MoveStrategy whitePawnStrategy = new WhitePawnMoveStrategy();
+    private static final MoveStrategy blackPawnStrategy = new BlackPawnMoveStrategy();
+    private static final MoveStrategy knightStrategy = new KnightMoveStrategy();
+    private static final MoveStrategy rookStrategy = new ContinuousMoveStrategy(UnitVector.orthogonalVectors(), MAXIMUM_MOVE_BOUND);
+    private static final MoveStrategy bishopStrategy = new ContinuousMoveStrategy(UnitVector.diagonalVectors(), MAXIMUM_MOVE_BOUND);
+    private static final MoveStrategy queenStrategy = new ContinuousMoveStrategy(UnitVector.omnidirectionalVectors(), MAXIMUM_MOVE_BOUND);
+    private static final MoveStrategy kingStrategy = new ContinuousMoveStrategy(UnitVector.omnidirectionalVectors(), KING_MAXIMUM_MOVE_BOUND);
+
+    private static final Map<PieceType, MoveStrategy> moveStrategies = Map.ofEntries(
+            Map.entry(BLACK_PAWN, blackPawnStrategy),
+            Map.entry(BLACK_ROOK, rookStrategy),
+            Map.entry(BLACK_KNIGHT, knightStrategy),
+            Map.entry(BLACK_BISHOP, bishopStrategy),
+            Map.entry(BLACK_QUEEN, queenStrategy),
+            Map.entry(BLACK_KING, kingStrategy),
+            Map.entry(WHITE_PAWN, whitePawnStrategy),
+            Map.entry(WHITE_ROOK, rookStrategy),
+            Map.entry(WHITE_KNIGHT, knightStrategy),
+            Map.entry(WHITE_BISHOP, bishopStrategy),
+            Map.entry(WHITE_QUEEN, queenStrategy),
+            Map.entry(WHITE_KING, kingStrategy)
+    );
+
+    public static Piece create(PieceType pieceType) {
+        return new Piece(pieceType, moveStrategies.get(pieceType));
+    }
+}

src/main/java/domain/game/PieceType.java

@@ -0,0 +1,6 @@
+package domain.game;
+
+public enum PieceType {
+    BLACK_PAWN, BLACK_ROOK, BLACK_KNIGHT, BLACK_BISHOP, BLACK_QUEEN, BLACK_KING,
+    WHITE_PAWN, WHITE_ROOK, WHITE_KNIGHT, WHITE_BISHOP, WHITE_QUEEN, WHITE_KING
+}

src/main/java/domain/game/TeamColor.java

@@ -0,0 +1,27 @@
+package domain.game;
+
+import java.util.Set;
+
+import static domain.game.PieceType.*;
+
+public enum TeamColor {
+    BLACK(Set.of(BLACK_KING, BLACK_QUEEN, BLACK_ROOK, BLACK_KNIGHT, BLACK_BISHOP, BLACK_PAWN)),
+    WHITE(Set.of(WHITE_KING, WHITE_QUEEN, WHITE_ROOK, WHITE_KNIGHT, WHITE_BISHOP, WHITE_PAWN));
+
+    private final Set<PieceType> includedPieces;
+
+    TeamColor(Set<PieceType> includedPieces) {
+        this.includedPieces = includedPieces;
+    }
+
+    public boolean contains(PieceType pieceType) {
+        return includedPieces.contains(pieceType);
+    }
+
+    public TeamColor toggle() {
+        if (this == BLACK) {
+            return WHITE;
+        }
+        return BLACK;
+    }
+}