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

README.md

@@ -21,6 +21,12 @@
   - 목적지에 같은 팀 기물이 존재한다면 이동하지 못한다.
   - 목적지에 다른 팀 기물이 존재한다면 해당 기물을 잡을 수 있다.
   - 이동할 기물이 포이고 이동 경로에 포를 제외한 다른 기물이 있다면 기물을 넘어서 이동할 수 있다.
+- [x] 기물의 이동에 궁성(宮城) 영역의 규칙을 포함한다.
+- [x] 왕이 잡히는 경우 게임에서 진다.
+  - 왕이 잡혔을 때 게임을 종료한다.
+- [x] 현재 남아 있는 기물에 대한 점수를 구할수 있어야 한다.
+- [x] 애플리케이션을 재시작하더라도 이전에 하던 장기 게임을 다시 시작할 수 있어야 한다.
+  - DB를 적용할 때 도메인 객체의 변경을 최소화해야 한다.
 
 ### 예외 기능
 - [x] 장기판을 벗어나면 예외를 발생한다.

build.gradle

@@ -9,6 +9,8 @@ repositories {
 }
 
 dependencies {
+    implementation 'org.mongodb:mongodb-driver-sync:5.3.1'
+
     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/Application.java

@@ -1,11 +1,15 @@
 import controller.JanggiController;
+import dao.mongodb.BoardDao;
+import dao.mongodb.MongoConnection;
 import view.InputView;
 import view.OutputView;
 
 public class Application {
 
     public static void main(String[] args) {
-        JanggiController janggiController = new JanggiController(new InputView(), new OutputView());
-        janggiController.run();
+        try (MongoConnection connection = new MongoConnection()) {
+            JanggiController janggiController = new JanggiController(new InputView(), new OutputView(), new BoardDao(connection));
+            janggiController.run();
+        }
     }
-}
+}

src/main/java/controller/JanggiController.java

@@ -1,43 +1,103 @@
 package controller;
 
+import dao.mongodb.BoardDao;
 import domain.Board;
 import domain.BoardFactory;
 import domain.Formation;
+import domain.JanggiGame;
 import domain.Team;
 import domain.vo.Position;
+import dto.PieceDto;
+import java.util.List;
+import presentation.PositionCommand;
 import view.InputView;
 import view.OutputView;
 
 public class JanggiController {
 
+    private static final String RESUME_GAME_NUMBER = "2";
+    private static final String SURRENDER = "항복";
+
     private final InputView inputView;
     private final OutputView outputView;
+    private final BoardDao boardDao;
 
-    public JanggiController(InputView inputView, OutputView outputView) {
+    public JanggiController(InputView inputView, OutputView outputView, BoardDao boardDao) {
         this.inputView = inputView;
         this.outputView = outputView;
+        this.boardDao = boardDao;
     }
 
     public void run() {
+        String command = inputView.readCommand();
+
+        if (command.equals(RESUME_GAME_NUMBER)) {
+            resumeGame();
+            return;
+        }
+
+        startNewGame();
+    }
+
+    private void startNewGame() {
         Board board = BoardFactory.setUp();
         board = readHanFormation(board);
         board = readChuFormation(board);
 
-        outputView.printBoard(board.getBoard());
+        JanggiGame janggiGame = JanggiGame.of(board);
+        String gameId = boardDao.save(PieceDto.fromBoard(board.getBoard()), janggiGame.getTurnCount());
+
+        playGame(gameId, janggiGame);
+    }
+
+    private void resumeGame() {
+        while (true) {
+            try {
+                String gameId = inputView.readGameId();
+                List<PieceDto> pieceDtos = boardDao.findPiecesByGameId(gameId);
+
+                int turnCount = boardDao.findTurnCountByGameId(gameId);
+                Board board = PieceDto.toBoard(pieceDtos);
+                JanggiGame janggiGame = JanggiGame.of(board, turnCount);
+
+                playGame(gameId, janggiGame);
+                return;
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+                System.out.println();
+            }
+        }
+    }
+
+    private void playGame(String gameId, JanggiGame janggiGame) {
+        outputView.printCurrentGameId(gameId);
+        outputView.printBoard(janggiGame.getBoardStatus());
 
-        int turnCount = 0;
-        turnCount = movePosition(board, turnCount);
+        while (true) {
+            movePosition(janggiGame);
+            boardDao.update(gameId, PieceDto.fromBoard(janggiGame.getBoardStatus()), janggiGame.getTurnCount());
+
+            if (janggiGame.isFinished()) {
+                boardDao.finish(gameId);
+                outputView.printGameFinishMessage();
+                outputView.printScore(janggiGame.calculateScore(Team.HAN), janggiGame.calculateScore(Team.CHU));
+                break;
+            }
 
-        while (inputView.readRetryCommand()) {
-            turnCount = movePosition(board, turnCount);
+            if (janggiGame.isSurrendered()) {
+                boardDao.finish(gameId);
+                outputView.printGameSurrenderMessage();
+                outputView.printScore(janggiGame.calculateScore(Team.HAN), janggiGame.calculateScore(Team.CHU));
+                break;
+            }
         }
     }
 
     private Board readChuFormation(Board board) {
         while (true) {
             try {
                 String chuArrangement = inputView.readArrangement(Team.CHU);
-                board = applyArrangement(chuArrangement, board, Team.CHU);
+                board = Formation.from(chuArrangement, board, Team.CHU);
                 return board;
             } catch (Exception e) {
                 System.out.println(e.getMessage());
@@ -50,7 +110,7 @@ private Board readHanFormation(Board board) {
         while (true) {
             try {
                 String hanArrangement = inputView.readArrangement(Team.HAN);
-                board = applyArrangement(hanArrangement, board, Team.HAN);
+                board = Formation.from(hanArrangement, board, Team.HAN);
 
                 return board;
             } catch (Exception e) {
@@ -60,35 +120,27 @@ private Board readHanFormation(Board board) {
         }
     }
 
-    private static Board applyArrangement(String arrangement, Board board, Team team) {
-        if (Formation.from(arrangement) == Formation.SANG_MA_SANG_MA) {
-            return BoardFactory.setUpLeftElephantFormation(board.getBoard(), team);
-        }
-        if (Formation.from(arrangement) == Formation.MA_SANG_MA_SANG) {
-            return BoardFactory.setUpRightElephantFormation(board.getBoard(), team);
-        }
-        if (Formation.from(arrangement) == Formation.MA_SANG_SANG_MA) {
-            return BoardFactory.setUpInnerElephantFormation(board.getBoard(), team);
-        }
-        if (Formation.from(arrangement) == Formation.SANG_MA_MA_SANG) {
-            return BoardFactory.setUpOuterElephantFormation(board.getBoard(), team);
-        }
-
-        return board;
-    }
-
-    private int movePosition(Board board, int turnCount) {
+    private void movePosition(JanggiGame janggiGame) {
         while (true) {
             try {
-                outputView.printCurrentTurn(turnCount);
+                outputView.printCurrentTurn(janggiGame.currentTurn());
+
+                String input = inputView.readPosition();
+                if (input.equals(SURRENDER)) {
+                    janggiGame.surrender();
+                    return;
+                }
+
+                String targetInput = inputView.readTargetPosition();
+
+                Position position = PositionCommand.from(input).toPosition();
+                Position targetPosition = PositionCommand.from(targetInput).toPosition();
 
-                Position position = inputView.readPosition();
-                Position targetPosition = inputView.readTargetPosition();
+                janggiGame.move(position, targetPosition);
+                outputView.printBoard(janggiGame.getBoardStatus());
+                janggiGame.passTheTurn();
 
-                Team currentTeam = Team.from(turnCount);
-                board.move(position, targetPosition, currentTeam);
-                outputView.printBoard(board.getBoard());
-                return turnCount += 1;
+                return;
             } catch (Exception e) {
                 System.out.println(e.getMessage());
                 System.out.println();

src/main/java/dao/mongodb/BoardDao.java

@@ -0,0 +1,111 @@
+package dao.mongodb;
+
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.model.Filters;
+import dto.PieceDto;
+import java.util.ArrayList;
+import java.util.List;
+import org.bson.Document;
+import org.bson.types.ObjectId;
+
+public class BoardDao {
+
+    private final MongoCollection<Document> collection;
+
+    public BoardDao(MongoConnection connection) {
+        this.collection = connection.getCollection("board");
+    }
+
+    public String save(List<PieceDto> pieces, int turnCount) {
+        ArrayList<Document> pieceDocuments = new ArrayList<>();
+
+        for (PieceDto pieceDto : pieces) {
+            pieceDocuments.add(toDocument(pieceDto));
+        }
+
+        Document gameDocument = getDocument(turnCount, pieceDocuments);
+
+        collection.insertOne(gameDocument);
+        return gameDocument.getObjectId("_id").toString();
+    }
+
+    public List<PieceDto> findPiecesByGameId(String gameId) {
+        Document gameDocument = findGameDocument(gameId);
+
+        if (gameDocument.getBoolean("isFinished")) {
+            throw new IllegalArgumentException("[ERROR] 이미 종료된 게임입니다: " + gameId);
+        }
+
+        List<Document> pieces = gameDocument.getList("pieces", Document.class);
+        List<PieceDto> pieceDtos = new ArrayList<>();
+
+        for (Document doc : pieces) {
+            pieceDtos.add(toPieceDto(doc));
+        }
+
+        return pieceDtos;
+    }
+
+    public int findTurnCountByGameId(String gameId) {
+        Document gameDocument = findGameDocument(gameId);
+        return gameDocument.getInteger("turnCount");
+    }
+
+    public void update(String gameId, List<PieceDto> pieces, int turnCount) {
+        ArrayList<Document> pieceDocuments = new ArrayList<>();
+
+        for (PieceDto pieceDto : pieces) {
+            pieceDocuments.add(toDocument(pieceDto));
+        }
+
+        Document updateFields = new Document("$set", new Document()
+                .append("pieces", pieceDocuments)
+                .append("turnCount", turnCount));
+
+        collection.updateOne(
+                Filters.eq("_id", new ObjectId(gameId)),
+                updateFields
+        );
+    }
+
+    public void finish(String gameId) {
+        Document updateFields = new Document("$set", new Document("isFinished", true));
+
+        collection.updateOne(
+                Filters.eq("_id", new ObjectId(gameId)),
+                updateFields
+        );
+    }
+
+    private Document findGameDocument(String gameId) {
+        Document gameDocument = collection.find(Filters.eq("_id", new ObjectId(gameId))).first();
+        if (gameDocument == null) {
+            throw new IllegalArgumentException("[ERROR] 해당 게임을 찾을 수 없습니다: " + gameId);
+        }
+        return gameDocument;
+    }
+
+    private Document getDocument(int turnCount, ArrayList<Document> pieceDocuments) {
+        return new Document()
+                .append("pieces", pieceDocuments)
+                .append("turnCount", turnCount)
+                .append("isFinished", false);
+    }
+
+    private Document toDocument(PieceDto pieceDto) {
+        return new Document()
+                .append("row", pieceDto.row())
+                .append("col", pieceDto.col())
+                .append("team", pieceDto.team())
+                .append("type", pieceDto.type());
+    }
+
+    private PieceDto toPieceDto(Document doc) {
+        return new PieceDto(
+                doc.getInteger("row"),
+                doc.getInteger("col"),
+                doc.getString("team"),
+                doc.getString("type")
+        );
+    }
+}

src/main/java/dao/mongodb/MongoConnection.java

@@ -0,0 +1,30 @@
+package dao.mongodb;
+
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+import org.bson.Document;
+
+public class MongoConnection implements AutoCloseable {
+
+    private static final String CONNECTION_STRING = "mongodb://admin:password123@localhost:27017";
+    private static final String DATABASE_NAME = "janggi";
+
+    private final MongoClient client;
+    private final MongoDatabase database;
+
+    public MongoConnection() {
+        this.client = MongoClients.create(CONNECTION_STRING);
+        this.database = client.getDatabase(DATABASE_NAME);
+    }
+
+    public MongoCollection<Document> getCollection(String name) {
+        return database.getCollection(name);
+    }
+
+    @Override
+    public void close() {
+        client.close();
+    }
+}