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

README.md

@@ -1,3 +1,84 @@
 # java-janggi
 
 장기 미션 저장소
+
+**주요 기능**
+
+- [x]  플레이어는 ‘상 차림’을 결정할 수 있다.
+- [x]  기물은 자동으로 배치된다.
+- [x]  현재 장기판의 현황을 볼 수 있다.
+- [x]  초나라(선)/한나라(후) 번갈아가며 플레이한다.
+- [x]  플레이어는 기물의 이동 규칙에 따라 이동시킬 수 있다.
+- [x]  상대 플레이어의 기물을 잡을 수 있다.
+- [ ]  상대 플레이어의 왕을 잡으면 승리하고, 게임은 종료된다.
+
+### **실행 예시**
+
+```
+초나라 상 차림을 결정해주세요.
+1. [마 상 마 상]
+2. [마 상 상 마]
+3. [상 마 상 마]
+4. [상 마 마 상]
+
+2
+
+한나라 상 차림을 결정해주세요.
+1. [마 상 마 상]
+2. [마 상 상 마]
+3. [상 마 상 마]
+4. [상 마 마 상]
+
+3
+
+기물이 배치 되었습니다.
+    0   1   2   3   4   5   6   7   8
+ 0  車   馬  象   士   ·  士   馬   象  車
+ 1  ·   ·   ·   ·   漢   ·   ·   ·   ·
+ 2  ·   砲   ·   ·   ·   ·   ·   砲   ·
+ 3  兵   ·   兵  ·   兵   ·   兵   ·  兵
+ 4  ·   ·   ·   ·   ·   ·   ·   ·   ·
+ 5  ·   ·   ·   ·   ·   ·   ·   ·   ·
+ 6  卒   ·   卒  ·   卒   ·   卒   ·   卒
+ 7  ·   炮   ·  ·   ·   ·   ·   炮   ·
+ 8  ·   ·   ·   ·   楚   ·   ·   ·   ·
+ 9  車   馬  相   士   ·   士  相   馬   車
+
+초나라 플레이어는 말을 선택해주세요.(입력예시 좌표: 0, 9)
+좌표: 0, 9
+
+초나라 플레이어는 선택한 말을 움직일 위치를 입력해 주세요.(입력예시 좌표: 0, 7)
+좌표: 0, 7
+
+이동되었습니다. 
+    0   1   2   3   4   5   6   7   8
+ 0  車   馬  象   士   ·  士   馬   象  車
+ 1  ·   ·   ·   ·   漢   ·   ·   ·   ·
+ 2  ·   砲   ·   ·   ·   ·   ·   砲   ·
+ 3  兵   ·   兵  ·   兵   ·   兵   ·  兵
+ 4  ·   ·   ·   ·   ·   ·   ·   ·   ·
+ 5  ·   ·   ·   ·   ·   ·   ·   ·   ·
+ 6  卒   ·   卒  ·   卒   ·   卒   ·   卒
+ 7  車   炮   ·  ·   ·   ·   ·   炮   ·
+ 8  ·   ·   ·   ·   楚   ·   ·   ·   ·
+ 9  ·   馬  相   士   ·   士  相   馬   車
+```
+
+**입력**
+
+- [x]  ‘상 차림’ 배치 타입 입력받는다.
+- [x]  선택할 기물의 좌표를 입력받는다.
+    - [x]  `[ERROR]` 해당 좌표에 기물이 없을 때
+    - [x]  `[ERROR]` 선택한 기물이 플레이어의 기물이 아닐 때
+- [x]  이동할 좌표를 입력받는다.
+    - [x]  `[ERROR]` 이동할 좌표가 보드 크기 내에 유효하지 않을 때
+    - [x]  `[ERROR]` 해당 좌표에 플레이어의 팀 기물이 있을 때
+    - [x]  `[ERROR]` 이동 규칙에 따라 이동할 수 없을 때
+
+**출력**
+
+- [x]  4 종류의 ‘상 차림’ 배치를 출력한다.
+- [x]  기물이 배치된 보드를 출력한다.
+- [x]  현재 턴을 출력한다.
+- [x]  턴이 끝나고 기물 이동이 된 보드를 출력한다.
+- [ ]  최종 승패를 출력한다.

src/main/java/Application.java

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

src/main/java/JanggiController.java

@@ -0,0 +1,80 @@
+import domain.Board;
+import domain.Camp;
+import domain.ElephantFormation;
+import domain.Position;
+import dto.BoardStatusDto;
+import view.InputView;
+import view.OutputView;
+
+public class JanggiController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+
+    JanggiController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        Board board = generateBoard();
+        printBoard(board);
+
+        playJanggi(board);
+    }
+
+    private Board generateBoard() {
+        Board board = new Board();
+        int choElephantFormation = inputView.askElephantFormation(Camp.CHO);
+        int hanElephantFormation = inputView.askElephantFormation(Camp.HAN);
+        board.generatePiecesBy(Camp.CHO, mappingElephantFormation(choElephantFormation));
+        board.generatePiecesBy(Camp.HAN, mappingElephantFormation(hanElephantFormation));
+        return board;
+    }
+
+    private void playJanggi(Board board) {
+        Camp camp = Camp.CHO;
+        while (true) {
+            try{
+                Position fromPosition = askFromPosition(camp, board);
+                Position toPosition = inputView.askToPosition(camp);
+                board.move(fromPosition, toPosition);
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e);
+                continue;
+            }
+            printBoard(board);
+            camp = turnCamp(camp);
+
+            //Todo: 사이클2 왕이 잡히면, 게임이 종료
+        }
+    }
+
+    private Camp turnCamp(Camp camp) {
+        if (camp.equals(Camp.CHO)) {
+            return Camp.HAN;
+        }
+        return Camp.CHO;
+    }
+
+    private Position askFromPosition(Camp camp, Board board) {
+        while (true) {
+            Position fromPosition = inputView.askFromPosition(camp);
+            if (!board.isPieceOfCamp(fromPosition, camp)) {
+                outputView.printWrongChoice();
+                continue;
+            }
+            return fromPosition;
+        }
+    }
+
+    private void printBoard(Board board) {
+        BoardStatusDto boardStatus = board.getBoardStatus();
+        outputView.printBoardStatus(boardStatus);
+    }
+
+    private ElephantFormation mappingElephantFormation(int userInput) {
+        return ElephantFormation.getFormationType(userInput);
+    }
+}

src/main/java/domain/Board.java

@@ -0,0 +1,101 @@
+package domain;
+
+import domain.pieces.Piece;
+import dto.BoardStatusDto;
+import dto.PositionStatusDto;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Board implements BoardReader {
+
+    private final Map<Position, Piece> board = new HashMap<>();
+
+    public void generatePiecesBy(Camp camp, ElephantFormation elephantFormation) {
+        Map<Position, Piece> pieces = PieceGenerator.generatePieces(camp, elephantFormation);
+
+        board.putAll(pieces);
+    }
+
+    public void locatePiece(Position position, Piece piece) {
+        if (!isExist(position)) {
+            board.put(position, piece);
+            return;
+        }
+
+        if (getPieceFrom(position).isSameCamp(piece)) {
+            throw new IllegalArgumentException("[ERROR] 같은 팀은 잡을 수 없습니다!");
+        }
+
+        board.put(position, piece);
+    }
+
+    public Piece getPieceFrom(Position position) {
+        return board.get(position);
+    }
+
+    @Override
+    public boolean isExist(Position position) {
+        return board.containsKey(position);
+    }
+
+    public void move(Position fromPosition, Position toPosition) {
+        if (fromPosition.equals(toPosition)) {
+            throw new IllegalArgumentException("[ERROR] 제자리 이동은 불가능합니다.");
+        }
+
+        Piece piece = board.get(fromPosition);
+        boolean canMove = piece.canMove(fromPosition, toPosition, this);
+        if (canMove) {
+            locatePiece(toPosition, piece);
+            board.remove(fromPosition);
+            return;
+        }
+
+        throw new IllegalArgumentException("[ERROR] 이동할 수 없습니다");
+    }
+
+    @Override
+    public boolean isDifferentPieceType(Position position, Piece piece) {
+        if (!board.containsKey(position)) {
+            return true;
+        }
+
+        return board.get(position).isDifferentPieceType(piece);
+    }
+
+    public BoardStatusDto getBoardStatus() {
+        List<List<PositionStatusDto>> boardStatusDto = new ArrayList<>();
+        for (int y = Position.MIN_Y_VALUE; y <= Position.MAX_Y_VALUE; y++) {
+            List<PositionStatusDto> xPositionStatus = new ArrayList<>();
+            for (int x = Position.MIN_X_VALUE; x <= Position.MAX_X_VALUE; x++) {
+                Position position = new Position(x, y);
+
+                PositionStatusDto positionStatusDto = getPositionStatusDto(position);
+                xPositionStatus.add(positionStatusDto);
+            }
+            boardStatusDto.add(xPositionStatus);
+        }
+        return new BoardStatusDto(boardStatusDto);
+    }
+
+    private PositionStatusDto getPositionStatusDto(Position position) {
+        if (!board.containsKey(position)) {
+            return new PositionStatusDto(position, PieceType.NONE, Camp.NONE);
+        }
+
+        Piece piece = board.get(position);
+        PieceType pieceType = piece.getPieceType();
+        Camp camp = piece.getCamp();
+        return new PositionStatusDto(position, pieceType, camp);
+    }
+
+    public boolean isPieceOfCamp(Position position, Camp camp) {
+        if (!board.containsKey(position)) {
+            return false;
+        }
+
+        return board.get(position).isSameCamp(camp);
+    }
+}

src/main/java/domain/BoardReader.java

@@ -0,0 +1,10 @@
+package domain;
+
+import domain.pieces.Piece;
+
+public interface BoardReader {
+
+    boolean isExist(Position position);
+
+    boolean isDifferentPieceType(Position position, Piece piece);
+}

src/main/java/domain/Camp.java

@@ -0,0 +1,18 @@
+package domain;
+
+public enum Camp {
+    HAN("한나라"),
+    CHO("초나라"),
+    NONE("중립");
+
+    private final String campName;
+
+    Camp(String campName) {
+        this.campName = campName;
+    }
+
+    public String getCampName() {
+        return campName;
+    }
+}
+

src/main/java/domain/Direction.java

@@ -0,0 +1,28 @@
+package domain;
+
+public enum Direction {
+    NORTH(0, -1),
+    NORTHEAST(1, -1),
+    EAST(1, 0),
+    SOUTHEAST(1, 1),
+    SOUTH(0,1),
+    SOUTHWEST(-1, 1),
+    WEST(-1, 0),
+    NORTHWEST(-1, -1);
+
+    private final int x;
+    private final int y;
+
+    Direction(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public int getDx() {
+        return x;
+    }
+
+    public int getDy() {
+        return y;
+    }
+}