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

.gitignore

@@ -30,3 +30,12 @@ out/
 
 ### VS Code ###
 .vscode/
+
+### macOS ###
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon?
+._*
+.Spotlight-V100
+.Trashes

README.md

@@ -1,3 +1,75 @@
 # java-janggi
 
 장기 미션 저장소
+
+### 기능 요구사항 체크리스트
+
+#### step 1
+- [x] 10x9 장기판 좌표를 `Point(y, x)`로 표현하고, 범위를 벗어난 좌표 생성 시 예외를 발생시킨다.
+- [x] 기물 타입(`PieceType`)과 진영(`Team`)을 분리해 도메인 모델링한다.
+- [x] 빈 칸을 `NonePiece`로 포장해 `Intersection.empty()`로 관리한다.
+- [x] 장기판 초기화 시 전체 좌표를 빈 칸으로 채운 뒤, 생성기(`IntersectionGenerator`)가 전달한 기물을 배치한다.
+- [x] 초/한 기본 배치(졸, 포, 장군, 사, 차)를 자동 생성한다.
+- [x] 상/마 차림(`Formation`) 4가지를 지원하고, 진영별로 대칭 배치한다.
+- [x] `Formation.valueOf(int)`로 입력 숫자를 차림 enum으로 변환한다.
+- [x] 보드에서 좌표로 교차점(`Intersection`)을 조회할 수 있다.
+- [x] 이동 규칙을 `MoveRule` 전략으로 분리하고, 기물 타입별 규칙 클래스를 연결한다.
+- [x] 이동 경로를 `Direction`/`Directions`로 추상화해 “도착 가능 여부 + 경유 좌표”를 계산한다.
+- [x] 차(`Chariot`)는 상하좌우 직선 이동만 가능하며, 경로 중간 장애물이 있으면 이동할 수 없다.
+- [x] 마(`Horse`)는 2단계 경로(멱) 중 중간 칸이 막히면 이동할 수 없다.
+- [x] 상(`Elephant`)은 3단계 경로 중 중간 칸이 막히면 이동할 수 없다.
+- [x] 포(`Cannon`)는 정확히 1개의 장애물을 넘어야 하며, 포를 넘거나 포를 공격할 수 없다.
+- [x] 장군(`General`)과 사(`Guard`)는 1칸 상하좌우 이동을 지원한다.
+- [x] 졸(`Soldier`)은 좌/우 + 전진 이동을 지원하며, 진영에 따라 전진 방향이 다르다.
+- [x] 같은 팀 기물이 있는 칸으로는 이동할 수 없다.
+- [x] `JanggiBoard.tryToMove()` 수행 시 도착지는 출발 기물로 갱신되고, 출발지는 빈 칸이 된다.
+
+### 주요 로직 요약
+
+#### step 1
+- **보드 생성**
+    - `JanggiBoard`가 10x9 전체 좌표를 `Intersection.empty()`로 초기화한다.
+- **초기 기물 배치**
+    - `JanggiGenerator`가 진영(`CHO`, `HAN`)별 기본 행/열 규칙으로 기물을 만든다.
+    - 상/마는 `Formation`에 정의된 열 인덱스 조합으로 배치한다.
+- **좌표/교차점 모델링**
+    - `Point`는 생성 시 범위 검증을 수행하고, `next(Vector)`로 이동 좌표를 계산한다.
+    - `Intersection`은 기물 도착(`arrive`)과 이탈(`leave`) 책임을 가진다.
+- **이동 규칙 선택**
+    - 보드는 출발 지점의 기물 타입을 기준으로 `MoveRule` 구현체를 선택한다.
+- **경로 계산**
+    - 규칙별 `Directions.findPoints(from, to)`로 목적지까지의 경유 좌표 목록을 만든다.
+- **규칙 검증**
+    - 공통적으로 같은 팀 도착지 여부를 검증한다.
+    - 차/마/상은 경로 장애물 조건을 검증한다.
+    - 포는 “장애물 1개 필수”, “포 넘기/포 공격 금지”를 추가 검증한다.
+- **실제 이동 반영**
+    - 검증 통과 시 도착지 `arrive(from)`, 출발지 `leave()` 순서로 상태를 갱신한다.
+
+### 기물별 이동 규칙 정리
+
+- **차(`Chariot`)**
+    - 상/하/좌/우 직선 다칸 이동
+    - 도착지 아군 금지
+    - 경로 중간 장애물 금지
+- **포(`Cannon`)**
+    - 상/하/좌/우 직선 이동
+    - 중간 장애물 정확히 1개 필요
+    - 장애물/도착지가 포인 경우 금지
+    - 도착지 아군 금지
+- **마(`Horse`)**
+    - 1칸 직선 + 1칸 대각(총 2스텝)
+    - 중간 경유 칸 장애물 금지
+    - 도착지 아군 금지
+- **상(`Elephant`)**
+    - 1칸 직선 + 2칸 대각(총 3스텝)
+    - 경유 칸 장애물 금지
+    - 도착지 아군 금지
+- **장군/사(`General`/`Guard`)**
+    - 1칸 상하좌우 이동
+    - 도착지 아군 금지
+    - (궁성 내부/대각 특수 규칙 미반영)
+- **졸(`Soldier`)**
+    - 좌/우 + 전진 이동
+    - CHO는 위쪽(UP), HAN은 아래쪽(DOWN) 전진
+    - 도착지 아군 금지

src/main/java/Application.java

@@ -0,0 +1,16 @@
+import controller.JanggiController;
+import view.InputView;
+import view.OutputView;
+
+public class Application {
+
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+
+        JanggiController janggiController = new JanggiController(inputView, outputView);
+        janggiController.run();
+
+    }
+
+}

src/main/java/controller/JanggiController.java

@@ -0,0 +1,41 @@
+package controller;
+
+import domain.board.Formation;
+import domain.board.JanggiBoard;
+import domain.board.JanggiGenerator;
+import domain.game.Game;
+import domain.team.Team;
+import dto.MoveDTO;
+import view.InputView;
+import view.OutputView;
+
+public class JanggiController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public JanggiController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        Formation hanFormation = Formation.valueOf(inputView.inputHanWingSetup());
+        Formation choFormation = Formation.valueOf(inputView.inputChoWingSetup());
+        JanggiGenerator janggiGenerator = new JanggiGenerator(hanFormation, choFormation);
+
+        Game game = new Game(new JanggiBoard(janggiGenerator));
+
+        while (true) {
+            try {
+                outputView.printCurrentBoardStatus(game.boardStatus());
+                final Team turn = game.currentTurn();
+                outputView.printCurrentTurn(turn);
+                MoveDTO move = new MoveDTO(inputView.inputMovePiecePoint(), inputView.inputDestinationPoint());
+                game.processTurn(move);
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+}

src/main/java/domain/board/Formation.java

@@ -0,0 +1,39 @@
+package domain.board;
+
+import java.util.Arrays;
+import java.util.List;
+
+public enum Formation {
+
+    HORSE_ELEPHANT_HORSE_ELEPHANT(1, List.of(2, 7), List.of(1, 6)),
+    HORSE_ELEPHANT_ELEPHANT_HORSE(2, List.of(2, 6), List.of(1, 7)),
+    ELEPHANT_HORSE_ELEPHANT_HORSE(3, List.of(1, 6), List.of(2, 7)),
+    ELEPHANT_HORSE_HORSE_ELEPHANT(4, List.of(1, 7), List.of(2, 6)),
+    ;
+
+    private final int formatNumber;
+    private final List<Integer> elephantFormations;
+    private final List<Integer> horseFormations;
+
+    Formation(int formatNumber, List<Integer> elephantFormations, List<Integer> horseFormations) {
+        this.formatNumber = formatNumber;
+        this.elephantFormations = elephantFormations;
+        this.horseFormations = horseFormations;
+    }
+
+    public static Formation valueOf(int formatNumber) {
+        return Arrays.stream(Formation.values())
+                .filter(formation -> formation.formatNumber == formatNumber)
+                .findFirst()
+                .orElseThrow(IllegalArgumentException::new);
+    }
+
+    public List<Integer> elephantFormations() {
+        return elephantFormations;
+    }
+
+    public List<Integer> horseFormations() {
+        return horseFormations;
+    }
+
+}

src/main/java/domain/board/IntersectionGenerator.java

@@ -0,0 +1,10 @@
+package domain.board;
+
+import domain.intersection.Intersection;
+import java.util.List;
+
+public interface IntersectionGenerator {
+
+    List<Intersection> makeIntersection();
+
+}

src/main/java/domain/board/JanggiBoard.java

@@ -0,0 +1,104 @@
+package domain.board;
+
+import domain.intersection.Intersection;
+import domain.piece.move.CannonMoveRule;
+import domain.piece.move.ChariotMoveRule;
+import domain.piece.move.ElephantMoveRule;
+import domain.piece.move.GeneralMoveRule;
+import domain.piece.move.GuardMoveRule;
+import domain.piece.move.HorseMoveRule;
+import domain.piece.move.MoveRule;
+import domain.piece.move.SoliderMoveRule;
+import domain.point.Point;
+import dto.BoardStatusDTO;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class JanggiBoard {
+
+    private static final int MAX_ROW = 10;
+    private static final int MAX_FILE = 9;
+
+    private final Map<Point, Intersection> intersections;
+    private final List<MoveRule> moveRules;
+
+    public JanggiBoard(IntersectionGenerator intersectionGenerator) {
+        this.intersections = fillEmptyIntersections();
+        this.moveRules = setMoveRules();
+        for (Intersection intersection : intersectionGenerator.makeIntersection()) {
+            intersections.put(intersection.getPoint(), intersection);
+        }
+    }
+
+    private static Stream<Point> getAllPoints() {
+        return range(MAX_ROW).boxed()
+                .flatMap(row -> range(MAX_FILE).mapToObj(f -> new Point(row, f)));
+    }
+
+    private static IntStream range(int maxRange) {
+        return IntStream.range(0, maxRange);
+    }
+
+    public void tryToMove(Point start, Point end) {
+        Intersection from = findIntersection(start);
+        Intersection to = findIntersection(end);
+
+        validateMoveRule(from, to);
+        move(to, from);
+    }
+
+    private void move(Intersection to, Intersection from) {
+        to.arrive(from);
+        from.leave();
+    }
+
+    private void validateMoveRule(Intersection from, Intersection to) {
+        MoveRule moveRule = findMoveRule(from);
+        List<Point> possiblePoints = moveRule.findPossiblePoints(from, to);
+        List<Intersection> path = findPath(possiblePoints);
+        moveRule.checkMoveRule(from, path);
+    }
+
+    public MoveRule findMoveRule(Intersection from) {
+        return moveRules.stream()
+                .filter(moveRule -> moveRule.support(from))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("선택한 좌표에 이동 가능한 기물이 없습니다."));
+    }
+
+    private List<Intersection> findPath(List<Point> possiblePoints) {
+        return possiblePoints.stream()
+                .map(this::findIntersection)
+                .toList();
+    }
+
+    public BoardStatusDTO boardStatus() {
+        return new BoardStatusDTO(intersections);
+    }
+
+    public Intersection findIntersection(Point point) {
+        return intersections.get(point);
+    }
+
+    private List<MoveRule> setMoveRules() {
+        return List.of(
+                new ChariotMoveRule(),
+                new GeneralMoveRule(),
+                new GuardMoveRule(),
+                new ElephantMoveRule(),
+                new SoliderMoveRule(),
+                new CannonMoveRule(),
+                new HorseMoveRule()
+        );
+    }
+
+    private Map<Point, Intersection> fillEmptyIntersections() {
+        return getAllPoints()
+                .collect(Collectors.toMap(point -> point, Intersection::empty));
+    }
+
+
+}