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

README.md

@@ -1,3 +1,195 @@
 # java-janggi
 
-장기 미션 저장소
+> 장기 미션 저장소
+
+페어 : [스타크](https://github.com/MODUGGAGI), [러키](https://github.com/Jiihyun)
+
+---
+
+## 👥 페어 프로그래밍 규칙
+
+네비게이터, 드라이버 역할 교환은 **15분**에 한번씩
+
+|          **네비게이터**          |            **드라이버**            |
+|:---------------------------:|:------------------------------:|
+| 드라이버에게 지시와 동시에 서로의 대화 내용 기록 | 자신이 작성하려는 코드의 의도를 항상 명확히 말로 전달 |
+
+---
+
+## 🀄️ 구현 기능 목록
+
+## ✅ 입력
+
+- [x] 게임 시작 시 상차림 입력 받기
+    - [x] 지정된 명령어 이외의 문자열 및 숫자 값은 `IllegalArgumentException`을 발생시킨다.
+
+- [x] 플레이어의 선택 기물 좌표 입력
+    - [x] 공백일 경우 `IllegalArgumentException`을 발생시킨다.
+    - [x] 숫자가 아닐 경우 `IllegalArgumentException`을 발생시킨다.
+    - [x] 구분자가 `,`가 아닐 경우 `IllegalArgumentException`을 발생시킨다.
+
+- [x] 플레이어의 목표 좌표 입력
+    - [x] 공백일 경우 `IllegalArgumentException`을 발생시킨다.
+    - [x] 숫자가 아닐 경우 `IllegalArgumentException`을 발생시킨다.
+    - [x] 구분자가 `,`가 아닐 경우 `IllegalArgumentException`을 발생시킨다.
+
+## ✅ 출력
+
+- [x] 장기판 출력
+    - 상차림 선택 후
+    - 목표 좌표 입력 후
+- [x] 현재 차례인 나라 출력
+    - 『한』, 『초』
+
+## ✅ 비지니스 기능
+
+### 보드 초기화
+
+- [x] 『한』 상차림
+- [x] 『초』 상차림
+
+```text
+- 좌측 상단을 0행 0열 이라 가정
+
+장*1개
+시작 위치
+- 한나라: 1행 4열
+- 초나라: 8행 4열
+
+사*2개
+시작 위치
+- 한나라: 0행 3열, 0행 5열
+- 초나라: 9행 3열, 9행 5열
+
+차*2개
+시작 위치
+- 한나라: 0행 0열, 0행 8열
+- 초나라: 9행 0열, 9행 8열
+
+포*2개
+시작 위치
+- 한나라: 2행 1열, 2행 7열
+- 초나라: 7행 1열, 7행 7열
+
+마*2개
+시작 위치
+- 한나라: 0행 2열, 0행 7열
+- 초나라: 9행 2열, 9행 7열
+
+상*2개
+시작 위치
+- 한나라: 0행 1열, 0행 6열
+- 초나라: 9행 1열, 9행 6열
+
+졸*5개
+시작 위치
+- 한나라: 3행 0열, 3행 2열, 3행 4열, 3행 6열, 3행 8열
+- 초나라: 6행 0열, 6행 2열, 6행 4열, 6행 6열, 6행 8열
+```
+
+### 기물 이동
+
+- [x] 이동 시키려는 기물의 좌표를 확인한다.
+    - [x] 좌표가 장기판 범위 벗어난 좌표일 경우 `IllegalArgumentException`을 발생시킨다.
+    - [x] 좌표에 기물이 존재 하지 않을 경우 `IllegalArgumentException`을 발생시킨다.
+    - [x] 좌표의 기물이 자신의 진영이 아닐 경우 `IllegalArgumentException`을 발생시킨다.
+
+- [x] 기물을 목적지 좌표로 이동한다.
+    - [x] 목적지 좌표가 장기판 범위 벗어난 좌표일 경우 `IllegalArgumentException`을 발생시킨다.
+    - [x] 기물 규칙 및 제약에 맞게 이동한다.
+        - [차(車)]
+            - [x] 상하좌우로 장애물을 만날 때까지 칸 수 제한 없이 이동한다.
+            - [x] 이동하려는 경로 중간에 다른 기물이 **있**다면 `IllegalArgumentException`을 발생시킨다.
+
+        - [포(包)]
+            - [x] 상하좌우로 이동하되, 반드시 중간에 다른 기물을 하나 뛰어넘어야 합니다.
+            - [x] 이동하려는 경로 중간에 다른 기물이 **없**다면 `IllegalArgumentException`을 발생시킨다.
+            - [x] 넘으려는 기물이 포(包) 일 경우 `IllegalArgumentException`을 발생시킨다.
+            - [x] 목적지 좌표의 기물이 포(包)일 경우 `IllegalArgumentException`을 발생시킨다.
+
+        - [마(馬)]
+            - [x] 직선 1칸 + 대각선 1칸(日) 이동한다.
+            - [x] 목적지 좌표(직선 1칸 또는 대각선 1칸)에 다른 기물이 있으면 `IllegalArgumentException`을 발생시킨다.
+
+        - [상(象)]
+            - [x] 직선 1칸 + 대각선 2칸(用) 이동한다.
+            - [x] 목적지 좌표(직선 1칸 또는 대각선 1칸)에 다른 기물이 있으면 `IllegalArgumentException`을 발생시킨다.
+
+        - [궁(楚/漢), 사(士)]
+            - [x] 상하좌우 직선 1칸 이동한다.
+
+        - [졸/병(卒/兵)]
+            - [x] 상좌우 직선 1칸 이동한다. 후진은 불가 주의
+
+---
+
+## 💻 실행 결과
+
+```text
+1. 상마상마
+2. 마상마상
+3. 마상상마
+4. 상마마상
+한나라의 상차림을 선택해주세요.
+1
+
+1. 상마상마
+2. 마상마상
+3. 마상상마
+4. 상마마상
+초나라의 상차림을 선택해주세요.
+3
+
+[장기판]
+  ０ １ ２ ３ ４ ５ ６ ７ ８
+０ 車 馬 象 士 ． 士 象 馬 車
+１ ． ． ． ． 楚 ． ． ． ．
+２ ． 包 ． ． ． ． ． 包 ．
+３ 卒 ． 卒 ． 卒 ． 卒 ． 卒
+４ ． ． ． ． ． ． ． ． ．
+５ ． ． ． ． ． ． ． ． ．
+６ 兵 ． 兵 ． 兵 ． 兵 ． 兵
+７ ． 包 ． ． ． ． ． 包 ．
+８ ． ． ． ． 漢 ． ． ． ．
+９ 車 象 馬 士 ． 士 象 馬 車
+
+초나라 차례 입니다.
+공격할 기물의 좌표를 입력해주세요.
+3,0
+
+이동 시킬 목적지 좌표를 입력해주세요.
+4,0
+
+[장기판]
+  ０ １ ２ ３ ４ ５ ６ ７ ８
+０ 車 馬 象 士 ． 士 象 馬 車
+１ ． ． ． ． 楚 ． ． ． ．
+２ ． 包 ． ． ． ． ． 包 ．
+３ ． ． 卒 ． 卒 ． 卒 ． 卒
+４ 卒 ． ． ． ． ． ． ． ．
+５ ． ． ． ． ． ． ． ． ．
+６ 兵 ． 兵 ． 兵 ． 兵 ． 兵
+７ ． 包 ． ． ． ． ． 包 ．
+８ ． ． ． ． 漢 ． ． ． ．
+９ 車 象 馬 士 ． 士 象 馬 車
+
+한나라 차례 입니다.
+공격할 기물의 좌표를 입력해주세요.
+9,0
+
+이동 시킬 목적지 좌표를 입력해주세요.
+8,0
+
+[장기판]
+  ０ １ ２ ３ ４ ５ ６ ７ ８
+０ 車 馬 象 士 ． 士 象 馬 車
+１ ． ． ． ． 楚 ． ． ． ．
+２ ． 包 ． ． ． ． ． 包 ．
+３ ． ． 卒 ． 卒 ． 卒 ． 卒
+４ 卒 ． ． ． ． ． ． ． ．
+５ ． ． ． ． ． ． ． ． ．
+６ 兵 ． 兵 ． 兵 ． 兵 ． 兵
+７ ． 包 ． ． ． ． ． 包 ．
+８ 車 ． ． ． 漢 ． ． ． ．
+９ ． 象 馬 士 ． 士 象 馬 車
+```

src/main/java/janggi/JanggiApplication.java

@@ -0,0 +1,8 @@
+package janggi;
+
+public class JanggiApplication {
+    public static void main(String[] args) {
+        JanggiGame game = new JanggiGame();
+        game.run();
+    }
+}

src/main/java/janggi/JanggiGame.java

@@ -0,0 +1,76 @@
+package janggi;
+
+import janggi.domain.Position;
+import janggi.domain.Turn;
+import janggi.domain.board.Board;
+import janggi.domain.board.ElephantFormation;
+import janggi.domain.board.InitialPiecePlacement;
+import janggi.domain.piece.Camp;
+import janggi.domain.piece.Piece;
+import janggi.dto.PiecePositionDto;
+import janggi.util.RetryHandler;
+import janggi.view.InputView;
+import janggi.view.OutputView;
+import janggi.view.format.ElephantSetUpFormat;
+import java.util.List;
+import java.util.Map;
+
+public class JanggiGame {
+
+    public void run() {
+        Board board = createBoard();
+        OutputView.printBoard(toPiecePositions(board.getBoard()));
+        play(board);
+    }
+
+    private Board createBoard() {
+        ElephantFormation hanElephantFormation = readElephantFormation(Camp.HAN);
+        ElephantFormation choElephantFormation = readElephantFormation(Camp.CHO);
+        return InitialPiecePlacement.initialize(hanElephantFormation, choElephantFormation);
+    }
+
+    private ElephantFormation readElephantFormation(Camp camp) {
+        return RetryHandler.retryOnInvalidInput(() -> {
+            ElephantSetUpFormat elephantSetUpFormat = InputView.readElephantSettingCommand(camp);
+            return elephantSetUpFormat.toElephantFormation(camp);
+        });
+    }
+
+    private List<PiecePositionDto> toPiecePositions(Map<Position, Piece> boardState) {
+        return boardState.entrySet().stream()
+                .map(entry -> PiecePositionDto.of(entry.getKey(), entry.getValue()))
+                .toList();
+    }
+
+    private void play(Board board) {
+        Turn turn = new Turn();
+        while (true) {
+            RetryHandler.retryOnInvalidInput(() -> playTurn(board, turn));
+            OutputView.printBoard(toPiecePositions(board.getBoard()));
+        }
+    }
+
+    private void playTurn(Board board, Turn turn) {
+        Camp camp = turn.currentTurn();
+        Position source = readSource(board, camp);
+        Position destination = readDestination(board, source, camp);
+        board.movePiece(source, destination, camp);
+        turn.finishTurn();
+    }
+
+    private Position readSource(Board board, Camp camp) {
+        return RetryHandler.retryOnInvalidInput(() -> {
+            Position source = Position.from(InputView.readSource(camp));
+            board.validateSource(source, camp);
+            return source;
+        });
+    }
+
+    private Position readDestination(Board board, Position source, Camp camp) {
+        return RetryHandler.retryOnInvalidInput(() -> {
+            Position destination = Position.from(InputView.readDestination());
+            board.validateDestination(destination, source, camp);
+            return destination;
+        });
+    }
+}

src/main/java/janggi/domain/Position.java

@@ -0,0 +1,60 @@
+package janggi.domain;
+
+import janggi.exception.ExceptionMessage;
+import java.util.List;
+
+public record Position(int row, int column) {
+
+    private static final int POSITION_SIZE = 2;
+    private static final int MIN_POSITION_INDEX = 0;
+    private static final int MAX_ROW_INDEX = 9;
+    private static final int MAX_COLUMN_INDEX = 8;
+
+    public static Position from(List<Integer> rawPosition) {
+        validatePositionSize(rawPosition);
+        return new Position(rawPosition.get(0), rawPosition.get(1));
+    }
+
+    private static void validatePositionSize(List<Integer> position) {
+        if (position.size() != POSITION_SIZE) {
+            throw new IllegalArgumentException(ExceptionMessage.INVALID_INPUT_FORMAT.getMessage());
+        }
+    }
+
+    public Position {
+        validateRow(row);
+        validateColumn(column);
+    }
+
+    private void validateRow(int row) {
+        if (row < MIN_POSITION_INDEX || MAX_ROW_INDEX < row) {
+            throw new IllegalArgumentException(ExceptionMessage.ROW_OUT_OF_RANGE.getMessage(MIN_POSITION_INDEX, MAX_ROW_INDEX));
+        }
+    }
+
+    private void validateColumn(int column) {
+        if (column < MIN_POSITION_INDEX || MAX_COLUMN_INDEX < column) {
+            throw new IllegalArgumentException(ExceptionMessage.COLUMN_OUT_OF_RANGE.getMessage(MIN_POSITION_INDEX, MAX_COLUMN_INDEX));
+        }
+    }
+
+    public int calculateRowDistance(Position other) {
+        return row - other.row;
+    }
+
+    public int calculateColumnDistance(Position other) {
+        return column - other.column;
+    }
+
+    public Position moveRow(int distance) {
+        return new Position(row + distance, column);
+    }
+
+    public Position moveCol(int distance) {
+        return new Position(row, column + distance);
+    }
+
+    public Position moveDiagonal(int rowDistance, int colDistance) {
+        return new Position(row + rowDistance, column + colDistance);
+    }
+}

src/main/java/janggi/domain/Turn.java

@@ -0,0 +1,16 @@
+package janggi.domain;
+
+import janggi.domain.piece.Camp;
+
+public class Turn {
+
+    private Camp currentCamp = Camp.CHO;
+
+    public Camp currentTurn() {
+        return currentCamp;
+    }
+
+    public void finishTurn() {
+        currentCamp = currentCamp.next();
+    }
+}