[1단계 - 장기] 차니(이동찬) 미션 제출합니다.

README.md

@@ -1,3 +1,71 @@
 # java-janggi
 
 장기 미션 저장소
+
+## 기능 구현
+
+### 장기(장기판), Janggi
+
+- [x] 생성 시 장기판을 초기화한다.
+- [x] 장기판의 위치를 선택하면, 해당 장기말이 움직일 수 있는 모든 경로를 반환한다.
+- [x] 장기말을 장기판의 위치를 이용해 선택하고, 도착지를 지정해 해당 장기말을 움직일 수 있다.
+    - [x] 도착지가 규칙에 벗어나면 예외를 발생시킨다.
+    - [x] 도착지에 적군이 있다면 잡는다.
+
+### 장기말(기물), Unit
+
+- [x] 해당 기물이 위치로부터 갈 수 있는 모든 위치를 반환한다.
+    - [x] 반환하는 경로는 다른 기물의 위치를 고려하지 않는다.
+    - [x] 장기판 내의 좌표인지는 고려한다.
+
+### 장기말 이동 규칙, UnitRule
+
+- [x] 각 장기말의 이동 규칙을 알고있다.
+
+### 장기판 내의 위치, Position
+
+- [x] 장기판 내의 위치를 관리한다.
+- [x] 범위를 벗어나서 위치를 생성하려하면 예외를 발생시킨다.
+
+### 출력 형식
+
+```
+* | 00 01 02 03 04 05 06 07 08 
+--------------------------------
+0 | CH EL HR GD .. GD EL HR CH
+1 | .. .. .. .. GN .. .. .. .. 
+2 | .. CN .. .. .. .. .. CN .. 
+3 | SD .. SD .. SD .. SD .. SD
+4 | .. .. .. .. .. .. .. .. ..
+5 | .. .. .. .. .. .. .. .. ..
+6 | SD .. SD .. SD .. SD .. SD
+7 | .. CN .. .. .. .. .. CN ..
+8 | .. .. .. .. GN .. .. .. ..
+9 | CH EL HR GD .. GD EL HR CH
+
+기물 별 대표 문자
+궁(General) : GN
+졸, 병(Soldiers) : SD
+사(Guards) : GD
+마(Horses) : HR
+차(Chariots) : CH
+포(Cannons) : CN
+상(Elephants) : EL
+```
+
+## 1단계 블랙잭 피드백
+
+- [x] 장기 네이밍 변경하기 [장기 기획서](https://en.wikipedia.org/wiki/Janggi)
+- [x] `Team#isFront()` 메서드 삭제
+- [x] `JanggiTest` 불필요한 줄바꿈 제거
+- [x] `Position#isHorizontal()` -> `isHorizontalOrVertical()` 메서드 네임 변경
+- [x] `ChariotUnitRule#calculateAllRoute()` 에서 `@Override` 애너테이션 붙이기
+- [x] `CannonUnitRule#calculateEndPoint()` 접근제한자 `private`으로 변경
+- [x] `OutputView`에서 if문에 도달하지 않는 경우 예외 발생시키기
+- [x] `Janggi` 외부에서 주입하기
+    - [ ] 주입하는 위치 고민
+- [x] `Janggi#changeTeam()`구현 로직 `Team` 객체에 메시지를 보내는 방향으로
+- [x] `Unit` -> 동등성 정의 로직 삭제
+- [x] `Unit` 객체 인스턴스 변수 3개를 2개로 줄이기
+- [x] 에외 메시지 작성
+- [ ] `DefaultUnitPosition`에서 기본 좌표 처리에 대한 고민

src/main/java/JanggiApplication.java

@@ -0,0 +1,20 @@
+import domain.Game;
+import view.InputView;
+import view.OutputView;
+
+public class JanggiApplication {
+
+    public static void main(String[] args) {
+        final InputView inputView = new InputView();
+        final OutputView outputView = new OutputView();
+        final Game game = new Game(inputView, outputView);
+
+        while (!game.isEnd()) {
+            try {
+                game.doTurn();
+            } catch (IllegalArgumentException e) {
+                System.out.println("[ERROR] " + e.getMessage());
+            }
+        }
+    }
+}

src/main/java/domain/Game.java

@@ -0,0 +1,69 @@
+package domain;
+
+import domain.position.DefaultUnitPosition;
+import domain.position.Position;
+import domain.position.Route;
+import domain.unit.Team;
+import domain.unit.Unit;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import view.InputView;
+import view.OutputView;
+
+public class Game {
+
+    private final Janggi janggi;
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public Game(InputView inputView, OutputView outputView) {
+        this.janggi = createJanggi();
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    private Janggi createJanggi() {
+        Map<Position, Unit> hanUnits = settingUnits(Team.HAN);
+        Map<Position, Unit> choUnits = settingUnits(Team.CHO);
+        return Janggi.of(hanUnits, choUnits, Team.CHO);
+    }
+
+    private Map<Position, Unit> settingUnits(Team team) {
+        Map<Position, Unit> units = new HashMap<>();
+        for (DefaultUnitPosition value : DefaultUnitPosition.values()) {
+            units.putAll(DefaultUnitPosition.createDefaultUnits(value, team));
+        }
+        return units;
+    }
+
+    public void doTurn() {
+        outputView.printJanggiUnits(janggi.getUnits());
+        Position pick = parsePosition(inputView.readUnitPosition(janggi.getTurn()));
+
+        List<Route> routes = janggi.findMovableRoutesFrom(pick);
+        outputView.printAvailableRoute(pick, routes);
+
+        Position destination = parsePosition(inputView.readDestinationPosition(janggi.getTurn()));
+
+        janggi.doTurn(pick, destination);
+        outputView.printJanggiUnits(janggi.getUnits());
+    }
+
+    public boolean isEnd() {
+        return janggi.isOneOfTeamNonExist();
+    }
+
+    private List<Integer> parseInteger(String rawPosition) {
+        return Arrays.stream(rawPosition.split(","))
+                .map(String::trim)
+                .map(Integer::parseInt)
+                .toList();
+    }
+
+    private Position parsePosition(String rawPosition) {
+        List<Integer> positionValue = parseInteger(rawPosition);
+        return Position.of(positionValue.get(0), positionValue.get(1));
+    }
+}

src/main/java/domain/Janggi.java

@@ -0,0 +1,164 @@
+package domain;
+
+import domain.position.Position;
+import domain.position.Route;
+import domain.unit.Team;
+import domain.unit.Unit;
+import domain.unit.UnitType;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Janggi {
+
+    public static final String EMPTY_POINT_EXCEPTION = "해당 위치에 기물이 존재하지 않습니다.";
+    public static final String PICK_OPPOSITE_UNIT_EXCEPTION = "상대팀 말은 고를 수 없습니다.";
+    public static final String CANNOT_MOVE_EXCEPTION = "이동할 수 없는 도착지입니다.";
+
+    private final Map<Position, Unit> units;
+    private Team turn;
+
+    private Janggi(Map<Position, Unit> units, Team turn) {
+        this.units = new HashMap<>(units);
+        this.turn = turn;
+    }
+
+    public static Janggi of(Map<Position, Unit> hanUnits, Map<Position, Unit> choUnits, Team turn) {
+        Map<Position, Unit> units = new HashMap<>();
+        units.putAll(hanUnits);
+        units.putAll(choUnits);
+        return new Janggi(units, turn);
+    }
+
+    public void doTurn(Position pick, Position destination) {
+        if (!canMove(pick, destination)) {
+            throw new IllegalArgumentException(CANNOT_MOVE_EXCEPTION);
+        }
+        Unit pickedUnit = units.get(pick);
+        Unit destinationUnit = units.get(destination);
+        if (destinationUnit != null && destinationUnit.getTeam() == turn.getOpposite()) {
+            units.remove(destination);
+        }
+        units.remove(pick);
+        units.put(destination, pickedUnit);
+        switchTurn();
+    }
+
+    private boolean canMove(Position pick, Position destination) {
+        List<Route> movableRoutes = findMovableRoutesFrom(pick);
+        return movableRoutes.stream()
+                .map(route -> route.searchDestination(pick))
+                .anyMatch(position -> position.equals(destination));
+    }
+
+    private void switchTurn() {
+        turn = turn.getOpposite();
+    }
+
+    public List<Route> findMovableRoutesFrom(Position pick) {
+        if (isEmptyPosition(pick)) {
+            throw new IllegalArgumentException(EMPTY_POINT_EXCEPTION);
+        }
+        Unit pickedUnit = units.get(pick);
+        if (pickedUnit.getTeam() != turn) {
+            throw new IllegalArgumentException(PICK_OPPOSITE_UNIT_EXCEPTION);
+        }
+
+        List<Route> totalRoutes = pickedUnit.calculateRoutes(pick);
+        totalRoutes = filterRoutesByUnitType(pickedUnit, pick, totalRoutes);
+        if (pickedUnit.getType() == UnitType.CANNON) {
+            return totalRoutes;
+        }
+        return filterBlockedRoutes(pick, totalRoutes);
+    }
+
+    private List<Route> filterRoutesByUnitType(Unit pickedUnit, Position pick, List<Route> totalRoutes) {
+        UnitType type = pickedUnit.getType();
+        if (type == UnitType.CANNON) {
+            return totalRoutes.stream()
+                    .filter(route -> canCannonJump(pick, route))
+                    .toList();
+        }
+        if (type == UnitType.SOLDIER) {
+            return filterSoldierMoves(pick, pickedUnit, totalRoutes);
+        }
+        return totalRoutes;
+    }
+
+    private List<Route> filterSoldierMoves(Position pick, Unit pickedUnit, List<Route> totalRoutes) {
+        if (pickedUnit.getTeam() == Team.HAN) {
+            return totalRoutes.stream()
+                    .filter(route -> route.getPositions().getFirst().getY() >= pick.getY())
+                    .toList();
+        }
+        return totalRoutes.stream()
+                .filter(route -> route.getPositions().getFirst().getY() <= pick.getY())
+                .toList();
+    }
+
+    private boolean canCannonJump(Position current, Route route) {
+        Position endPoint = route.searchDestination(current);
+        if (!isEmptyPosition(endPoint)) {
+            Unit endUnit = units.get(endPoint);
+            if (endUnit.getType() == UnitType.CANNON) {
+                return false;
+            }
+        }
+
+        int count = 0;
+        for (Position position : route.getPositionsExceptDestination(current)) {
+            if (isEmptyPosition(position)) {
+                continue;
+            }
+            Unit unit = units.get(position);
+            if (unit.getType() == UnitType.CANNON) {
+                return false;
+            }
+            count++;
+        }
+        return (count == 1);
+    }
+
+    private List<Route> filterBlockedRoutes(Position pick, List<Route> routes) {
+        return routes.stream()
+                .filter(route -> isClearRoute(pick, route))
+                .filter(route -> isClearDestination(pick, route))
+                .toList();
+    }
+
+    private boolean isClearRoute(Position pick, Route route) {
+        return route.getPositionsExceptDestination(pick).stream()
+                .allMatch(this::isEmptyPosition);
+    }
+
+    private boolean isClearDestination(Position pick, Route route) {
+        Position endPosition = route.searchDestination(pick);
+        if (isEmptyPosition(endPosition)) {
+            return true;
+        }
+        Unit endPointUnit = units.get(endPosition);
+        return endPointUnit.getTeam() != this.turn;
+    }
+
+    private boolean isEmptyPosition(Position position) {
+        return !units.containsKey(position);
+    }
+
+    public boolean isOneOfTeamNonExist() {
+        long hanUnitCount = units.values().stream().
+                filter(unit -> unit.getTeam() == Team.HAN)
+                .count();
+        long choUnitCount = units.values().stream().
+                filter(unit -> unit.getTeam() == Team.CHO)
+                .count();
+        return (hanUnitCount == 0 || choUnitCount == 0);
+    }
+
+    public Team getTurn() {
+        return turn;
+    }
+
+    public Map<Position, Unit> getUnits() {
+        return units;
+    }
+}

src/main/java/domain/position/DefaultUnitPosition.java

@@ -0,0 +1,51 @@
+package domain.position;
+
+import domain.unit.Team;
+import domain.unit.Unit;
+import domain.unit.rule.CannonUnitRule;
+import domain.unit.rule.ChariotUnitRule;
+import domain.unit.rule.ElephantUnitRule;
+import domain.unit.rule.HorseUnitRule;
+import domain.unit.rule.NoneUnitRule;
+import domain.unit.rule.SoldierUnitRule;
+import domain.unit.rule.UnitRule;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+public enum DefaultUnitPosition {
+
+    GENERAL(1, 8, List.of(4), NoneUnitRule::new),
+    GUARD(0, 9, List.of(3, 5), NoneUnitRule::new),
+    CHARIOT(0, 9, List.of(0, 8), ChariotUnitRule::new),
+    CANNON(2, 7, List.of(1, 7), CannonUnitRule::new),
+    SOLDIER(3, 6, List.of(0, 2, 4, 6, 8), SoldierUnitRule::new),
+    HORSE(0, 9, List.of(2, 7), HorseUnitRule::new),
+    ELEPHANT(0, 9, List.of(1, 6), ElephantUnitRule::new),
+    ;
+
+    private final int hanY;
+    private final int choY;
+    private final List<Integer> xPositions;
+    private final Supplier<UnitRule> rule;
+
+    DefaultUnitPosition(int hanY, int choY, List<Integer> xPositions, Supplier<UnitRule> rule) {
+        this.hanY = hanY;
+        this.choY = choY;
+        this.xPositions = xPositions;
+        this.rule = rule;
+    }
+
+    public static Map<Position, Unit> createDefaultUnits(DefaultUnitPosition position, Team team) {
+        if (team == Team.CHO) {
+            return position.xPositions.stream()
+                    .map(x -> Position.of(x, position.choY))
+                    .collect(Collectors.toMap(pos -> pos, pos -> Unit.of(team, position.rule.get())
+                    ));
+        }
+        return position.xPositions.stream()
+                .map(x -> Position.of(x, position.hanY))
+                .collect(Collectors.toMap(pos -> pos, pos -> Unit.of(team, position.rule.get())));
+    }
+}