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

README.md

@@ -1,3 +1,35 @@
 # java-janggi
 
-장기 미션 저장소
+## 1.1 장기판 초기화
+
+- [x] 장기판은 9행 * 10열 크기이다. (x축은 가로, y축은 세로이다.)
+    - [x] x좌표는 0 이상 8 이하의 범위를 가진다. (총 9칸)
+    - [x] y좌표는 0 이상 9 이하의 범위를 가진다. (총 10칸)
+    - [x] 장기판의 범위를 벗어난 좌표에 접근할 경우, IllegalArgumentException을 발생시킨다.
+- [x] 장기판의 좌측 하단을 (0, 0)으로 정의한다.
+
+- [x] 장기판을 초기화한다.
+    - [x] 상차림에 맞도록 기물을 배치한다.
+        - [x] 왼상차림 : 상마상마
+        - [x] 오른상차림 : 마상마상
+        - [x] 바깥상차림 : 마상상마
+        - [x] 안상차림 : 상마마상
+
+## 1.2 기물 이동
+
+- [x] `궁`은 왼쪽, 오른쪽, 앞쪽, 뒤쪽으로 1칸씩 움직일 수 있다.
+    - [x] 가로막는 기물이 적의 것일 경우 잡아내고 그 기물이 있던 곳까지 이동할 수 있다.
+- [x] `사`는 왼쪽, 오른쪽, 앞쪽, 뒤쪽으로 1칸씩 움직일 수 있다.
+    - [x] 가로막는 기물이 적의 것일 경우 잡아내고 그 기물이 있던 곳까지 이동할 수 있다.
+- [x] `차`는 장기판 위의 곧은 선을 따라 한 방향으로 원하는 만큼 이동 할 수 있다.
+    - [x] 단, 다른 기물을 뛰어넘을 수는 없다.
+    - [x] 가로막는 기물이 있는 지점의 바로 앞까지, 혹은 가로막는 기물이 적의 것일 경우 잡아내고 그 기물이 있던 곳까지 이동할 수 있다.
+- [x] `포`는 장기판 위의 곧은 선을 따라 한 방향으로 원하는 만큼 이동 가능하지만, 반드시 기물을 한 개 뛰어넘어야만 그 방향으로 이동이 가능하다.
+    - [x] 단, 경로에 두 개 이상의 기물이 존재하면 이동할 수 없다.
+    - [x] 단, 포끼리는 서로 뛰어넘을 수 없다.
+    - [x] 단, 포끼리는 서로 잡을 수 없다.
+- [x] `마`는 수직 또는 수평 방향으로 한 칸 갔다가 45도를 꺾어서 대각선으로 한 칸 더 이동한다.
+    - [x] 경로에 다른 기물이 있을 경우, 이동할 수 없다.
+- [x] `상`은 수직 또는 수평 방향으로 한 칸 갔다가 45도를 꺾어서 대각선으로 두 칸 더 이동한다.
+    - [x] 경로에 다른 기물이 있을 경우, 이동할 수 없다.
+- [x] `졸, 병`은 왼쪽, 오른쪽, 앞쪽으로 1칸씩 움직일 수 있으나, 후퇴할 수 없다.

src/main/java/Application.java

@@ -0,0 +1,19 @@
+import controller.GameController;
+import domain.board.Board;
+import domain.board.BoardInitializer;
+import view.InputView;
+
+public class Application {
+    public static void main(String[] args) {
+        Board board = new Board(BoardInitializer.init(InputView.readBoardSetting()));
+        GameController gameController = new GameController();
+
+        while (!board.isGameOver()) {
+            gameController.printBoard(board);
+            gameController.move(board);
+        }
+
+        gameController.printBoard(board);
+        gameController.printWinner(board);
+    }
+}

src/main/java/controller/GameController.java

@@ -0,0 +1,45 @@
+
+package controller;
+
+import domain.board.Board;
+import domain.board.Position;
+import view.InputView;
+import view.OutputView;
+
+public class GameController {
+    public void move(Board board) {
+        while (true) {
+            try {
+                Position departure = parsePosition(InputView.readDeparturePosition());
+                Position destination = parsePosition(InputView.readDestinationPosition());
+                board.move(departure, destination);
+                return;
+            } catch (IllegalArgumentException exception) {
+                OutputView.printError(exception.getMessage());
+            }
+        }
+    }
+
+    public void printBoard(Board board) {
+        OutputView.printBoard(board);
+    }
+
+    public void printWinner(Board board) {
+        OutputView.printWinner(board.winner());
+    }
+
+    private Position parsePosition(String value) {
+        String[] tokens = value.split(",");
+        if (tokens.length != 2) {
+            throw new IllegalArgumentException("좌표는 x,y 형식으로 입력해야 합니다.");
+        }
+
+        try {
+            int column = Integer.parseInt(tokens[0].trim());
+            int row = Integer.parseInt(tokens[1].trim());
+            return new Position(column, row);
+        } catch (NumberFormatException exception) {
+            throw new IllegalArgumentException("좌표는 숫자로 입력해야 합니다.");
+        }
+    }
+}

src/main/java/domain/board/Board.java

@@ -0,0 +1,101 @@
+package domain.board;
+
+import domain.path.PathInfo;
+import domain.piece.Camp;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+
+import java.util.List;
+import java.util.Map;
+
+public class Board {
+    private final Map<Position, Piece> pieces;
+    private boolean gameOver;
+    private Camp winner;
+
+    public Board(Map<Position, Piece> pieces) {
+        this.pieces = pieces;
+    }
+
+    public boolean isExistPieceAt(Position position) {
+        return pieces.containsKey(position);
+    }
+
+    public Piece pieceAt(Position position) {
+        if (!isExistPieceAt(position)) {
+            throw new IllegalArgumentException("해당 위치에 기물이 존재하지 않습니다.");
+        }
+
+        return pieces.get(position);
+    }
+
+    public boolean isGameOver() {
+        return gameOver;
+    }
+
+    public Camp winner() {
+        if (!gameOver) {
+            throw new IllegalStateException("아직 게임이 종료되지 않았습니다.");
+        }
+
+        return winner;
+    }
+
+    public void move(Position departure, Position destination) {
+        validateGameStatus();
+        validateDepartureAndDestinationPosition(departure, destination);
+
+        Piece departurePiece = pieceAt(departure);
+        List<PathInfo> path = getPath(departure, destination, departurePiece);
+
+        departurePiece.validateBlockingPiece(path, destination);
+
+        if (isExistPieceAt(destination)) {
+            handleCapture(pieceAt(departure), destination);
+        }
+
+        executeMove(departure, destination, departurePiece);
+    }
+
+    private void validateGameStatus() {
+        if (gameOver) {
+            throw new IllegalStateException("이미 종료된 게임입니다.");
+        }
+    }
+
+    private void handleCapture(Piece departurePiece, Position destination) {
+        Piece destinationPiece = pieceAt(destination);
+        validateCapture(departurePiece, destinationPiece);
+        updateGameOver(departurePiece, destinationPiece);
+    }
+
+    private void validateDepartureAndDestinationPosition(Position departure, Position destination) {
+        if (departure.equals(destination)) {
+            throw new IllegalArgumentException("출발 위치와 도착 위치가 같습니다.");
+        }
+    }
+
+    private void validateCapture(Piece departurePiece, Piece destinationPiece) {
+        if (departurePiece.isSameCamp(destinationPiece)) {
+            throw new IllegalArgumentException("같은 진영의 기물은 잡을 수 없습니다.");
+        }
+    }
+
+    private List<PathInfo> getPath(Position departure, Position destination, Piece piece) {
+        return piece.getPath(departure, destination).stream()
+                .map(pos -> new PathInfo(pos, pieces.get(pos)))
+                .toList();
+    }
+
+    private void updateGameOver(Piece departurePiece, Piece destinationPiece) {
+        if (destinationPiece.isSameType(PieceType.GENERAL)) {
+            gameOver = true;
+            winner = departurePiece.getCamp();
+        }
+    }
+
+    private void executeMove(Position from, Position to, Piece piece) {
+        pieces.remove(from);
+        pieces.put(to, piece);
+    }
+}

src/main/java/domain/board/BoardInitializer.java

@@ -0,0 +1,99 @@
+package domain.board;
+
+import domain.piece.Camp;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BoardInitializer {
+    private static final int CHO_BASE_ROW = 0;
+    private static final int CHO_GENERAL_ROW = CHO_BASE_ROW + 1;
+    private static final int CHO_CANNON_ROW = CHO_BASE_ROW + 2;
+    private static final int CHO_SOLDIER_ROW = CHO_BASE_ROW + 3;
+
+    private static final int HAN_BASE_ROW = 9;
+    private static final int HAN_GENERAL_ROW = HAN_BASE_ROW - 1;
+    private static final int HAN_CANNON_ROW = HAN_BASE_ROW - 2;
+    private static final int HAN_SOLDIER_ROW = HAN_BASE_ROW - 3;
+
+    private static final int GENERAL_COLUMN = 4;
+    private static final List<Integer> GUARD_COLUMNS = List.of(3, 5);
+    private static final List<Integer> CHARIOT_COLUMNS = List.of(0, 8);
+    private static final List<Integer> CANNON_COLUMNS = List.of(1, 7);
+    private static final List<Integer> HORSE_AND_ELEPHANT_COLUMNS = List.of(1, 2, 6, 7);
+    private static final List<Integer> SOLDIER_COLUMNS = List.of(0, 2, 4, 6, 8);
+
+    public static Map<Position, Piece> init(BoardSetting boardSetting) {
+        Map<Position, Piece> pieces = new HashMap<>();
+
+        pieces.putAll(createGeneral());
+        pieces.putAll(createGuard());
+        pieces.putAll(createChariot());
+        pieces.putAll(createCannon());
+        pieces.putAll(createHorseAndElephant(boardSetting));
+        pieces.putAll(createSoldier());
+
+        return pieces;
+    }
+
+    private static Map<Position, Piece> createGeneral() {
+        Map<Position, Piece> pieces = new HashMap<>();
+        pieces.put(new Position(GENERAL_COLUMN, CHO_GENERAL_ROW), Piece.of(Camp.CHO, PieceType.GENERAL));
+        pieces.put(new Position(GENERAL_COLUMN, HAN_GENERAL_ROW), Piece.of(Camp.HAN, PieceType.GENERAL));
+
+        return pieces;
+    }
+
+    private static Map<Position, Piece> createGuard() {
+        Map<Position, Piece> pieces = new HashMap<>();
+        for (Integer column : GUARD_COLUMNS) {
+            pieces.put(new Position(column, CHO_BASE_ROW), Piece.of(Camp.CHO, PieceType.GUARD));
+            pieces.put(new Position(column, HAN_BASE_ROW), Piece.of(Camp.HAN, PieceType.GUARD));
+        }
+
+        return pieces;
+    }
+
+    private static Map<Position, Piece> createChariot() {
+        Map<Position, Piece> pieces = new HashMap<>();
+        for (Integer column : CHARIOT_COLUMNS) {
+            pieces.put(new Position(column, CHO_BASE_ROW), Piece.of(Camp.CHO, PieceType.CHARIOT));
+            pieces.put(new Position(column, HAN_BASE_ROW), Piece.of(Camp.HAN, PieceType.CHARIOT));
+        }
+
+        return pieces;
+    }
+
+    private static Map<Position, Piece> createCannon() {
+        Map<Position, Piece> pieces = new HashMap<>();
+        for (Integer column : CANNON_COLUMNS) {
+            pieces.put(new Position(column, CHO_CANNON_ROW), Piece.of(Camp.CHO, PieceType.CANNON));
+            pieces.put(new Position(column, HAN_CANNON_ROW), Piece.of(Camp.HAN, PieceType.CANNON));
+        }
+
+        return pieces;
+    }
+
+    private static Map<Position, Piece> createHorseAndElephant(BoardSetting boardSetting) {
+        Map<Position, Piece> pieces = new HashMap<>();
+        for (int i = 0; i < boardSetting.piecesArrangement().size(); i++) {
+            pieces.put(new Position(HORSE_AND_ELEPHANT_COLUMNS.get(i), CHO_BASE_ROW), Piece.of(Camp.CHO, boardSetting.piecesArrangement().get(i)));
+            pieces.put(new Position(HORSE_AND_ELEPHANT_COLUMNS.get(i), HAN_BASE_ROW), Piece.of(Camp.HAN, boardSetting.piecesArrangement().get(i)));
+        }
+
+        return pieces;
+    }
+
+    private static Map<Position, Piece> createSoldier() {
+        Map<Position, Piece> pieces = new HashMap<>();
+        for (Integer column : SOLDIER_COLUMNS) {
+            pieces.put(new Position(column, CHO_SOLDIER_ROW), Piece.of(Camp.CHO, PieceType.SOLDIER));
+            pieces.put(new Position(column, HAN_SOLDIER_ROW), Piece.of(Camp.HAN, PieceType.SOLDIER));
+        }
+
+        return pieces;
+    }
+}

src/main/java/domain/board/BoardSetting.java

@@ -0,0 +1,35 @@
+package domain.board;
+
+import domain.piece.PieceType;
+
+import java.util.List;
+
+import static domain.piece.PieceType.ELEPHANT;
+import static domain.piece.PieceType.HORSE;
+
+public enum BoardSetting {
+    LEFT_ELEPHANT_SET_UP(List.of(ELEPHANT, HORSE, ELEPHANT, HORSE)),
+    RIGHT_ELEPHANT_SET_UP(List.of(HORSE, ELEPHANT, HORSE, ELEPHANT)),
+    OUTER_ELEPHANT_SET_UP(List.of(HORSE, ELEPHANT, ELEPHANT, HORSE)),
+    INNER_ELEPHANT_SET_UP(List.of(ELEPHANT, HORSE, HORSE, ELEPHANT));
+
+    private final List<PieceType> piecesArrangement;
+
+    BoardSetting(List<PieceType> pieceTypes) {
+        this.piecesArrangement = pieceTypes;
+    }
+
+    public List<PieceType> piecesArrangement() {
+        return piecesArrangement;
+    }
+
+    public static BoardSetting from(String value) {
+        return switch (value.trim()) {
+            case "1", "왼상차림" -> LEFT_ELEPHANT_SET_UP;
+            case "2", "오른상차림" -> RIGHT_ELEPHANT_SET_UP;
+            case "3", "바깥상차림" -> OUTER_ELEPHANT_SET_UP;
+            case "4", "안상차림" -> INNER_ELEPHANT_SET_UP;
+            default -> throw new IllegalArgumentException("상차림은 1~4 또는 이름으로 입력해야 합니다.");
+        };
+    }
+}

src/main/java/domain/board/Position.java

@@ -0,0 +1,38 @@
+package domain.board;
+
+public record Position(int column, int row) {
+    private static final int MIN_POSITION = 0;
+    private static final int MAX_COLUMN = 8;
+    private static final int MAX_ROW = 9;
+
+    public Position {
+        validateColumn(column);
+        validateRow(row);
+    }
+
+    public Position move(int deltaX, int deltaY) {
+        return new Position(this.column + deltaX, this.row + deltaY);
+    }
+
+    public int calculateDeltaX(Position destination) {
+        return destination.column - this.column;
+    }
+
+    public int calculateDeltaY(Position destination) {
+        return destination.row - this.row;
+    }
+
+    private void validateColumn(int column) {
+        if (column < MIN_POSITION || column > MAX_COLUMN) {
+            throw new IllegalArgumentException(
+                    String.format("[ERROR] x좌표는 %d에서 %d 사이입니다.", MIN_POSITION, MAX_COLUMN));
+        }
+    }
+
+    private void validateRow(int row) {
+        if (row < MIN_POSITION || row > MAX_ROW) {
+            throw new IllegalArgumentException(
+                    String.format("[ERROR] y좌표는 %d에서 %d 사이입니다.", MIN_POSITION, MAX_ROW));
+        }
+    }
+}