[1단계 - 장기] 헤일러(민서현) 미션 제출합니다.

README.md

@@ -1,3 +1,92 @@
 # java-janggi
 
-장기 미션 저장소
+## 프로그램 실행 흐름
+
+### 게임 시작
+
+- 게임 시작 안내 메시지를 출력한다.
+
+```
+장기 게임에 오신 것을 환영합니다.
+```
+
+### 상마 순서 입력
+
+- 상마 순서 결정을 위한 입력을 받는다.
+
+```
+한나라 상마 순서를 입력해주세요. (예: 3)
+1. 상마상마
+2. 상마마상
+3. 마상상마
+4. 마상마상
+1
+
+초나라 상마 순서를 입력해주세요. (예: 3)
+1. 상마상마
+2. 상마마상
+3. 마상상마
+4. 마상마상
+2
+```
+
+- 예외
+    - 올바르지 않은 입력이 들어온 경우 에러 메시지를 출력한다.
+
+```
+초나라 상마 순서를 입력해주세요. (예: 3)
+1. 상마상마
+2. 상마마상
+3. 마상상마
+4. 마상마상
+6
+[ERROR] 올바른 상마 순서 번호를 입력해주세요. (예: 3)
+```
+
+### 기물 위치 초기화
+
+- 입력한 상마 순서에 따라 기물 위치를 초기화한다.
+
+### 이동 커맨드 입력
+
+- move src dst 양식으로 입력해야 한다.
+- src에 있는 내 기물을 dst로 이동한다.
+
+```
+현재 턴 : 초나라
+이동할 기물의 현재 위치와 이동할 위치를 입력해주세요. (예: move 1,1 2,1)
+move 1,1 2,1
+```
+
+- 예외
+    - src가 빈 칸인 경우 예외가 발생한다.
+    - src에 상대 기물이 있는 경우 예외가 발생한다.
+    - src에서 dst로 이동할 수 없는 경우 예외가 발생한다.
+
+### 보드 출력
+
+- 현재 장기판 상태를 출력한다.
+- 팀은 색깔로 구분한다.
+    - 초나라 : 초록색
+    - 한나라 : 빨간색
+
+```
+차 상 마 사 ㅁ 사 상 마 차
+ㅁ ㅁ ㅁ ㅁ 왕 ㅁ ㅁ ㅁ ㅁ
+ㅁ 포 ㅁ ㅁ ㅁ ㅁ ㅁ 포 ㅁ
+병 ㅁ 병 ㅁ 병 ㅁ 병 ㅁ 병
+ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ
+ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ
+병 ㅁ 병 ㅁ 병 ㅁ 병 ㅁ 병
+ㅁ 포 ㅁ ㅁ ㅁ ㅁ ㅁ 포 ㅁ
+ㅁ ㅁ ㅁ ㅁ 왕 ㅁ ㅁ ㅁ ㅁ
+차 상 마 사 ㅁ 사 마 상 차
+```
+
+### 승패 결과 출력
+
+- 이동 중간에 왕이 죽으면 승패 결과를 출력한다.
+
+```
+초나라의 승리입니다.
+```

src/main/java/Application.java

@@ -0,0 +1,9 @@
+import manager.JanggiGameManager;
+
+public class Application {
+
+    public static void main(String[] args) {
+        JanggiGameManager janggiGameManager = new JanggiGameManager();
+        janggiGameManager.startGame();
+    }
+}

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

@@ -0,0 +1,153 @@
+package domain.board;
+
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.piece.Team;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class Board {
+
+    private final Map<Point, Piece> pieceByPoint;
+    private final PointNodeMapper pointNodeMapper;
+
+    public Board(final Map<Point, Piece> pieceByPoint, final PointNodeMapper pointNodeMapper) {
+        this.pieceByPoint = pieceByPoint;
+        this.pointNodeMapper = pointNodeMapper;
+    }
+
+    public boolean isEnd() {
+        return !isTwoWangsAlive();
+    }
+
+    private boolean isTwoWangsAlive() {
+        return findTeamsOfWang().containsAll(List.of(Team.CHO, Team.HAN));
+    }
+
+    public Team findWinTeam() {
+        if (!isEnd()) {
+            throw new IllegalStateException("아직 게임이 끝나지 않았습니다.");
+        }
+        Set<Team> foundTeam = findTeamsOfWang();
+        if (foundTeam.contains(Team.CHO)) {
+            return Team.CHO;
+        }
+        return Team.HAN;
+    }
+
+    private Set<Team> findTeamsOfWang() {
+        return pieceByPoint.values().stream()
+                .filter(piece -> piece.type() == PieceType.WANG)
+                .map(Piece::team)
+                .collect(Collectors.toSet());
+    }
+
+    public boolean canMove(final Point source, final Point destination) {
+        if (!existsPiece(source)) {
+            return false;
+        }
+        Piece piece = getPieceByPoint(source);
+        return piece.canMove(source, destination, this);
+    }
+
+    public void movePiece(final Point source, final Point destination) {
+        Piece sourcePiece = getPieceByPoint(source);
+        if (!sourcePiece.canMove(source, destination, this)) {
+            throw new IllegalArgumentException(source + " -> " + destination + " [ERROR] 이동할 수 없는 경로입니다.");
+        }
+
+        pieceByPoint.put(destination, sourcePiece);
+        removePiece(source);
+    }
+
+    public boolean existsPiece(final Point point) {
+        if (!existsPoint(point)) {
+            return false;
+        }
+        return pieceByPoint.containsKey(point);
+    }
+
+    private boolean existsPoint(final Point point) {
+        return pointNodeMapper.existsPoint(point);
+    }
+
+    public boolean existsPo(final Point point) {
+        if (!existsPiece(point)) {
+            return false;
+        }
+        Piece piece = getPieceByPoint(point);
+        return piece.type() == PieceType.PO;
+    }
+
+    public void removePiece(final Point point) {
+        if (!existsPiece(point)) {
+            return;
+        }
+        Piece piece = getPieceByPoint(point);
+        pieceByPoint.remove(point, piece);
+    }
+
+    public boolean matchTeam(final Point point, final Team team) {
+        if (!existsPiece(point)) {
+            return false;
+        }
+        Piece piece = getPieceByPoint(point);
+        return piece.team() == team;
+    }
+
+    public boolean hasPieceType(final Point point, final PieceType pieceType) {
+        if (!existsPiece(point)) {
+            return false;
+        }
+        Piece piece = getPieceByPoint(point);
+        return piece.type() == pieceType;
+    }
+
+    private Piece getPieceByPoint(final Point point) {
+        if (!existsPiece(point)) {
+            throw new IllegalArgumentException(point + ": [ERROR] 해당 좌표에 기물이 존재하지 않습니다.");
+        }
+        return pieceByPoint.get(point);
+    }
+
+    public boolean existsNextPoint(final Point point, final Direction direction) {
+        if (!existsPoint(point)) {
+            return false;
+        }
+        Node node = pointNodeMapper.getNodeByPoint(point);
+        return node.hasNextNode(direction);
+    }
+
+    public Point getNextPoint(final Point point, final Direction direction) {
+        validateExistPoint(point);
+        Node node = pointNodeMapper.getNodeByPoint(point);
+        Node nextNode = node.getNextNodeByDirection(direction);
+        return pointNodeMapper.getPointByNode(nextNode);
+    }
+
+    public boolean canMoveByPath(final Point point, final Path path) {
+        if (!existsPoint(point)) {
+            return false;
+        }
+        Node node = pointNodeMapper.getNodeByPoint(point);
+        return node.canMoveByPath(path);
+    }
+
+    public Point getPointMovedByPath(final Point point, final Path path) {
+        validateExistPoint(point);
+        Node node = pointNodeMapper.getNodeByPoint(point);
+        return pointNodeMapper.getPointByNode(node.moveByPath(path));
+    }
+
+    private void validateExistPoint(final Point point) {
+        if (!existsPoint(point)) {
+            throw new IllegalArgumentException(point.row() + ", " + point.column() + ": 존재하지 않는 좌표입니다.");
+        }
+    }
+
+    public Map<Point, Piece> getPieceByPoint() {
+        return pieceByPoint;
+    }
+}

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

@@ -0,0 +1,109 @@
+package domain.board;
+
+import domain.piece.Byeong;
+import domain.piece.Cha;
+import domain.piece.Ma;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.piece.Po;
+import domain.piece.Sa;
+import domain.piece.Sang;
+import domain.piece.Team;
+import domain.piece.Wang;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import view.SangMaOrderCommand;
+
+public class BoardGenerator {
+
+    public Board generateBoard(final SangMaOrderCommand hanSangMaOrderCommand,
+                               final SangMaOrderCommand choSangMaOrderCommand) {
+        PointNodeMapperFactory pointNodeMapperFactory = new PointNodeMapperFactory();
+        PointNodeMapper pointNodeMapper = pointNodeMapperFactory.createDefaultPointNodeMapper();
+        Map<Point, Piece> pieceByPoint = createPieces(hanSangMaOrderCommand, choSangMaOrderCommand);
+
+        return new Board(pieceByPoint, pointNodeMapper);
+    }
+
+    private Map<Point, Piece> createPieces(
+            final SangMaOrderCommand hanSangMaOrderCommand,
+            final SangMaOrderCommand choSangMaOrderCommand) {
+        Map<Point, Piece> pieceByPoint = new HashMap<>();
+        List<Point> hanSangMaPoints = List.of(Point.of(1, 2), Point.of(1, 3), Point.of(1, 7), Point.of(1, 8));
+        initializeHanPieces(hanSangMaPoints, hanSangMaOrderCommand, pieceByPoint);
+
+        List<Point> choSangMaPoints = List.of(Point.of(10, 2), Point.of(10, 3), Point.of(10, 7), Point.of(10, 8));
+        initializeChoPieces(choSangMaPoints, choSangMaOrderCommand, pieceByPoint);
+
+        return pieceByPoint;
+    }
+
+    private void initializeHanPieces(final List<Point> sangMaPoints,
+                                     final SangMaOrderCommand sangMaOrderCommand,
+                                     final Map<Point, Piece> pieceByPoint) {
+        pieceByPoint.put(Point.of(4, 1), new Byeong(Team.HAN));
+        pieceByPoint.put(Point.of(4, 3), new Byeong(Team.HAN));
+        pieceByPoint.put(Point.of(4, 5), new Byeong(Team.HAN));
+        pieceByPoint.put(Point.of(4, 7), new Byeong(Team.HAN));
+        pieceByPoint.put(Point.of(4, 9), new Byeong(Team.HAN));
+
+        pieceByPoint.put(Point.of(3, 2), new Po(Team.HAN));
+        pieceByPoint.put(Point.of(3, 8), new Po(Team.HAN));
+
+        pieceByPoint.put(Point.of(2, 5), new Wang(Team.HAN));
+
+        pieceByPoint.put(Point.of(1, 1), new Cha(Team.HAN));
+        pieceByPoint.put(Point.of(1, 4), new Sa(Team.HAN));
+        pieceByPoint.put(Point.of(1, 6), new Sa(Team.HAN));
+        pieceByPoint.put(Point.of(1, 9), new Cha(Team.HAN));
+        Deque<Piece> sangMaOrder = createSangMaByCommand(sangMaOrderCommand, Team.HAN);
+        for (Point point : sangMaPoints) {
+            pieceByPoint.put(point, sangMaOrder.removeFirst());
+        }
+    }
+
+    private void initializeChoPieces(final List<Point> sangMaPoints,
+                                     final SangMaOrderCommand sangMaOrderCommand,
+                                     final Map<Point, Piece> pieceByPoint) {
+        pieceByPoint.put(Point.of(7, 1), new Byeong(Team.CHO));
+        pieceByPoint.put(Point.of(7, 3), new Byeong(Team.CHO));
+        pieceByPoint.put(Point.of(7, 5), new Byeong(Team.CHO));
+        pieceByPoint.put(Point.of(7, 7), new Byeong(Team.CHO));
+        pieceByPoint.put(Point.of(7, 9), new Byeong(Team.CHO));
+
+        pieceByPoint.put(Point.of(8, 2), new Po(Team.CHO));
+        pieceByPoint.put(Point.of(8, 8), new Po(Team.CHO));
+
+        pieceByPoint.put(Point.of(9, 5), new Wang(Team.CHO));
+
+        pieceByPoint.put(Point.of(10, 1), new Cha(Team.CHO));
+        pieceByPoint.put(Point.of(10, 4), new Sa(Team.CHO));
+        pieceByPoint.put(Point.of(10, 6), new Sa(Team.CHO));
+        pieceByPoint.put(Point.of(10, 9), new Cha(Team.CHO));
+        Deque<Piece> sangMaOrder = createSangMaByCommand(sangMaOrderCommand, Team.CHO);
+        for (Point point : sangMaPoints) {
+            pieceByPoint.put(point, sangMaOrder.removeFirst());
+        }
+    }
+
+    private Deque<Piece> createSangMaByCommand(final SangMaOrderCommand sangMaOrderCommand,
+                                               final Team team) {
+        List<PieceType> pieceTypes = sangMaOrderCommand.getPieceTypes();
+        Deque<Piece> pieces = new ArrayDeque<>();
+        for (PieceType pieceType : pieceTypes) {
+            pieces.addLast(createPiece(pieceType, team));
+        }
+        return pieces;
+    }
+
+    private Piece createPiece(final PieceType pieceType, final Team team) {
+        return switch (pieceType) {
+            case SANG -> new Sang(team);
+            case MA -> new Ma(team);
+            default -> throw new IllegalArgumentException("[ERROR] 상 또는 마가 아닙니다.");
+        };
+    }
+}