[3, 4단계 - 체스] 제이(이재윤) 미션 제출합니다.

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

@@ -1,10 +1,12 @@
 package chess.controller;
 
+import chess.domain.board.Board;
 import chess.domain.commnad.Command;
 import chess.domain.commnad.LoadGameCommand;
 import chess.domain.game.ChessGame;
 import chess.dto.BoardResultDto;
 import chess.dto.BoardSaveDto;
+import chess.dto.ChessGameResponseDto;
 import chess.dto.GameScoreResultDto;
 import chess.factory.BoardFactory;
 import chess.service.BoardService;
@@ -43,9 +45,11 @@ public void run() {
 
     private ChessGame loadGame(final LoadGameCommand loadCommand) {
         if (loadCommand.isSavedGame()) {
-            ChessGame chessGame = boardService.findById(BOARD_ID).getChessGame();
-            outputView.printBoard(BoardResultDto.toDto(chessGame));
-            return chessGame;
+            ChessGameResponseDto chessGameResponseDto = boardService.findById(BOARD_ID);
+            BoardResultDto boardResultDto = chessGameResponseDto.getBoardResultDto();
+
+            outputView.printBoard(boardResultDto.getPieces());
+            return new ChessGame(BoardFactory.createFromDto(boardResultDto), chessGameResponseDto.isLowerTeamTurn());
         }
 
         return new ChessGame(BoardFactory.createBoard(), true);
@@ -59,7 +63,7 @@ private void playChess(ChessGame chessGame) {
             chessGame = checkCreateNewGame(chessGame, command);
 
             checkMovePiece(chessGame, command);
-            outputView.printBoard(BoardResultDto.toDto(chessGame));
+            outputView.printBoard(BoardResultDto.toDto(new Board(chessGame.getBoard())).getPieces());
 
             if (isGameDone(chessGame)) {
                 break;

src/main/java/chess/dto/BoardResultDto.java

@@ -1,24 +1,27 @@
 package chess.dto;
 
-import chess.domain.board.Position;
-import chess.domain.game.ChessGame;
-import chess.domain.pieces.Piece;
-import java.util.Collections;
-import java.util.Map;
+import chess.domain.board.Board;
+import java.util.List;
+import java.util.stream.Collectors;
 
 public class BoardResultDto {
 
-    private final Map<Position, Piece> board;
+    private final List<PieceDto> pieces;
 
-    private BoardResultDto(final Map<Position, Piece> board) {
-        this.board = board;
+    private BoardResultDto(final List<PieceDto> pieces) {
+        this.pieces = pieces;
     }
 
-    public static BoardResultDto toDto(final ChessGame chessGame) {
-        return new BoardResultDto(chessGame.getBoard());
+    public static BoardResultDto toDto(final Board board) {
+
+        List<PieceDto> positionsWithPieces = board.getBoard().entrySet().stream()
+                .map(entry -> PieceDto.toDto(entry.getKey(), board.getBoard().get(entry.getKey())))
+                .collect(Collectors.toList());
+
+        return new BoardResultDto(positionsWithPieces);
     }
 
-    public Map<Position, Piece> getBoard() {
-        return Collections.unmodifiableMap(board);
+    public List<PieceDto> getPieces() {
+        return pieces;
     }
 }

src/main/java/chess/dto/ChessGameResponseDto.java

@@ -1,21 +1,26 @@
 package chess.dto;
 
 import chess.domain.board.Board;
-import chess.domain.game.ChessGame;
 
 public class ChessGameResponseDto {
 
-    private final ChessGame chessGame;
+    private final BoardResultDto boardResultDto;
+    private final boolean isLowerTeamTurn;
 
-    private ChessGameResponseDto(final ChessGame chessGame) {
-        this.chessGame = chessGame;
+    public ChessGameResponseDto(final BoardResultDto boardResultDto, final boolean isLowerTeamTurn) {
+        this.boardResultDto = boardResultDto;
+        this.isLowerTeamTurn = isLowerTeamTurn;
     }
 
     public static ChessGameResponseDto toDto(final Board board, final boolean isLowerTeamTurn) {
-        return new ChessGameResponseDto(new ChessGame(board, isLowerTeamTurn));
+        return new ChessGameResponseDto(BoardResultDto.toDto(board), isLowerTeamTurn);
     }
 
-    public ChessGame getChessGame() {
-        return chessGame;
+    public BoardResultDto getBoardResultDto() {
+        return boardResultDto;
+    }
+
+    public boolean isLowerTeamTurn() {
+        return isLowerTeamTurn;
     }
 }

src/main/java/chess/dto/PieceDto.java

@@ -0,0 +1,33 @@
+package chess.dto;
+
+import chess.domain.board.Position;
+import chess.domain.pieces.Piece;
+
+public class PieceDto {
+
+    private final char col;
+    private final char row;
+    private final String piece;
+
+    private PieceDto(final char row, final char col, final String piece) {
+        this.row = row;
+        this.col = col;
+        this.piece = piece;
+    }
+
+    public static PieceDto toDto(final Position position, final Piece piece) {
+        return new PieceDto(position.getCol(), position.getRow(), piece.getName());
+    }
+
+    public char getCol() {
+        return col;
+    }
+
+    public char getRow() {
+        return row;
+    }
+
+    public String getPiece() {
+        return piece;
+    }
+}

src/main/java/chess/factory/BoardFactory.java

@@ -1,5 +1,7 @@
 package chess.factory;
 
+import static chess.util.PieceParser.parsePiece;
+
 import chess.domain.board.Board;
 import chess.domain.board.Column;
 import chess.domain.board.Position;
@@ -13,6 +15,8 @@
 import chess.domain.pieces.Place;
 import chess.domain.pieces.Queen;
 import chess.domain.pieces.Rook;
+import chess.dto.BoardResultDto;
+import chess.dto.PieceDto;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -30,6 +34,21 @@ public static Board createBoard() {
         return new Board(chessBoard);
     }
 
+    public static Board createFromDto(final BoardResultDto boardResultDto) {
+        Map<Position, Piece> chessBoard = new HashMap<>();
+        List<PieceDto> pieces = boardResultDto.getPieces();
+
+        pieces.stream()
+                .forEach(piece -> chessBoard.put(Position.from(String.valueOf(piece.getRow()) + piece.getCol()),
+                        parsePiece(piece.getPiece())));
+
+        return new Board(chessBoard);
+    }
+
+    public static Board createFromUncompressedBoard(final Map<Position, Piece> unCompressedBoard) {
+        return new Board(unCompressedBoard);
+    }
+
     private static List<Position> makePosition() {
         List<Position> positions = Arrays.stream(Column.values())
                 .flatMap(col -> Arrays.stream(Row.values())

src/main/java/chess/service/BoardService.java

@@ -1,12 +1,10 @@
 package chess.service;
 
 import chess.dao.board.BoardDao;
-import chess.domain.board.Board;
 import chess.domain.board.Position;
-import chess.domain.game.ChessGame;
 import chess.domain.pieces.Piece;
-import chess.dto.ChessGameResponseDto;
 import chess.dto.BoardSaveDto;
+import chess.dto.ChessGameResponseDto;
 import chess.factory.BoardFactory;
 import chess.util.BoardUtil;
 import java.util.List;
@@ -36,7 +34,9 @@ public ChessGameResponseDto findById(final int boardId) {
         }
 
         Map<Position, Piece> unCompressedBoard = boardUtil.unCompressBoard(compressedBoardFromDatabase);
-        return ChessGameResponseDto.toDto(new Board(unCompressedBoard), boardDao.isLowerTeamTurnByBoardId(boardId));
+
+        return ChessGameResponseDto.toDto(BoardFactory.createFromUncompressedBoard(unCompressedBoard),
+                boardDao.isLowerTeamTurnByBoardId(boardId));
     }
 
     public void delete(final int boardId) {

src/main/java/chess/util/PieceParser.java

@@ -0,0 +1,42 @@
+package chess.util;
+
+import chess.domain.pieces.Bishop;
+import chess.domain.pieces.King;
+import chess.domain.pieces.Knight;
+import chess.domain.pieces.Name;
+import chess.domain.pieces.Pawn;
+import chess.domain.pieces.Piece;
+import chess.domain.pieces.Place;
+import chess.domain.pieces.Queen;
+import chess.domain.pieces.Rook;
+
+public class PieceParser {
+
+    public static Piece parsePiece(final String name) {
+        if (name.equals("r") || name.equals("R")) {
+            return new Rook(new Name(name));
+        }
+
+        if (name.equals("n") || name.equals("N")) {
+            return new Knight(new Name(name));
+        }
+
+        if (name.equals("b") || name.equals("B")) {
+            return new Bishop(new Name(name));
+        }
+
+        if (name.equals("q") || name.equals("Q")) {
+            return new Queen(new Name(name));
+        }
+
+        if (name.equals("p") || name.equals("P")) {
+            return new Pawn(new Name(name));
+        }
+
+        if (name.equals("k") || name.equals("K")) {
+            return new King(new Name(name));
+        }
+
+        return new Place();
+    }
+}

src/main/java/chess/view/OutputView.java

@@ -1,8 +1,12 @@
 package chess.view;
 
+import static chess.util.PieceParser.parsePiece;
+
 import chess.domain.board.Position;
 import chess.domain.pieces.Piece;
-import chess.dto.BoardResultDto;
+import chess.dto.PieceDto;
+import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public class OutputView {
@@ -16,14 +20,21 @@ public void printStartMessage() {
                 + "> 게임 이동 : move source위치 target위치 - 예. move b2 b3");
     }
 
-    public void printBoard(final BoardResultDto boardResultDto) {
-        System.out.println();
+    public void printBoard(final List<PieceDto> pieces) {
+        Map<Position, Piece> board = new HashMap<>();
+
+        pieces.forEach(pieceDto -> board.put(Position.from(findPosition(pieceDto)), parsePiece(pieceDto.getPiece())));
+
         for (char row = '8'; row >= '1'; row--) {
-            printLine(boardResultDto.getBoard(), row);
+            printLine(board, row);
             System.out.println();
         }
     }
 
+    private String findPosition(final PieceDto pieceDto) {
+        return String.valueOf(pieceDto.getRow()) + pieceDto.getCol();
+    }
+
     private void printLine(final Map<Position, Piece> board, final char row) {
         for (char col = 'a'; col <= 'h'; col++) {
             String position = String.valueOf(col) + String.valueOf(row);