[체스 - 3, 4 단계] 재즈(함석명) 미션 제출합니다.

README.md

@@ -5,3 +5,56 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+
+# 기능 구현 목록
+
+## 체스 게임
+- [X] : 체스 게임 시작 문구를 출력한다.
+- [X] : 사용자는 체스 게임 방을 생성할 수 있다.
+- [X] : 체스 게임 방 목록중 원하는 방을 선택해서 게임을 시작할 수 있다.
+- [X] : 시작 명령어를 입력 받는다.
+  - [X] : 명령어 형식이 올바르지 않으면 예외를 터트리고 재입력 받는다.
+  - [X] : start 입력 시 게임을 시작한다.
+  - [X] : end 입력 시 게임을 종료한다.
+  - [X] : status 입력 시 각 팀의 점수와 어느 팀이 우세한지 출력한다.
+  - [X] : move 명령어를 통해 기물을 움직일 수 있다.
+- [X] : 보드판을 초기화한다.
+  - [X] : 소문자, 대문자로 팀을 구분한다.
+  - [X] : 각 팀은 총 16개의 말을 갖는다.
+    - [X] : 폰 8개, 룩 2개, 나이트 2개, 비숍 2개, 퀸 1개, 킹 1개
+- [X] : 왕이 잡히면 게임이 종료되고 게임 결과를 출력한다.
+
+
+## 체스 기물
+### 방향
+  - [X] : 북, 북동, 동, 동남, 남, 남서, 서, 북서쪽의 총 8방향을 갖는다. 
+  - [X] : 방향에 따라 방향 가중치 (1, -1, 0)을 갖는다.
+
+### 위치
+  - [X] : 행, 열 enum을 갖는다.
+  - [X] : 현재 위치를 기준으로 방향에 따른 최대 가중치를 계산한다.
+  - [X] : 기물이 고유로 갖는 이동 방향과 가중치를 이용하여 이동할 수 있는 위치들을 반환한다.
+
+### 기물
+  - [X] : 기물은 기물 타입을 갖는다.
+  - [X] : 기물은 팀 색깔을 갖는다.
+
+### 기물 타입
+  - [X] : 기물 타입은 이동 전략을 갖는다.
+  - [X] : 각 기물의 이동 전략 구현체는 기물의 현재 위치, 방향, 가중치를 가지고 이동할 수 있는 후보 위치들을 계산한다.
+    - [X] : 룩은 기본적으로 북, 동, 남, 서 방향으로 이동할 수 있다.
+    - [X] : 비숍은 기본적으로 북동, 동남, 남서, 북서 방향으로 이동할 수 있다.
+    - [X] : 퀸은 기본적으로 모든 방향으로 이동할 수 있다.
+    - [X] : 킹은 기본적으로 모든 방향으로 이동할 수 있다.
+    - [X] : 폰은 기본적으로 팀 색깔에 따라 북 또는 남 방향으로만 이동할 수 있다.
+    - [X] : 나이트는 기본적으로 북북동, 동북동, 동남동, 남남동, 남남서, 서남서, 서북서, 북북서 방향으로 이동할 수 있다.
+
+## 기물 이동
+ - [X] : 각 기물이 생성한 후보 위치를 이용하여 실제 이동 가능한 위치인지 판단한다.
+    - [X] : 위치에 기물이 존재하지 않으면 이동 가능한 위치이므로 포함한다.
+    - [X] : 위치에 우리팀 기물이 존재할 경우 이동할 수 없는 위치이므로 포함하지 않고 다음 방향으로 넘어간다.
+    - [X] : 위치에 상대팀 기물이 존재할 경우 이동가능한 위치이므로 포함하고 다음 방향으로 넘어간다.
+ - [X] : 명령어 입력으로 들어온 목적지 위치가 실제 이동 가능한 위치인지 판단한다.
+    - [X] : 실제 이동 가능한 위치에 포함되어 있는 경우 이동한다.
+    - [X] : 실제 이동 가능한 위치에 포함되어 있지 않은 경우 에러를 발생시킨다.

build.gradle

@@ -13,6 +13,8 @@ dependencies {
     testImplementation platform('org.assertj:assertj-bom:3.25.1')
     testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation('org.assertj:assertj-core')
+
+    runtimeOnly("com.mysql:mysql-connector-j:8.3.0")
 }
 
 java {

src/main/java/chess/Application.java

@@ -0,0 +1,21 @@
+package chess;
+
+import chess.controller.ChessGameController;
+import chess.repository.BoardRepository;
+import chess.repository.BoardRepositoryImpl;
+import chess.repository.RoomRepository;
+import chess.repository.RoomRepositoryImpl;
+import chess.service.BoardService;
+import chess.service.GameService;
+
+public class Application {
+    public static void main(String[] args) {
+        RoomRepository roomRepository = new RoomRepositoryImpl();
+        BoardRepository boardRepository = new BoardRepositoryImpl();
+
+        GameService gameService = new GameService(roomRepository, boardRepository);
+        BoardService boardService = new BoardService(roomRepository, boardRepository);
+        ChessGameController chessGameController = new ChessGameController(gameService, boardService);
+        chessGameController.run();
+    }
+}

src/main/java/chess/controller/ChessGameController.java

@@ -0,0 +1,54 @@
+package chess.controller;
+
+import chess.controller.command.Command;
+import chess.controller.command.CommandRouter;
+import chess.domain.game.Room;
+import chess.service.BoardService;
+import chess.service.GameService;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class ChessGameController {
+
+    private final GameService gameService;
+    private final BoardService boardService;
+
+    public ChessGameController(GameService gameService, BoardService boardService) {
+        this.gameService = gameService;
+        this.boardService = boardService;
+    }
+
+    public void run() {
+        OutputView.printRoomNames(gameService.findAllRoomNames());
+        Room room = createRoom();
+        OutputView.printStartMessage(room.getName());
+        process(gameService, boardService, room.getId());
+    }
+
+    private Room createRoom() {
+        try {
+            String input = InputView.readRoomName();
+            return gameService.loadRoom(input);
+        } catch (RuntimeException error) {
+            OutputView.printError(error);
+            return createRoom();
+        }
+    }
+
+    private void process(GameService gameService, BoardService boardService, Long roomId) {
+        State state = State.RUNNING;
+        do {
+            state = executeCommand(gameService, boardService, state, roomId);
+        } while (state != State.END);
+    }
+
+    private State executeCommand(GameService gameService, BoardService boardService, State state, Long roomId) {
+        try {
+            Command command = CommandRouter.findCommendByInput(InputView.readCommend());
+            return command.execute(gameService, boardService, roomId);
+        } catch (RuntimeException error) {
+            OutputView.printError(error);
+            return state;
+        }
+    }
+}

src/main/java/chess/controller/State.java

@@ -0,0 +1,7 @@
+package chess.controller;
+
+public enum State {
+
+    RUNNING,
+    END
+}

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

@@ -0,0 +1,10 @@
+package chess.controller.command;
+
+import chess.controller.State;
+import chess.service.BoardService;
+import chess.service.GameService;
+
+public interface Command {
+
+    State execute(GameService gameService, BoardService boardService, Long roomId);
+}

src/main/java/chess/controller/command/CommandRouter.java

@@ -0,0 +1,34 @@
+package chess.controller.command;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+
+public enum CommandRouter {
+    START("start", Start::new),
+    END("end", End::new),
+    MOVE("move", Move::new),
+    STATUS("status", Status::new);
+
+    private static final int COMMAND_INDEX = 0;
+
+    private final String value;
+    private final Function<List<String>, Command> command;
+
+    CommandRouter(String value,
+                  Function<List<String>, Command> command) {
+        this.value = value;
+        this.command = command;
+    }
+
+    public static Command findCommendByInput(List<String> commandInput) {
+        if (commandInput == null || commandInput.size() == 0) {
+            throw new IllegalArgumentException("빈 값 입력을 허용하지 않습니다.");
+        }
+        return Arrays.stream(values())
+                .filter(commandRouter -> commandRouter.value.equals(commandInput.get(COMMAND_INDEX)))
+                .map(commandRouter -> commandRouter.command.apply(commandInput))
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("올바르지 않은 명령어 입력입니다."));
+    }
+}

src/main/java/chess/controller/command/End.java

@@ -0,0 +1,22 @@
+package chess.controller.command;
+
+import chess.controller.State;
+import chess.service.BoardService;
+import chess.service.GameService;
+import java.util.List;
+
+public class End implements Command {
+
+    private static final int END_COMMAND_SIZE = 1;
+
+    public End(List<String> commandInput) {
+        if (commandInput.size() != END_COMMAND_SIZE) {
+            throw new IllegalArgumentException("게임 종료 명령어 입력 형식이 올바르지 않습니다.");
+        }
+    }
+
+    @Override
+    public State execute(GameService gameService, BoardService boardService, Long roomId) {
+        return State.END;
+    }
+}

src/main/java/chess/controller/command/Move.java

@@ -0,0 +1,61 @@
+package chess.controller.command;
+
+import chess.controller.State;
+import chess.domain.board.position.Column;
+import chess.domain.board.position.Position;
+import chess.domain.board.position.Row;
+import chess.service.BoardService;
+import chess.service.GameService;
+import chess.service.dto.ChessGameResult;
+import chess.view.OutputView;
+import chess.view.mapper.ColumnMapper;
+import chess.view.mapper.RowMapper;
+import java.util.List;
+import java.util.regex.Pattern;
+
+public class Move implements Command {
+
+    private static final Pattern POSITION_REGEX = Pattern.compile(""
+            + "move\\s+([a-h][1-8])\\s+([a-h][1-8])");
+
+    private final Position from;
+    private final Position to;
+
+    public Move(List<String> commandInput) {
+        validateMoveCommandPattern(commandInput);
+        String fromPosition = commandInput.get(1);
+        String toPosition = commandInput.get(2);
+        this.from = createPosition(fromPosition.substring(0, 1), fromPosition.substring(1, 2));
+        this.to = createPosition(toPosition.substring(0, 1), toPosition.substring(1, 2));
+    }
+
+    private void validateMoveCommandPattern(List<String> commandInput) {
+        String moveCommand = String.join(" ", commandInput);
+        if (!POSITION_REGEX.matcher(moveCommand).matches()) {
+            throw new IllegalArgumentException("게임 이동 명령어 입력 형식이 올바르지 않습니다.");
+        }
+    }
+
+    @Override
+    public State execute(GameService gameService, BoardService boardService, Long roomId) {
+        if (boardService.isCheckmate(to, roomId)) {
+            moveAndPrintBoard(gameService, boardService, roomId);
+            ChessGameResult chessGameResult = gameService.generateGameResult(roomId);
+            OutputView.printChessGameResult(chessGameResult);
+            return State.END;
+        }
+        moveAndPrintBoard(gameService, boardService, roomId);
+        return State.RUNNING;
+    }
+
+    private void moveAndPrintBoard(GameService gameService, BoardService boardService, Long roomId) {
+        boardService.movePiece(from, to, roomId);
+        OutputView.printBoard(boardService.getAllPieces(roomId));
+    }
+
+    private Position createPosition(String requestColumn, String requestRow) {
+        Column column = ColumnMapper.findByInputValue(requestColumn);
+        Row row = RowMapper.findByInputValue(requestRow);
+        return new Position(row, column);
+    }
+}

src/main/java/chess/controller/command/Start.java

@@ -0,0 +1,24 @@
+package chess.controller.command;
+
+import chess.controller.State;
+import chess.service.BoardService;
+import chess.service.GameService;
+import chess.view.OutputView;
+import java.util.List;
+
+public class Start implements Command {
+
+    private static final int END_COMMAND_SIZE = 1;
+
+    public Start(List<String> commandInput) {
+        if (commandInput.size() != END_COMMAND_SIZE) {
+            throw new IllegalArgumentException("게임 시작 명령어 입력 형식이 올바르지 않습니다.");
+        }
+    }
+
+    @Override
+    public State execute(GameService gameService, BoardService boardService, Long roomId) {
+        OutputView.printBoard(boardService.getAllPieces(roomId));
+        return State.RUNNING;
+    }
+}

src/main/java/chess/controller/command/Status.java

@@ -0,0 +1,24 @@
+package chess.controller.command;
+
+import chess.controller.State;
+import chess.service.BoardService;
+import chess.service.GameService;
+import chess.view.OutputView;
+import java.util.List;
+
+public class Status implements Command {
+
+    private static final int STATUS_COMMAND_SIZE = 1;
+
+    public Status(List<String> commandInput) {
+        if (commandInput.size() != STATUS_COMMAND_SIZE) {
+            throw new IllegalArgumentException("게임 점수 명령어 입력 형식이 올바르지 않습니다.");
+        }
+    }
+
+    @Override
+    public State execute(GameService gameService, BoardService boardService, Long roomId) {
+        OutputView.printTeamScore(gameService.generateGameResult(roomId));
+        return State.RUNNING;
+    }
+}

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

@@ -0,0 +1,56 @@
+package chess.domain.board;
+
+import chess.domain.board.position.Column;
+import chess.domain.board.position.Position;
+import chess.domain.board.position.Row;
+import chess.domain.piece.Color;
+import chess.domain.piece.Piece;
+import chess.domain.piece.PieceType;
+import java.util.HashMap;
+import java.util.Map;
+
+public class BoardFactory {
+
+    public Map<Position, Piece> initialize() {
+        Map<Position, Piece> map = new HashMap<>();
+        initializeBlackTeam(map);
+        initializeWhiteTeam(map);
+        return map;
+    }
+
+    private void initializeBlackTeam(Map<Position, Piece> map) {
+        initializePawn(map, Row.SEVEN, Color.BLACK);
+        initializeHighValuePiece(map, Row.EIGHT, Color.BLACK);
+    }
+
+    private void initializeWhiteTeam(Map<Position, Piece> map) {
+        initializePawn(map, Row.TWO, Color.WHITE);
+        initializeHighValuePiece(map, Row.ONE, Color.WHITE);
+    }
+
+    private void initializePawn(Map<Position, Piece> map, Row row, Color color) {
+        for (Column column : Column.values()) {
+            Position position = new Position(row, column);
+            if (color == Color.WHITE) {
+                map.put(position, new Piece(PieceType.WHITE_PAWN, color));
+            }
+            if (color == Color.BLACK) {
+                map.put(position, new Piece(PieceType.BLACK_PAWN, color));
+            }
+        }
+    }
+
+    private void initializeHighValuePiece(Map<Position, Piece> map, Row row, Color color) {
+        map.put(new Position(row, Column.A), new Piece(PieceType.ROOK, color));
+        map.put(new Position(row, Column.H), new Piece(PieceType.ROOK, color));
+
+        map.put(new Position(row, Column.B), new Piece(PieceType.KNIGHT, color));
+        map.put(new Position(row, Column.G), new Piece(PieceType.KNIGHT, color));
+
+        map.put(new Position(row, Column.C), new Piece(PieceType.BISHOP, color));
+        map.put(new Position(row, Column.F), new Piece(PieceType.BISHOP, color));
+
+        map.put(new Position(row, Column.D), new Piece(PieceType.QUEEN, color));
+        map.put(new Position(row, Column.E), new Piece(PieceType.KING, color));
+    }
+}