[3, 4단계 - 체스] 커찬(이충안) 미션 제출합니다.

.gitignore

@@ -30,7 +30,4 @@ out/
 
 ### VS Code ###
 .vscode/
-
 db/
-
-docker-compose.yml

README.md

@@ -1,14 +1,18 @@
 # java-chess
 
-## 페어와 지킬 컨벤션
-1. 클래스 정의 다음 줄은 공백으로 한다.
-2. test code에 사용하는 메서드는 `static import`한다.
-3. `this`는 같은 클래스의 객체가 파라미터로 넘어왔을 때, 파라미터 변수 명이 필드의 변수 명과 겹칠 때 사용한다.
+## 실행 방법
+1. [database](./database) 폴더로 이동한다.
+2. [docker-compose.yml](./database/docker-compose.yml)를 통하여 docker를 실행한다.
+3. [init.sql](./database/init.sql)의 명령어를 docker 내부에서 차례로 실행한다.
+4. IDE를 통해 ChessApplication를 실행한다.
 
 ## 기능 요구 사항
 
 ### 체스 말
 - [x] 무슨 팀인지 알려준다.
+- [x] 자신의 기물 점수를 알려준다.
+  - [x] queen 9점, rook 5점, bishop 3점, knight 2.5점, king 0점
+  - [x] pawn은 1점, 같은 세로줄에 같은 색의 폰이 있는 경우 0.5점
 
 ### 움직임
 - [x] 이동 가능한지 판단한다.
@@ -17,6 +21,9 @@
 ### 팀
 - [x] 흰색, 검은색을 구분한다.
 
+### 말 점수
+- [x] 말 점수를 서로 더할 수 있다.
+
 ### 체스 보드
 - [x] 체스 말 위치 초기화를 한다.
 - [x] 해당 위치에 어떤 말이 있는지 알려준다.
@@ -26,13 +33,20 @@
   - [x] 이동 경로에 다른 말이 있을 경우 예외
   - [x] 마지막 위치에 적 말이 있을 경우, 잡아먹는다.
   - [x] 흰색부터 번갈아가며 플레이한다.
-
+  - [x] 상대편 왕을 잡으면, 해당 팀의 게임 승리로 게임을 종료한다. 
+- [x] 현재 각 팀별 기물 점수를 구한다.
 
 ### 위치
 - [x] 가로 위치(왼쪽부터 a~h)를 저장한다.
 - [x] 세로 위치(아래부터 1~8)를 저장한다.
 - [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 {

database/docker-compose.yml

@@ -0,0 +1,18 @@
+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

database/init.sql

@@ -0,0 +1,16 @@
+CREATE DATABASE IF NOT EXISTS chess;
+
+USE chess;
+
+CREATE TABLE chess_game (
+    turn VARCHAR(10) CHECK (turn IN ('BLACK', 'WHITE')) not null,
+    PRIMARY KEY (turn)
+);
+
+CREATE TABLE pieces (
+    board_file VARCHAR(2) CHECK (board_file IN ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')) not null,
+    board_rank VARCHAR(2) CHECK (board_rank IN ('1', '2', '3', '4', '5', '6', '7', '8')) not null,
+    type VARCHAR(10) CHECK (type IN ('KING', 'QUEEN', 'ROOK', 'BISHOP', 'KNIGHT', 'PAWN', 'EMPTY')) not null,
+    team VARCHAR(10) CHECK (team IN ('BLACK', 'WHITE', 'EMPTY')) not null,
+    PRIMARY KEY (board_rank, board_file)
+);

src/main/java/chess/ChessApplication.java

@@ -1,19 +1,35 @@
 package chess;
 
+import chess.dao.ChessDao;
+import chess.dao.ChessGameRepository;
+import chess.dao.ConnectionManager;
+import chess.dao.MysqlChessGameRepository;
+import chess.dao.MysqlPieceRepository;
+import chess.dao.PieceRepository;
 import chess.view.InputView;
 import chess.view.OutputView;
 
 public class ChessApplication {
 
+    private static final InputView INPUT_VIEW = new InputView();
+    private static final OutputView OUTPUT_VIEW = new OutputView();
+
     public static void main(String[] args) {
-        InputView inputView = new InputView();
-        OutputView outputView = new OutputView();
-        ChessGame chessGame = new ChessGame(inputView, outputView);
+        ConnectionManager connectionManager = new ConnectionManager();
+        ChessGameRepository chessGameRepository = new MysqlChessGameRepository(connectionManager);
+        PieceRepository pieceRepository = new MysqlPieceRepository(connectionManager);
+        ChessDao chessDao = new ChessDao(chessGameRepository, pieceRepository);
+        ChessService chessService = new ChessService(chessDao);
+
+        ChessGame chessGame = new ChessGame(INPUT_VIEW, OUTPUT_VIEW, chessService);
+        run(chessGame);
+    }
 
+    private static void run(ChessGame chessGame) {
         try {
-            chessGame.start();
+            chessGame.run();
         } catch (IllegalArgumentException exception) {
-            outputView.printExceptionMessage(exception);
+            OUTPUT_VIEW.printExceptionMessage(exception);
         }
     }
 }

src/main/java/chess/ChessGame.java

@@ -1,81 +1,97 @@
 package chess;
 
-import chess.domain.Board;
-import chess.domain.BoardFactory;
-import chess.domain.piece.Piece;
+import chess.domain.Team;
 import chess.domain.position.Position;
 import chess.dto.PieceDto;
+import chess.dto.ProgressStatus;
 import chess.view.GameCommand;
 import chess.view.InputView;
 import chess.view.OutputView;
-import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 
 public class ChessGame {
 
     private final InputView inputView;
     private final OutputView outputView;
+    private final ChessService chessService;
 
-    public ChessGame(InputView inputView, OutputView outputView) {
+    public ChessGame(InputView inputView, OutputView outputView, ChessService chessService) {
         this.inputView = inputView;
         this.outputView = outputView;
+        this.chessService = chessService;
     }
 
-    public void start() {
+    public void run() {
+        startGame();
+        play();
+    }
+
+    private void startGame() {
         outputView.printStartGame();
         GameCommand command = inputView.readCommand();
         if (command.isStart()) {
-            Board board = BoardFactory.createInitBoard();
-            showBoard(board);
-            play(board);
-        }
-        if (command.isMove()) {
-            throw new IllegalArgumentException("아직 게임을 시작하지 않았습니다.");
+            initBoard();
+            showCurrentTeam();
+            showBoard();
+            return;
         }
+        throw new IllegalArgumentException("아직 게임을 시작하지 않았습니다.");
     }
 
-    private void play(Board board) {
-        while (true) {
-            processTurn(board);
-        }
+    private void initBoard() {
+        chessService.init();
+    }
+
+    private void showCurrentTeam() {
+        Team turn = chessService.findCurrentTurn();
+        outputView.printCurrentTurn(turn);
     }
 
-    private void processTurn(Board board) {
+    private void play() {
+        ProgressStatus status;
+        do {
+            status = processTurn();
+        } while (status.isContinue());
+        showResult(status);
+    }
+
+    private ProgressStatus processTurn() {
         GameCommand command = inputView.readCommand();
         if (command.isStart()) {
             throw new IllegalArgumentException("이미 게임을 시작했습니다.");
         }
-        if (command.isEnd()) {
-            System.exit(0);
+        if (command.isMove()) {
+            return executeMove();
+        }
+        if (command.isStatus()) {
+            return executeStatus();
         }
-        executeMove(board);
+        return ProgressStatus.END_GAME;
     }
 
-    private void executeMove(Board board) {
+    private ProgressStatus executeMove() {
         Position start = inputView.readPosition();
         Position end = inputView.readPosition();
-        board.move(start, end);
-        showBoard(board);
+        ProgressStatus status = chessService.moveTo(start, end);
+        showBoard();
+        return status;
     }
 
-    private void showBoard(Board board) {
-        List<Position> positions = Position.ALL_POSITIONS;
-        Map<Position, PieceDto> boardDto = new HashMap<>();
-        positions.forEach(position -> addPiece(board, position, boardDto));
-        outputView.printBoard(boardDto);
+    private ProgressStatus executeStatus() {
+        Map<Team, Double> statusDto = chessService.calculatePiecePoints();
+        outputView.printStatus(statusDto);
+        return ProgressStatus.PROGRESS;
     }
 
-    private void addPiece(Board board, Position position, Map<Position, PieceDto> boardDto) {
-        Optional<Piece> optionalPiece = board.find(position);
-
-        if (optionalPiece.isEmpty()) {
+    private void showResult(ProgressStatus status) {
+        if (status.isInputEndCommand()) {
             return;
         }
+        outputView.printWinnerMessage(status);
+    }
 
-        Piece piece = optionalPiece.get();
-        PieceDto pieceDto = PieceDto.from(piece);
-        boardDto.put(position, pieceDto);
+    private void showBoard() {
+        Map<Position, PieceDto> boardDto = chessService.findTotalBoard();
+        outputView.printBoard(boardDto);
     }
 }