폴로 체스

.gitignore

@@ -30,3 +30,7 @@ out/
 
 ### VS Code ###
 .vscode/
+
+### docker ###
+/docker/db/mysql/config
+/docker/db/mysql/data

README.md

@@ -5,3 +5,41 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## ✨ 기능 구현 목록
+- [x] 체스보드를 만든다.
+  - [x] 체스보드는 8 * 8 구성되어있다.
+  - [x] 세로는 숫자로(1~8), 가로는 알파벳(a~h)
+
+
+- [x] 게임 시작및 종료 명령어를 입력 받는다.
+  - [x] start 는 시작
+  - [x] end 는 종료
+  - [x] move 는 말의 이동시킨다
+
+
+- [x] 기물(Piece)를 배치한다.
+  - [x] 검은색은 대문자로, 흰색은 소문자로 표기한다.
+
+
+- [x] 말을 이동시킨다.
+  - [x] 각진영은 자신의 차례에만 말을 움직일 수 있다.
+  - [x] 비숍은 대각선 방향으로만 움직인다.
+  - [x] 룩은 직선방향으로만 움직인다.
+  - [x] 퀸은 직선과 대각선 방향 모두 움직인다.
+  - [x] 위 세개의 기물은 움직이는 경로에 다른 기물이 잇으면 움직일 수 없다.
+  - [x] 나이트는 대각선한칸, 직선한칸 움직인다.
+    - [x] 나이트는 경로에 있는 기물과 상관 없이 움직인다.
+  - [x] 킹은 상하좌우대각선 한칸씩 움직인다.
+  - [x] 위의 모든 기물은 도착지점에 같은 진영의말이 있은 경우 해당 지점으로 갈 수 없다.
+
+
+- [x] 폰을 이동시킨다.
+  - [x] 폰을 직진 시킨다.
+    - [x] 첫 움직임인 경우 두칸움직일 수 있다(더블스텝)
+      - [x] 두칸 움직이는 경우 경로에 다른 말이 있으면 갈수 없다.
+    - [x] 폰이 직진하는 경우 도착지점은 비어있어야 한다.
+  - [x] 폰이 대각선으로 한칸 이동한다.
+    - [x] 폰의 대각선 방향에 상대방의 기물이 있는 경우 상대방의 기물을 잡으며 이동할 수 있다.
+    - [x] 대각선 방향이 비어있으면 대각선 방향으로 이동할 수없다.
+  - [x] 폰은 자신의 진영 방향으로 움직일 수 없다. (후진 불가, 전진만 가능)

build.gradle

@@ -11,6 +11,7 @@ repositories {
 dependencies {
     testImplementation 'org.assertj:assertj-core:3.22.0'
     testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
+    runtimeOnly 'mysql:mysql-connector-java:8.0.28'
 }
 
 java {

docker/db/mysql/init/create_table.sql

@@ -0,0 +1,30 @@
+CREATE TABLE `room`
+(
+    `_id`         int PRIMARY KEY NOT NULL AUTO_INCREMENT,
+    `gameName`    varchar(10),
+    `currentTurn` varchar(5) default 'WHITE'
+)ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `moveHistory`
+(
+    `_id`           int PRIMARY KEY AUTO_INCREMENT,
+    `source`        varchar(2),
+    `target`        varchar(2),
+    `pieceOnTarget` varchar(6),
+    `r_id`          int
+);
+
+CREATE TABLE `board`
+(
+    `_id`    int PRIMARY KEY AUTO_INCREMENT,
+    `square` varchar(2),
+    `piece`  varchar(6),
+    `camp`   varchar(5),
+    `r_id`   int
+);
+
+ALTER TABLE `board`
+    ADD FOREIGN KEY (`r_id`) REFERENCES `room` (`_id`);
+
+ALTER TABLE `moveHistory`
+    ADD FOREIGN KEY (`r_id`) REFERENCES `room` (`_id`);

docker/docker-compose.yml

@@ -0,0 +1,19 @@
+version: "3.9"
+services:
+  db:
+    image: mysql:8.0.28
+    platform: linux/x86_64
+    restart: always
+    ports:
+      - "13306:3306"
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: chess
+      MYSQL_USER: user
+      MYSQL_PASSWORD: password
+      TZ: Asia/Seoul
+    volumes:
+      - ./db/mysql/data:/var/lib/mysql
+      - ./db/mysql/config:/etc/mysql/conf.d
+      - ./db/mysql/init:/docker-entrypoint-initdb.d
+

src/main/java/Application.java

@@ -0,0 +1,20 @@
+import controller.Controller;
+import repository.connector.ProdConnector;
+import repository.game.GameDao;
+import repository.game.JdbcGameDao;
+import repository.room.JdbcRoomDao;
+import repository.room.RoomDao;
+import service.ChessService;
+import service.GameRoomService;
+
+public class Application {
+    public static void main(String[] args) {
+        RoomDao roomDao = new JdbcRoomDao(new ProdConnector());
+        GameRoomService gameRoomService = new GameRoomService(roomDao);
+
+        GameDao gameDao = new JdbcGameDao(new ProdConnector());
+        ChessService chessService = new ChessService(gameDao);
+
+        new Controller(gameRoomService, chessService).run();
+    }
+}

src/main/java/controller/Controller.java

@@ -0,0 +1,161 @@
+package controller;
+
+import static controller.game.Command.CANCEL;
+import static controller.game.Command.COMMAND_INDEX;
+import static controller.game.Command.CURRENT_SQUARE_INDEX;
+import static controller.game.Command.EMPTY;
+import static controller.game.Command.END;
+import static controller.game.Command.MOVE;
+import static controller.game.Command.MOVE_COMMAND_LENGTH;
+import static controller.game.Command.STANDARD_COMMAND_LENGTH;
+import static controller.game.Command.START;
+import static controller.game.Command.STATUS;
+import static controller.game.Command.TARGET_SQUARE_INDEX;
+import static controller.room.GameRoomCommand.CREATE;
+import static controller.room.GameRoomCommand.EXIT;
+import static controller.room.GameRoomCommand.JOIN;
+import static controller.room.GameRoomCommand.LIST;
+import static controller.room.GameRoomCommand.SPECIAL_ROOM_COMMAND_LENGTH;
+import static controller.room.GameRoomCommand.STANDARD_ROOM_COMMAND_LENGTH;
+import static controller.room.GameRoomCommand.validateCommandLength;
+
+import java.util.EnumMap;
+import java.util.List;
+
+import controller.game.Action;
+import controller.game.Command;
+import controller.room.GameRoomAction;
+import controller.room.GameRoomCommand;
+import dto.GameInfoDto;
+import dto.ScoreDto;
+import service.ChessService;
+import service.GameRoomService;
+import view.InputView;
+import view.OutputView;
+
+public class Controller {
+    private final GameRoomService gameRoomService;
+    private final ChessService chessService;
+    private final EnumMap<GameRoomCommand, GameRoomAction> gameRoomActions = new EnumMap<>(GameRoomCommand.class);
+    private final EnumMap<Command, Action> actions = new EnumMap<>(Command.class);
+
+    public Controller(GameRoomService gameRoomService, ChessService chessService) {
+        this.gameRoomService = gameRoomService;
+        this.chessService = chessService;
+        gameRoomActions.put(CREATE, this::createGameRoom);
+        gameRoomActions.put(LIST, this::readGameRooms);
+        gameRoomActions.put(EXIT, this::exitGame);
+        gameRoomActions.put(JOIN, this::joinGame);
+        actions.put(START, this::start);
+        actions.put(MOVE, this::move);
+        actions.put(END, this::end);
+        actions.put(STATUS, this::status);
+        actions.put(CANCEL, this::cancelMove);
+    }
+
+    public void run() {
+        GameRoomCommand gameRoomCommand = GameRoomCommand.NONE;
+        while (gameRoomCommand != EXIT) {
+            gameRoomCommand = runByGameRooAction();
+        }
+    }
+
+    private GameRoomCommand runByGameRooAction() {
+        try {
+            GameRoomCommand gameRoomCommand;
+            OutputView.printGameRoomInfo();
+            List<String> inputs = InputView.requestCommand();
+            gameRoomCommand = GameRoomCommand.find(inputs.get(0));
+            GameRoomAction gameRoomAction = gameRoomActions.get(gameRoomCommand);
+            gameRoomAction.execute(inputs);
+            return gameRoomCommand;
+        } catch (IllegalArgumentException e) {
+            OutputView.printErrorMessage(e);
+            return GameRoomCommand.NONE;
+        }
+    }
+
+    private void createGameRoom(List<String> inputs) {
+        validateCommandLength(inputs.size(), SPECIAL_ROOM_COMMAND_LENGTH);
+        gameRoomService.createGameRoom(inputs.get(1));
+    }
+
+    private void joinGame(List<String> inputs) {
+        validateCommandLength(inputs.size(), SPECIAL_ROOM_COMMAND_LENGTH);
+        String gameName = inputs.get(1);
+        long roomId = gameRoomService.findRoomIdByRoomName(gameName);
+        gameStart(roomId);
+    }
+
+    private void readGameRooms(List<String> inputs) {
+        validateCommandLength(inputs.size(), STANDARD_ROOM_COMMAND_LENGTH);
+        List<String> gameRooms = gameRoomService.readGameRooms();
+        OutputView.printGameRooms(gameRooms);
+    }
+
+    private void exitGame(List<String> inputs) {
+        validateCommandLength(inputs.size(), STANDARD_ROOM_COMMAND_LENGTH);
+    }
+
+    public void gameStart(long roomId) {
+        GameInfoDto gameInfo = chessService.getGameInfo(roomId);
+        OutputView.printIsSavedGame(gameInfo.getBoardDtos().size());
+        chessService.setUp(gameInfo);
+        OutputView.printChessBoard(chessService.getChessBoard());
+        OutputView.printChessInfo();
+        Command command = START;
+        while (command != END) {
+            command = play(roomId);
+        }
+        chessService.end(roomId);
+    }
+
+    private Command play(long roomId) {
+        try {
+            List<String> inputs = InputView.requestCommand();
+            Command command = Command.find(inputs.get(COMMAND_INDEX));
+            Action action = actions.get(command);
+            action.execute(roomId, inputs);
+            return refreshCommandByResult(command);
+        } catch (IllegalArgumentException | IllegalStateException e) {
+            OutputView.printErrorMessage(e);
+            return EMPTY;
+        }
+    }
+
+    private Command refreshCommandByResult(Command command) {
+        if (chessService.isFinished()) {
+            return END;
+        }
+        return command;
+    }
+
+    private void start(long ignored, List<String> inputs) {
+        Command.validateCommandLength(inputs.size(), STANDARD_COMMAND_LENGTH);
+        OutputView.printChessBoard(chessService.getChessBoard());
+    }
+
+    private void move(long roomId, List<String> inputs) {
+        Command.validateCommandLength(inputs.size(), MOVE_COMMAND_LENGTH);
+        String currentSquareInput = inputs.get(CURRENT_SQUARE_INDEX);
+        String targetSquareInput = inputs.get(TARGET_SQUARE_INDEX);
+        chessService.move(roomId, currentSquareInput, targetSquareInput);
+        OutputView.printChessBoard(chessService.getChessBoard());
+    }
+
+    private void status(long ignored, List<String> inputs) {
+        Command.validateCommandLength(inputs.size(), STANDARD_COMMAND_LENGTH);
+        List<ScoreDto> scoreDto = chessService.calculateFinalScore();
+        OutputView.printScores(scoreDto);
+    }
+
+    private void end(long ignored, List<String> inputs) {
+        Command.validateCommandLength(inputs.size(), STANDARD_COMMAND_LENGTH);
+    }
+
+    private void cancelMove(long gameId, List<String> inputs) {
+        Command.validateCommandLength(inputs.size(), STANDARD_COMMAND_LENGTH);
+        chessService.cancelMove(gameId);
+        OutputView.printChessBoard(chessService.getChessBoard());
+    }
+}

src/main/java/controller/game/Action.java

@@ -0,0 +1,8 @@
+package controller.game;
+
+import java.util.List;
+
+@FunctionalInterface
+public interface Action {
+    void execute(long gameId, List<String> inputs);
+}

src/main/java/controller/game/Command.java

@@ -0,0 +1,40 @@
+package controller.game;
+
+import java.util.Arrays;
+
+public enum Command {
+    START("start"),
+    END("end"),
+    MOVE("move"),
+    STATUS("status"),
+    CANCEL("cancel"),
+    EMPTY("");
+
+    public static final int COMMAND_INDEX = 0;
+    public static final int CURRENT_SQUARE_INDEX = 1;
+    public static final int TARGET_SQUARE_INDEX = 2;
+    public static final int STANDARD_COMMAND_LENGTH = 1;
+    public static final int MOVE_COMMAND_LENGTH = 3;
+    public static final String COMMAND_ERROR_MESSAGE = "입력이 올바르지 않습니다.";
+
+
+    private final String value;
+
+    Command(String value) {
+        this.value = value;
+    }
+
+
+    public static Command find(String command) {
+        return Arrays.stream(Command.values())
+                .filter(runCommand -> runCommand.value.equals(command))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("잘못된 명령입니다."));
+    }
+
+    public static void validateCommandLength(int given, int expected) {
+        if (given != expected) {
+            throw new IllegalArgumentException(COMMAND_ERROR_MESSAGE);
+        }
+    }
+}

src/main/java/controller/room/GameRoomAction.java

@@ -0,0 +1,8 @@
+package controller.room;
+
+import java.util.List;
+
+@FunctionalInterface
+public interface GameRoomAction {
+    void execute(List<String> inputs);
+}

src/main/java/controller/room/GameRoomCommand.java

@@ -0,0 +1,29 @@
+package controller.room;
+
+import java.util.Arrays;
+
+public enum GameRoomCommand {
+    LIST,
+    CREATE,
+    EXIT,
+    JOIN,
+    NONE;
+
+    public static final int STANDARD_ROOM_COMMAND_LENGTH = 1;
+    public static final int SPECIAL_ROOM_COMMAND_LENGTH = 2;
+    public static final String ROOM_COMMAND_ERROR_MESSAGE = "입력이 올바르지 않습니다.";
+
+    public static GameRoomCommand find(String command) {
+        return Arrays.stream(GameRoomCommand.values())
+                .filter(gameRoomCommand -> !gameRoomCommand.equals(NONE))
+                .filter(gameRoomCommand -> gameRoomCommand.name().equals(command))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("올바른 입력이 아닙니다."));
+    }
+
+    public static void validateCommandLength(int given, int expected) {
+        if (given != expected) {
+            throw new IllegalArgumentException(ROOM_COMMAND_ERROR_MESSAGE);
+        }
+    }
+}