[1단계 - 보드 초기화, 기물 이동] 윌슨(박형균) 미션 제출합니다.

README.md

@@ -1,3 +1,51 @@
 # java-janggi
 
 장기 미션 저장소
+
+## 미션을 수행하며 반드시 고민할 것
+
+### ✅ 장기의 말(駒)들은 어떻게 객체로 나누어야 하는가?
+
+장기가 이동할 수 있는 경로를 정의한 인터페이스를 각 기물 종류마다 구현한다.
+
+### ✅ 각 말의 이동 규칙을 어떻게 설계할 것인가?
+
+Enum으로 상,하,좌,우,대각선 4방향을 정의하고, 각 기물이 해당 Enum을 이용해서 이동 규칙을 구현한다.
+
+### ✅ 객체 간의 책임을 어떻게 나눌 것인가?
+
+- 객체가 주체성을 갖고 행동하는가? (_'객체의 결합도가 낮고 응집도가 높은가?'_)
+- 객체안의 메서드들을 테스트할 수 있는지 판단 (_'메서드가 public으로 유지 될 수 있는가?'_)
+- 객체안의 메서드들이 필드 멤버를 온전히 사용하고 있는지 확인
+
+### ✅ 어떤 원칙을 적용해야 더 좋은 설계를 할 수 있을까?
+
+#### TDD 사이클이 한번 끝날때 마다 아래 항목들을 검사한다.
+
+- 각 객체의 책임이 적절히 할당이 되었는가?
+- 메서드 시그니처가 자연스러운가?
+- getter의 사용이 적절한가? (_'진짜 여기서 getter를 써야만할까?'_)
+
+## 기능 구현 목록
+
+### 보드
+
+- [ ] 특정 위치에서 이동 가능한 위치 리스트를 반환한다
+- [ ] 점수를 계산 한다
+- [ ] 예외 처리
+  - [ ] 해당 위치에 기물이 없으면 예외
+
+### 기물들의 위치
+
+- [x] 기물들의 위치를 초기화 한다
+- [x] 특정 위치에 어떤 기물이 있는지 반환한다
+
+### 기물
+
+- [x] 이동 가능한 위치를 리스트로 반환
+  - [x] 포 (`Cannon`)
+  - [x] 차 (`Chariot`)
+  - [x] 상 (`Elephant`)
+  - [x] 졸/병 (`Guard`)
+  - [x] 마 (`Horse`)
+- [x] 대상 기물을 먹을 수 있는지 판단

src/main/java/Application.java

@@ -0,0 +1,13 @@
+import game.JanggiGame;
+import view.InputView;
+import view.OutputView;
+
+public class Application {
+    public static void main(String[] args) {
+        JanggiGame janggiGame = new JanggiGame(
+                new InputView(),
+                new OutputView()
+        );
+        janggiGame.run();
+    }
+}

src/main/java/domain/Board.java

@@ -0,0 +1,77 @@
+package domain;
+
+import domain.chessPiece.ChessPiece;
+import domain.hurdlePolicy.HurdlePolicy;
+import domain.path.Path;
+import domain.position.ChessPiecePositions;
+import domain.position.ChessPosition;
+import domain.score.Score;
+import domain.type.ChessTeam;
+
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+public class Board {
+
+    private final ChessPiecePositions chessPiecePositions;
+    private final Map<ChessTeam, Score> scores = new EnumMap<>(ChessTeam.class);
+
+    public Board(final ChessPiecePositions chessPiecePositions) {
+        this.chessPiecePositions = chessPiecePositions;
+        scores.putAll(Map.of(
+                ChessTeam.RED, Score.zero(),
+                ChessTeam.BLUE, Score.zero()
+        ));
+    }
+
+    public boolean isExistPieceAt(ChessPosition position) {
+        return chessPiecePositions.existChessPieceByPosition(position);
+    }
+
+    public void move(final ChessTeam currentTeam, final ChessPosition from, final ChessPosition to) {
+        validateTeam(currentTeam, from);
+        validateDestination(from, to);
+        if (chessPiecePositions.existChessPieceByPosition(to)) {
+            killTarget(currentTeam, to);
+        }
+        chessPiecePositions.move(from, to);
+    }
+
+    public List<ChessPosition> getAvailableDestination(final ChessPosition position) {
+        ChessPiece chessPiece = chessPiecePositions.getChessPieceByPosition(position);
+        final List<Path> coordinatePaths = chessPiece.getCoordinatePaths(position);
+        final HurdlePolicy hurdlePolicy = chessPiece.getHurdlePolicy();
+        return hurdlePolicy.pickDestinations(chessPiece.getTeam(), coordinatePaths, chessPiecePositions);
+    }
+
+    public void validateTeam(final ChessTeam currentTeam, final ChessPosition from) {
+        ChessPiece chessPiece = chessPiecePositions.getChessPieceByPosition(from);
+        if (currentTeam != chessPiece.getTeam()) {
+            throw new IllegalArgumentException("상대편의 기물을 움직일 수 없습니다.");
+        }
+    }
+
+    private void killTarget(ChessTeam currentTeam, ChessPosition to) {
+        ChessPiece target = chessPiecePositions.getChessPieceByPosition(to);
+        updateScore(currentTeam, target);
+        chessPiecePositions.removeChessPieceByPosition(to);
+    }
+
+    private void updateScore(ChessTeam currentTeam, ChessPiece target) {
+        Score score = target.getScore();
+        Score updatedScore = scores.get(currentTeam).add(score);
+        scores.put(currentTeam, updatedScore);
+    }
+
+    private void validateDestination(final ChessPosition from, final ChessPosition to) {
+        List<ChessPosition> destinations = getAvailableDestination(from);
+        if (!destinations.contains(to)) {
+            throw new IllegalArgumentException("이동할 수 없는 경로입니다.");
+        }
+    }
+
+    public Map<ChessPosition, ChessPiece> getPositions() {
+        return chessPiecePositions.getChessPieces();
+    }
+}

src/main/java/domain/chessPiece/Cannon.java

@@ -0,0 +1,44 @@
+package domain.chessPiece;
+
+import domain.direction.Direction;
+import domain.hurdlePolicy.CannonHurdlePolicy;
+import domain.hurdlePolicy.HurdlePolicy;
+import domain.position.ChessPosition;
+import domain.type.ChessPieceType;
+import domain.type.ChessTeam;
+
+import java.util.List;
+import java.util.Map;
+
+public class Cannon extends UnlimitedMoveChessPiece {
+    private static final List<Direction> directions = List.of(
+            Direction.UP,
+            Direction.DOWN,
+            Direction.LEFT,
+            Direction.RIGHT
+    );
+    private final HurdlePolicy hurdlePolicy = new CannonHurdlePolicy();
+
+    public Cannon(final ChessTeam team) {
+        super(team, directions);
+    }
+
+    public static Map<ChessPosition, ChessPiece> initPieces() {
+        return Map.of(
+                new ChessPosition(2, 1), new Cannon(ChessTeam.RED),
+                new ChessPosition(2, 7), new Cannon(ChessTeam.RED),
+                new ChessPosition(7, 1), new Cannon(ChessTeam.BLUE),
+                new ChessPosition(7, 7), new Cannon(ChessTeam.BLUE)
+        );
+    }
+
+    @Override
+    public HurdlePolicy getHurdlePolicy() {
+        return hurdlePolicy;
+    }
+
+    @Override
+    public ChessPieceType getChessPieceType() {
+        return ChessPieceType.CANNON;
+    }
+}

src/main/java/domain/chessPiece/Chariot.java

@@ -0,0 +1,45 @@
+package domain.chessPiece;
+
+import domain.direction.Direction;
+import domain.hurdlePolicy.HurdlePolicy;
+import domain.hurdlePolicy.StopAtHurdlePolicy;
+import domain.position.ChessPosition;
+import domain.type.ChessPieceType;
+import domain.type.ChessTeam;
+
+import java.util.List;
+import java.util.Map;
+
+public class Chariot extends UnlimitedMoveChessPiece {
+
+    private static final List<Direction> directions = List.of(
+            Direction.UP,
+            Direction.DOWN,
+            Direction.LEFT,
+            Direction.RIGHT
+    );
+    private final HurdlePolicy hurdlePolicy = new StopAtHurdlePolicy();
+
+    public Chariot(final ChessTeam team) {
+        super(team, directions);
+    }
+
+    public static Map<ChessPosition, ChessPiece> initPieces() {
+        return Map.of(
+                new ChessPosition(0, 0), new Chariot(ChessTeam.RED),
+                new ChessPosition(0, 8), new Chariot(ChessTeam.RED),
+                new ChessPosition(9, 0), new Chariot(ChessTeam.BLUE),
+                new ChessPosition(9, 8), new Chariot(ChessTeam.BLUE)
+        );
+    }
+
+    @Override
+    public HurdlePolicy getHurdlePolicy() {
+        return hurdlePolicy;
+    }
+
+    @Override
+    public ChessPieceType getChessPieceType() {
+        return ChessPieceType.CHARIOT;
+    }
+}

src/main/java/domain/chessPiece/ChessPiece.java

@@ -0,0 +1,20 @@
+package domain.chessPiece;
+
+import domain.hurdlePolicy.HurdlePolicy;
+import domain.path.Path;
+import domain.position.ChessPiecePositions;
+import domain.score.Score;
+import domain.type.ChessPieceType;
+import domain.position.ChessPosition;
+import domain.type.ChessTeam;
+
+import java.util.List;
+
+public interface ChessPiece {
+    List<ChessPosition> getDestinations(ChessPosition startPosition, ChessPiecePositions positions);
+    ChessPieceType getChessPieceType();
+    ChessTeam getTeam();
+    Score getScore();
+    List<Path> getCoordinatePaths(final ChessPosition startPosition);
+    HurdlePolicy getHurdlePolicy();
+}

src/main/java/domain/chessPiece/Elephant.java

@@ -0,0 +1,49 @@
+package domain.chessPiece;
+
+import domain.direction.Direction;
+import domain.direction.Directions;
+import domain.hurdlePolicy.HurdlePolicy;
+import domain.hurdlePolicy.UnpassableHurdlePolicy;
+import domain.position.ChessPosition;
+import domain.type.ChessPieceType;
+import domain.type.ChessTeam;
+
+import java.util.List;
+import java.util.Map;
+
+public class Elephant extends LimitedMoveChessPiece {
+    private static final List<Directions> directions = List.of(
+            new Directions(List.of(Direction.UP, Direction.RIGHT_UP, Direction.RIGHT_UP)),
+            new Directions(List.of(Direction.UP, Direction.LEFT_UP, Direction.LEFT_UP)),
+            new Directions(List.of(Direction.LEFT, Direction.LEFT_UP, Direction.LEFT_UP)),
+            new Directions(List.of(Direction.LEFT, Direction.LEFT_DOWN, Direction.LEFT_DOWN)),
+            new Directions(List.of(Direction.RIGHT, Direction.RIGHT_UP, Direction.RIGHT_UP)),
+            new Directions(List.of(Direction.RIGHT, Direction.RIGHT_DOWN, Direction.RIGHT_DOWN)),
+            new Directions(List.of(Direction.DOWN, Direction.LEFT_DOWN, Direction.LEFT_DOWN)),
+            new Directions(List.of(Direction.DOWN, Direction.RIGHT_DOWN, Direction.RIGHT_DOWN))
+    );
+    private final HurdlePolicy hurdlePolicy = new UnpassableHurdlePolicy();
+
+    public Elephant(final ChessTeam team) {
+        super(team, directions);
+    }
+
+    public static Map<ChessPosition, ChessPiece> initPieces() {
+        return Map.of(
+                new ChessPosition(0, 2), new Elephant(ChessTeam.RED),
+                new ChessPosition(0, 6), new Elephant(ChessTeam.RED),
+                new ChessPosition(9, 2), new Elephant(ChessTeam.BLUE),
+                new ChessPosition(9, 6), new Elephant(ChessTeam.BLUE)
+        );
+    }
+
+    @Override
+    public HurdlePolicy getHurdlePolicy() {
+        return hurdlePolicy;
+    }
+
+    @Override
+    public ChessPieceType getChessPieceType() {
+        return ChessPieceType.ELEPHANT;
+    }
+}

src/main/java/domain/chessPiece/Horse.java

@@ -0,0 +1,49 @@
+package domain.chessPiece;
+
+import domain.direction.Direction;
+import domain.direction.Directions;
+import domain.hurdlePolicy.HurdlePolicy;
+import domain.hurdlePolicy.UnpassableHurdlePolicy;
+import domain.position.ChessPosition;
+import domain.type.ChessPieceType;
+import domain.type.ChessTeam;
+
+import java.util.List;
+import java.util.Map;
+
+public class Horse extends LimitedMoveChessPiece {
+    private static final List<Directions> directions = List.of(
+            new Directions(List.of(Direction.UP, Direction.RIGHT_UP)),
+            new Directions(List.of(Direction.UP, Direction.LEFT_UP)),
+            new Directions(List.of(Direction.LEFT, Direction.LEFT_UP)),
+            new Directions(List.of(Direction.LEFT, Direction.LEFT_DOWN)),
+            new Directions(List.of(Direction.RIGHT, Direction.RIGHT_UP)),
+            new Directions(List.of(Direction.RIGHT, Direction.RIGHT_DOWN)),
+            new Directions(List.of(Direction.DOWN, Direction.LEFT_DOWN)),
+            new Directions(List.of(Direction.DOWN, Direction.RIGHT_DOWN))
+    );
+    private final HurdlePolicy hurdlePolicy = new UnpassableHurdlePolicy();
+
+    public Horse(final ChessTeam team) {
+        super(team, directions);
+    }
+
+    public static Map<ChessPosition, ChessPiece> initPieces() {
+        return Map.of(
+                new ChessPosition(0, 1), new Horse(ChessTeam.RED),
+                new ChessPosition(0, 7), new Horse(ChessTeam.RED),
+                new ChessPosition(9, 1), new Horse(ChessTeam.BLUE),
+                new ChessPosition(9, 7), new Horse(ChessTeam.BLUE)
+        );
+    }
+
+    @Override
+    public HurdlePolicy getHurdlePolicy() {
+        return hurdlePolicy;
+    }
+
+    @Override
+    public ChessPieceType getChessPieceType() {
+        return ChessPieceType.HORSE;
+    }
+}

src/main/java/domain/chessPiece/JanggiChessPiece.java

@@ -0,0 +1,43 @@
+package domain.chessPiece;
+
+import domain.hurdlePolicy.HurdlePolicy;
+import domain.position.ChessPiecePositions;
+import domain.position.ChessPosition;
+import domain.score.Score;
+import domain.type.ChessTeam;
+import domain.path.Path;
+
+import java.util.List;
+
+public abstract class JanggiChessPiece implements ChessPiece {
+
+    private final ChessTeam team;
+
+    protected JanggiChessPiece(ChessTeam team) {
+        this.team = team;
+    }
+
+    @Override
+    public final List<ChessPosition> getDestinations(ChessPosition startPosition, ChessPiecePositions positions) {
+        List<Path> coordinates = getCoordinatePaths(startPosition);
+        HurdlePolicy hurdlePolicy = getHurdlePolicy();
+        return hurdlePolicy.pickDestinations(team, coordinates, positions);
+    }
+
+
+    @Override
+    public abstract List<Path> getCoordinatePaths(ChessPosition startPosition);
+
+    @Override
+    public abstract HurdlePolicy getHurdlePolicy();
+
+    @Override
+    public final ChessTeam getTeam() {
+        return team;
+    }
+
+    @Override
+    public final Score getScore() {
+        return getChessPieceType().score;
+    }
+}