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

README.md

@@ -1,3 +1,67 @@
 # java-janggi
 
 장기 미션 저장소
+
+---
+
+## 💡 주요 게임 규칙
+
+### 기물 이동 규칙
+
+- **궁, 사**
+    - 궁궐 안에서만 방향 상관없이 1칸씩 이동
+    - 뛰어넘기 불가
+    - 시작 위치 고정
+- **상**
+    - 앞/옆/뒤 1칸 + 대각선 2칸
+    - 뛰어넘기 불가
+    - 마와 위치 변경 가능
+- **마**
+    - 앞/옆/뒤 1칸 + 대각선 1칸
+    - 뛰어넘기 불가
+    - 상과 위치 변경 가능
+- **차**
+    - 직선으로 원하는 만큼 이동
+    - 뛰어넘기 불가
+    - 시작 위치 고정
+- **포**
+    - 앞/옆/뒤 원하는 만큼 이동
+    - 포를 제외한 기물을 1개 뛰어넘어야만 이동
+    - 시작 위치 고정
+- **졸/병**
+    - 앞/옆으로만 1칸 전진
+    - 뛰어넘기 불가
+    - 시작 위치 고정
+
+## 🚀 기능 요구 사항
+
+### 1.1 **보드 초기화**
+
+게임 시작 시 장기판과 전체 기물을 올바른 위치에 초기화한다.
+
+- [x] 장기판 초기화 전략을 번호로 입력받는다.
+    - 상마마상, 상마상마, 마상마상, 마상상마
+    - [x] 사용자 입력값 유효성 검사
+        - [x] 공백인 경우 예외 처리
+        - [x] 숫자가 아닌 문자일 경우 예외 처리
+        - [x] 정수 범위를 벗어난 경우 예외 처리
+    - [x] 도메인 규칙 검증
+        - [x] 입력값이 선택지 범위에 포함되지 않는 경우 예외 처리
+- [x] 전략이 반영된 장기판 상태를 출력한다.
+
+### 1.2 기물 이동
+
+- [x] 이동할 기물의 위치와 이동할 위치를 사용자로부터 입력받는다.
+    - [x] 사용자 입력값 유효성 검사
+        - [x] 공백인 경우 예외 처리
+        - [x] `,` 로 구분된 좌표 형식이 아닌 경우 예외 처리
+        - [x] 좌표값이 숫자가 아닌 경우 예외 처리
+        - [x] 좌표값이 정수 범위를 벗어난 경우 예외 처리
+    - [x] 도메인 규칙 검증
+        - [x] 좌표값이 보드판의 범위를 벗어난 경우 예외 처리
+        - [x] 해당 좌표에 이동시키고자 하는 기물이 존재하지 않는 경우 예외 처리
+- [x]  기물을 이동시킨다.
+    - [x] 도메인 규칙 검증
+        - [x] 기물 규칙에 따라 이동할 위치에 도달할 수 없는 경우 예외 처리
+    - [x] 이동할 위치의 기존 기물은 제거된다.
+- [x] 이동이 반영된 장기판 상태를 출력한다.

src/main/java/janggi/Application.java

@@ -0,0 +1,16 @@
+package janggi;
+
+import janggi.controller.JanggiFlow;
+import janggi.view.ApplicationView;
+import janggi.view.ConsoleReader;
+import janggi.view.ConsoleWriter;
+
+public class Application {
+
+    public static void main(String[] args) {
+        ApplicationView view = new ApplicationView(new ConsoleWriter(), new ConsoleReader());
+        JanggiFlow janggi = new JanggiFlow(view);
+
+        janggi.process();
+    }
+}

src/main/java/janggi/controller/ArrangementOption.java

@@ -0,0 +1,67 @@
+package janggi.controller;
+
+import static janggi.domain.piece.PieceType.MA;
+import static janggi.domain.piece.PieceType.SANG;
+
+import janggi.domain.Side;
+import janggi.domain.piece.PieceType;
+import janggi.strategy.ArrangementStrategy;
+import janggi.strategy.MaSangArrangementStrategy;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public enum ArrangementOption {
+    MA_SANG_MA_SANG(1, "마상마상", List.of(MA, SANG, MA, SANG)),
+    SANG_MA_SANG_MA(2, "상마상마", List.of(SANG, MA, SANG, MA)),
+    SANG_MA_MA_SANG(3, "상마마상", List.of(SANG, MA, MA, SANG)),
+    MA_SANG_SANG_MA(4, "마상상마", List.of(MA, SANG, SANG, MA));
+
+    private static final Map<Integer, String> STRATEGY_OPTIONS =
+            Collections.unmodifiableMap(
+                    Arrays.stream(values())
+                            .collect(Collectors.toMap(
+                                    ArrangementOption::getOptionNumber,
+                                    ArrangementOption::getDisplayName,
+                                    (existing, replacement) -> existing,
+                                    LinkedHashMap::new
+                            ))
+            );
+
+    private final int optionNumber;
+    private final String displayName;
+    private final List<PieceType> arrangement;
+
+    ArrangementOption(int optionNumber, String displayName, List<PieceType> arrangement) {
+        this.optionNumber = optionNumber;
+        this.displayName = displayName;
+        this.arrangement = arrangement;
+    }
+
+    public static ArrangementStrategy createStrategyOf(Side side, int optionNumber) {
+        return Arrays.stream(values())
+                .filter(resolver -> resolver.optionNumber == optionNumber)
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 배치 전략 번호입니다."))
+                .toStrategy(side);
+    }
+
+    public static Map<Integer, String> getStrategyOptions() {
+        return STRATEGY_OPTIONS;
+    }
+
+    private int getOptionNumber() {
+        return optionNumber;
+    }
+
+    private String getDisplayName() {
+        return displayName;
+    }
+
+    private ArrangementStrategy toStrategy(Side side) {
+        return MaSangArrangementStrategy.of(side, arrangement);
+    }
+}

src/main/java/janggi/controller/JanggiFlow.java

@@ -0,0 +1,106 @@
+package janggi.controller;
+
+import janggi.domain.Location;
+import janggi.domain.Side;
+import janggi.domain.board.Board;
+import janggi.domain.piece.Piece;
+import janggi.domain.piece.PieceType;
+import janggi.strategy.ArrangementStrategy;
+import janggi.strategy.BoardAssembler;
+import janggi.view.ApplicationView;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+
+public class JanggiFlow {
+
+    private final ApplicationView view;
+
+    public JanggiFlow(ApplicationView view) {
+        this.view = view;
+    }
+
+    public void process() {
+        ArrangementStrategy hanStrategy = repeatAskStrategyUntilSuccess(Side.HAN);
+        ArrangementStrategy choStrategy = repeatAskStrategyUntilSuccess(Side.CHO);
+        Board board = Board.create(BoardAssembler.from(List.of(hanStrategy, choStrategy)));
+
+        Side current = Side.HAN;
+        while (board.isNotEmpty()) {
+            view.showBoardArray(convertBoardStatus(board));
+            view.showCurrentSide(current.getName());
+
+            final Side turnSide = current;
+            retryUntilPieceIsSuccessfullyMoved(() -> {
+                Location from = repeatAskLocationOfPieceUntilSuccess(turnSide, board);
+                Location to = repeatAskLocationToMoveUntilSuccess(from, board);
+                board.move(from, to);
+            });
+            current = current.switchSide();
+        }
+    }
+
+    private <T> T retry(Supplier<T> supplier) {
+        while (true) {
+            try {
+                return supplier.get();
+            } catch (IllegalArgumentException e) {
+                view.showErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private List<List<String>> convertBoardStatus(Board board) {
+        List<List<Piece>> boardIn2D = board.to2DArray();
+        return boardIn2D.stream()
+                .map(
+                        row -> row.stream()
+                                .map(Piece::getPieceType)
+                                .map(PieceType::getNameFormat)
+                                .toList()
+                ).toList();
+    }
+
+    private ArrangementStrategy repeatAskStrategyUntilSuccess(Side side) {
+        return retry(() -> askStrategy(side));
+    }
+
+    private ArrangementStrategy askStrategy(Side side) {
+        Map<Integer, String> strategyInfos = ArrangementOption.getStrategyOptions();
+        int decisionNumber = view.promptForArrangementStrategyDecision(side.getName(), strategyInfos);
+        return ArrangementOption.createStrategyOf(side, decisionNumber);
+    }
+
+    private Location repeatAskLocationOfPieceUntilSuccess(Side turnSide, Board board) {
+        return retry(() -> askLocationOfPiece(turnSide, board));
+    }
+
+    private Location askLocationOfPiece(Side current, Board board) {
+        List<Integer> locationOfPiece = view.promptForLocationOfPiece();
+        Location verifiedLocation = Location.from(locationOfPiece);
+        board.validateLocationOfPiece(current, verifiedLocation);
+        return verifiedLocation;
+    }
+
+    private Location repeatAskLocationToMoveUntilSuccess(Location from, Board board) {
+        return retry(() -> askLocationToMove(from, board));
+    }
+
+    private Location askLocationToMove(Location startingLocation, Board board) {
+        List<Integer> locationToMove = view.promptForLocationToMove();
+        Location verifiedLocation = Location.from(locationToMove);
+        board.validateLocationToMove(startingLocation, verifiedLocation);
+        return verifiedLocation;
+    }
+
+    private void retryUntilPieceIsSuccessfullyMoved(Runnable runnable) {
+        while (true) {
+            try {
+                runnable.run();
+                break;
+            } catch (IllegalArgumentException e) {
+                view.showErrorMessage(e.getMessage());
+            }
+        }
+    }
+}

src/main/java/janggi/domain/Location.java

@@ -0,0 +1,33 @@
+package janggi.domain;
+
+import java.util.List;
+
+public record Location(int x, int y) {
+
+    private static final int COORDINATION_COUNT = 2;
+
+    public static Location from(List<Integer> coordination) {
+        validateCount(coordination);
+        int row = coordination.get(0) - 1;
+        int col = coordination.get(1) - 1;
+        return new Location(row, col);
+    }
+
+    private static void validateCount(List<Integer> coordination) {
+        if (coordination.size() != COORDINATION_COUNT) {
+            throw new IllegalArgumentException("좌표의 개수는 " + COORDINATION_COUNT + "개 입니다.");
+        }
+    }
+
+    public Location add(int dx, int dy) {
+        return new Location(x + dx, y + dy);
+    }
+
+    public int calculateHorizontalDiff(Location to) {
+        return to.y - this.y;
+    }
+
+    public int calculateVerticalDiff(Location to) {
+        return to.x - this.x;
+    }
+}

src/main/java/janggi/domain/Side.java

@@ -0,0 +1,28 @@
+package janggi.domain;
+
+public enum Side {
+
+    HAN("한"),
+    CHO("초"),
+    NONE("없음");
+
+    private final String name;
+
+    Side(String name) {
+        this.name = name;
+    }
+
+    public Side switchSide() {
+        if (this == HAN) {
+            return CHO;
+        }
+        if (this == CHO) {
+            return HAN;
+        }
+        throw new UnsupportedOperationException("진영이 존재하지 않아 진영을 반전시킬 수 없습니다.");
+    }
+
+    public String getName() {
+        return name;
+    }
+}