[1,2,3단계 - 체스] 현구막(최현구) 미션 제출합니다.

README.md

@@ -1,2 +1,64 @@
 # java-chess
 체스 게임 구현을 위한 저장소
+
+<br>
+
+## 리팩토링 구상 목록
+- ~~Board를 출력을 위해 좌표를 정렬해둔 객체로만 사용하고, Piece들의 일급 컬렉션을~~
+- List<Map<Position, Piece>> 로 이루어진 Board의 부분을 컬렉션 객체로 감싸기 (Rank)
+
+<br>
+
+## 기능 목록
+
+- [x] 체스판을 초기화한다.
+    - [x] 체스판의 x, y 좌표를 나눈다.
+    - [x] 좌표를 캐싱한다.
+    - [x] 좌표를 감싼 체스판을 만든다.
+    - [x] 체스말을 만든다.
+        - [x] 폰을 만든다.
+            - [x] 폰의 이동로직 '수직 한 칸'
+            - [x] 폰의 초기 이동로직 '수직 두 칸'
+        - [x] 룩을 만든다.
+            - [x] 룩의 이동로직 '수직수평 무한'
+        - [x] 나이트를 만든다.
+            - [x] 나이트의 이동로직 '수직수평 두 칸 후 대각선 한 칸'
+        - [x] 비숍을 만든다.
+            - [x] 비숍의 이동로직 '대각선 무한'
+        - [x] 퀸을 만든다.
+            - [x] 퀸의 이동로직 '수직수평 대각선 무한'
+        - [x] 킹을 만든다.
+            - [x] 킹의 이동로직 '수직수평 대각선 한 칸'
+        - [x] 좌표를 채우기 위한 빈말
+    - [x] 체스말들을 체스판 좌표에 배치시킨다.
+- [x] 체스말을 이동시킨다.
+    - [x] source 좌표에 체스말이 존재하는지 확인한다.
+        - 좌표가 체스판에 존재하는지
+        - Empty 체스말을 둔 경우, 유효한 체스말인지 확인
+        - [x] 체스말이 없는 빈 좌표인 경우... (이동불가)
+        - [x] 적군 체스말이 존재하는 경우...  (이동불가)
+        - [x] 체스판을 벗어나는 좌표인 경우...(이동불가)
+        - [x] 아군 체스말이 존재하는 경우... (이동가능 + target 좌표 검사 진행)
+            - [x] target 좌표에 체스말이 존재하는지 확인한다.
+                - [x] 아군 체스말이 존재하는 경우... (이동불가)
+                - [x] 체스판을 벗어나는 좌표인 경우...(이동불가)
+                - [x] 체스말이 없는 빈 좌표인 경우... (이동가능)
+                - [x] 적군 체스말이 존재하는 경우...  (이동가능 + 적군 체스말을 제거하는 추가동작)
+                    - 1. 내가 잡아먹은 체스 말이 '킹'인지 검사하는 방법
+                    - 2. 현재 체스판에 '킹'이 2개 존재하는지 검사하는 방법
+- [x] 승패 및 점수를 계산한다
+    - [x] 'end' 가 입력되는 경우 게임을 종료한다.
+    - [x] 킹이 잡히는 경우 게임을 종료한다.
+    - [x] 체스판에 남아있는 체스말의 점수를 총합한다
+        - [x] 폰은 1점으로 계산한다.
+        - [x] 같은 색의 폰이 세로줄에 있는 경우 해당 폰들의 점수를 0.5로 계산한다.
+        - [x] 룩은 5점으로 계산한다.
+        - [x] 나이트는 2.5점으로 계산한다.
+        - [x] 비숍은 3점으로 계산한다.
+        - [x] 퀸은 9점으로 계산한다.
+        - [x] 킹은 0점으로 계산한다.
+
+<br>
+
+## 질문 목록
+- ~~InitBoardGenerator의 역할을 InitPieces에 통합하는게 어떤지?~~

src/main/java/chess/WebUIChessApplication.java

@@ -1,19 +1,19 @@
 package chess;
 
+import chess.controller.ChessController;
+import java.util.Map;
 import spark.ModelAndView;
 import spark.template.handlebars.HandlebarsTemplateEngine;
 
-import java.util.HashMap;
-import java.util.Map;
-
-import static spark.Spark.get;
-
 public class WebUIChessApplication {
+
     public static void main(String[] args) {
-        get("/", (req, res) -> {
-            Map<String, Object> model = new HashMap<>();
-            return render(model, "index.html");
-        });
+//        get("/", (req, res) -> {
+//            Map<String, Object> model = new HashMap<>();
+//            return render(model, "index.html");
+//        });
+        ChessController chessController = new ChessController();
+        chessController.run();
     }
 
     private static String render(Map<String, Object> model, String templatePath) {

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

@@ -0,0 +1,67 @@
+package chess.controller;
+
+import chess.domain.board.Board;
+import chess.domain.command.Command;
+import chess.domain.command.Commands;
+import chess.domain.command.Status;
+import chess.domain.game.ChessGame;
+import chess.utils.DtoAssembler;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class ChessController {
+
+    public void run() {
+        ChessGame chessGame = new ChessGame(new Board());
+        OutputView.printCommandNotice();
+
+        while (chessGame.isNotEnd()) {
+            chessGame = new ChessGame(new Board());
+            Commands commands = Commands.initCommands(chessGame);
+            readyChess(chessGame, commands);
+            runningChess(chessGame, commands);
+            finishedChess(chessGame, commands);
+        }
+    }
+
+    private void readyChess(ChessGame chessGame, Commands commands) {
+        OutputView.printRequestInputStart();
+        while (chessGame.isInit()) {
+            executeCommand(commands);
+        }
+    }
+
+    private void runningChess(ChessGame chessGame, Commands commands) {
+        OutputView.printChessStarted();
+        while (chessGame.isRunning()) {
+            OutputView.printChessBoard(DtoAssembler.board(chessGame.ranks()));
+            executeCommand(commands);
+        }
+    }
+
+    private void finishedChess(ChessGame chessGame, Commands commands) {
+        OutputView.printFinishWithReason(chessGame.winner());
+        while (chessGame.isFinished()) {
+            executeCommand(commands);
+        }
+    }
+
+    private void executeCommand(final Commands commands) {
+        try {
+            String input = InputView.command();
+            Command command = commands.matchedCommand(input);
+            command.execution(input);
+            printStatus(command);
+        } catch (IllegalStateException | IllegalArgumentException e) {
+            OutputView.printErrorException(e.getMessage());
+        }
+    }
+
+    private void printStatus(Command command) {
+        if (command.isStatus()) {
+            Status status = (Status) command;
+            OutputView.printWinner(status.winner());
+            OutputView.printScoreStatus(status.totalWhiteScore(), status.totalBlackScore());
+        }
+    }
+}

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

@@ -0,0 +1,74 @@
+package chess.domain.board;
+
+import chess.domain.board.position.InitPosition;
+import chess.domain.board.position.Position;
+import chess.domain.movestrategy.MoveStrategy;
+import chess.domain.piece.Empty;
+import chess.domain.piece.Piece;
+import java.util.List;
+import java.util.Set;
+
+public class Board {
+
+    public static final int BOTH_KINGS_ALIVE = 2;
+    public static final String INVALID_POSITION_MESSAGE = "유효하지 않은 좌표 입력입니다.";
+
+    private final List<Rank> ranks;
+
+    public Board() {
+        this(InitPosition.initRanks());
+    }
+
+    public Board(final List<Rank> ranks) {
+        this.ranks = ranks;
+    }
+
+    public List<Rank> ranks() {
+        return this.ranks;
+    }
+
+    public Piece pieceByPosition(Position position) {
+        return this.ranks.stream()
+            .filter(rank -> rank.hasPosition(position))
+            .map(map -> map.piece(position))
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException(INVALID_POSITION_MESSAGE));
+    }
+
+    public boolean isAliveBothKings() {
+        return this.ranks.stream()
+            .flatMap(rank -> rank.pieces().stream())
+            .filter(Piece::isKing)
+            .count() == BOTH_KINGS_ALIVE;
+    }
+
+    public void moveIfValidPosition(Position source, Position target) {
+        if (isInvalidPosition(source, target)) {
+            throw new IllegalArgumentException(INVALID_POSITION_MESSAGE);
+        }
+
+        swapPieces(source, target);
+    }
+
+    private boolean isInvalidPosition(Position source, Position target) {
+        Piece piece = pieceByPosition(source);
+        MoveStrategy moveStrategy = piece.moveStrategy();
+        Set<Position> movablePath = moveStrategy.moveStrategy(this, source);
+        return !movablePath.contains(target);
+    }
+
+    private void swapPieces(Position source, Position target) {
+        Piece sourcePiece = pieceByPosition(source);
+        replacePiece(source, Empty.create());
+        replacePiece(target, sourcePiece);
+    }
+
+    private void replacePiece(Position position, Piece piece) {
+        Rank foundRank = this.ranks.stream()
+            .filter(rank -> rank.hasPosition(position))
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException(INVALID_POSITION_MESSAGE));
+
+        foundRank.replacePiece(position, piece);
+    }
+}

src/main/java/chess/domain/board/Rank.java

@@ -0,0 +1,36 @@
+package chess.domain.board;
+
+import chess.domain.board.position.Position;
+import chess.domain.piece.Piece;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Rank {
+
+    private final Map<Position, Piece> squares;
+
+    public Rank(final Map<Position, Piece> squares) {
+        this.squares = squares;
+    }
+
+    public boolean hasPosition(final Position position) {
+        return this.squares.containsKey(position);
+    }
+
+    public void replacePiece(final Position position, final Piece piece) {
+        this.squares.replace(position, piece);
+    }
+
+    public Piece piece(Position position) {
+        return this.squares.get(position);
+    }
+
+    public List<Piece> pieces() {
+        return new ArrayList<>(this.squares.values());
+    }
+
+    public Map<Position, Piece> squares() {
+        return this.squares;
+    }
+}

src/main/java/chess/domain/board/position/InitPosition.java

@@ -0,0 +1,70 @@
+package chess.domain.board.position;
+
+import chess.domain.board.Rank;
+import chess.domain.piece.Bishop;
+import chess.domain.piece.Empty;
+import chess.domain.piece.King;
+import chess.domain.piece.Knight;
+import chess.domain.piece.Pawn;
+import chess.domain.piece.Piece;
+import chess.domain.piece.Queen;
+import chess.domain.piece.Rook;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public enum InitPosition {
+    BLACK_ROOK(Xpoint.getRookPoints(), Ypoint.getBlackPoint(), Rook.createBlack()),
+    WHITE_ROOK(Xpoint.getRookPoints(), Ypoint.getWhitePoint(), Rook.createWhite()),
+    BLACK_KNIGHT(Xpoint.getKnightPoints(), Ypoint.getBlackPoint(), Knight.createBlack()),
+    WHITE_KNIGHT(Xpoint.getKnightPoints(), Ypoint.getWhitePoint(), Knight.createWhite()),
+    BLACK_BISHOP(Xpoint.getBishopPoints(), Ypoint.getBlackPoint(), Bishop.createBlack()),
+    WHITE_BISHOP(Xpoint.getBishopPoints(), Ypoint.getWhitePoint(), Bishop.createWhite()),
+    BLACK_QUEEN(Xpoint.getQueenPoint(), Ypoint.getBlackPoint(), Queen.createBlack()),
+    WHITE_QUEEN(Xpoint.getQueenPoint(), Ypoint.getWhitePoint(), Queen.createWhite()),
+    BLACK_KING(Xpoint.getKingPoint(), Ypoint.getBlackPoint(), King.createBlack()),
+    WHITE_KING(Xpoint.getKingPoint(), Ypoint.getWhitePoint(), King.createWhite()),
+    BLACK_PAWN(Xpoint.getPawnOrEmptyPoints(), Ypoint.getBlackPawnPoint(), Pawn.createBlack()),
+    WHITE_PAWN(Xpoint.getPawnOrEmptyPoints(), Ypoint.getWhitePawnPoint(), Pawn.createWhite()),
+    EMPTY_PIECE(Xpoint.getPawnOrEmptyPoints(), Ypoint.getEmptyPoints(), Empty.create());
+
+    private final List<Xpoint> xPoints;
+    private final List<Ypoint> yPoints;
+    private final Piece piece;
+
+    InitPosition(final List<Xpoint> xPoints, final List<Ypoint> yPoints, final Piece piece) {
+        this.xPoints = xPoints;
+        this.yPoints = yPoints;
+        this.piece = piece;
+    }
+
+    public static List<Rank> initRanks() {
+        List<Rank> ranks = new ArrayList<>();
+        for (Ypoint ypoint : Ypoint.values()) {
+            ranks.add(initRank(ypoint));
+        }
+        return ranks;
+    }
+
+    private static Rank initRank(final Ypoint ypoint) {
+        Map<Position, Piece> line = new LinkedHashMap<>();
+        for (Xpoint xpoint : Xpoint.values()) {
+            line.put(Position.of(xpoint, ypoint), InitPosition.findPiece(xpoint, ypoint));
+        }
+        return new Rank(line);
+    }
+
+    private static Piece findPiece(final Xpoint xpoint, final Ypoint ypoint) {
+        return Arrays.stream(values())
+            .filter(p -> p.containsXY(xpoint, ypoint))
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException("해당좌표의 체스말을 찾지 못했습니다."))
+            .piece;
+    }
+
+    private boolean containsXY(final Xpoint xpoint, final Ypoint ypoint) {
+        return this.xPoints.contains(xpoint) && this.yPoints.contains(ypoint);
+    }
+}