[🚀 사이클1 - 미션 (보드 초기화 + 기물 이동)] 에버 미션 제출합니다.

README.md

@@ -1,3 +1,62 @@
 # java-janggi
 
-장기 미션 저장소
+## 프로그램 흐름
+1. **[출력] 장기 게임 시작 문구를 출력한다.**
+2. **[중간 과정] 장기판을 초기화한다.**
+3. **[출력] 초기화된 장기판을 출력한다.**
+4. **[입력] 움직일 기물 좌표를 입력받는다.**
+
+   [예외처리] 좌표를 쉼표로 구분하지 않았을 경우 IllegalArgmentException 예외를 발생시킨다.
+
+   [예외처리] 좌표를 숫자로 입력하지 않았을 경우 IllegalArgmentException 예외를 발생시킨다.
+
+   [예외처리] 장기판 범위 밖의 좌표를 입력했을 경우 IllegalArgmentException 예외를 발생시킨다.
+
+   [예외처리] 입력한 좌표에 기물이 없을 경우 IllegalArgmentException 예외를 발생시킨다.
+5. **[입력] 목적지 좌표를 입력받는다.**
+
+   [예외처리] 좌표를 쉼표로 구분하지 않았을 경우 IllegalArgmentException 예외를 발생시킨다.
+
+   [예외처리] 좌표를 숫자로 입력하지 않았을 경우 IllegalArgmentException 예외를 발생시킨다.
+
+   [예외처리] 장기판 범위 밖의 좌표를 입력했을 경우 IllegalArgmentException 예외를 발생시킨다.
+
+   [예외처리] 입력한 좌표 또는 이동 경로에 아군 기물이 존재할 경우 IllegalArgmentException 예외를 발생시킨다.
+6. **[중간 과정] 기물을 이동시킨다.**
+7. **[출력] 갱신된 장기판을 출력한다.**
+
+## 출력예시
+```
+장기 게임을 시작합니다.
+
+  　　１　２　３　４　５　６　７　８　９　
+１０　차　마　상　사　．　사　상　마　차　
+　９　．　．　．　．　궁　．　．　．　．　
+　８　．　포　．　．　．　．　．　포　．　
+　７　졸　．　졸　．　졸　．　졸　．　졸　
+　６　．　．　．　．　．　．　．　．　．　
+　５　．　．　．　．　．　．　．　．　．　
+　４　졸　．　졸　．　졸　．　졸　．　졸　
+　３　．　포　．　．　．　．　．　포　．　
+　２　．　．　．　．　궁　．　．　．　．　
+　１　차　마　상　사　．　사　상　마　차　
+초나라의 차례입니다.
+움직일 기물의 좌표를 입력해주세요. (ex. 1,3)
+1,1
+차의 목적 좌표를 입력해주세요. (ex. 1,3)
+1,3
+  　　１　２　３　４　５　６　７　８　９　
+１０　차　마　상　사　．　사　상　마　차　
+　９　．　．　．　．　궁　．　．　．　．　
+　８　．　포　．　．　．　．　．　포　．　
+　７　졸　．　졸　．　졸　．　졸　．　졸　
+　６　．　．　．　．　．　．　．　．　．　
+　５　．　．　．　．　．　．　．　．　．　
+　４　졸　．　졸　．　졸　．　졸　．　졸　
+　３　차　포　．　．　．　．　．　포　．　
+　２　．　．　．　．　궁　．　．　．　．　
+　１　．　마　상　사　．　사　상　마　차　
+한나라의 차례입니다.
+움직일 기물의 좌표를 입력해주세요. (ex. 1,3)
+
+```

src/main/java/janggi/Application.java

@@ -0,0 +1,9 @@
+package janggi;
+
+public class Application {
+
+    public static void main(String[] args) {
+        JanggiRunner janggiRunner = new JanggiRunner();
+        janggiRunner.execute();
+    }
+}

src/main/java/janggi/JanggiRunner.java

@@ -0,0 +1,50 @@
+package janggi;
+
+import janggi.domain.JanggiGame;
+import janggi.domain.Position;
+import janggi.util.DelimiterParser;
+import janggi.util.ActionExecutor;
+import janggi.view.InputView;
+import janggi.view.OutputView;
+import java.util.List;
+
+public class JanggiRunner {
+
+    private final JanggiGame janggiGame;
+
+    public JanggiRunner() {
+        this.janggiGame = JanggiGame.createInitialJanggiGame();
+    }
+
+    public void execute() {
+        OutputView.printStartMessage();
+
+        while (true) {
+            OutputView.printBoard(janggiGame.makeCurrentTurnBoardSnapShot());
+            Position startPosition = ActionExecutor.retryUntilSuccess(this::readValidStartPosition);
+            Position endPosition = ActionExecutor.retryUntilSuccess(() -> readValidEndPosition(startPosition));
+            janggiGame.doGame(startPosition, endPosition);
+        }
+    }
+
+    private Position readValidStartPosition() {
+        OutputView.printTurnNotice(janggiGame.getCurrentTurnTeamName());
+        OutputView.printAskPiecePosition();
+        Position startPosition = createPosition();
+        janggiGame.validatePieceExists(startPosition);
+        return startPosition;
+    }
+
+    private Position readValidEndPosition(Position startPosition) {
+        OutputView.printAskMovePosition(janggiGame.getPieceName(startPosition));
+        Position endPosition = createPosition();
+        janggiGame.validateValidEndPosition(startPosition, endPosition);
+        return endPosition;
+    }
+
+    private static Position createPosition() {
+        String rawPiecePosition = InputView.readLine();
+        List<String> parsedPiecePosition = DelimiterParser.parse(rawPiecePosition);
+        return Position.makePosition(parsedPiecePosition);
+    }
+}

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

@@ -0,0 +1,143 @@
+package janggi.domain;
+
+import janggi.domain.piece.Piece;
+import janggi.domain.side.Chu;
+import janggi.domain.side.Han;
+import janggi.domain.side.Team;
+import janggi.domain.side.TeamType;
+import janggi.dto.BoardSpots;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class Board {
+
+    private static final int FIRST_INDEX = 1;
+    private static final int LAST_X_INDEX = 9;
+    private static final int LAST_Y_INDEX = 10;
+
+    private final Team chu;
+    private final Team han;
+
+    private Board(Team chu, Team han) {
+        this.chu = chu;
+        this.han = han;
+    }
+
+    public static Board createInitialBoard() {
+        return new Board(Chu.createInitialChu(), Han.createInitialHan());
+    }
+
+    public BoardSpots makeSnapShot() {
+        Map<Position, Piece> allPieces = new HashMap<>(chu.getPieces());
+        allPieces.putAll(han.getPieces());
+        return BoardSpots.from(allPieces);
+    }
+
+    public boolean isPieceExists(Position position, TeamType currentTeamType) {
+        validateRange(position);
+        Team currentTeam = currentTeam(currentTeamType);
+        return currentTeam.isPieceExists(position);
+    }
+
+    public String getPieceName(Position position, TeamType currentTeamType) {
+        Piece piece = findTeamPiece(position, currentTeam(currentTeamType));
+        return piece.name();
+    }
+
+    public void validateCanMove(Position start, Position end, TeamType currentTeamType) {
+        validateRange(end);
+        checkSamePosition(start, end);
+        validateTeamPieceExistsAtEnd(currentTeam(currentTeamType), end);
+        validatePiecesInPath(start, end, currentTeam(currentTeamType));
+    }
+
+    public Optional<Piece> findPiece(Position position) {
+        Optional<Piece> chuPiece = chu.findPiece(position);
+        if (chuPiece.isPresent()) {
+            return chuPiece;
+        }
+        return han.findPiece(position);
+    }
+
+    public Board move(Position start, Position end, TeamType currentTeamType) {
+        Team updatedCurrentTeam = currentTeam(currentTeamType).move(start, end);
+        Team updatedOpponentTeam = removeOpponentPiece(currentTeamType, end);
+        return createMovedBoard(currentTeamType, updatedCurrentTeam, updatedOpponentTeam);
+    }
+
+    private void validateRange(Position inputPosition) {
+        int x = inputPosition.getX();
+        int y = inputPosition.getY();
+        if (isNotInRange(FIRST_INDEX, LAST_X_INDEX, x) || isNotInRange(FIRST_INDEX, LAST_Y_INDEX, y)) {
+            throw new IllegalArgumentException("입력한 좌표가 장기판 범위 밖입니다.");
+        }
+    }
+
+    private boolean isNotInRange(int start, int last, int index) {
+        return !isInRange(start, last, index);
+    }
+
+    private boolean isInRange(int start, int last, int index) {
+        return index >= start && index <= last;
+    }
+
+    private void checkSamePosition(Position start, Position end) {
+        if (start.isSamePosition(end)) {
+            throw new IllegalArgumentException("출발지와 목적지가 동일합니다.");
+        }
+    }
+
+    private void validateTeamPieceExistsAtEnd(Team team, Position end) {
+        if (team.isPieceExists(end)) {
+            throw new IllegalArgumentException("아군이 존재하는 좌표로는 이동할 수 없습니다.");
+        }
+    }
+
+    private Team currentTeam(TeamType currentTeamType) {
+        if (currentTeamType == TeamType.CHU) {
+            return chu;
+        }
+        return han;
+    }
+
+    private void validatePiecesInPath(Position start, Position end, Team currentTeam) {
+        Piece piece = findTeamPiece(start, currentTeam);
+        List<Position> piecePositionsInPath = piece.getPiecePositionsInPath(start, end);
+        List<Piece> piecesInPath = piecePositionsInPath.stream()
+                .map(this::findPiece)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .toList();
+        piece.validateCanMove(piecesInPath);
+    }
+
+    private Piece findTeamPiece(Position position, Team currentTeam) {
+        return currentTeam.findPiece(position)
+                .orElseThrow(() -> new IllegalArgumentException("입력한 위치에 기물이 없습니다."));
+    }
+
+    private Team removeOpponentPiece(TeamType currentTeamType, Position end) {
+        Team opponentTeam = opponentTeam(currentTeamType);
+        if (opponentTeam.findPiece(end).isEmpty()) {
+            return opponentTeam;
+        }
+        return opponentTeam.remove(end);
+    }
+
+    private Team opponentTeam(TeamType currentTeamType) {
+        if (currentTeamType == TeamType.CHU) {
+            return han;
+        }
+        return chu;
+    }
+
+    private Board createMovedBoard(TeamType currentTeamType, Team updatedCurrentTeam, Team updatedOpponentTeam) {
+        if (currentTeamType == TeamType.CHU) {
+            return new Board(updatedCurrentTeam, updatedOpponentTeam);
+        }
+        return new Board(updatedOpponentTeam, updatedCurrentTeam);
+    }
+}

src/main/java/janggi/domain/Delta.java

@@ -0,0 +1,30 @@
+package janggi.domain;
+
+public enum Delta {
+
+    UP(0, 1),
+    DOWN(0, -1),
+    RIGHT(1, 0),
+    LEFT(-1, 0),
+    RIGHT_UP(1, 1),
+    LEFT_UP(-1, 1),
+    RIGHT_DOWN(1, -1),
+    LEFT_DOWN(-1, -1),
+    ;
+
+    private final int dx;
+    private final int dy;
+
+    Delta(int dx, int dy) {
+        this.dx = dx;
+        this.dy = dy;
+    }
+
+    public int getDx() {
+        return dx;
+    }
+
+    public int getDy() {
+        return dy;
+    }
+}

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

@@ -0,0 +1,55 @@
+package janggi.domain;
+
+import janggi.dto.BoardSpots;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class JanggiGame {
+
+    private final List<Turn> turns;
+
+    private JanggiGame(List<Turn> turns) {
+        this.turns = new ArrayList<>(turns);
+    }
+
+    public static JanggiGame createInitialJanggiGame() {
+        return new JanggiGame(List.of(Turn.createInitialTurn()));
+    }
+
+    public BoardSpots makeCurrentTurnBoardSnapShot() {
+        Turn lastTurn = getLastTurn();
+        return lastTurn.makeBoardSnapShot();
+    }
+
+    public String getCurrentTurnTeamName() {
+        Turn lastTurn = getLastTurn();
+        return lastTurn.nextTurnTeam();
+    }
+
+    public void validatePieceExists(Position position) {
+        Turn lastTurn = getLastTurn();
+        if (!lastTurn.isNextTurnTeamPieceExists(position)) {
+            throw new IllegalArgumentException("기물이 존재하는 좌표가 아닙니다.");
+        }
+    }
+
+    public String getPieceName(Position position) {
+        return getLastTurn().getPieceName(position);
+    }
+
+    public void validateValidEndPosition(Position start, Position end) {
+        Turn lastTurn = getLastTurn();
+        lastTurn.validateCanMove(start, end);
+    }
+
+    public void doGame(Position start, Position end) {
+        Turn lastTurn = getLastTurn();
+        Turn newTurn = lastTurn.move(start, end);
+        turns.add(newTurn);
+    }
+
+    private Turn getLastTurn() {
+        return turns.getLast();
+    }
+}