안뇽하쇼 DB잘 모르기 때문에 날카로운 지적부탁

README.md

@@ -1,7 +1,105 @@
 # java-chess
 
-체스 미션 저장소
+# 기능 목록
 
-## 우아한테크코스 코드리뷰
+# 🚀 도메인
+## Piece
+- [x] 진영을 가진다 (Color)
+- [x] 타입을 가진다 (PieceType)
+- [x] 종류별로 움직일 수 있는 방향을 가진다
+  - [x] 움직일 수 있는 방향인지 판단한다
+  - [x] 움직일 수 있는 거리인지 판단한다
 
-- [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+### 1) Rook
+- [x] 점수 : 5점
+- [x] 움직일 수 있는 방향 : N, E, S, W
+- [x] 움직일 수 있는 거리 : 상관 x
+
+### 2) Bishop
+- [x] 점수 : 3점
+- [x] 움직일 수 있는 방향 : NE, SE, SW, NW
+- [x] 움직일 수 있는 거리 : 상관 x
+
+### 3) Queen
+- [x] 점수 : 9점
+- [x] 움직일 수 있는 방향 : N, NE, E, SE, S, SW, W, NW
+- [x] 움직일 수 있는 거리 : 상관 x
+
+### 4) King
+- [x] 점수 : 0점
+- [x] 움직일 수 있는 방향 : N, NE, E, SE, S, SW, W, NW
+- [x] 움직일 수 있는 거리 : 1
+- [x] 잡히는 경우 경기가 끝난다
+
+### 5) Knight
+- [x] 점수 : 2.5점
+- [x] 움직일 수 있는 방향 : ENE, ESE, SSW, SSE, WNW, WSW, NNW, NNE
+- [x] 움직일 수 있는 거리 : 제곱의 합이 5 (ex. 2*2+1*1=5)
+- [x] 경로에 다른 기물이 있어도 이동할 수 있다
+
+### 6) Pawn
+- [x] 점수
+  - [x] 기본 점수 : 1점
+  - [x] 같은 세로줄에 같은 색의 폰이 있는 경우 : 0.5점
+- [x] 움직일 수 있는 방향
+  - [x] White 팀 : N, NE, NW
+  - [x] Black 팀 : S, SE, SW
+- [x] 움직일 수 있는 거리
+  - [x] 처음 움직임 : 1 또는 2
+  - [x] 그 외 : 1
+- [x] 대각선에 상대말이 있을 때에만 대각선으로 이동할 수 있다
+- [x] 단순 이동은 위아래만 가능하다
+
+### +) PieceFactory : 기본 세팅에 필요한 Piece들을 만든다
+### +) PieceType : Piece의 종류를 나타내는 enum
+
+## Position
+- [x] file과 rank로 이루어진다
+- [x] (A,1) ~ (H,8)
+- [x] 다른 Position으로의 방향을 계산한다
+- [x] 다른 Position으로의 거리를 계산한다
+- [x] 다른 방향으로 이동할 수 있다
+
+### +) Rank : 체스판의 가로줄을 나타내는 enum
+### +) File : 체스판의 세로줄을 나타내는 enum
+### +) Direction : 이동 방향을 나타내는 enum
+
+## Board
+- [x] 초기화한다 (기본 체스보드 세팅)
+- [x] 특정 Position에 있는 Piece를 반환한다
+- [x] 움직일 수 있는 Piece인지 확인한다
+  - [x] 빈 Piece인지
+  - [x] 같은 Color인지
+- [x] 이동경로 사이에 다른 Piece가 있는지 확인한다
+- [x] Piece를 교체한다
+- [x] Rank에 위치한 Piece들을 반환한다
+- [x] 각 진영의 점수를 계산한다
+
+## ChessGame
+- [x] 게임을 시작한다
+- [x] Piece를 움직인다
+  - [x] King이 잡혔는지 확인한다
+- [x] 각 진영의 점수를 반환한다
+- [x] 게임을 끝낸다
+
+### +) Color : Piece의 색을 나타내는 enum
+### +) GameStatus : 게임의 상태를 나타내는 enum
+
+## CommandLine
+- [x] 입력을 검증한다
+  - [x] start
+  - [x] move - 2개의 추가 인자를 가져야 한다
+  - [x] status
+  - [x] end
+- [x] 메인 명령 토큰을 제외한 나머지 인자들을 반환한다
+
+# 🖋 UI
+## 입력
+- [x] 명령을 입력받는다
+
+## 출력
+- [x] 게임시작 메시지를 출력한다
+- [x] 보드의 상태를 출력한다
+- [x] 각 팀의 현재 점수를 출력한다
+- [x] King이 잡혀 게임이 끝난 경우 우승자를 출력한다.
+- [x] 에러를 출력한다

build.gradle

@@ -9,11 +9,9 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.sparkjava:spark-core:2.9.3'
-    implementation 'com.sparkjava:spark-template-handlebars:2.7.1'
-    implementation 'ch.qos.logback:logback-classic:1.2.10'
     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 {

src/main/java/chess/Applictaion.java

@@ -0,0 +1,11 @@
+package chess;
+
+import chess.controller.ChessController;
+
+public class Applictaion {
+
+    public static void main(String[] args) {
+        ChessController chessController = new ChessController();
+        chessController.execute();
+    }
+}

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

@@ -0,0 +1,82 @@
+package chess.controller;
+
+import chess.dao.JdbcGameDao;
+import chess.dao.JdbcPieceDao;
+import chess.domain.ChessGame;
+import chess.domain.Color;
+import chess.dto.BoardDto;
+import chess.service.ChessService;
+import chess.view.InputView;
+import chess.view.OutputView;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+
+public class ChessController {
+    private final ChessService chessService;
+    private final Map<String, GameAction> commandMapper = new HashMap<>();
+
+    public ChessController() {
+        chessService = new ChessService(new JdbcGameDao(), new JdbcPieceDao());
+        commandMapper.put("start", (gameId, ignore, chessGame) -> start(gameId, chessGame));
+        commandMapper.put("move", (gameId, arguments, chessGame) -> move(gameId, chessGame, arguments));
+        commandMapper.put("status", (ignore1, ignore2, chessGame) -> status(chessGame));
+        commandMapper.put("end", (gameId, ignore, chessGame) -> end(gameId, chessGame));
+    }
+
+    public void execute() {
+        List<Integer> possibleGameIds = chessService.findPossibleGameIds();
+        List<Integer> impossibleGameIds = chessService.findImpossibleGameIds();
+        OutputView.printRoomState(possibleGameIds, impossibleGameIds);
+
+        int gameId = InputView.readGameId();
+        ChessGame chessGame = chessService.loadChessGame(gameId);
+
+        OutputView.printGameStartMessage(gameId);
+        OutputView.printBoard(BoardDto.create(chessGame.getBoard()));
+
+        while (!chessGame.isEnd() && !chessGame.isCatch()) {
+            runGame(gameId, chessGame);
+        }
+
+        if (chessGame.isCatch()) {
+            OutputView.printResultWhenKingCatch(chessGame.getTurn().reverse());
+            return;
+        }
+        showStatus(chessGame);
+    }
+
+    private void runGame(int gameId, ChessGame chessGame) {
+        try {
+            CommandLine commandLine = new CommandLine(InputView.readCommand());
+            commandMapper.get(commandLine.getCommand())
+                    .execute(gameId, commandLine.getArguments(), chessGame);
+        } catch (IllegalArgumentException | IllegalStateException | NoSuchElementException e) {
+            OutputView.printError(e.getMessage());
+        }
+    }
+
+    private void start(int gameId, ChessGame chessGame) {
+        chessService.start(gameId, chessGame);
+        OutputView.printBoard(BoardDto.create(chessGame.getBoard()));
+    }
+
+    private void move(int gameId, ChessGame chessGame, List<String> arguments) {
+        chessService.move(gameId, chessGame, arguments);
+        OutputView.printBoard(BoardDto.create(chessGame.getBoard()));
+    }
+
+    private void status(ChessGame chessGame) {
+        showStatus(chessGame);
+    }
+
+    private void end(int gameId, ChessGame chessGame) {
+        chessService.end(gameId, chessGame);
+    }
+
+    private void showStatus(ChessGame chessGame) {
+        Map<Color, Double> score = chessGame.status().getScore();
+        OutputView.printStatus(score.get(Color.WHITE), score.get(Color.BLACK));
+    }
+}

src/main/java/chess/controller/CommandLine.java

@@ -0,0 +1,48 @@
+package chess.controller;
+
+import java.util.List;
+
+public class CommandLine {
+
+    private static final String START = "start";
+    private static final String MOVE = "move";
+    private static final String STATUS = "status";
+    private static final String END = "end";
+    private static final int ZERO_ARGUMENT_SIZE = 1;
+    private static final int TWO_ARGUMENT_SIZE = 3;
+    private static final int SOURCE_INDEX = 1;
+    private static final int TARGET_INDEX = 3;
+    private static final int MAIN_COMMAND_INDEX = 0;
+    private static final List<String> VALID_COMMANDS = List.of(START, MOVE, END, STATUS);
+
+    private final List<String> tokens;
+
+    public CommandLine(final List<String> tokens) {
+        this.validate(tokens);
+        this.tokens = tokens;
+    }
+
+    private void validate(final List<String> tokens) {
+        String command = tokens.get(MAIN_COMMAND_INDEX);
+        if (!VALID_COMMANDS.contains(command)) {
+            throw new IllegalArgumentException("잘못된 명령어입니다.");
+        }
+        if (!command.equals(MOVE) && tokens.size() != ZERO_ARGUMENT_SIZE) {
+            throw new IllegalArgumentException(command + "는 인자를 입력할 수 없습니다.");
+        }
+        if (command.equals(MOVE) && tokens.size() != TWO_ARGUMENT_SIZE) {
+            throw new IllegalArgumentException(command + "는 인자를 2개만 가질 수 있습니다.");
+        }
+    }
+
+    public String getCommand() {
+        return this.tokens.get(MAIN_COMMAND_INDEX);
+    }
+
+    public List<String> getArguments() {
+        if (this.tokens.size() != TWO_ARGUMENT_SIZE) {
+            return List.of();
+        }
+        return this.tokens.subList(SOURCE_INDEX, TARGET_INDEX);
+    }
+}

src/main/java/chess/controller/GameAction.java

@@ -0,0 +1,9 @@
+package chess.controller;
+
+import chess.domain.ChessGame;
+import java.util.List;
+
+@FunctionalInterface
+public interface GameAction {
+    void execute(int gameId, List<String> arguments, ChessGame chessGame);
+}

src/main/java/chess/dao/ConnectionProvider.java

@@ -0,0 +1,23 @@
+package chess.dao;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+public class ConnectionProvider {
+    private static final String SERVER = "localhost:3306"; // MySQL 서버 주소
+    private static final String DATABASE = "chess"; // MySQL DATABASE 이름
+    private static final String OPTION = "?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true";
+    private static final String USERNAME = "username"; //  MySQL 서버 아이디
+    private static final String PASSWORD = "password"; // MySQL 서버 비밀번호
+
+    public static Connection getConnection() {
+        try {
+            return DriverManager.getConnection("jdbc:mysql://" + SERVER + "/" + DATABASE + OPTION, USERNAME, PASSWORD);
+        } catch (final SQLException e) {
+            System.err.println("DB 연결 오류:" + e.getMessage());
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

src/main/java/chess/dao/GameDao.java

@@ -0,0 +1,14 @@
+package chess.dao;
+
+import chess.dto.GameInfoDto;
+import java.util.List;
+
+public interface GameDao {
+    List<Integer> findAllPossibleId();
+    List<Integer> findAllImpossibleId();
+    GameInfoDto findById(int gameId);
+    void create(GameInfoDto gameInfoDto);
+    void updateById(GameInfoDto gameInfoDto);
+    void deleteById(int gameId);
+    void deleteAll();
+}