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

README.md

@@ -10,6 +10,8 @@
 - 시작 시 초/한 진영의 기본 기물 배치와 마상 배치를 반영해 초기화한다.
 - 장기판은 현재 위치의 기물 조회, 빈 칸 여부, 아군/적군 여부를 판단한다.
 - 장기판은 기물 이동 요청을 받아 실제 상태를 변경한다.
+- 장기판은 상대 기물을 잡았을 때 해당 진영의 점수를 실시간으로 차감한다.
+- 장기판은 어느 한 진영의 궁이 잡히면 즉시 게임 종료 상태로 변경한다.
 
 ### 기물
 - 기물은 종류와 진영 정보를 가진다.
@@ -23,20 +25,27 @@
 - 좌표는 입력값을 검증하여 생성한다.
 - 좌표는 보드 범위(행 1~10, 열 1~9)를 벗어날 수 없다.
 - 좌표는 이동값(`Movement`)을 적용해 다음 위치를 계산할 수 있다.
+- 좌표는 다른 위치에 대해서 선형(직선, 대각선)여부를 판단할 수 있다.
+- 좌표는 특정 좌표 범위(한: 1~3행/4~6열, 초: 8~10행/4~6열)를 '궁성'으로 정의한다.
 
 ### 이동 전략
 - 각 기물은 목적지까지의 경로를 계산한다.
 - 경로 검증은 `RoutePolicy`를 통해 수행한다.
 - 일반 기물은 경로가 비어 있고 도착 지점에 아군이 없을 때 이동할 수 있다.
 - 포는 이동 경로 중 정확히 하나의 기물을 넘어야 하며, 포를 넘을 수 없다.
+- 궁성 내부에 위치한 기물(궁, 사, 차, 포, 졸)은 궁성 라인을 따른 대각선 이동이 가능하다.
 - 목적지 자체가 이동 규칙에 맞지 않으면 예외를 발생시킨다.
 
 ### 게임 진행
 - 게임은 초 진영부터 시작한다.
 - 플레이어는 턴마다 시작 좌표와 도착 좌표를 입력한다.
+- 사용자가 시작 좌표 입력 시 '종료'를 입력하면 게임 중단 여부를 재확인한다.
+  - 상대편이 동의(종료 입력)하면 게임을 즉시 종료한다.
+  - 동의하지 않으면(종료가 아닌 다른 값을 입력) 현재 턴을 유지하며 다시 입력을 받는다.
 - 현재 턴의 진영만 자신의 기물을 이동할 수 있다.
 - 이동이 완료되면 턴이 상대 진영으로 넘어간다.
 - 게임 상태는 `ChoTurn`, `HanTurn`, `Finish`로 구분된다.
+- 200턴이 넘어가면 종료된다.
 
 ### 초기 배치
 - 초와 한은 각각 마상 배치를 입력할 수 있다.
@@ -46,16 +55,27 @@
 ### 입력
 - 한 진영의 마상 배치를 입력받는다.
 - 초 진영의 마상 배치를 입력받는다.
-- 이동할 기물의 시작 좌표를 입력받는다. (예: `3,4`)
+- 이동할 기물의 시작 좌표 또는 종료를 입력받는다. (예: `3,4` 또는 `종료` )
+  - 종료 재확인 시 종료 동의 여부를 입력받는다. (예: `종료`)
 - 이동할 기물의 도착 좌표를 입력받는다. (예: `4,4`)
 - 잘못된 입력이 들어오면 예외 메시지를 출력하고 다시 입력받는다.
 
 ### 출력
 - 현재 장기판 상태를 행/열 좌표와 함께 출력한다.
 - 초와 한 기물은 ANSI 색상으로 구분해 출력한다.
 - 현재 턴의 진영을 출력한다.
+- 매 턴 이동이 성공하면 현재 양 진영의 점수 합계를 출력한다.
+- 게임 종료 시 최종 점수와 함께 승리한 진영을 출력한다.
 - 예외가 발생하면 `[ERROR]` 형식의 메시지를 출력한다.
 
+### 데이터베이스
+- 현재 DB에 저장된 전체 장기 게임방 목록을 조회한다.
+- 선택한 게임방의 ID를 기반으로 해당 판의 모든 기물 정보를 불러와 보드를 복원한다.
+- 새로운 게임 시작 시 입력받은 게임방 정보(이름, 생성 시간 등)를 DB에 저장한다.
+- 새로운 게임의 초기 기물 배치 정보를 DB에 일괄 저장한다.
+- 기물 이동 시, 이전 위치의 기물 데이터를 삭제하고 새로운 위치의 정보를 업데이트하여 상태를 영속화한다.
+- 게임 종료 시(궁이 잡히거나 중단 동의 시, 또는 200턴을 넘길 시) 해당 게임방과 관련된 모든 데이터를 DB에서 삭제한다.
+
 ### 예외 처리
 - 존재하지 않는 마상 배치를 입력한 경우
 - 숫자가 아닌 좌표를 입력한 경우
@@ -65,3 +85,4 @@
 - 현재 턴의 진영이 아닌 기물을 움직이려는 경우
 - 기물의 이동 규칙에 맞지 않는 목적지를 입력한 경우
 - 이동 경로가 막혀 있거나 도착 지점에 아군 기물이 있는 경우
+- 점수 차감 시 유효하지 않은 점수값(음수 등)이 계산되는 경우

build.gradle

@@ -1,5 +1,6 @@
 plugins {
     id 'java'
+    id 'application'
 }
 
 version '1.0-SNAPSHOT'
@@ -9,12 +10,19 @@ repositories {
 }
 
 dependencies {
+    implementation 'org.xerial:sqlite-jdbc:3.46.0.0'
+    implementation 'org.slf4j:slf4j-simple:2.0.9'
+
     testImplementation platform('org.junit:junit-bom:5.11.4')
     testImplementation platform('org.assertj:assertj-bom:3.27.3')
     testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation('org.assertj:assertj-core')
 }
 
+application {
+    mainClass = 'janggi.Application'
+}
+
 java {
     toolchain {
         languageVersion = JavaLanguageVersion.of(21)

src/main/java/janggi/Application.java

@@ -1,8 +1,31 @@
 package janggi;
 
+import janggi.dao.GameRoom;
+import janggi.dao.Piece;
+import janggi.db.SQLManager;
+import janggi.db.TransactionManager;
+import janggi.domain.Game;
+
 public class Application {
     public static void main(String[] args) {
-        Runner runner = new Runner();
-        runner.run();
+        SQLManager sqlManager = new SQLManager("jdbc:sqlite:src/main/resources/janggi.db");
+        TransactionManager transactionManager = new TransactionManager(sqlManager);
+
+        GameRoom gameRoom = new GameRoom(sqlManager);
+        gameRoom.initTable();
+
+        Piece piece = new Piece(sqlManager);
+        piece.initTable();
+
+        JanggiService janggiService = new JanggiService(transactionManager, gameRoom, piece);
+
+        Game game = new Game();
+
+        Runner runner = new Runner(janggiService, game);
+
+        int gameId = runner.initBoard();
+        runner.runJanggi(gameId);
+
+        sqlManager.closeConnection();
     }
 }

src/main/java/janggi/JanggiService.java

@@ -0,0 +1,59 @@
+package janggi;
+
+import janggi.dao.GameRoom;
+import janggi.dao.Piece;
+import janggi.db.TransactionManager;
+import janggi.domain.Position;
+import janggi.domain.Side;
+import janggi.domain.piece.PieceType;
+import janggi.dto.GameDto;
+import janggi.dto.GameResponseDto;
+import janggi.dto.PieceDto;
+import janggi.dto.TurnDto;
+import java.util.List;
+
+public class JanggiService {
+    private final TransactionManager transactionManager;
+    private final GameRoom gameRoom;
+    private final Piece piece;
+
+    public JanggiService(TransactionManager transactionManager, GameRoom gameRoom, Piece piece) {
+        this.transactionManager = transactionManager;
+        this.gameRoom = gameRoom;
+        this.piece = piece;
+    }
+
+    public List<GameResponseDto> getEntireGame() {
+        return gameRoom.findAllGames();
+    }
+
+    public int addGameData(GameDto gameDto, List<PieceDto> pieceDtos) {
+        return transactionManager.sync((connection) -> {
+            int gameId = gameRoom.insertGame(connection, gameDto);
+            piece.updatePieces(connection, gameId, pieceDtos);
+
+            return gameId;
+        });
+    }
+
+    public void removeGame(int id) {
+        transactionManager.sync((connection) -> {
+            gameRoom.removeGame(connection, id);
+        });
+    }
+
+    public List<PieceDto> getPieceInitInfos(int gameId) {
+        return piece.getAllPieces(gameId);
+    }
+
+
+    public void movePiece(int gameId, Position start, Position end, Side side, PieceType pieceType, TurnDto turnDto) {
+        transactionManager.sync(connection -> {
+            gameRoom.updateGameTurn(connection, gameId, turnDto);
+            piece.deletePiece(connection, gameId, start.getX(), start.getY());
+
+            PieceDto pieceDto = new PieceDto(end.getX(), end.getY(), pieceType.getName(), side.getName());
+            piece.updatePiece(connection, gameId, pieceDto);
+        });
+    }
+}

src/main/java/janggi/Runner.java

@@ -2,45 +2,110 @@
 
 import janggi.domain.Arrangement;
 import janggi.domain.Game;
+import janggi.domain.GameInfo;
+import janggi.domain.GameInfos;
+import janggi.domain.GameName;
+import janggi.domain.MoveResult;
+import janggi.domain.PieceInitInfo;
 import janggi.domain.Position;
+import janggi.domain.Side;
+import janggi.domain.SideScore;
+import janggi.domain.piece.PieceType;
+import janggi.dto.GameDto;
+import janggi.dto.PieceDto;
+import janggi.dto.TurnDto;
 import janggi.view.InputView;
 import janggi.view.OutputView;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.List;
+import java.util.Optional;
+import java.util.function.Supplier;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 public class Runner {
+    public static final String END_TEXT = "종료";
+
     private static final String UNEXPECTED_SERVER_ERROR_LOG_MESSAGE = "예측하지 못한 시스템 오류 발생";
     private static final String SYSTEM_ERROR_MESSAGE = "시스템 오류가 발생하여 게임을 종료합니다.";
 
     private static final Logger logger = Logger.getLogger(Runner.class.getName());
-    private Game game;
 
-    public void run() {
-        initArrangeGame();
-        turnGame();
+    private final JanggiService janggiService;
+    private final Game game;
+
+    public Runner(JanggiService janggiService, Game game) {
+        this.janggiService = janggiService;
+        this.game = game;
+    }
+
+    public int initBoard() {
+        Optional<Integer> previousBoard = getPreviousBoard();
+        return previousBoard.orElseGet(() -> createNewBoard().id());
     }
 
-    private void initArrangeGame() {
+    public void runJanggi(int gameId) {
+        while (playTurnGame(gameId)) {
+        }
+        endGame(gameId);
+    }
+
+    private Optional<Integer> getPreviousBoard() {
+        GameInfos gameInfos = new GameInfos(janggiService.getEntireGame().stream()
+                .map(gameResponseDto -> new GameInfo(gameResponseDto.id(), gameResponseDto.name(), gameResponseDto.createdAt(), gameResponseDto.updatedAt(), Side.from(gameResponseDto.side()), gameResponseDto.turn()))
+                .toList());
+
+
+        if(gameInfos.isEmpty()) {
+            return Optional.empty();
+        }
+
+        GameInfo selectedGame = askUntilValid(() -> getSelectedGame(gameInfos));
+
+        List<PieceInitInfo> pieceInitInfos = janggiService.getPieceInitInfos(selectedGame.id()).stream().map(pieceDto -> new PieceInitInfo(new Position(pieceDto.x(), pieceDto.y()), Side.from(pieceDto.side()),
+                PieceType.from(pieceDto.pieceType()))).toList();
+
+        game.init(pieceInitInfos, selectedGame.side(), selectedGame.turn());
+        return Optional.of(selectedGame.id());
+    }
+
+    private GameInfo getSelectedGame(GameInfos gameInfos) {
+        OutputView.printGameRoom(gameInfos.getGameInfos());
+        Optional<Integer> input = InputView.askLoadGame();
+
+        if(input.isEmpty()) {
+            return createNewBoard();
+        }
+        return gameInfos.getGameInfo(input.get());
+    }
+
+    private GameInfo createNewBoard() {
+        GameName gameName = new GameName(InputView.askGameName());
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+        String formattedNow = LocalDateTime.now().format(formatter);
+
         String hanArrangementInput = InputView.askHanArrangement();
         Arrangement hanArrangement = Arrangement.from(hanArrangementInput);
 
         String choArrangementInput = InputView.askChoArrangement();
         Arrangement choArrangement = Arrangement.from(choArrangementInput);
 
-        game = new Game(choArrangement, hanArrangement);
-    }
+        List<PieceDto> pieceDtos = game.init(choArrangement, hanArrangement).stream()
+                .map(pieceInitInfo -> new PieceDto(pieceInitInfo.position().getX(), pieceInitInfo.position().getY(), pieceInitInfo.pieceType().getName(), pieceInitInfo.side().getName()))
+                .toList();
 
-    private void turnGame() {
-        while (playTurnGame()) {
-        }
+        int id = janggiService.addGameData(new GameDto(gameName.name(), formattedNow, formattedNow, Side.CHO.getName(), 1), pieceDtos);
+        return new GameInfo(id, gameName.name(), formattedNow, formattedNow, Side.CHO, 1);
     }
 
-    private boolean playTurnGame() {
+    private boolean playTurnGame(int gameId) {
         try {
-            printCurrentStatus();
-            movePiece();
-            return isFinishedGame();
+            OutputView.printLine();
+            OutputView.printBoard(game.getCurrentBoardDto());
+            OutputView.printTurn(game.getCurrentSide());
+
+            return executeTurn(gameId);
         } catch (IllegalArgumentException e) {
             OutputView.printErrorMessage(e.getMessage());
             return true;
@@ -51,26 +116,68 @@ private boolean playTurnGame() {
         }
     }
 
-    private void printCurrentStatus() {
-        OutputView.printBoard(game.getCurrentBoardDto());
-        OutputView.printTurn(game.getCurrentSide());
-    }
+    private boolean executeTurn(int gameId) {
+        Optional<List<Integer>> startPositionInput = InputView.askStartPosition();
 
-    private void movePiece() {
-        List<Integer> startPositionInput = InputView.askStartPosition();
-        Position startPosition = Position.from(startPositionInput);
+        if(startPositionInput.isEmpty()) {
+            return consentEndGame(gameId);
+        }
+
+        Position startPosition = Position.from(startPositionInput.get());
 
         List<Integer> endPositionInput = InputView.askEndPosition();
         Position endPosition = Position.from(endPositionInput);
 
-        game.move(startPosition, endPosition);
+        OutputView.printLine();
+
+        MoveResult moveResult = game.move(startPosition, endPosition);
+        TurnDto turnDto = new TurnDto(moveResult.turnAttribute().side().getName(), moveResult.turnAttribute().turn());
+
+        janggiService.movePiece(gameId, startPosition, endPosition, moveResult.pieceAttribute().side(), moveResult.pieceAttribute().pieceType(), turnDto);
+
+        OutputView.printScore(game.getCurrentSideScore());
+        return !game.isFinished();
     }
 
-    private boolean isFinishedGame() {
-        if (game.isFinished()) {
-            OutputView.printWinner(game.getWinnerSide());
+    private void endGame(int gameId) {
+        janggiService.removeGame(gameId);
+
+        Side winnerSide = game.getWinnerSide();
+
+        if(winnerSide == null) {
+            OutputView.printScore(game.getCurrentSideScore());
+            printScoreWinner();
+            return;
+        }
+        OutputView.printWinner(winnerSide);
+    }
+
+    private boolean consentEndGame(int gameId) {
+        String consentInput = InputView.consentEnd();
+
+        if(consentInput.equals(END_TEXT)) {
             return false;
         }
-        return true;
+
+        return executeTurn(gameId);
+    }
+
+    private void printScoreWinner() {
+        SideScore score = game.getCurrentSideScore();
+        if(score.cho() > score.han()) {
+            OutputView.printWinner(Side.CHO);
+            return;
+        }
+        OutputView.printWinner(Side.HAN);
+    }
+
+    private static <T> T askUntilValid(Supplier<T> supplier) {
+        while (true) {
+            try {
+                return supplier.get();
+            } catch (Exception e) {
+                System.out.println(e.getMessage());
+            }
+        }
     }
 }