[🚀 사이클2 - 미션 (기물 확장 + DB 적용)] 보예 미션 제출합니다.

build.gradle

@@ -13,6 +13,9 @@ dependencies {
     testImplementation platform('org.assertj:assertj-bom:3.27.3')
     testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation('org.assertj:assertj-core')
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.2'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+    implementation 'org.xerial:sqlite-jdbc:3.46.1.3'
 }
 
 java {

src/main/java/janggi/Application.java

@@ -1,16 +1,14 @@
 package janggi;
 
-import janggi.view.output.ConsoleOutputView;
-import janggi.view.input.ConsoleInputView;
-import janggi.view.input.InputView;
-import janggi.view.output.OutputView;
+import janggi.config.AppConfig;
+import janggi.persistence.DatabaseInitializer;
 
 public class Application {
 
     public static void main(String[] args) {
-        InputView inputView = new ConsoleInputView();
-        OutputView outputView = new ConsoleOutputView();
-        JanggiRunner janggiRunner = new JanggiRunner(inputView, outputView);
-        janggiRunner.execute();
+        AppConfig appConfig = new AppConfig();
+        DatabaseInitializer databaseInitializer = appConfig.databaseInitializer();
+        databaseInitializer.initialize();
+        appConfig.janggiRunner().execute();
     }
 }

src/main/java/janggi/JanggiRunner.java

@@ -2,36 +2,66 @@
 
 import janggi.domain.JanggiGame;
 import janggi.domain.Position;
+import janggi.domain.WinnerResult;
+import janggi.service.JanggiService;
 import janggi.util.ActionExecutor;
 import janggi.util.DelimiterParser;
+import janggi.util.PersistenceExecutor;
 import janggi.view.input.InputView;
 import janggi.view.output.OutputView;
 import java.util.List;
+import java.util.Optional;
 
 public class JanggiRunner {
 
     private final InputView inputView;
     private final OutputView outputView;
+    private final JanggiService janggiService;
 
-    public JanggiRunner(InputView inputView, OutputView outputView) {
+    public JanggiRunner(InputView inputView, OutputView outputView, JanggiService janggiService) {
         this.inputView = inputView;
         this.outputView = outputView;
+        this.janggiService = janggiService;
     }
 
     public void execute() {
         outputView.printStartMessage();
-
-        JanggiGame janggiGame = JanggiGame.createInitialJanggiGame();
-        while (true) {
+        JanggiGame janggiGame = PersistenceExecutor.retryOnTimeout(
+            janggiService::loadGame,
+            this::printPersistenceTimeoutMessage
+        );
+        while (isGameContinue(janggiGame)) {
             outputView.printBoard(janggiGame.makeCurrentTurnBoardSnapShot());
             Position startPosition = ActionExecutor.retryUntilSuccess(
                 () -> readValidStartPosition(janggiGame), outputView
             );
-            Position endPosition = ActionExecutor.retryUntilSuccess(
+            Optional<Position> endPosition = ActionExecutor.retryUntilSuccess(
                 () -> readValidEndPosition(janggiGame, startPosition), outputView
             );
-            janggiGame.doGame(startPosition, endPosition);
+            if (endPosition.isEmpty()) {
+                outputView.printMessage("말 선택을 취소했습니다. 다시 선택해주세요.");
+                continue;
+            }
+            PersistenceExecutor.retryOnTimeout(
+                () -> janggiService.play(janggiGame, startPosition, endPosition.get()),
+                this::printPersistenceTimeoutMessage
+            );
         }
+        finish(janggiGame);
+    }
+
+    private void finish(JanggiGame janggiGame) {
+        PersistenceExecutor.retryOnTimeout(janggiService::finishGame, this::printPersistenceTimeoutMessage);
+        WinnerResult winnerResult = janggiGame.getWinnerResult();
+        outputView.printResult(
+            janggiGame.makeCurrentTurnBoardSnapShot(),
+            winnerResult.winner(),
+            winnerResult.winnerScore()
+        );
+    }
+
+    private boolean isGameContinue(JanggiGame janggiGame) {
+        return !janggiGame.isGameOver();
     }
 
     private Position readValidStartPosition(JanggiGame janggiGame) {
@@ -44,12 +74,19 @@ private Position readValidStartPosition(JanggiGame janggiGame) {
         return startPosition;
     }
 
-    private Position readValidEndPosition(JanggiGame janggiGame, Position startPosition) {
+    private Optional<Position> readValidEndPosition(JanggiGame janggiGame, Position startPosition) {
         outputView.printAskMovePosition(janggiGame.findPiece(startPosition).nickname());
-        String rawMovePosition = inputView.readLine();
-        List<String> parsedMovePosition = DelimiterParser.parse(rawMovePosition);
+        Optional<String> rawMovePosition = inputView.readCancelableLine();
+        if (rawMovePosition.isEmpty()) {
+            return Optional.empty();
+        }
+        List<String> parsedMovePosition = DelimiterParser.parse(rawMovePosition.get());
         Position endPosition = Position.makePosition(parsedMovePosition);
         janggiGame.validateValidEndPosition(startPosition, endPosition);
-        return endPosition;
+        return Optional.of(endPosition);
+    }
+
+    private void printPersistenceTimeoutMessage() {
+        outputView.printMessage("데이터베이스 응답이 지연되었습니다. 다시 시도합니다.");
     }
 }

src/main/java/janggi/config/AppConfig.java

@@ -0,0 +1,38 @@
+package janggi.config;
+
+import janggi.JanggiRunner;
+import janggi.persistence.DatabaseInitializer;
+import janggi.persistence.repository.JanggiGameRepository;
+import janggi.persistence.repository.JdbcJanggiGameRepository;
+import janggi.service.JanggiService;
+import janggi.view.input.ConsoleInputView;
+import janggi.view.input.InputView;
+import janggi.view.output.ConsoleOutputView;
+import janggi.view.output.OutputView;
+
+public class AppConfig {
+
+    public DatabaseInitializer databaseInitializer() {
+        return new DatabaseInitializer();
+    }
+
+    public JanggiRunner janggiRunner() {
+        return new JanggiRunner(inputView(), outputView(), janggiService());
+    }
+
+    public JanggiService janggiService() {
+        return new JanggiService(janggiGameRepository());
+    }
+
+    public JanggiGameRepository janggiGameRepository() {
+        return new JdbcJanggiGameRepository();
+    }
+
+    public InputView inputView() {
+        return new ConsoleInputView();
+    }
+
+    public OutputView outputView() {
+        return new ConsoleOutputView();
+    }
+}

src/main/java/janggi/domain/Board.java

@@ -1,12 +1,16 @@
 package janggi.domain;
 
+import janggi.domain.movepath.MovePathStrategy;
 import janggi.domain.piece.Piece;
+import janggi.domain.piece.PieceType;
 import janggi.domain.team.Team;
 import janggi.domain.team.TeamType;
 import janggi.dto.BoardSpot;
 import janggi.dto.BoardSpots;
+import janggi.dto.MoveRoute;
 import java.util.EnumMap;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
@@ -55,11 +59,7 @@ public Optional<Piece> findPiece(Position position) {
             .findFirst();
     }
 
-    public boolean hasPiece(Position position) {
-        return findPiece(position).isPresent();
-    }
-
-    public void canMove(Position startPosition, Position endPosition, TeamType playingTeam) {
+    public void validateMove(Position startPosition, Position endPosition, TeamType playingTeam) {
         validateRange(startPosition);
         validateRange(endPosition);
         Piece piece = findTeamPiece(startPosition, currentTeam(playingTeam));
@@ -72,12 +72,33 @@ public Board move(
         Position endPosition,
         TeamType playingTeam
     ) {
-        canMove(startPosition, endPosition, playingTeam);
+        validateMove(startPosition, endPosition, playingTeam);
         Team movedCurrentTeam = currentTeam(playingTeam).move(startPosition, endPosition);
         Team remainedOpponentTeam = removeOpponentPiece(playingTeam, endPosition);
         return createMovedBoard(playingTeam, movedCurrentTeam, remainedOpponentTeam);
     }
 
+    public boolean hasGung(TeamType teamType) {
+        return findSpecificTeam(teamType).hasPieceType(PieceType.GUNG);
+    }
+
+    public Optional<TeamType> findWinner() {
+        boolean chuHasGung = hasGung(TeamType.CHU);
+        boolean hanHasGung = hasGung(TeamType.HAN);
+        if (chuHasGung == hanHasGung) {
+            return Optional.empty();
+        }
+        if (chuHasGung) {
+            return Optional.of(TeamType.CHU);
+        }
+        return Optional.of(TeamType.HAN);
+    }
+
+    public int calculateScore(TeamType teamType) {
+        Team team = findSpecificTeam(teamType);
+        return team.calculatePiecesScore();
+    }
+
     private Piece findTeamPiece(Position position, Team nowTeam) {
         return nowTeam.findPiece(position)
             .orElseThrow(() -> new IllegalArgumentException("입력한 위치에 기물이 없습니다."));
@@ -92,15 +113,52 @@ private Team opponentTeam(TeamType nowTurnTeamType) {
     }
 
     private void validateCanMove(Piece piece, Position piecePosition, Position targetPosition) {
-        if (!piece.isValidMovePattern(piecePosition.getX(), piecePosition.getY(), targetPosition.getX(),
-            targetPosition.getY())) {
+        Optional<MovePathStrategy> movePath = piece.findMovePath(
+            piecePosition.getX(),
+            piecePosition.getY(),
+            targetPosition.getX(),
+            targetPosition.getY()
+        );
+        if (movePath.isEmpty()) {
             throw new IllegalArgumentException("이동할 수 없는 위치입니다.");
         }
-        if (!piece.isObstaclesNotExist(piecePosition, targetPosition, this)) {
+        MoveRoute moveRoute = createMoveRoute(piecePosition, targetPosition, movePath.get());
+        if (!piece.canMove(moveRoute)) {
             throw new IllegalArgumentException("이동할 수 없는 위치입니다.");
         }
     }
 
+    private MoveRoute createMoveRoute(
+        Position startPosition,
+        Position targetPosition,
+        MovePathStrategy movePath
+    ) {
+        return new MoveRoute(
+            findIntermediatePieceTypes(startPosition, targetPosition, movePath),
+            findTargetPieceType(targetPosition)
+        );
+    }
+
+    private List<PieceType> findIntermediatePieceTypes(
+        Position startPosition,
+        Position targetPosition,
+        MovePathStrategy movePath
+    ) {
+        return movePath.intermediatePositions(startPosition, targetPosition).stream()
+            .map(this::findPieceType)
+            .flatMap(Optional::stream)
+            .toList();
+    }
+
+    private Optional<PieceType> findTargetPieceType(Position targetPosition) {
+        return findPieceType(targetPosition);
+    }
+
+    private Optional<PieceType> findPieceType(Position position) {
+        return findPiece(position)
+            .map(Piece::getPieceType);
+    }
+
     private void validateTargetPosition(Team team, Position targetPosition) {
         if (team.findPiece(targetPosition).isPresent()) {
             throw new IllegalArgumentException("같은 팀의 기물이 있는 위치로는 이동할 수 없습니다.");