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

README.md

@@ -1,3 +1,40 @@
 # java-janggi
 
-장기 미션 저장소
+# 기능 구현 목록
+
+## 장기판 생성
+- [x] 9 * 10 구조의 장기판을 생성한다.
+
+## 기물 생성
+- [x] 기물을 생성한다. 
+  - [x] 궁, 사, 마, 상, 차, 포, 졸(병)
+  - [x] None(장기판에 기물이 올라가있지 않은 상태)의 기물
+
+## 보드 초기화
+- [x] 게임 시작시 장기판과 기물을 올바른 위치에 초기화한다.
+  - [x] 오른상(마상마상) 구조로 초기화한다.
+  - [x] 기물이 올바른 위치에 놓여있는지 확인한다.
+
+## 좌표 기본 이동 전략
+- [x] 기본적으로 좌표는 앞,뒤,좌,우,우상,좌상,우하,좌하로 움직일 수 있다.
+  - [x] 앞으로 이동하면 (-1,0)만큼 이동한다.
+  - [x] 뒤로 이동하면 (1,0)만큼 이동한다.
+  - [x] 좌로 이동하면 (0,-1)만큼 이동한다.
+  - [x] 우로 이동하면 (0,1)만큼 이동한다.
+  - [x] 우상으로 이동하면 (-1,1)만큼 이동한다.
+  - [x] 좌상으로 이동하면 (-1,-1)만큼 이동한다.
+  - [x] 우하로 이동하면 (1,1)만큼 이동한다.
+  - [x] 좌하로 이동하면 (1,-1)만큼 이동한다.
+
+## 기물 이동 전략
+- [x] 기물 이동 전략을 생성한다.
+  - [x] 궁,사 : 방향에 관계 없이 한 칸씩 이동할 수 있다.
+  - [x] 마 : 방향에 관계 없이 직진 후 대각선으로 한 칸 이동할 수 있다.
+    - [x] 이동하는 경로에 기물이 존재해서는 안된다.
+  - [x] 상 : 방향에 관계 없이 직진 후 대각선으로 두 칸 이동할 수 있다.
+    - [x] 이동하는 경로에 기물이 존재해서는 안된다.
+  - [x] 차 : 방향에 관계 없이 원하는만큼 이동할 수 있다.
+  - [x] 졸 : 좌,우,앞으로 한 칸씩 이동할 수 있다. 
+    - [x] 뒤로는 갈 수 없다.
+  - [x] 포 : 앞에 기물이 한 개 존재할 때 원하는 곳으로 뛰어넘을 수 있다.
+    - [x] 포끼리는 뛰어넘을 수 없다.

src/main/java/Application.java

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

src/main/java/controller/JanggiController.java

@@ -0,0 +1,58 @@
+package controller;
+
+import domain.JanggiBoard;
+import domain.JanggiBoardInitializer;
+import domain.piece.Piece;
+import domain.position.Position;
+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() {
+        JanggiBoard janggiBoard = new JanggiBoard(new JanggiBoardInitializer());
+        while (true) {
+            try {
+                outputView.printBoard(janggiBoard);
+                Position from = inputMovePosition();
+                Position to = inputTargetPosition();
+                Piece currentPiece = janggiBoard.getPiece(from);
+                boolean movePiece = currentPiece.canMove(from, to, janggiBoard);
+                if (!movePiece) {
+                    throw new IllegalArgumentException("[ERROR] 해당 위치로 이동할 수 없는 기물입니다.");
+                }
+                janggiBoard.move(from, to, currentPiece);
+                outputView.printBoard(janggiBoard);
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e);
+            }
+        }
+    }
+
+    private Position inputMovePosition() {
+        String inputMovePosition = inputView.inputMovePiece();
+        String[] parts = inputMovePosition.split(",");
+
+        int row = Integer.parseInt(parts[0].trim());
+        int column = Integer.parseInt(parts[1].trim());
+
+        return new Position(row, column);
+    }
+
+    private Position inputTargetPosition() {
+        String inputTargetPosition = inputView.inputTargetPosition();
+        String[] parts = inputTargetPosition.split(",");
+
+        int row = Integer.parseInt(parts[0].trim());
+        int column = Integer.parseInt(parts[1].trim());
+
+        return new Position(row, column);
+    }
+}

src/main/java/domain/Index.java

@@ -0,0 +1,17 @@
+package domain;
+
+public enum Index {
+
+    BOARD_ROWS(10),
+    BOARD_COLUMNS(9);
+
+    private final int index;
+
+    Index(int index) {
+        this.index = index;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+}

src/main/java/domain/JanggiBoard.java

@@ -0,0 +1,46 @@
+package domain;
+
+import static domain.Index.BOARD_COLUMNS;
+import static domain.Index.BOARD_ROWS;
+
+import domain.piece.*;
+
+import domain.position.Position;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class JanggiBoard implements PieceProvider {
+
+    private final Map<Position, Piece> janggiBoard;
+
+    public JanggiBoard(JanggiBoardInitializer initializer) {
+        this.janggiBoard = initializer.init();
+    }
+
+    public Map<Position, Piece> getJanggiBoard() {
+        return Collections.unmodifiableMap(janggiBoard);
+    }
+
+    public void move(Position from, Position to, Piece currentPiece) {
+        janggiBoard.put(to, currentPiece);
+        janggiBoard.put(from, new Blank());
+    }
+
+    @Override
+    public boolean isBlank(Position position) {
+        Piece piece = janggiBoard.get(position);
+        return piece instanceof Blank;
+    }
+
+    @Override
+    public boolean isCannon(Position position) {
+        Piece piece = janggiBoard.get(position);
+        return piece instanceof Cannon;
+    }
+
+    @Override
+    public Piece getPiece(Position position) {
+        return janggiBoard.get(position);
+    }
+}

src/main/java/domain/JanggiBoardInitializer.java

@@ -0,0 +1,60 @@
+package domain;
+
+import static domain.Index.BOARD_COLUMNS;
+import static domain.Index.BOARD_ROWS;
+
+import domain.piece.Blank;
+import domain.piece.Cannon;
+import domain.piece.Car;
+import domain.piece.Elephant;
+import domain.piece.Guard;
+import domain.piece.Horse;
+import domain.piece.King;
+import domain.piece.Pawn;
+import domain.piece.Piece;
+import domain.position.Position;
+import java.util.HashMap;
+import java.util.Map;
+
+public class JanggiBoardInitializer {
+    public Map<Position, Piece> init() {
+        Map<Position, Piece> boardSetting = new HashMap<>();
+
+        for (int row = 0; row < BOARD_ROWS.getIndex(); row++) {
+            for (int col = 0; col < BOARD_COLUMNS.getIndex(); col++) {
+                boardSetting.put(new Position(row, col), new Blank());
+            }
+        }
+
+        setupTeamPieces(boardSetting, Team.HAN, 0, 1, 2, 3); // 한나라 기물 배치 (0~3행 위주)
+        setupTeamPieces(boardSetting, Team.CHO, 9, 8, 7, 6); // 초나라 기물 배치 (9~6행 위주)
+
+        return boardSetting;
+    }
+
+    private void setupTeamPieces(Map<Position, Piece> boardSetting, Team team, int baseRow, int kingRow, int cannonRow,
+                                 int pawnRow) {
+        // 차
+        boardSetting.put(new Position(baseRow, 0), new Car(team));
+        boardSetting.put(new Position(baseRow, 8), new Car(team));
+        // 마
+        boardSetting.put(new Position(baseRow, 1), new Horse(team));
+        boardSetting.put(new Position(baseRow, 6), new Horse(team));
+        // 상
+        boardSetting.put(new Position(baseRow, 2), new Elephant(team));
+        boardSetting.put(new Position(baseRow, 7), new Elephant(team));
+        // 사
+        boardSetting.put(new Position(baseRow, 3), new Guard(team));
+        boardSetting.put(new Position(baseRow, 5), new Guard(team));
+        // 궁
+        boardSetting.put(new Position(kingRow, 4), new King(team));
+        // 포
+        boardSetting.put(new Position(cannonRow, 1), new Cannon(team));
+        boardSetting.put(new Position(cannonRow, 7), new Cannon(team));
+        // 졸/병
+        for (int col = 0; col < 9; col += 2) {
+            boardSetting.put(new Position(pawnRow, col), new Pawn(team));
+        }
+    }
+
+}

src/main/java/domain/JanggiGame.java

@@ -0,0 +1,20 @@
+package domain;
+
+import domain.piece.Blank;
+import domain.piece.Piece;
+import domain.position.Position;
+
+public class JanggiGame {
+
+    public void play(Position from, Position to, PieceProvider janggiBoard) {
+        Piece piece = janggiBoard.getPiece(from);
+        validateBlank(piece);
+        piece.canMove(from, to, janggiBoard);
+    }
+
+    private void validateBlank(Piece piece) {
+        if (piece instanceof Blank) {
+            throw new IllegalArgumentException("해당 위치에 기물이 존재하지 않습니다.");
+        }
+    }
+}

src/main/java/domain/PieceProvider.java

@@ -0,0 +1,10 @@
+package domain;
+
+import domain.piece.Piece;
+import domain.position.Position;
+
+public interface PieceProvider {
+    boolean isBlank(Position position);
+    boolean isCannon(Position position);
+    Piece getPiece(Position position);
+}

src/main/java/domain/Team.java

@@ -0,0 +1,7 @@
+package domain;
+
+public enum Team {
+    CHO,
+    HAN,
+    NONE
+}

src/main/java/domain/dto/JanggiBoardDTO.java

@@ -0,0 +1,14 @@
+package domain.dto;
+
+import domain.JanggiBoard;
+import java.util.List;
+
+public record JanggiBoardDTO(List<PieceDTO> janggiBoardDto) {
+    public static  JanggiBoardDTO from(JanggiBoard janggiBoard) {
+        List<PieceDTO> pieceDtos = janggiBoard.getJanggiBoard().entrySet().stream()
+                .map(entry -> PieceDTO.from(entry.getKey(), entry.getValue()))
+                .toList();
+
+        return new JanggiBoardDTO(pieceDtos);
+    }
+}

src/main/java/domain/dto/PieceDTO.java

@@ -0,0 +1,11 @@
+package domain.dto;
+
+import domain.Team;
+import domain.piece.Piece;
+import domain.position.Position;
+
+public record PieceDTO(int row, int col, Team team) {
+    public static PieceDTO from(Position position, Piece piece) {
+        return new PieceDTO(position.row(), position.col(), piece.getTeam());
+    }
+}

src/main/java/domain/piece/Blank.java

@@ -0,0 +1,18 @@
+package domain.piece;
+
+import domain.PieceProvider;
+import domain.Team;
+import domain.position.Position;
+import domain.strategy.NoStrategy;
+
+public class Blank extends Piece {
+
+    public Blank() {
+        super(Team.NONE, new NoStrategy());
+    }
+
+    @Override
+    public boolean canMove(Position from, Position to, PieceProvider pieceProvider) {
+        return false;
+    }
+}

src/main/java/domain/piece/Cannon.java

@@ -0,0 +1,27 @@
+package domain.piece;
+
+import domain.PieceProvider;
+import domain.position.Position;
+import domain.Team;
+import domain.strategy.CannonStrategy;
+
+import domain.strategy.Strategy;
+import java.util.List;
+
+public class Cannon extends Piece {
+
+    public Cannon(Team team) {
+        super(team, new CannonStrategy());
+    }
+
+    @Override
+    public boolean canMove(Position from, Position to, PieceProvider pieceProvider) {
+        List<Position> moveCandidates = moveStrategy.getMoveCandidates(from, pieceProvider);
+        for (Position candidatePosition : moveCandidates) {
+            if (candidatePosition.equals(to)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/main/java/domain/piece/Car.java

@@ -0,0 +1,28 @@
+package domain.piece;
+
+import domain.PieceProvider;
+import domain.position.Position;
+import domain.Team;
+import domain.strategy.CarStrategy;
+import domain.strategy.Strategy;
+
+import java.util.List;
+
+public class Car extends Piece {
+
+    public Car(Team team) {
+        super(team, new CarStrategy());
+    }
+
+    @Override
+    public boolean canMove(Position from, Position to, PieceProvider pieceProvider) {
+        List<Position> moveCandidates = moveStrategy.getMoveCandidates(from, pieceProvider);
+
+        for (Position candidatePosition : moveCandidates) {
+            if (candidatePosition.equals(to)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}