[체스 - 스피드런] 밍곰(박민선) 미션 제출합니다.

README.md

@@ -5,3 +5,35 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 실행 흐름
+1. 보드에 있는 기물을 선택하면, 해당 기물이 이동할 수 있는 위치들을 알려준다.
+2. 사용자가 위치를 입력하면 해당 기물을 지정 위치로 이동시킨다.
+3. 이동 위치에 기물이 존재하는 경우, 해당 기물을 잡아서 점수를 얻을 수 있다.
+
+## 기물 이동 구현하기
+
+- [x] 비숍
+  - [x] 대각선으로 원하는만큼 이동 가능
+  - [x] 장애물을 통과할 수 없음
+- [x] 왕
+  - [x] 상, 하, 좌, 우, 대각선 한 칸씩 이동 가능
+- [x] 나이트
+  - [x] 상, 하, 좌, 우 방향으로 앞으로 한 칸, 대각선으로 한 칸 이동 가능
+  - [x] 장애물을 통과할 수 있음
+- [ ] 폰
+  - [ ] 처음 이동할 때는 앞으로 두 칸 이동도 가능 (한 칸만 움직일 수도 있음)
+  - [ ] 상대 말을 잡을 때는 무조건 대각선으로만 잡을 수 있음
+  - [ ] 뒤로는 이동할 수 없음
+- [x] 여왕
+  - [x] 상, 하, 좌, 우, 대각선 원하는만큼 이동 가능
+  - [x] 장애물을 통과할 수 없음
+- [x] 룩
+  - [x] 상, 하, 좌, 우 원하는만큼 이동 가능
+  - [x] 장애물을 통과할 수 없음
+
+## 기물 배치하기
+
+## 기물 잡기
+
+- [ ] 기물이 이동한 위치에 다른 팀의 기물이 존재하는 경우

src/main/java/chess/Board.java

@@ -0,0 +1,5 @@
+package chess;
+
+public class Board {
+
+}

src/main/java/chess/ChessPositions.java

@@ -0,0 +1,14 @@
+package chess;
+
+import chess.piece.ChessPiece;
+
+import java.util.List;
+import java.util.Map;
+
+public class ChessPositions {
+    private final Map<Position, ChessPiece> positions;
+
+    public ChessPositions(Map<Position, ChessPiece> positions) {
+        this.positions = positions;
+    }
+}

src/main/java/chess/Column.java

@@ -1,6 +1,7 @@
 package chess;
 
-public enum Column {
+public enum
+Column {
 
     A,
     B,

src/main/java/chess/piece/Bishop.java

@@ -1,5 +1,69 @@
 package chess.piece;
 
-public class Bishop {
+import chess.Color;
+import chess.Movement;
+import chess.Position;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Bishop implements ChessPiece {
+    private final Color color;
+    private final List<Movement> movements = List.of(
+            Movement.LEFT_UP,
+            Movement.RIGHT_UP,
+            Movement.LEFT_DOWN,
+            Movement.RIGHT_DOWN
+    );
+
+    public Bishop(Color color) {
+        this.color = color;
+    }
+
+    @Override
+    public Position move(Position from, Position to, Map<Position, ChessPiece> positions) {
+        if (!isValidPath(from, to, positions)) {
+            throw new IllegalArgumentException("경로가 유효하지 않습니다.");
+        }
+        return to;
+    }
+
+    private boolean isValidPath(Position from, Position to, Map<Position, ChessPiece> positions) {
+        List<Position> availableDestinations = getAvailableDestinations(from, positions);
+        return availableDestinations.contains(to);
+    }
+
+    public List<Position> getAvailableDestinations(Position startPosition, Map<Position, ChessPiece> positions) {
+        List<Position> destinations = new ArrayList<>();
+
+        for (Movement movement : movements) {
+            Position currentPosition = startPosition;
+            while (currentPosition.canMove(movement)) {
+                currentPosition = currentPosition.move(movement);
+                if (!canMove(currentPosition, positions)) {
+                    break;
+                }
+                destinations.add(currentPosition);
+                if (positions.containsKey(currentPosition)) {
+                    break;
+                }
+            }
+        }
+
+        return destinations;
+    }
+
+    private boolean canMove(Position targetPosition, Map<Position, ChessPiece> positions) {
+        return !positions.containsKey(targetPosition) || canCatch(targetPosition, positions);
+    }
+
+    private boolean canCatch(Position targetPosition, Map<Position, ChessPiece> positions) {
+        return positions.containsKey(targetPosition) && positions.get(targetPosition).getColor() != color;
+    }
+
+    @Override
+    public Color getColor() {
+        return color;
+    }
 }

src/main/java/chess/piece/ChessPiece.java

@@ -0,0 +1,13 @@
+package chess.piece;
+
+import chess.Color;
+import chess.Position;
+
+import java.util.List;
+import java.util.Map;
+
+public interface ChessPiece {
+    List<Position> getAvailableDestinations(Position startPosition, Map<Position, ChessPiece> positions);
+    Color getColor();
+    Position move(Position from, Position to, Map<Position, ChessPiece> positions);
+}

src/main/java/chess/piece/King.java

@@ -1,5 +1,57 @@
 package chess.piece;
 
-public class King {
+import chess.Color;
+import chess.Movement;
+import chess.Position;
 
+import java.util.List;
+import java.util.Map;
+
+public class King implements ChessPiece {
+    private final Color color;
+    private final List<Movement> movements = List.of(
+            Movement.UP,
+            Movement.DOWN,
+            Movement.LEFT,
+            Movement.RIGHT,
+            Movement.LEFT_UP,
+            Movement.RIGHT_UP,
+            Movement.LEFT_DOWN,
+            Movement.RIGHT_DOWN
+    );
+
+    public King(Color color) {
+        this.color = color;
+    }
+
+    @Override
+    public Position move(Position from, Position to, Map<Position, ChessPiece> positions) {
+        if (!isValidPath(from, to, positions)) {
+            throw new IllegalArgumentException("경로가 유효하지 않습니다.");
+        }
+        return to;
+    }
+
+    private boolean isValidPath(Position from, Position to, Map<Position, ChessPiece> positions) {
+        List<Position> availableDestinations = getAvailableDestinations(from, positions);
+        return availableDestinations.contains(to);
+    }
+
+    @Override
+    public List<Position> getAvailableDestinations(Position startPosition, Map<Position, ChessPiece> positions) {
+        return movements.stream()
+                .filter(startPosition::canMove)
+                .map(startPosition::move)
+                .filter(position -> canMove(position, positions))
+                .toList();
+    }
+
+    private boolean canMove(Position targetPosition, Map<Position, ChessPiece> positions) {
+        return !positions.containsKey(targetPosition) || positions.get(targetPosition).getColor() != color;
+    }
+
+    @Override
+    public Color getColor() {
+        return color;
+    }
 }

src/main/java/chess/piece/Knight.java

@@ -1,5 +1,60 @@
 package chess.piece;
 
-public class Knight {
+import chess.Color;
+import chess.Movement;
+import chess.Position;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Knight implements ChessPiece {
+    private final Color color;
+    private final List<Movement> movements = List.of(
+            Movement.UP_UP_LEFT,
+            Movement.UP_UP_RIGHT,
+            Movement.DOWN_DOWN_LEFT,
+            Movement.DOWN_DOWN_RIGHT,
+            Movement.LEFT_LEFT_UP,
+            Movement.LEFT_LEFT_DOWN,
+            Movement.RIGHT_RIGHT_UP,
+            Movement.RIGHT_RIGHT_DOWN
+    );
+
+    public Knight(Color color) {
+        this.color = color;
+    }
+
+    @Override
+    public Position move(Position from, Position to, Map<Position, ChessPiece> positions) {
+        if (!isValidPath(from, to, positions)) {
+            throw new IllegalArgumentException("경로가 유효하지 않습니다.");
+        }
+        return to;
+    }
+
+    private boolean isValidPath(Position from, Position to, Map<Position, ChessPiece> positions) {
+        List<Position> availableDestinations = getAvailableDestinations(from, positions);
+        return availableDestinations.contains(to);
+    }
+
+    @Override
+    public List<Position> getAvailableDestinations(Position startPosition, Map<Position, ChessPiece> positions) {
+        List<Position> destinations = new ArrayList<>();
+        for (Movement movement : movements) {
+            if (startPosition.canMove(movement) && canMove(startPosition.move(movement), positions)) {
+                destinations.add(startPosition.move(movement));
+            }
+        }
+        return destinations;
+    }
+
+    private boolean canMove(Position targetPosition, Map<Position, ChessPiece> positions) {
+        return !positions.containsKey(targetPosition) || positions.get(targetPosition).getColor() != color;
+    }
+
+    @Override
+    public Color getColor() {
+        return color;
+    }
 }

src/main/java/chess/piece/Pawn.java

@@ -1,5 +1,86 @@
 package chess.piece;
 
-public class Pawn {
+import chess.Color;
+import chess.Movement;
+import chess.Position;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+public class Pawn implements ChessPiece {
+    private final Color color;
+    private boolean isFirstMove;
+
+    public Pawn(Color color) {
+        this.color = color;
+        isFirstMove = true;
+    }
+
+    @Override
+    public Position move(Position from, Position to, Map<Position, ChessPiece> positions) {
+        isFirstMove = false;
+        return null;
+    }
+
+    @Override
+    public List<Position> getAvailableDestinations(Position startPosition, Map<Position, ChessPiece> positions) {
+        List<Position> destinations = new ArrayList<>();
+        for (Movement movement : getMovements()) {
+            if (canMove(startPosition, movement, positions)) {
+                destinations.add(startPosition.move(movement));
+            }
+        }
+        return destinations;
+    }
+
+    private List<Movement> getMovements() {
+        if (color.isBlack()) {
+            return getBlackMovements();
+        }
+        return getWhiteMovements();
+    }
+
+    private List<Movement> getBlackMovements() {
+        List<Movement> result = new ArrayList<>(List.of(
+                Movement.DOWN,
+                Movement.LEFT_DOWN,
+                Movement.RIGHT_DOWN
+        ));
+        if (isFirstMove) {
+            result.add(Movement.DOWN_DOWN);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    private List<Movement> getWhiteMovements() {
+        List<Movement> result = new ArrayList<>(List.of(
+                Movement.UP,
+                Movement.LEFT_UP,
+                Movement.RIGHT_UP
+        ));
+        if (isFirstMove) {
+            result.add(Movement.UP_UP);
+        }
+        return Collections.unmodifiableList(result);
+    }
+
+    private boolean canMove(Position startPosition, Movement movement, Map<Position, ChessPiece> positions) {
+        if (!startPosition.canMove(movement)) {
+            return false;
+        }
+        Position targetPosition = startPosition.move(movement);
+        if (movement.isDiagonal()) {
+            // 대각선 방향인 경우 - 상대 기물이 존재하는지 확인
+            return positions.containsKey(targetPosition) && positions.get(targetPosition).getColor() != color;
+        }
+        // 빈 칸 확인
+        return !positions.containsKey(targetPosition);
+    }
+
+    @Override
+    public Color getColor() {
+        return color;
+    }
 }