[4, 5단계 - 체스] 라이언(권영훈) 미션 제출합니다.

README.md

@@ -75,4 +75,15 @@
 - [x] 왕 잡으면 종료되는 기능
 - [x] Status: (말이 잡힐때마다 업데이트)
 - [x] 승패여부 및 점수 관리(3단계 이후)
-- [x] 플레이어가 자신의 말만 옮길 수 있는 유효성 검증 넣기
+- [x] 플레이어가 자신의 말만 옮길 수 있는 유효성 검증 넣기
+
+
+## 4단계
+- [x] ChessBoard에 대한 html파일을 만든다.
+- [x] ChessBoard에 대한 css파일을 만든다.
+- [x] ChessBoard에서 클릭하는 부분 자바스크립트 작성.
+- [x] ChessBoard에서 클릭한 정보 백엔드로 전송
+- [x] 백엔드에서 rest api 작성
+
+## 5단계
+- [x] 진행중이던 게임을 불러오는 Db 구현.

build.gradle

@@ -14,6 +14,10 @@ dependencies {
     compile('ch.qos.logback:logback-classic:1.2.3')
     testCompile('org.junit.jupiter:junit-jupiter:5.6.0')
     testCompile('org.assertj:assertj-core:3.15.0')
+    implementation group: 'com.google.code.gson', name: 'gson', version: '2.8.6'
+    implementation("mysql:mysql-connector-java:8.0.16")
+    implementation group: 'commons-dbcp', name: 'commons-dbcp', version: '1.4'
+
 }
 
 test {

src/main/java/chess/WebUIChessApplication.java

@@ -1,18 +1,98 @@
 package chess;
 
+import chess.dao.ChessDAO;
+import chess.domain.grid.ChessGame;
+import chess.domain.grid.Grid;
+import chess.domain.grid.gridStrategy.NormalGridStrategy;
+import chess.domain.piece.Color;
+import chess.domain.position.Position;
+import chess.dto.PositionDTO;
+import chess.entity.Chess;
+import com.google.gson.Gson;
 import spark.ModelAndView;
 import spark.template.handlebars.HandlebarsTemplateEngine;
 
+import java.sql.SQLDataException;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 
-import static spark.Spark.get;
+import static spark.Spark.*;
 
 public class WebUIChessApplication {
+    private static final Gson GSON = new Gson();
+    private static final int SUCCESSFUL_RESPONSE = 200;
+    private static final int CLIENT_ERROR_RESPONSE = 400;
+    private static final String CHESS_ID = "1";
+
     public static void main(String[] args) {
+        staticFiles.location("/public");
+        ChessGame chessGame = new ChessGame(new Grid(new NormalGridStrategy()));
+        ChessDAO chessDAO = new ChessDAO();
+
         get("/", (req, res) -> {
-            Map<String, Object> model = new HashMap<>();
-            return render(model, "index.html");
+            return render(new HashMap<>(), "index.html");
+        });
+
+        get("/pieces", (req, res) -> {
+            return chessGame.pieceMap();
+        }, GSON::toJson);
+
+        get("/turn", (req, res) -> {
+            return chessGame.turn();
+        }, GSON::toJson);
+
+        get("/score/white", (req, res) -> {
+            return chessGame.score(Color.WHITE);
+        }, GSON::toJson);
+
+        get("/score/black", (req, res) -> {
+            return chessGame.score(Color.BLACK);
+        }, GSON::toJson);
+
+        get("/gameover", (req, res) -> {
+            return Arrays.asList(chessGame.isGameOver(), chessGame.getWinner());
+        }, GSON::toJson);
+
+        post("/move", (req, res) -> {
+            PositionDTO positionDTO = GSON.fromJson(req.body(), PositionDTO.class);
+            String sourcePosition = positionDTO.getSourcePosition();
+            String targetPosition = positionDTO.getTargetPosition();
+            try {
+                chessGame.move(chessGame.grid().piece(new Position(sourcePosition)),
+                        chessGame.grid().piece(new Position(targetPosition)));
+                return SUCCESSFUL_RESPONSE;
+            } catch (IllegalArgumentException error) {
+                return CLIENT_ERROR_RESPONSE;
+            }
+        });
+
+        post("/start", (req, res) -> {
+            chessGame.start();
+            return SUCCESSFUL_RESPONSE;
+        });
+
+        post("/reset", (req, res) -> {
+            chessGame.reset();
+            return SUCCESSFUL_RESPONSE;
+        });
+
+        post("/save", (req, res) -> {
+            Chess chess = new Chess(CHESS_ID, chessGame.gridStringify(), chessGame.turn().name());
+            if (chessDAO.findByChessId(CHESS_ID) == null) {
+                chessDAO.addChess(chess);
+            }
+            chessDAO.updateChess(chess, chess.getChess(), chess.getTurn());
+            return SUCCESSFUL_RESPONSE;
+        });
+
+        post("/load", (req, res) -> {
+            if (chessDAO.findByChessId(CHESS_ID) == null) {
+                throw new SQLDataException("저장된 보드가 없습니다.");
+            }
+            Chess chess = chessDAO.findByChessId(CHESS_ID);
+            chessGame.load(chess);
+            return SUCCESSFUL_RESPONSE;
         });
     }
 

src/main/java/chess/controller/ChessController.java

@@ -1,86 +1,78 @@
 package chess.controller;
 
+import chess.domain.grid.ChessGame;
 import chess.domain.grid.Grid;
 import chess.domain.grid.gridStrategy.GridStrategy;
 import chess.domain.grid.gridStrategy.NormalGridStrategy;
 import chess.domain.piece.Color;
-import chess.domain.state.*;
+import chess.domain.piece.Piece;
+import chess.domain.position.Position;
 import chess.view.InputView;
 import chess.view.OutputView;
 
+import java.util.Arrays;
+import java.util.List;
+
 public class ChessController {
     private static final String COMMAND_START = "start";
     private static final String COMMAND_END = "end";
     private static final String COMMAND_MOVE = "move";
     private static final String COMMAND_STATUS = "status";
-
-    private GameState gameState;
-
-    public ChessController() {
-        this.gameState = new Ready();
-    }
+    private static final String WHITE_SPACE_DELIMITER = " ";
 
     public final void run() {
         OutputView.printChessInstruction();
         GridStrategy gridStrategy = new NormalGridStrategy();
         Grid grid = new Grid(gridStrategy);
+        ChessGame game = new ChessGame(grid);
         do {
-            command(grid);
+            command(game);
         }
-        while (!gameState.isFinished());
+        while (!game.isFinished());
     }
 
-    private void command(final Grid grid) {
+    private void command(final ChessGame game) {
         try {
-            runCommand(grid);
+            runCommand(game);
         } catch (IllegalArgumentException error) {
             OutputView.printError(error);
         }
     }
 
-    private void runCommand(final Grid grid) {
+    private void runCommand(final ChessGame game) {
         String command = InputView.command();
         if (command.equals(COMMAND_START)) {
-            startCommand(grid, command);
+            startCommand(game);
             return;
         }
         if (command.equals(COMMAND_END)) {
-            endCommand();
+            endCommand(game);
             return;
         }
         if (command.equals(COMMAND_STATUS)) {
-            statusCommand(grid);
+            statusCommand(game);
             return;
         }
         if (command.startsWith(COMMAND_MOVE)) {
-            moveCommand(grid, command);
+            moveCommand(game, command);
             return;
         }
         throw new IllegalArgumentException("잘못 입력 하셨습니다.");
     }
 
-    private void startCommand(final Grid grid, final String command) {
-        if (gameState instanceof Ready) {
-            OutputView.printGridStatus(grid.lines());
-            gameState = gameState.run(grid, command);
-            return;
-        }
-        throw new IllegalArgumentException("게임이 이미 시작 하였습니다.");
+    private void startCommand(final ChessGame game) {
+        OutputView.printGridStatus(game.grid().lines());
+        game.start();
     }
 
-    private void endCommand() {
-        gameState = new End();
+    private void endCommand(ChessGame game) {
+        game.end();
     }
 
-    private void statusCommand(final Grid grid) {
-        if (gameState instanceof Ready) {
-            throw new IllegalArgumentException("게임을 아직 시작 하지 않았습니다.");
-        }
-        if (gameState instanceof Playing) {
-            gameState = new Status();
-        }
-        double blackScore = grid.score(Color.BLACK);
-        double whiteScore = grid.score(Color.WHITE);
+    private void statusCommand(final ChessGame game) {
+        game.status();
+        double blackScore = game.grid().score(Color.BLACK);
+        double whiteScore = game.grid().score(Color.WHITE);
         OutputView.printScores(Color.BLACK, blackScore);
         OutputView.printScores(Color.WHITE, whiteScore);
         if (blackScore > whiteScore) {
@@ -91,21 +83,17 @@ private void statusCommand(final Grid grid) {
         }
     }
 
-    private void moveCommand(final Grid grid, final String command) {
-        if (!(gameState instanceof Playing)) {
-            throw new IllegalArgumentException("게임을 아직 시작 하지 않았습니다.");
-        }
-        gameState = gameState.run(grid, command);
-        if (!grid.kingSurvived(Color.BLACK)) {
-            OutputView.printWinner(Color.WHITE);
-            gameState = new End();
-            return;
-        }
-        if (!grid.kingSurvived(Color.WHITE)) {
-            OutputView.printWinner(Color.BLACK);
-            gameState = new End();
+    private void moveCommand(final ChessGame game, final String command) {
+        List<String> moveInput = Arrays.asList(command.split(WHITE_SPACE_DELIMITER));
+        Position sourcePosition = new Position(moveInput.get(1));
+        Position targetPosition = new Position(moveInput.get(2));
+        Piece sourcePiece = game.grid().piece(sourcePosition);
+        Piece targetPiece = game.grid().piece(targetPosition);
+        game.move(sourcePiece, targetPiece);
+        if (game.isGameOver()) {
+            OutputView.printWinner(game.getWinner());
             return;
         }
-        OutputView.printGridStatus(grid.lines());
+        OutputView.printGridStatus(game.grid().lines());
     }
 }