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

README.md

@@ -12,6 +12,10 @@
     - [X] 현재 위치와 이동할 위치 입력 안내 메시지 출력 (예: 1,1 1,2)
     - [X] 사용자 입력 받기
     - [X] 입력값 앞뒤 공백 제거
+- [X] 사용자로부터 게임 선택 입력 받기
+  - [X] 새로운 게임 선택 여부 입력받기(y,n)
+  - [X] n 입력시 기존 게임방 ID 입력받기
+
 
 ### 장기 게임 (JanggiGame)
 - [X] 장기 게임 흐름 관리
@@ -31,6 +35,7 @@
 - [X] 기물(Piece)이 반환한 이동 경로 상에 다른 기물(장애물)이 있는지 최종 검증 (길막힘 판별)
 - [X] 검증 통과 시 보드 상태 업데이트 (기물 이동)
 - [X] 도착지에 적군 기물이 있다면 맵에서 제거 (포획 처리)
+- [X] 현재 점수 계산 결과 반환
 
 #### 기물 공통 (Piece - 움직임 전략 패턴)
 - [X] 기물의 소속 팀(한/초) 반환
@@ -51,8 +56,9 @@
 ### 📤 출력 (OutputView)
 #### 게임 진행 상태 출력
 - [X] 게임 시작 안내 메시지 출력
-- [ ] 매 턴마다 현재 누구의 턴인지 출력
+- [X] 매 턴마다 현재 누구의 턴인지 출력
 - [X] 매 턴마다 이동 결과가 반영된 현재 장기판의 상태를 시각적으로 출력
+- [X] 매 턴마다 현재 점수 출력
 
 #### 게임 종료 출력
 - [X] 승리 팀 안내 및 게임 종료 메시지 출력 
@@ -63,5 +69,82 @@
 #### 구현되지 않은 기능
 - 상마상마, 마상마상 등의 상차림 변경은 미구현
 - 외통수 시 게임을 종료하는 기능 미구현(장을 잡을 때까지 게임 진행)
-- 궁성을 구현하지 않아서, 장, 사의 이동 범위 제한이 현재는 없음
-- 궁성 내부에서의 기물마다의 특수한 이동 경로 또한 현재는 없음
+
+
+```mermaid
+classDiagram
+  Piece <|.. Ma
+  Piece <|.. Cha
+  Piece <|.. Pho
+  Piece <|.. Sang
+  Piece <|.. Jang
+  Piece <|.. Sa
+  Piece <|.. Jol
+  Board -- Piece
+  GameTurn .. HanTurn
+  GameTurn .. ChoTurn
+  GameTurn .. FinishedGame
+  JanggiGame -- GameTurn
+  JanggiGame -- Board
+
+  class Point {
+	  int x
+	  int y
+	  of(int x, int y)
+  }
+  class Piece {
+	  Team team
+	  isSameTeam(Team team)
+	  getRoute(Point from, Point to)
+	  canMove(List<Piece> route)
+  }
+  class Board {
+	  Map~Point, Piece~ state
+	  init()
+	  move(Point from, Point to)
+  }
+  class JanggiGame {
+		Board board
+		GameTurn gameState
+	  play()
+  }
+  class GameTurn {
+	  Team team
+	  <<interface>>
+	  move()
+  }
+  class HanTurn {
+		Team han
+	  move()
+  }
+  class ChoTurn {
+	  Team cho
+	  move()
+  }
+  class FinishedGame {
+	  Team winner
+	  move()
+  }
+```
+```mermaid
+erDiagram
+    GameRoom ||--o{ Piece : "contains (1:N)"
+
+    GameRoom {
+        BIGINT id PK
+        VARCHAR current_turn
+        VARCHAR winner
+        DOUBLE cho_score
+        DOUBLE han_score
+    }
+
+    Piece {
+        BIGINT id PK
+        BIGINT game_room_id FK
+        VARCHAR piece_name
+        VARCHAR team
+        INT row_pos
+        INT col_pos
+    }
+
+```

build.gradle

@@ -9,6 +9,7 @@ repositories {
 }
 
 dependencies {
+    implementation 'com.h2database:h2:2.2.224'
     testImplementation platform('org.junit:junit-bom:5.11.4')
     testImplementation platform('org.assertj:assertj-bom:3.27.3')
     testImplementation('org.junit.jupiter:junit-jupiter')

src/main/java/janggi/JanggiApplication.java

@@ -1,37 +1,25 @@
 package janggi;
 
-import janggi.domain.Board;
-import janggi.domain.JanggiGame;
-import janggi.domain.Point;
-import janggi.domain.piece.Piece;
-import janggi.presentation.dto.GameStatusInfo;
-import janggi.presentation.dto.MoveCommand;
-import janggi.presentation.dto.PositionInfo;
+import janggi.application.JanggiGameService;
+import janggi.domain.board.BoardRepository;
+import janggi.infra.DataConnectionManager;
+import janggi.infra.JdbcBoardRepository;
+import janggi.presentation.JanggiGameController;
 import janggi.presentation.ui.InputView;
 import janggi.presentation.ui.OutputView;
-import janggi.util.Console;
-import janggi.util.FileParser;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
+import java.sql.SQLException;
+import org.h2.tools.Server;
 
 public class JanggiApplication {
-    public static void main(String[] args) {
-        List<PositionInfo> positionInfos = FileParser.readCsvFile("/janggi.csv");
-        Map<Point, Piece> pieces = new LinkedHashMap<>();
-        positionInfos.forEach(info -> pieces.put(info.point(), info.piece()));
-        Board board = new Board();
-        board.init(pieces);
-        JanggiGame game = new JanggiGame(board);
-
-        OutputView.printGameStatus(GameStatusInfo.from(game.getBoardStatus()));
-        OutputView.printStartGame();
-        while (!game.isFinished()) {
-            MoveCommand points = InputView.readPoints();
-            game.play(points.from(), points.to());
-            OutputView.printGameStatus(GameStatusInfo.from(game.getBoardStatus()));
-        }
-        OutputView.printWinner(game.getWinner());
-        Console.close();
+    public static void main(String[] args) throws SQLException {
+        Server server = Server.createTcpServer("-tcp", "-tcpAllowOthers", "-tcpPort", "9092").start();
+        DataConnectionManager manager = new DataConnectionManager();
+        BoardRepository repository = new JdbcBoardRepository(manager);
+        JanggiGameService service = new JanggiGameService(repository);
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        JanggiGameController controller = new JanggiGameController(service, inputView, outputView);
+        controller.run();
+        server.stop();
     }
 }

src/main/java/janggi/application/JanggiGameService.java

@@ -0,0 +1,58 @@
+package janggi.application;
+
+import janggi.domain.board.Board;
+import janggi.domain.board.BoardRepository;
+import janggi.domain.JanggiGame;
+import janggi.domain.point.Point;
+import janggi.domain.status.ChoTurn;
+import janggi.domain.status.Team;
+import janggi.presentation.dto.GameStatusInfo;
+
+public class JanggiGameService {
+
+    private final BoardRepository repository;
+
+    public JanggiGameService(BoardRepository repository) {
+        this.repository = repository;
+    }
+
+    public long startNewGame(Board initBoard) {
+        JanggiGame game = new JanggiGame(initBoard, new ChoTurn());
+        return repository.save(game);
+    }
+
+    public GameStatusInfo getBoardStatus(Long roomId) {
+        return GameStatusInfo.from(repository.loadGame(roomId).getBoardStatus());
+    }
+
+    public boolean isFinished(Long roomId) {
+        return repository.loadGame(roomId)
+                .isFinished();
+    }
+
+    public void play(Long roomId, Point from, Point to) {
+        JanggiGame game = repository.loadGame(roomId);
+        game.play(from, to);
+        repository.update(roomId, from, to, game);
+    }
+
+    public Team winner(Long roomId) {
+        return repository.loadGame(roomId)
+                .getWinner();
+    }
+
+    public Team currentTurn(Long roomId) {
+        return repository.loadGame(roomId)
+                .getTeam();
+    }
+
+    public double getHanScore(Long roomId) {
+        return repository.loadGame(roomId)
+                .getHanScore();
+    }
+
+    public double getChoScore(Long roomId) {
+        return repository.loadGame(roomId)
+                .getChoScore();
+    }
+}

src/main/java/janggi/domain/JanggiGame.java

@@ -1,19 +1,21 @@
 package janggi.domain;
 
+import janggi.domain.board.Board;
 import janggi.domain.piece.Piece;
-import janggi.domain.status.ChoTurn;
+import janggi.domain.point.Point;
 import janggi.domain.status.GameStatus;
 import janggi.domain.status.Team;
-import java.util.List;
+import java.util.Map;
 
 public class JanggiGame {
 
+    private static final double BONUS_SCORE = 1.5;
     private final Board board;
     private GameStatus gameStatus;
 
-    public JanggiGame(Board board) {
+    public JanggiGame(Board board, GameStatus gameStatus) {
         this.board = board;
-        this.gameStatus = new ChoTurn();
+        this.gameStatus = gameStatus;
     }
 
     public boolean isFinished() {
@@ -27,11 +29,23 @@ public Team getWinner() {
         return gameStatus.getTeam();
     }
 
-    public List<List<Piece>> getBoardStatus() {
-        return board.getPoints();
+    public Map<Point, Piece> getBoardStatus() {
+        return board.getPieces();
     }
 
     public void play(Point from, Point to) {
         this.gameStatus = gameStatus.move(from, to, board);
     }
+
+    public Team getTeam() {
+        return gameStatus.getTeam();
+    }
+
+    public double getChoScore() {
+        return board.calculateScore(Team.CHO);
+    }
+
+    public double getHanScore() {
+        return board.calculateScore(Team.HAN) + BONUS_SCORE;
+    }
 }

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

@@ -1,26 +1,20 @@
-package janggi.domain;
+package janggi.domain.board;
 
 import janggi.domain.piece.Piece;
 import janggi.domain.piece.PieceType;
+import janggi.domain.point.Point;
+import janggi.domain.point.Points;
+import janggi.domain.point.Route;
 import janggi.domain.status.Team;
-import java.util.LinkedHashMap;
-import java.util.List;
+import java.util.Collections;
 import java.util.Map;
 import java.util.Objects;
-import java.util.stream.IntStream;
 
 public class Board {
 
-    private static final int BOARD_HEIGHT = 10;
-    private static final int BOARD_WIDTH = 9;
+    private final Map<Point, Piece> pieces;
 
-    private Map<Point, Piece> pieces;
-
-    public Board() {
-        this.pieces = new LinkedHashMap<>();
-    }
-
-    public void init(Map<Point, Piece> pieces) {
+    public Board(Map<Point, Piece> pieces) {
         this.pieces = pieces;
     }
 
@@ -32,8 +26,8 @@ public void move(Point from, Point to, Team team) {
         if (targetPiece != null && !piece.canCapture(targetPiece)) {
             throw new IllegalArgumentException("[ERROR] 이 기물은 해당 타겟을 잡을 수 없습니다.");
         }
-        List<Point> route = piece.getRoute(from, to);
-        if (!piece.canMove(getPieces(route))) {
+        Points points = piece.getRoutePoints(from, to);
+        if (!piece.canMove(getRoute(points))) {
             throw new IllegalArgumentException("[ERROR] 해당 기물의 이동 경로에 장애물이 있거나 규칙에 어긋납니다.");
         }
         pieces.remove(from);
@@ -46,20 +40,23 @@ public boolean isKingDie() {
                 .count() < 2;
     }
 
-    public List<List<Piece>> getPoints() {
-        return IntStream.range(0, BOARD_HEIGHT)
-                .mapToObj(row -> IntStream.range(0, BOARD_WIDTH)
-                        .mapToObj(col -> Point.of(col, row))
-                        .map(point -> this.pieces.get(point))
-                        .toList()
-                ).toList();
+    public Map<Point, Piece> getPieces() {
+        return Collections.unmodifiableMap(this.pieces);
+    }
+
+    public double calculateScore(Team team) {
+        return pieces.values()
+                .stream()
+                .filter(piece -> piece.isSameTeam(team))
+                .mapToInt(Piece::getScore)
+                .sum();
     }
 
-    public List<Piece> getPieces(List<Point> point) {
-        return point.stream()
+    public Route getRoute(Points points) {
+        return new Route(points.getPoints().stream()
                 .map(pieces::get)
                 .filter(Objects::nonNull)
-                .toList();
+                .toList());
     }
 
     private void validateFromPoint(Point from, Team team) {

src/main/java/janggi/domain/board/BoardRepository.java

@@ -0,0 +1,10 @@
+package janggi.domain.board;
+
+import janggi.domain.JanggiGame;
+import janggi.domain.point.Point;
+
+public interface BoardRepository {
+    long save(JanggiGame game);
+    void update(Long roomId, Point from, Point to, JanggiGame game);
+    JanggiGame loadGame(Long gameRoomId);
+}