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

README.md

@@ -1,3 +1,73 @@
 # java-janggi
 
 장기 미션 저장소
+
+# 기능
+
+## 1-1 요구사항
+- [x] 각 플레이어 진형 입력 기능
+- [x] 장기판 초기화 기능
+- [x] 장기판 상태 출력 기능
+
+## 1-2 요구사항
+- [x] 이동할 기물 위치 좌표 입력 기능
+- [x] 이동할 목적지 좌표 입력 기능
+- [x] 턴제 시스템 기능
+- [x] 장기 진행 상태 출력 기능
+- [x] 기물 이동 기능
+
+## ⚠️ 기능 예외 사항
+
+### 입력 검증
+- 포진 선택: 1~4 범위 외 입력 시 예외
+- 좌표 범위: x(1~9), y(1~10) 범위 외 입력 시 예외
+
+### 기물 선택 검증
+- 선택한 위치에 기물이 존재하지 않을 경우 예외
+- 선택한 기물이 아군 기물이 아닐 경우 예외
+
+### 이동 규칙 검증
+- 목적지가 기물의 이동 규칙에 맞지 않을 경우 예외
+- 목적지에 아군 기물이 존재할 경우 예외
+- 이동 경로에 기물이 존재할 경우 예외 (포 제외)
+
+### 포 규칙 검증
+- 이동 경로에 포가 존재할 경우 예외
+- 이동 경로에 기물이 정확히 1개가 아닐 경우 예외
+- 포로 포를 잡으려 할 경우 예외
+
+---
+
+## 📁 프로젝트 구조
+
+```
+src/main/java
+├── Main.java
+├── controller
+│   └── JanggiController.java
+├── domain
+│   ├── Board.java
+│   ├── Direction.java
+│   ├── Formation.java
+│   ├── Position.java
+│   ├── Side.java
+│   ├── Turn.java
+│   ├── piece
+│   │   ├── Piece.java
+│   │   ├── PieceType.java
+│   │   ├── King.java
+│   │   ├── Guard.java
+│   │   ├── Horse.java
+│   │   ├── Elephant.java
+│   │   ├── Chariot.java
+│   │   ├── Cannon.java
+│   │   ├── Soldier.java
+│   │   └── Empty.java
+│   └── strategy
+│       ├── MovementStrategy.java
+│       ├── PathMovement.java
+│       └── LinearMovement.java
+└── view
+    ├── InputView.java
+    └── OutputView.java
+```

src/main/java/Main.java

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

src/main/java/constant/BoardSpec.java

@@ -0,0 +1,13 @@
+package constant;
+
+import domain.Side;
+
+public class BoardSpec {
+
+    public static final int MIN_X = 1;
+    public static final int MAX_X = 9;
+    public static final int MIN_Y = 1;
+    public static final int MAX_Y = 10;
+
+    public static final Side DEFAULT_STARTING_SIDE = Side.CHO;
+}

src/main/java/controller/JanggiController.java

@@ -0,0 +1,98 @@
+package controller;
+
+import domain.Board;
+import domain.BoardFactory;
+import domain.Formation;
+import domain.Game;
+import domain.Position;
+import domain.Side;
+import util.Parser;
+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() {
+        Game game = initGame();
+        processMove(game);
+    }
+
+    private Game initGame() {
+        Formation choformation = readChoFormation();
+        Formation hanformation = readHanFormation();
+
+        Board board = BoardFactory.createBoard(choformation, hanformation);
+        Game game = new Game(board);
+        outputView.printBoardStatus(game.getBoard());
+        return game;
+    }
+
+    private void processMove(Game game) {
+        while (!game.isGameEnd()) {
+            Side currentTurn = game.getCurrentTurn();
+            outputView.printCurrentTurn(currentTurn);
+            Position sourcePosition = readSourcePosition();
+            Position targetPosition = readTargetPosition();
+            try {
+                game.move(sourcePosition, targetPosition);
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e.getMessage());
+            }
+            outputView.printBoardStatus(game.getBoard());
+        }
+    }
+
+    private Position readSourcePosition() {
+        while (true) {
+            try {
+                int x = Parser.parseInput(inputView.readSourceXPosition());
+                int y = Parser.parseInput(inputView.readSourceYPosition());
+                return Position.of(x, y);
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private Position readTargetPosition() {
+        while (true) {
+            try {
+                int x = Parser.parseInput(inputView.readTargetXPosition());
+                int y = Parser.parseInput(inputView.readTargetYPosition());
+                return Position.of(x, y);
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private Formation readChoFormation() {
+        while (true) {
+            try {
+                String choFormation = inputView.readChoFormation();
+                return Formation.from(choFormation);
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private Formation readHanFormation() {
+        while (true) {
+            try {
+                String hanFormation = inputView.readHanFormation();
+                return Formation.from(hanFormation);
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+}

src/main/java/domain/Board.java

@@ -0,0 +1,49 @@
+package domain;
+
+import domain.piece.Empty;
+import domain.piece.King;
+import domain.piece.Piece;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Board {
+
+    private final Map<Position, Piece> board;
+
+    public Board(Map<Position, Piece> board) {
+        this.board = board;
+    }
+
+    public void movePiece(Position sourcePosition, Position targetPosition) {
+        board.put(targetPosition, board.get(sourcePosition));
+        board.put(sourcePosition, new Empty());
+    }
+
+    public Piece getPiece(Position position) {
+        return board.get(position);
+    }
+
+    public List<Piece> findPiecesOnRoute(List<Position> route, Position targetPosition) {
+        List<Piece> pieces = new ArrayList<>();
+        for (Position position : route) {
+            if (!position.equals(targetPosition)) {
+                pieces.add(board.get(position));
+            }
+        }
+        return pieces;
+    }
+
+    public boolean hasKing(Side side) {
+        for (Piece piece : board.values()) {
+            if (piece instanceof King && piece.isSameSide(side)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public Map<Position, Piece> getBoard() {
+        return Map.copyOf(board);
+    }
+}

src/main/java/domain/BoardFactory.java

@@ -0,0 +1,73 @@
+package domain;
+
+import constant.BoardSpec;
+import domain.piece.Empty;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BoardFactory {
+
+    private static final int BACK_Y = 0;
+    private static final int KING_Y = 1;
+    private static final int CANNON_Y = 2;
+    private static final int SOLDIER_Y = 3;
+
+    private static final List<Integer> CANNON_X = List.of(2, 8);
+    private static final List<Integer> CHARIOT_X = List.of(1, 9);
+    private static final List<Integer> GUARD_X = List.of(4, 6);
+    private static final List<Integer> KING_X = List.of(5);
+    private static final List<Integer> SOLIDER_X = List.of(1, 3, 5, 7, 9);
+    private static final List<Integer> FORMATION_X = List.of(2, 3, 7, 8);
+
+    public static Board createBoard(Formation choFormation, Formation hanFormation) {
+        Map<Position, Piece> board = new HashMap<>();
+        for (int x = BoardSpec.MIN_X; x <= BoardSpec.MAX_X; x++) {
+            for (int y = BoardSpec.MIN_Y; y <= BoardSpec.MAX_Y; y++) {
+                placePiece(board, Position.of(x, y), new Empty());
+            }
+        }
+        placePieces(board, choFormation, Side.CHO);
+        placePieces(board, hanFormation, Side.HAN);
+
+        return new Board(board);
+    }
+
+    private static void placePieces(Map<Position, Piece> board, Formation formation, Side side) {
+        List<Integer> rows = getRowForSide(side);
+        placePiece(board, CANNON_X, rows.get(CANNON_Y), PieceType.CANNON, side);
+        placePiece(board, CHARIOT_X, rows.get(BACK_Y), PieceType.CHARIOT, side);
+        placePiece(board, GUARD_X, rows.get(BACK_Y), PieceType.GUARD, side);
+        placePiece(board, KING_X, rows.get(KING_Y), PieceType.KING, side);
+        placePiece(board, SOLIDER_X, rows.get(SOLDIER_Y), PieceType.SOLDIER, side);
+        placeFormationPiece(board, formation, FORMATION_X, rows.get(BACK_Y), side);
+    }
+
+    private static List<Integer> getRowForSide(Side side) {
+        if (side == Side.HAN) {
+            return List.of(1, 2, 3, 4);
+        }
+        return List.of(10, 9, 8, 7);
+    }
+
+    private static void placePiece(Map<Position, Piece> board, Position position, Piece piece) {
+        board.put(position, piece);
+    }
+
+    private static void placePiece(Map<Position, Piece> board, List<Integer> xPositions, int y, PieceType pieceType,
+        Side side) {
+        for (int x : xPositions) {
+            board.put(Position.of(x, y), pieceType.create(side));
+        }
+    }
+
+    private static void placeFormationPiece(Map<Position, Piece> board, Formation formation, List<Integer> xPositions,
+        int y, Side side) {
+        List<PieceType> pieceTypes = formation.getPieceTypes();
+        for (int i = 0; i < pieceTypes.size(); i++) {
+            board.put(Position.of(xPositions.get(i), y), pieceTypes.get(i).create(side));
+        }
+    }
+}

src/main/java/domain/Direction.java

@@ -0,0 +1,28 @@
+package domain;
+
+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 int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+}

src/main/java/domain/Formation.java

@@ -0,0 +1,38 @@
+package domain;
+
+import domain.piece.PieceType;
+import java.util.List;
+
+public enum Formation {
+    상마마상("1", List.of(PieceType.ELEPHANT, PieceType.HORSE, PieceType.HORSE, PieceType.ELEPHANT)),
+    마상상마("2", List.of(PieceType.HORSE, PieceType.ELEPHANT, PieceType.ELEPHANT, PieceType.HORSE)),
+    상마상마("3", List.of(PieceType.ELEPHANT, PieceType.HORSE, PieceType.ELEPHANT, PieceType.HORSE)),
+    마상마상("4", List.of(PieceType.HORSE, PieceType.ELEPHANT, PieceType.HORSE, PieceType.ELEPHANT));
+
+    private static final String INVALID_OPTION_RANGE = "번호는 1~4 사이의 숫자여야 합니다.";
+
+    private final String option;
+    private final List<PieceType> pieceTypes;
+
+    Formation(String option, List<PieceType> pieceTypes) {
+        this.option = option;
+        this.pieceTypes = pieceTypes;
+    }
+
+    public static Formation from(String input) {
+        for (Formation formation : Formation.values()) {
+            if (formation.option.equals(input)) {
+                return formation;
+            }
+        }
+        throw new IllegalArgumentException(INVALID_OPTION_RANGE);
+    }
+
+    public List<PieceType> getPieceTypes() {
+        return pieceTypes;
+    }
+
+    public String toDisplayString() {
+        return option + ". " + name();
+    }
+}