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

README.md

@@ -1,3 +1,44 @@
 # java-janggi
 
 장기 미션 저장소
+
+version : 1.2 (구현의 어려움에 따른 도메인 변경 : 돌아가는 코드를 우선 만들어보기)
+
+# 시나리오
+
+1. 한나라 사용자가 상차림을 선택한다.
+2. 초나라 사용자가 상차림을 선택한다.
+3. 초나라 시작
+    1. 이동할 기물의 좌표를 입력한다. (무르기 : q)
+
+       현재 보드를 보여준다.
+
+       ex) 졸을 선택했습니다. 졸은 현재 (1,1)에 있습니다.
+
+    2. 해당 기물이 이동할 수 있는 좌표를 보여준다. (기물 다시선택 : r)
+        - 만약에 아무데도 이동 불가능하면 다시 a로 돌아가서 선택하게 한다.
+    3. 보여진 좌표 중 이동할 좌표를 입력한다.
+        - 이동할 좌표를 입력해주세요.(예시: 3, 5)
+    4. 해당 좌표로 이동한다.
+4. 한나라 시작
+
+   초나라와 동일
+
+# 도메인 구현 리스트
+
+- **보드**
+    - [x] 상차림은 마상마상으로 고정하여 초기화 한다. (추후 추가 예정)
+    - [x]  해당 기물의 이동 가능 여부를 판단한다
+        - 멱에 다른 기물이 있으면 안 되는 경우: 마,상, 졸/병, 차, 장, 사
+        - 멱 사이에 하나의 기물이 있어야 하는 경우: 포
+            - 그 기물이 포여서는 안 된다.
+            - 이동하고자 하는 좌표 자체가 포 or 아군이면 안 된다.
+    - [x]  기물을 이동시킨다.
+- **좌표**
+    - [x]  보드 내의 좌표 범위를 검증한다.
+- **기물**
+    - [x]  해당 기물은 팀과 기물 타입을 가진다.
+      - [x]  PieceType(enum) 작성
+      - [x]  팀 Team(enum) 작성
+- **규칙**
+    - [x]  각 기물은 고유의 규칙을 가진다.

src/main/java/janggi/Application.java

@@ -0,0 +1,10 @@
+package janggi;
+
+import janggi.controller.JanggiController;
+
+public class Application {
+    public static void main(String[] args) {
+        JanggiController janggiController = new JanggiController();
+        janggiController.run();
+    }
+}

src/main/java/janggi/controller/JanggiController.java

@@ -0,0 +1,92 @@
+package janggi.controller;
+
+import janggi.domain.board.Board;
+import janggi.domain.board.BoardFormation;
+import janggi.domain.board.BoardInitiator;
+import janggi.domain.common.Position;
+import janggi.domain.common.Team;
+import janggi.domain.route.RouteChecker;
+import janggi.view.InputView;
+import janggi.view.OutputView;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class JanggiController {
+
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+    private final BoardInitiator boardInitiator = new BoardInitiator();
+    private final RouteChecker routeChecker = new RouteChecker();
+
+    public void run() {
+        Board board = new Board();
+
+        choiceBoardFormation(board);
+
+        boolean isChoTurn = true;
+
+        outputView.printBoard(board.getBoard());
+
+        while (true) {
+            playGame(isChoTurn, board);
+
+            isChoTurn = changeTurn(isChoTurn);
+        }
+    }
+
+    private void choiceBoardFormation(Board board) {
+        askBoardFormation(board, Team.HAN);
+        askBoardFormation(board, Team.CHO);
+    }
+
+    private void askBoardFormation(Board board, Team team) {
+        outputView.printBoardFormation(team);
+        int boardFormationChoice = inputView.readBoardFormationChoice();
+        BoardFormation formation = BoardFormation.selectByChoice(boardFormationChoice);
+        boardInitiator.initializeByFormation(board, formation, team);
+    }
+
+    private void playGame(boolean isChoTurn, Board board) {
+        outputView.printTurnMessage(isChoTurn);
+
+        Position movePiecePosition = doLoop(() -> askMovePiecePosition(board));
+
+        List<Position> availablePositions = routeChecker.findAvailablePositions(board, movePiecePosition);
+
+        outputView.printAvailablePositions(board.getBoard(), availablePositions);
+
+        Position movePosition = doLoop(() -> askMovePosition(board, movePiecePosition));
+
+        board.movePiece(movePiecePosition, movePosition);
+
+        outputView.printBoard(board.getBoard());
+    }
+
+    private boolean changeTurn(boolean isChoTurn) {
+        return !isChoTurn;
+    }
+
+    private Position askMovePosition(Board board, Position movePiecePosition) {
+        outputView.printMoveChoiceInfo();
+        Position position = inputView.readPosition();
+        routeChecker.validateDestination(board, movePiecePosition, position);
+        return position;
+    }
+
+    private Position askMovePiecePosition(Board board) {
+        outputView.printMoveInfo();
+        Position position = inputView.readPosition();
+        routeChecker.findAvailablePositions(board, position);
+        return position;
+    }
+
+    private <T> T doLoop(Supplier<T> inputFunction) {
+        while (true) {
+            try {
+                return inputFunction.get();
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+package janggi.domain.board;
+
+import janggi.domain.common.Position;
+import janggi.domain.piece.Piece;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Board {
+
+    private final Map<Position, Piece> board = new HashMap<>();
+
+    public void place(Position position, Piece piece) {
+        board.put(position, piece);
+    }
+
+    public Map<Position, Piece> getBoard() {
+        return board;
+    }
+
+    public void movePiece(Position movePiecePosition, Position destination) {
+        Piece piece = board.get(movePiecePosition);
+        board.remove(movePiecePosition);
+        board.put(destination, piece);
+    }
+
+    public Piece pieceAt(Position position) {
+        return board.get(position);
+    }
+
+    public boolean hasPiece(Position position) {
+        return board.containsKey(position);
+    }
+}

src/main/java/janggi/domain/board/BoardFormation.java

@@ -0,0 +1,54 @@
+package janggi.domain.board;
+
+import java.util.List;
+
+public enum BoardFormation {
+    MA_SANG_MA_SANG(1, "마상마상", List.of(2, 7), List.of(3, 8)),
+    MA_SANG_SANG_MA(2, "마상상마", List.of(2, 8), List.of(3, 7)),
+    SANG_MA_SANG_MA(3, "상마상마", List.of(3, 8), List.of(2, 7)),
+    SANG_MA_MA_SANG(4, "상마마상", List.of(3, 7), List.of(2, 8));
+
+    private final int choice;
+    private final String name;
+    private final List<Integer> maXPositions;
+    private final List<Integer> sangXPositions;
+
+    BoardFormation(int choice, String name, List<Integer> maXPositions, List<Integer> sangXPositions) {
+        this.choice = choice;
+        this.name = name;
+        this.maXPositions = maXPositions;
+        this.sangXPositions = sangXPositions;
+    }
+
+    public static BoardFormation selectByChoice(int choice) {
+        if (choice == 1) {
+            return MA_SANG_MA_SANG;
+        }
+        if (choice == 2) {
+            return MA_SANG_SANG_MA;
+        }
+        if (choice == 3) {
+            return SANG_MA_SANG_MA;
+        }
+        if (choice == 4) {
+            return SANG_MA_MA_SANG;
+        }
+        throw new IllegalArgumentException("[ERROR] 잘못된 번호를 입력하셨습니다.");
+    }
+
+    public int getChoice() {
+        return choice;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<Integer> getMaXPositions() {
+        return maXPositions;
+    }
+
+    public List<Integer> getSangXPositions() {
+        return sangXPositions;
+    }
+}

src/main/java/janggi/domain/board/BoardInitiator.java

@@ -0,0 +1,73 @@
+package janggi.domain.board;
+
+import janggi.domain.common.Position;
+import janggi.domain.common.Team;
+import janggi.domain.piece.Piece;
+import janggi.domain.piece.PieceType;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BoardInitiator {
+
+    private static final int MAX_Y = 11;
+
+    private final Map<PieceType, List<Integer>> defaultXPositions = Map.of(
+            PieceType.KING, List.of(5),
+            PieceType.SA, List.of(4, 6),
+            PieceType.CHA, List.of(1, 9),
+            PieceType.PO, List.of(2, 8),
+            PieceType.ZOL, List.of(1, 3, 5, 7, 9)
+    );
+
+    private final Map<PieceType, Integer> defaultYPosition = Map.of(
+            PieceType.KING, 9,
+            PieceType.SA, 10,
+            PieceType.SANG, 10,
+            PieceType.MA, 10,
+            PieceType.CHA, 10,
+            PieceType.PO, 8,
+            PieceType.ZOL, 7
+    );
+
+    public void initializeByFormation(Board board, BoardFormation formation, Team team) {
+        Map<PieceType, List<Integer>> xPositions = initXPositionsByFormation(formation);
+        placeByPieceType(board, xPositions, team);
+    }
+
+    private Map<PieceType, List<Integer>> initXPositionsByFormation(BoardFormation formation) {
+        Map<PieceType, List<Integer>> result = new HashMap<>();
+        for (PieceType pieceType : PieceType.values()) {
+            if (pieceType == PieceType.MA) {
+                result.put(pieceType, formation.getMaXPositions());
+                continue;
+            }
+            if (pieceType == PieceType.SANG) {
+                result.put(pieceType, formation.getSangXPositions());
+                continue;
+            }
+            result.put(pieceType, defaultXPositions.get(pieceType));
+        }
+        return result;
+    }
+
+    private void placeByPieceType(Board board, Map<PieceType, List<Integer>> hanXPositions, Team team) {
+        for (PieceType pieceType : PieceType.values()) {
+            placeByPieceType(board, hanXPositions, team, pieceType);
+        }
+    }
+
+    private void placeByPieceType(Board board, Map<PieceType, List<Integer>> hanXPositions, Team team,
+                                  PieceType pieceType) {
+        for (Integer x : hanXPositions.get(pieceType)) {
+            if (team == Team.CHO) {
+                Position position = new Position(x, defaultYPosition.get(pieceType));
+                board.place(position, new Piece(team, pieceType));
+            }
+            if (team == Team.HAN) {
+                Position position = new Position(x, MAX_Y - defaultYPosition.get(pieceType));
+                board.place(position, new Piece(team, pieceType));
+            }
+        }
+    }
+}

src/main/java/janggi/domain/common/Direction.java

@@ -0,0 +1,26 @@
+package janggi.domain.common;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public enum Direction {
+    UP(0, -1), DOWN(0, 1), LEFT(-1, 0), RIGHT(1, 0),
+    UP_LEFT(-1, -1), UP_RIGHT(1, -1), DOWN_LEFT(-1, 1), DOWN_RIGHT(1, 1);
+
+    private final int x;
+    private final int y;
+
+    Direction(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public Optional<Position> nextPosition(Position position) {
+        return position.applyDirection(x, y);
+    }
+
+    public void nextContinuousPosition(Position position, Map<Position, List<Position>> continuousRoute) {
+        position.applyContinuousDirection(x, y, continuousRoute);
+    }
+}