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

README.md

@@ -1,3 +1,40 @@
-# java-janggi
+## 기능 요구사항 체크리스트
 
-장기 미션 저장소
+### 게임 초기화
+
+- [x] 두 플레이어가 각각 진형을 선택한다
+- [x] 진형 선택지: 왼상마(귀마), 오른상마(귀마), 원앙마, 양귀마
+- [x] 선택한 진형에 따라 마(馬)와 상(象)의 위치가 결정된다
+
+### 기물 이동
+
+- [x] 차(車): 직선(가로/세로) 이동, 이동 경로에 기물이 없어야 한다
+- [x] 마(馬): 직선 1칸 + 대각선 1칸 이동, 첫 번째 칸에 기물이 없어야 한다
+- [x] 상(象): 직선 1칸 + 대각선 2칸 이동, 이동 경로 2칸에 기물이 없어야 한다
+- [x] 궁(將/帥): 상하좌우 1칸 이동
+- [x] 사(士): 상하좌우 1칸 이동
+- [x] 포(包): 직선 이동, 반드시 기물 1개를 뛰어넘어야 하며 포를 넘거나 포를 잡을 수 없다
+- [x] 병/졸(兵/卒): 앞 또는 좌우 1칸 이동
+
+### 이동 유효성 검증
+
+- [x] 이동 불가능한 위치로 이동 시 예외 처리
+- [x] 이동 경로 중간에 기물이 있을 경우 이동 불가 (포 제외)
+- [x] 아군 기물이 있는 위치로 이동 불가
+- [x] 적군 기물이 있는 위치로 이동 시 해당 기물 잡기
+- [x] 포의 경우 이동 경로에 정확히 1개의 기물이 있어야 이동 가능
+- [x] 포는 포를 뛰어넘거나 포를 잡을 수 없다
+
+### 게임 진행
+
+- [x] 초(CHO)가 먼저 시작하고 이후 번갈아 진행한다
+- [x] 매 턴 현재 보드 상태를 출력한다
+- [x] 잘못된 입력 시 재입력을 받는다
+
+### 출력
+
+- [x] 10x9 보드를 콘솔에 출력한다
+- [x] 초(CHO)는 파란색, 한(HAN)은 빨간색으로 구분하여 출력한다
+- [x] 빈 칸은 `ㅡ`로 표시한다
+
+---

src/main/java/JanggiApplication.java

@@ -0,0 +1,12 @@
+import controller.JanggiController;
+import domain.piece.ConsolePieceAppearance;
+import view.InputView;
+import view.OutputView;
+
+public class JanggiApplication {
+    public static void main(String[] args) {
+        JanggiController janggiController = new JanggiController(new InputView(),
+                new OutputView(new ConsolePieceAppearance()));
+        janggiController.run();
+    }
+}

src/main/java/controller/FormationConverter.java

@@ -0,0 +1,18 @@
+package controller;
+
+import domain.board.FormationType;
+
+public final class FormationConverter {
+
+    private FormationConverter() {}
+
+    public static FormationType convert(int formationType) {
+        if (formationType == 1) return FormationType.LEFT_GIWMA;
+        if (formationType == 2) return FormationType.RIGHT_GIWMA;
+        if (formationType == 3) return FormationType.WONANGMA;
+        if (formationType == 4) return FormationType.YANGGWIMA;
+
+        throw new IllegalArgumentException("올바르지 않은 상차림 번호입니다.");
+    };
+
+}

src/main/java/controller/JanggiController.java

@@ -0,0 +1,46 @@
+package controller;
+
+import domain.board.FormationType;
+import domain.game.JanggiGame;
+import domain.game.Team;
+import domain.position.Position;
+import java.util.List;
+import view.InputView;
+import view.OutputView;
+
+public class JanggiController {
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public JanggiController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        JanggiGame game = createGame();
+        outputView.printBoard(game.getBoard());
+        while (game.isRunning()) {
+            playTurn(game);
+        }
+    }
+
+    private JanggiGame createGame() {
+        FormationType choFormation = FormationConverter.convert(inputView.initialFormation(Team.CHO));
+        FormationType hanFormation = FormationConverter.convert(inputView.initialFormation(Team.HAN));
+        return JanggiGame.of(choFormation, hanFormation);
+    }
+
+    private void playTurn(JanggiGame game) {
+        while (true) {
+            try {
+                List<Position> positions = inputView.askMovePiecePosition(game.currentTurn());
+                game.move(positions.get(0), positions.get(1));
+                outputView.printBoard(game.getBoard());
+                return;
+            } catch (IllegalArgumentException e) {
+                outputView.printError(e.getMessage());
+            }
+        }
+    }
+}

src/main/java/domain/board/AbstractBoardFactory.java

@@ -0,0 +1,50 @@
+package domain.board;
+
+import domain.game.Team;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.position.Position;
+import java.util.HashMap;
+import java.util.Map;
+
+public abstract class AbstractBoardFactory implements BoardFactory {
+
+    private static final Map<FormationType, AbstractBoardFactory> factories = Map.of(
+            FormationType.LEFT_GIWMA, new LeftGwimaFactory(),
+            FormationType.RIGHT_GIWMA, new RightGwimaFactory(),
+            FormationType.WONANGMA, new WonangmaFactory(),
+            FormationType.YANGGWIMA, new YanggwimaFactory()
+    );
+
+    public static AbstractBoardFactory from(FormationType type) {
+        AbstractBoardFactory factory = factories.get(type);
+        if (factory == null) {
+            throw new IllegalStateException("해당 타입의 팩토리가 등록되지 않았습니다.");
+        }
+        return factory;
+    }
+
+    @Override
+    public Map<Position, Piece> createFormation(Team team) {
+        Map<Position, Piece> pieces = new HashMap<>();
+        setFixedPieces(pieces, team);
+        setVariablePieces(pieces, team);
+        return pieces;
+    }
+
+    private void setFixedPieces(Map<Position, Piece> pieces, Team team) {
+        placePieces(pieces, team, team.getBackRow(), PieceType.CHA);
+        placePieces(pieces, team, team.getBackRow(), PieceType.SA);
+        placePieces(pieces, team, team.getGeneralRow(), PieceType.GENERAL);
+        placePieces(pieces, team, team.getCannonRow(), PieceType.PHO);
+        placePieces(pieces, team, team.getSoldierRow(), PieceType.BYEONG);
+    }
+
+    private void placePieces(Map<Position, Piece> pieces, Team team, int row, PieceType type) {
+        for (int column : type.getInitialColumns()) {
+            pieces.put(new Position(row, column), type.createPiece(team));
+        }
+    }
+
+    protected abstract void setVariablePieces(Map<Position, Piece> pieces, Team team);
+}

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

@@ -0,0 +1,43 @@
+package domain.board;
+
+import domain.piece.EmptyPiece;
+import domain.piece.Piece;
+import domain.position.Position;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class Board {
+    private final Map<Position, Piece> pieces;
+
+    public Board(Map<Position, Piece> pieces) {
+        this.pieces = new HashMap<>(pieces);
+    }
+
+    public void move(Position source, Position destination) {
+        Piece piece = pieceAt(source);
+        validateCanMove(piece, source, destination);
+        List<Position> route = piece.calculateRoute(source, destination);
+        List<Piece> piecesOnRoute = route.stream()
+                .map(this::pieceAt)
+                .collect(Collectors.toList());
+        piece.validateRoute(piecesOnRoute, pieceAt(destination));
+        applyMove(source, destination, piece);
+    }
+
+    private void validateCanMove(Piece piece, Position source, Position destination) {
+        if (!piece.canMove(source, destination)) {
+            throw new IllegalArgumentException("이동할 수 없는 위치입니다.");
+        }
+    }
+
+    private void applyMove(Position source, Position destination, Piece piece) {
+        pieces.put(destination, piece);
+        pieces.put(source, EmptyPiece.getInstance());
+    }
+
+    public Piece pieceAt(Position position) {
+        return pieces.getOrDefault(position, EmptyPiece.getInstance());
+    }
+}

src/main/java/domain/board/BoardFactory.java

@@ -0,0 +1,10 @@
+package domain.board;
+
+import domain.position.Position;
+import domain.piece.Piece;
+import domain.game.Team;
+import java.util.Map;
+
+public interface BoardFactory {
+    Map<Position, Piece> createFormation(Team team);
+}

src/main/java/domain/board/FormationType.java

@@ -0,0 +1,8 @@
+package domain.board;
+
+public enum FormationType {
+    LEFT_GIWMA,
+    RIGHT_GIWMA,
+    WONANGMA,
+    YANGGWIMA
+}

src/main/java/domain/board/LeftGwimaFactory.java

@@ -0,0 +1,21 @@
+package domain.board;
+
+import domain.position.Position;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.game.Team;
+import java.util.Map;
+
+public class LeftGwimaFactory extends AbstractBoardFactory {
+    @Override
+    protected void setVariablePieces(Map<Position, Piece> pieces, Team team) {
+        pieces.put(new Position(team.getBackRow(), PieceType.SANG.getInitialColumns().get(0)),
+                PieceType.SANG.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.MA.getInitialColumns().get(1)),
+                PieceType.MA.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.SANG.getInitialColumns().get(2)),
+                PieceType.SANG.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.MA.getInitialColumns().get(3)),
+                PieceType.MA.createPiece(team));
+    }
+}

src/main/java/domain/board/RightGwimaFactory.java

@@ -0,0 +1,23 @@
+package domain.board;
+
+import domain.position.Position;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.game.Team;
+import java.util.Map;
+
+public class RightGwimaFactory extends AbstractBoardFactory {
+    @Override
+    protected void setVariablePieces(Map<Position, Piece> pieces, Team team) {
+        pieces.put(new Position(team.getBackRow(), PieceType.MA.getInitialColumns().get(0)),
+                PieceType.MA.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.SANG.getInitialColumns().get(1)),
+                PieceType.SANG.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.MA.getInitialColumns().get(2)),
+                PieceType.MA.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.SANG.getInitialColumns().get(3)),
+                PieceType.SANG.createPiece(team));
+    }
+}
+
+

src/main/java/domain/board/WonangmaFactory.java

@@ -0,0 +1,21 @@
+package domain.board;
+
+import domain.position.Position;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.game.Team;
+import java.util.Map;
+
+public class WonangmaFactory extends AbstractBoardFactory {
+    @Override
+    protected void setVariablePieces(Map<Position, Piece> pieces, Team team) {
+        pieces.put(new Position(team.getBackRow(), PieceType.SANG.getInitialColumns().get(0)),
+                PieceType.SANG.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.MA.getInitialColumns().get(1)),
+                PieceType.MA.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.MA.getInitialColumns().get(2)),
+                PieceType.MA.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.SANG.getInitialColumns().get(3)),
+                PieceType.SANG.createPiece(team));
+    }
+}

src/main/java/domain/board/YanggwimaFactory.java

@@ -0,0 +1,21 @@
+package domain.board;
+
+import domain.position.Position;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.game.Team;
+import java.util.Map;
+
+public class YanggwimaFactory extends AbstractBoardFactory {
+    @Override
+    protected void setVariablePieces(Map<Position, Piece> pieces, Team team) {
+        pieces.put(new Position(team.getBackRow(), PieceType.MA.getInitialColumns().get(0)),
+                PieceType.MA.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.SANG.getInitialColumns().get(1)),
+                PieceType.SANG.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.SANG.getInitialColumns().get(2)),
+                PieceType.SANG.createPiece(team));
+        pieces.put(new Position(team.getBackRow(), PieceType.MA.getInitialColumns().get(3)),
+                PieceType.MA.createPiece(team));
+    }
+}

src/main/java/domain/game/JanggiGame.java

@@ -0,0 +1,45 @@
+package domain.game;
+
+import domain.board.AbstractBoardFactory;
+import domain.board.Board;
+import domain.board.FormationType;
+import domain.piece.Piece;
+import domain.position.Position;
+import java.util.HashMap;
+import java.util.Map;
+
+public class JanggiGame {
+    private Turn turn;
+    private final Board board;
+
+    public JanggiGame(Turn turn, Board board) {
+        this.turn = turn;
+        this.board = board;
+    }
+
+    public static JanggiGame of(FormationType choFormation, FormationType hanFormation) {
+        Map<Position, Piece> pieces = new HashMap<>();
+        pieces.putAll(AbstractBoardFactory.from(choFormation)
+                .createFormation(Team.CHO));
+        pieces.putAll(AbstractBoardFactory.from(hanFormation)
+                .createFormation(Team.HAN));
+        return new JanggiGame(Turn.first(),new Board(pieces));
+    }
+
+    public void move(Position source, Position destination) {
+        board.move(source, destination);
+        turn = turn.next();
+    }
+
+    public boolean isRunning() {
+        return true; // TODO: 종료 조건 구현
+    }
+
+    public Team currentTurn() {
+        return turn.current();
+    }
+
+    public Board getBoard() {
+        return board;
+    }
+}