[3, 4단계 - 체스] 몰리(김지민) 미션 제출합니다.

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 {

docker/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

docs/README.md

@@ -7,14 +7,24 @@
 
 ## 보드
 
-- [x] 보드는 체스 말과 위치를 가진다.
+- [x] 보드는 체스 말별 위치를 가진다.
 - [x] 보드에서 체스 말을 이동시킬 수 있다.
-- [x] 보드에서 체스 말을 이동할 수 없는 경우 예외가 발생한다.
+    - [x] 이동하려는 말의 팀이 현재 턴이여야 이동이 가능하다.
+    - [x] 보드에서 체스 말을 이동할 수 없는 경우 예외가 발생한다.
 - [x] 체스 말과 위치 정보를 반환할 수 있다.
+- [x] King이 잡힐 시에 게임이 종료된다.
+
+### 게임 턴
+
+- [x] 게임 시작 시 턴은 검정팀부터 시작한다.
+- [x] 다음 차례를 반환한다.
+    - [x] 2팀이 턴을 번갈아가며 수행한다.
+- [x] 해당 색상의 팀 차례인지 확인한다.
 
 ## 체스 말
 
-- [x] 체스 말은 진영의 색깔과 종류를 가진다.
+- [x] 체스 말은 말의 종류를 가진다.
+- [x] 체스 말은 이동을 가진다.
 - [x] 체스 말은 출발 위치, 도착 위치, 첫 이동 여부, 말의 위치 정보 목록을 바탕으로 움직일 수 있는지 확인한다.
 - [x] 폰
     - [x] 이동이 가능한 경우
@@ -38,7 +48,8 @@
 
 ## 말 종류
 
-- [x] 체스 말은 이동을 가진다.
+- [x] 체스 말 종류는 각각의 이동 목록을 가진다.
+- [x] 체스 말 종류는 각각의 점수 규칙을 가진다.
 
 ## 이동
 
@@ -82,21 +93,41 @@
     - [x] File값이 최소인지 확인한다.
     - [x] File값이 최대인지 확인한다.
 
-## 장애물 규칙
+### 점수 규칙
+
+- [x] 점수 규칙은 기본점수를 가진다.
+- [x] 폰에 대한 점수 규칙은 다음과 같다.
+    - [x] 같은 세로 줄에 같은 색의 폰이 여러개 있는 경우, 각각 0.5점
+    - [x] 같은 세로 줄에 같은 색의 폰이 하나만 있는 경우, 1점(기본점수)
+- [x] 폰을 제외한 다른 말들은 기본 점수 * 말의 개수이다.
+
+## 심판
+
+- [x] 팀별 피스 목록을 점수 규칙에 맞게 점수를 계산한다.
+
+## 공격 유형
 
 ### 공격 공통
 
 - [x] EMPTY가 아닌 Piece들의 위치 목록 조회
 - [x] 목표 위치가 상대편 말일 경우, 공격할 수 있기 때문에 장애물 목록에서 제거
 - [x] 출발 위치는 현재 자신의 위치이므로, 장애물 목록에서 제거
 
-### 대각선 공격 시 (공격 공통 + 추가)
+### 이동 방향으로 공격
+
+- [x] EMPTY가 아닌 Piece들의 위치 목록 조회
+- [x] 목표 위치가 상대편 말일 경우, 공격할 수 있기 때문에 장애물 목록에서 제거
+- [x] 출발 위치는 현재 자신의 위치이므로, 장애물 목록에서 제거
+
+### 이동 방향과 다른 대각선 공격
 
 아래의 경우에 장애물 목록에 도착 위치 Piece를 추가한다.
 
 - [x] 도착 위치가 상대편 말이지만 출발 위치와 도착 위치가 직선 이동일 경우
 - [x] 도착 위치가 EMPTY이고 출발 위치와 도착 위치가 대각 이동일 경우
 
+---
+
 ## 입출력
 
 - [x] 입력 기능 구현

src/main/java/chess/Application.java

@@ -1,13 +1,17 @@
 package chess;
 
 import chess.controller.ChessGameController;
+import chess.repository.piece.PieceDaoImpl;
+import chess.repository.turn.TurnDaoImpl;
+import chess.service.ChessGameService;
 import chess.view.InputView;
 import chess.view.OutputView;
 
 public class Application {
     public static void main(String[] args) {
         try {
-            ChessGameController chessGameController = new ChessGameController(new InputView(), new OutputView());
+            ChessGameController chessGameController = new ChessGameController(new InputView(), new OutputView(),
+                    new ChessGameService(new PieceDaoImpl(), new TurnDaoImpl()));
             chessGameController.start();
         } catch (RuntimeException e) {
             System.out.println(e.getMessage());

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

@@ -1,28 +1,41 @@
 package chess.controller;
 
-import chess.domain.board.Board;
-import chess.domain.board.BoardInitializer;
+import chess.domain.board.ClearBoardInitializer;
+import chess.domain.board.SavedBoardInitializer;
+import chess.domain.game.Game;
+import chess.domain.piece.Color;
+import chess.domain.piece.Piece;
 import chess.domain.position.Position;
+import chess.domain.scorerule.Referee;
+import chess.service.ChessGameService;
 import chess.view.GameCommand;
 import chess.view.InputView;
 import chess.view.OutputView;
+import java.util.Map;
 
 public class ChessGameController {
 
     private final OutputView outputView;
     private final InputView inputView;
+    private final ChessGameService gameService;
 
-    public ChessGameController(final InputView inputView, final OutputView outputView) {
+    public ChessGameController(final InputView inputView, final OutputView outputView,
+                               final ChessGameService gameService) {
         this.inputView = inputView;
         this.outputView = outputView;
+        this.gameService = gameService;
     }
 
     public void start() {
         outputView.printInitialMessage();
-        GameCommand gameCommand = inputView.getGameCommand();
-        checkStart(gameCommand);
+        checkStart(inputView.getGameCommand());
+
+        if (gameService.existSavedGame() && inputView.isPlaySavedGame()) {
+            playSavedGame();
+            return;
+        }
 
-        play();
+        playNewGame();
     }
 
     private void checkStart(final GameCommand gameCommand) {
@@ -31,31 +44,84 @@ private void checkStart(final GameCommand gameCommand) {
         }
     }
 
-    private void play() {
-        Board board = initializeBoard();
+    private void playSavedGame() {
+        Game game = Game.of(new SavedBoardInitializer(gameService.findAllPiece()), gameService.findTurn());
+        outputView.printBoard(game.getBoard());
+        outputView.printCurrentTurn(game.getTurn());
+        execute(game);
+    }
+
+    private void playNewGame() {
+        Game game = new Game(new ClearBoardInitializer());
+        outputView.printBoard(game.getBoard());
+        execute(game);
+    }
+
+    private void execute(final Game game) {
         GameCommand gameCommand = inputView.getGameCommand();
 
-        while (gameCommand == GameCommand.MOVE) {
-            playTurn(board);
+        while (isGameActionIfOngoing(game, gameCommand)) {
+            executeMoveCommand(game, gameCommand);
+            executeStatusCommand(game, gameCommand);
             gameCommand = inputView.getGameCommand();
         }
 
+        checkGameRestart(gameCommand);
+        checkGameFinish(game);
+        checkGameTerminate(game, gameCommand);
+    }
+
+    private boolean isGameActionIfOngoing(final Game game, final GameCommand gameCommand) {
+        return !game.isFinish()
+                && gameCommand != GameCommand.START
+                && gameCommand != GameCommand.END;
+    }
+
+    private void executeMoveCommand(final Game game, final GameCommand gameCommand) {
+        if (gameCommand == GameCommand.MOVE) {
+            executeTurn(game);
+        }
+    }
+
+    private void executeStatusCommand(final Game game, final GameCommand gameCommand) {
+        if (gameCommand == GameCommand.STATUS) {
+            viewScore(game.getBoard());
+        }
+    }
+
+    private void checkGameRestart(final GameCommand gameCommand) {
         if (gameCommand == GameCommand.START) {
-            play();
+            playNewGame();
+        }
+    }
+
+    private void checkGameFinish(final Game game) {
+        if (game.isFinish()) {
+            outputView.printFinish();
+            gameService.delete();
         }
     }
 
-    private Board initializeBoard() {
-        Board board = new Board(new BoardInitializer());
-        outputView.printBoard(board);
-        return board;
+    private void checkGameTerminate(final Game game, final GameCommand gameCommand) {
+        if (gameCommand == GameCommand.END) {
+            gameService.saveGame(game);
+        }
     }
 
-    private void playTurn(final Board board) {
+    private void executeTurn(final Game game) {
         Position source = Position.of(inputView.getPosition());
         Position target = Position.of(inputView.getPosition());
 
-        board.tryMove(source, target);
-        outputView.printBoard(board);
+        game.move(source, target);
+        outputView.printBoard(game.getBoard());
+    }
+
+    private void viewScore(final Map<Position, Piece> board) {
+        Referee referee = new Referee(board);
+
+        double blackTeamScore = referee.calculateScore(Color.BLACK);
+        outputView.printScore(blackTeamScore, Color.BLACK);
+        double whiteTeamScore = referee.calculateScore(Color.WHITE);
+        outputView.printScore(whiteTeamScore, Color.WHITE);
     }
 }

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

@@ -1,36 +1,46 @@
 package chess.domain.board;
 
+import chess.domain.piece.Empty;
 import chess.domain.piece.Piece;
+import chess.domain.piece.PieceType;
 import chess.domain.position.Position;
 import java.util.Collections;
 import java.util.Map;
 
 public class Board {
-
-    private final BoardInitializer boardInitializer;
     private final Map<Position, Piece> board;
 
     public Board(final BoardInitializer boardInitializer) {
-        this.boardInitializer = boardInitializer;
         this.board = boardInitializer.initialize();
     }
 
-    public void tryMove(final Position source, final Position target) {
-        Piece piece = board.get(source);
-        if (piece.canMove(source, target, getBoard())) {
-            move(source, target, piece);
-            return;
+    public boolean tryMove(final Position source, final Position target) {
+        Piece sourcePiece = board.get(source);
+        if (sourcePiece.canMove(source, target, board)) {
+            move(source, target);
+            return true;
         }
 
-        throw new IllegalArgumentException("이동이 불가능한 위치입니다.");
+        return false;
+    }
+
+    private void move(final Position source, final Position target) {
+        board.put(target, board.get(source));
+        board.put(source, Empty.getInstance());
     }
 
-    private void move(final Position source, final Position target, final Piece piece) {
-        board.put(target, piece);
-        board.put(source, Piece.getEmptyPiece());
+    public boolean isKingKilled() {
+        int kingCount = (int) board.entrySet().stream()
+                .filter(entry -> entry.getValue().getPieceType() == PieceType.KING)
+                .count();
+        return kingCount < 2;
     }
 
     public Map<Position, Piece> getBoard() {
         return Collections.unmodifiableMap(board);
     }
+
+    public Piece get(final Position source) {
+        return board.get(source);
+    }
 }

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

@@ -1,61 +1,10 @@
 package chess.domain.board;
 
-import static chess.domain.piece.Color.BLACK;
-import static chess.domain.piece.Color.WHITE;
-
-import chess.domain.piece.Color;
 import chess.domain.piece.Piece;
 import chess.domain.position.Position;
-import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.stream.Collector;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
-
-public class BoardInitializer {
-
-    private static final int MINIMUM_BOARD_POSITION = 1;
-    private static final int MAXIMUM_BOARD_POSITION = 8;
-
-    private final Map<Position, Piece> initialPiecePositions;
-
-    public BoardInitializer() {
-        Map<Position, Piece> initialPiecePositions = generateEmptyBoard();
-        initialPiecePositions.putAll(getPiecesByColor(WHITE));
-        initialPiecePositions.putAll(getPiecesByColor(BLACK));
-        this.initialPiecePositions = initialPiecePositions;
-    }
-
-    public Map<Position, Piece> initialize() {
-        return new HashMap<>(initialPiecePositions);
-    }
-
-    private Map<Position, Piece> generateEmptyBoard() {
-        return IntStream.rangeClosed(MINIMUM_BOARD_POSITION, MAXIMUM_BOARD_POSITION)
-                .boxed()
-                .flatMap(this::generateHorizontalLine)
-                .collect(generateEntry(Piece.getEmptyPiece()));
-    }
-
-    private Stream<Position> generateHorizontalLine(final int rank) {
-        return IntStream.rangeClosed(MINIMUM_BOARD_POSITION, MAXIMUM_BOARD_POSITION)
-                .mapToObj(file -> Position.of(file, rank));
-    }
 
-    private Collector<Position, ?, Map<Position, Piece>> generateEntry(final Piece piece) {
-        return Collectors.toMap(
-                position -> position,
-                position -> piece
-        );
-    }
+public interface BoardInitializer {
 
-    private Map<Position, Piece> getPiecesByColor(final Color color) {
-        List<InitialPiecePosition> whitePieces = InitialPiecePosition.getInitialPositionByColor(color);
-        return whitePieces.stream()
-                .flatMap(initialPiecePosition -> initialPiecePosition.getInitialPositions().stream()
-                        .collect(generateEntry(initialPiecePosition.getPiece())).entrySet().stream())
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (existing, replacement) -> existing));
-    }
+    Map<Position, Piece> initialize();
 }