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

README.md

@@ -1,3 +1,47 @@
 # java-janggi
 
-장기 미션 저장소
+# 구현 기능
+
+- 보드 초기화
+    - 각 플레이어에게 장기판 차림 방법을 입력 받는다.
+        - 먼저 플레이하는 초나라부터 명령 번호를 입력하여 판차림 방법을 결정한다.
+            - 1, 2, 3, 4 이외의 숫자가 들어오는 경우 예외 처리한다.
+        - 선택할 수 있는 판차림은 다음과 같다.
+            1. 왼상 차림
+            2. 오른상 차림
+            3. 안상 차림
+            4. 바깥상 차림
+    - 입력한 장기판 차림을 기반으로 보드를 세팅한다.
+    - 보드 출력
+        - 빈 공간은 온점 전각 문자를 활용한다.
+        - 팀 구분은 색상(빨강, 파랑)으로 구분한다.
+        - 기물은 각 기물에 대응하는 한나라의 한자로 표기한다.
+
+- 기물 이동 구현
+    - 움직일 기물의 좌표를 플레이어에게 입력받는다.
+        - 다음의 경우 다시 입력받는다.
+            - `row`, `column` 형식이 아닌 경우
+            - 플레이어의 팀이 아닌 기물의 좌표를 입력한 경우
+            - 입력한 기물이 이동 가능한 위치가 없는 경우
+    - 입력받은 위치의 기물이 이동 가능한 위치를 출력한다.
+        - 이동 가능한 위치는 초록색으로 표현된다.
+    - 플레이어에게 이동 가능한 위치 중 하나를 입력받는다.
+        - 다음의 경우 다시 입력받는다.
+            - `row`, `column` 형식이 아닌 경우
+            - 이동 가능한 위치가 아닌 경우
+    - 입력받은 위치로 기물을 이동시킨다.
+    - 각 기물의 이동 규칙은 다음과 같다.
+        - 차 (車): 가로/세로 직선 이동가능, 거리 제한 없음, 중간에 기물이 있으면 못 지나감
+        - 마 (馬): 1칸 직선 + 1칸 대각선, 가는 길이 막히면 이동 불가
+        - 상 (象): 1칸 직선 + 2칸 대각선, 가는 길이 막히면 이동 불가
+        - 사 (士): 모든 방향으로 1칸 이동 가능
+        - 장 (將): 모든 방향으로 1칸 이동 가능
+        - 포 (砲): 반드시 하나를 넘어 전후좌우로 이동이 가능하고 포는 서로 넘거나 잡을 수 없다.
+        - 졸 (卒): 앞, 왼쪽, 오른쪽 1칸씩 이동 가능
+
+- 게임 루프 로직
+    - 처음엔 한나라(Red Team)로 시작한다.
+    - 각 플레이어가 움직일 기물의 위치를 입력한다.
+        - 기물 이동 구현의 규칙과 같다.
+    - 한나라 -> 초나라 -> 한나라... 반복된다.
+        - 종료 조건은 어느 한 팀의 장 기물이 잡히면 게임은 종료된다. 

src/main/java/janggi/Application.java

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

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

@@ -0,0 +1,103 @@
+package janggi.controller;
+
+import janggi.domain.Position;
+import janggi.domain.board.Board;
+import janggi.domain.board.BoardGenerator;
+import janggi.domain.board.setup.ElephantFormation;
+import janggi.domain.board.setup.SetupStrategy;
+import janggi.domain.team.BlueTeam;
+import janggi.domain.team.RedTeam;
+import janggi.domain.team.Team;
+import janggi.domain.team.TeamType;
+import janggi.domain.team.TurnManager;
+import janggi.dto.BoardDto;
+import janggi.utils.RetryExecutor;
+import janggi.view.InputView;
+import janggi.view.OutputView;
+import java.util.List;
+
+public class JanggiController {
+
+    public JanggiController() {
+    }
+
+    public void run() {
+        Board board = BoardGenerator.generate(setupRedTeam(), setupBlueTeam());
+        TurnManager turnManager = new TurnManager();
+        while (board.hasGeneral(turnManager.currentTeamType())) {
+            playTurn(board, turnManager);
+        }
+        turnManager.changeTurn();
+        OutputView.printGameOverMessage(turnManager.currentTeamTypeToString());
+    }
+
+    private Team setupRedTeam() {
+        OutputView.printSetupGuide(TeamType.RED);
+        final SetupStrategy setupStrategyCommand = RetryExecutor.retry(this::readSetupCommand);
+        final ElephantFormation elephantFormation = setupStrategyCommand.toPolicy();
+        return new RedTeam(elephantFormation);
+    }
+
+    private Team setupBlueTeam() {
+        OutputView.printSetupGuide(TeamType.BLUE);
+        final SetupStrategy setupStrategyCommand = RetryExecutor.retry(this::readSetupCommand);
+        final ElephantFormation elephantFormation = setupStrategyCommand.toPolicy();
+        return new BlueTeam(elephantFormation);
+    }
+
+    private SetupStrategy readSetupCommand() {
+        int inputCommand = InputView.readSetupCommand();
+        return SetupStrategy.from(inputCommand);
+    }
+
+    private void playTurn(Board board, TurnManager turnManager) {
+        OutputView.printBoard(BoardDto.from(board), turnManager.currentTeamTypeToString());
+        Position from = findFromPosition(board, turnManager);
+        List<Position> movable = board.calculateMovablePositions(from);
+        OutputView.printBoardWithMovable(BoardDto.from(board), movable);
+        Position to = RetryExecutor.retry(() -> inputToPosition(movable));
+        board.movePiece(from, to);
+        turnManager.changeTurn();
+    }
+
+    private Position findFromPosition(Board board, TurnManager turnManager) {
+        while (true) {
+            Position from = RetryExecutor.retry(() -> inputFromPosition(board, turnManager));
+            List<Position> movable = board.calculateMovablePositions(from);
+            if (!movable.isEmpty()) {
+                return from;
+            }
+            OutputView.printErrorMessage("이동 가능한 위치가 없습니다. 다른 기물을 선택하세요.");
+        }
+    }
+
+    private Position inputFromPosition(Board board, TurnManager turnManager) {
+        while (true) {
+            try {
+                OutputView.printInputFromPosition();
+                Position from = InputView.readPosition();
+                if (!board.isSameTeamType(from, turnManager.currentTeamType())) {
+                    throw new IllegalArgumentException("자신의 기물을 선택하세요.");
+                }
+                return from;
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private Position inputToPosition(List<Position> movable) {
+        while (true) {
+            try {
+                OutputView.printInputToPosition();
+                Position to = InputView.readPosition();
+                if (!movable.contains(to)) {
+                    throw new IllegalArgumentException("이동 불가능한 위치입니다.");
+                }
+                return to;
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+}

src/main/java/janggi/domain/Position.java

@@ -0,0 +1,87 @@
+package janggi.domain;
+
+import janggi.domain.movement.Direction;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+
+public final class Position {
+
+    public static final int MAXIMUM_ROW = 10;
+    public static final int MAXIMUM_COLUMN = 9;
+    public static final int MINIMUM_ROW = 1;
+    public static final int MINIMUM_COLUMN = 1;
+    private static final int ROW_FLIP_VALUE = 11;
+    private static final Map<Integer, Map<Integer, Position>> CACHE;
+
+    static {
+        CACHE = new LinkedHashMap<>();
+        for (int row = MINIMUM_ROW; row <= MAXIMUM_ROW; row++) {
+            CACHE.put(row, new LinkedHashMap<>());
+        }
+    }
+
+    private final int row;
+    private final int column;
+
+    private Position(final int row, final int column) {
+        this.row = row;
+        this.column = column;
+    }
+
+    public static Position valueOf(final int row, final int column) {
+        validateRowRange(row);
+        validateColumnRange(column);
+        final Map<Integer, Position> secondaryMap = CACHE.get(row);
+        if (!secondaryMap.containsKey(column)) {
+            secondaryMap.put(column, new Position(row, column));
+        }
+        return secondaryMap.get(column);
+    }
+
+    private static void validateRowRange(final int row) {
+        if (row < MINIMUM_ROW || row > MAXIMUM_ROW) {
+            throw new IllegalArgumentException(String.format("행 입력은 %d~%d을 입력해야 합니다.", MINIMUM_ROW, MAXIMUM_ROW));
+        }
+    }
+
+    private static void validateColumnRange(final int column) {
+        if (column < MINIMUM_COLUMN || column > MAXIMUM_COLUMN) {
+            throw new IllegalArgumentException(String.format("열 입력은 %d~%d을 입력해야 합니다.", MINIMUM_COLUMN, MAXIMUM_COLUMN));
+        }
+    }
+
+    public Position flipAroundMiddleRow() {
+        return Position.valueOf(ROW_FLIP_VALUE - row, column);
+    }
+
+    public boolean checkNextBound(final int distance, final Direction direction) {
+        final int nextRow = row + direction.getRowDirection() * distance;
+        final int nextColumn = column + direction.getColumnDirection() * distance;
+
+        return nextRow >= MINIMUM_ROW && nextRow <= MAXIMUM_ROW && nextColumn >= MINIMUM_COLUMN
+                && nextColumn <= MAXIMUM_COLUMN;
+    }
+
+    public Position calculateNext(final int distance, final Direction direction) {
+        final int nextRow = row + direction.getRowDirection() * distance;
+        final int nextColumn = column + direction.getColumnDirection() * distance;
+
+        return Position.valueOf(Math.clamp(nextRow, MINIMUM_ROW, MAXIMUM_ROW),
+                Math.clamp(nextColumn, MINIMUM_COLUMN, MAXIMUM_COLUMN));
+    }
+
+    @Override
+    public boolean equals(final Object object) {
+        if (object == null || getClass() != object.getClass()) {
+            return false;
+        }
+        final Position position = (Position) object;
+        return row == position.row && column == position.column;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(row, column);
+    }
+}

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

@@ -0,0 +1,61 @@
+package janggi.domain.board;
+
+import janggi.domain.Position;
+import janggi.domain.piece.Piece;
+import janggi.domain.team.TeamType;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Board implements BoardMediator {
+
+    private final Map<Position, Piece> positionPieceMap;
+
+    public Board(final Map<Position, Piece> positionPieceMap) {
+        this.positionPieceMap = new LinkedHashMap<>(positionPieceMap);
+    }
+
+    public void movePiece(final Position from, final Position to) {
+        positionPieceMap.put(to, positionPieceMap.remove(from));
+    }
+
+    public List<Position> calculateMovablePositions(Position from) {
+        return findPieceByPosition(from).calculateMovablePositions(from, this);
+    }
+
+    @Override
+    public boolean hasPieceAt(final Position position) {
+        return hasPieceIn(position);
+    }
+
+    @Override
+    public boolean hasGeneral(TeamType teamType) {
+        return positionPieceMap.values().stream()
+                .anyMatch(piece -> piece.isGeneral() && piece.isSameTeamType(teamType));
+    }
+
+    @Override
+    public boolean isCannon(Position position) {
+        return findPieceByPosition(position).isCannon();
+    }
+
+    @Override
+    public boolean isSameTeamType(Position position, TeamType teamType) {
+        return findPieceByPosition(position).isSameTeamType(teamType);
+    }
+
+    public Map<Position, Piece> getPositionPieceMapForDTO() {
+        return Map.copyOf(positionPieceMap);
+    }
+
+    private boolean hasPieceIn(final Position position) {
+        return positionPieceMap.containsKey(position);
+    }
+
+    private Piece findPieceByPosition(final Position position) {
+        if (hasPieceIn(position)) {
+            return positionPieceMap.get(position);
+        }
+        throw new IllegalArgumentException("요청된 위치에는 기물이 존재하지 않습니다.");
+    }
+}

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

@@ -0,0 +1,20 @@
+package janggi.domain.board;
+
+import janggi.domain.Position;
+import janggi.domain.piece.Piece;
+import janggi.domain.team.Team;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public final class BoardGenerator {
+
+    private BoardGenerator() {
+    }
+
+    public static Board generate(final Team redTeam, final Team blueTeam) {
+        final Map<Position, Piece> positionPieceMap = new LinkedHashMap<>();
+        positionPieceMap.putAll(redTeam.generatePieces());
+        positionPieceMap.putAll(blueTeam.generatePieces());
+        return new Board(positionPieceMap);
+    }
+}

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

@@ -0,0 +1,14 @@
+package janggi.domain.board;
+
+import janggi.domain.Position;
+import janggi.domain.team.TeamType;
+
+public interface BoardMediator {
+    boolean hasPieceAt(Position position);
+
+    boolean hasGeneral(TeamType teamType);
+
+    boolean isCannon(Position position);
+
+    boolean isSameTeamType(Position position, TeamType teamType);
+}

src/main/java/janggi/domain/board/setup/ElephantFormation.java

@@ -0,0 +1,30 @@
+package janggi.domain.board.setup;
+
+import janggi.domain.Position;
+import janggi.domain.piece.PieceType;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public abstract class ElephantFormation {
+    static final Map<Position, PieceType> COMMON_BOARD_MAP;
+
+    static {
+        Map<Position, PieceType> boardMap = new LinkedHashMap<>();
+        boardMap.put(Position.valueOf(1, 1), PieceType.CHARIOT);
+        boardMap.put(Position.valueOf(1, 4), PieceType.GUARD);
+        boardMap.put(Position.valueOf(1, 6), PieceType.GUARD);
+        boardMap.put(Position.valueOf(1, 9), PieceType.CHARIOT);
+        boardMap.put(Position.valueOf(2, 5), PieceType.GENERAL);
+        boardMap.put(Position.valueOf(3, 2), PieceType.CANNON);
+        boardMap.put(Position.valueOf(3, 8), PieceType.CANNON);
+        boardMap.put(Position.valueOf(4, 1), PieceType.SOLDIER);
+        boardMap.put(Position.valueOf(4, 3), PieceType.SOLDIER);
+        boardMap.put(Position.valueOf(4, 5), PieceType.SOLDIER);
+        boardMap.put(Position.valueOf(4, 7), PieceType.SOLDIER);
+        boardMap.put(Position.valueOf(4, 9), PieceType.SOLDIER);
+        COMMON_BOARD_MAP = Collections.unmodifiableMap(boardMap);
+    }
+
+    public abstract Map<Position, PieceType> offerBoardMap();
+}