Feat/level1

build.gradle

@@ -2,18 +2,23 @@ plugins {
     id 'java'
 }
 
-group 'org.example'
 version '1.0-SNAPSHOT'
 
 repositories {
     mavenCentral()
 }
 
 dependencies {
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
+    testImplementation 'org.assertj:assertj-core:3.22.0'
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(11)
+    }
 }
 
 test {
     useJUnitPlatform()
-}
+}

src/main/java/Main.java

@@ -1,2 +1,8 @@
+import controller.Controller;
+
 public class Main {
+    public static void main(String[] args) {
+        Controller controller = new Controller();
+        controller.start();
+    }
 }

src/main/java/README.md

@@ -0,0 +1,39 @@
+# 체스
+
+- 체스판 위에 알맞은 순서대로 기물을 배치시킴
+- 입력에 따라 해당 위치의 기물을 옮김
+
+- 도메인 설계
+
+## 체스판(8x8) 체스칸을 관리하는 일급 컬렉션
+- [x] 맵으로 체스칸을 관리
+- [x] 정적팩토리 메서드를 사용하여 초기화를 통해 기물을 배치
+- [x] 해당 위치의 기물이 이동가능한지
+- [x] 입력으로 들어온 위치에 기물이 있는지
+- [x] 시작점과 끝점의 기물의 색상이 같은지
+- [x] 시작점에서 이동가능한 위치인지
+- [x] 이동경로에 기물이 있는지
+- [x] 현재 체스판 상황을 반환
+
+## 기물 
+- [x] 이동할수 있는지
+- [x] 해당 말이 검정색인지
+- [x] 이름을 반환
+- [x] 검은색 기물인지
+- [x] 나이트인지
+- [x] 폰인지
+
+
+## 위치 (인스턴스 변수 가로(Rank(, 세로(File)를 가짐 - Rank,File은 체스 용어)
+- [x] 같은 위치인지
+- [x] 같은 file인지
+- [x] 같은 rank인지
+- [x] rank 이름을 반환
+- [x] file 이름을 반환
+
+## 방향 enum
+- [x] 같은 방향인지
+- [x] 이동하려는 방향이 어느쪽인지
+- [x] 해당 방향이 위또는 아래인지
+- [x] row를 반환
+- [x] column을 반환

src/main/java/controller/Controller.java

@@ -0,0 +1,70 @@
+package controller;
+
+import domain.Board;
+import domain.Command;
+import domain.Location;
+import dto.BoardStatusResponse;
+import service.InitBoard;
+import view.InputView;
+import view.OutputView;
+
+public class Controller {
+
+    private static final String SEPARATOR = " ";
+    private static final int PRE_INDEX = 1;
+    private static final int MOVE_INDEX = 2;
+    private static final int RANK_INDEX = 0;
+    private static final int FILE_INDEX = 1;
+
+    private Board board;
+
+    public void start() {
+        OutputView.printStart();
+        startGame();
+    }
+
+    private void startGame() {
+        String input = InputView.readFirstCommand();
+        Command command = Command.from(input);
+
+        while (!command.isEnd()) {
+            checkCommand(command, input);
+            input = InputView.readCommand();
+            command = Command.from(input);
+        }
+    }
+
+    private void checkCommand(final Command command, final String input) {
+        if (command.isStart()) {
+            initBoard();
+        }
+
+        if (command.isMove()) {
+            findMoveLocation(input);
+        }
+
+        OutputView.printBoardStatus(BoardStatusResponse.from(board));
+    }
+
+    private void initBoard() {
+        board = new Board(new InitBoard().getInitBoard());
+    }
+
+    private void findMoveLocation(final String input) {
+        String[] inputInfo = input.split(SEPARATOR);
+        String preLocation = inputInfo[PRE_INDEX];
+        String moveLocation = inputInfo[MOVE_INDEX];
+
+        movePieces(preLocation, moveLocation);
+    }
+
+    private void movePieces(final String preLocation, final String moveLocation) {
+        try {
+            Location pre = Location.from(preLocation.charAt(RANK_INDEX), preLocation.charAt(FILE_INDEX));
+            Location move = Location.from(moveLocation.charAt(RANK_INDEX), moveLocation.charAt(FILE_INDEX));
+            board.movePieces(pre, move);
+        } catch (IllegalStateException e) {
+            OutputView.printErrorMessage(e.getMessage());
+        }
+    }
+}

src/main/java/domain/Bishop.java

@@ -0,0 +1,26 @@
+package domain;
+
+public class Bishop extends Pieces {
+
+    public Bishop(final State state) {
+        super(state);
+    }
+
+    @Override
+    boolean canMove(final char preRank, final char preFile, final Location moveLocation) {
+        char moveRank = moveLocation.getRank();
+        char moveFile = moveLocation.getFile();
+
+        return Math.abs(preRank - moveRank) == Math.abs(preFile - moveFile);
+    }
+
+    @Override
+    boolean isKnight() {
+        return false;
+    }
+
+    @Override
+    boolean isPawn() {
+        return false;
+    }
+}

src/main/java/domain/Board.java

@@ -0,0 +1,138 @@
+package domain;
+
+import java.util.Map;
+
+import static domain.Error.*;
+
+public class Board {
+
+    private static final int FILE_MAX = 8;
+    private static final int FILE_INIT = 1;
+    private static final int RANK_MAX = 7;
+    private static final int RANK_INIT = 0;
+    private static final String EMPTY = ".";
+    private static final char FIRST_RANK = 'a';
+    private static final char FIRST_FILE = '0';
+
+    private final Map<Location, Pieces> board;
+
+    public Board(final Map<Location, Pieces> board) {
+        this.board = board;
+    }
+
+    public String getBoardStatus() {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int file = FILE_MAX; file >= FILE_INIT; file--) {
+            findBoardStatus(file, stringBuilder);
+        }
+        return stringBuilder.toString();
+    }
+
+    private void findBoardStatus(final int file, final StringBuilder stringBuilder) {
+        for (int rank = RANK_INIT; rank <= RANK_MAX; rank++) {
+            Location location = Location.from((char) (FIRST_RANK + rank), (char) (FIRST_FILE + file));
+            addBoardStatus(location, stringBuilder);
+        }
+    }
+
+    private void addBoardStatus(final Location location, final StringBuilder stringBuilder) {
+        if (board.containsKey(location)) {
+            stringBuilder.append(board.get(location).getName());
+            return;
+        }
+        stringBuilder.append(EMPTY);
+    }
+
+    public void movePieces(final Location preLocation, final Location moveLocation) {
+        validationMovePieces(preLocation, moveLocation);
+        move(preLocation, moveLocation);
+    }
+
+    private void validationMovePieces(final Location preLocation, final Location moveLocation) {
+        checkExistPiecesInLocation(preLocation, moveLocation);
+        checkCanMovePiecesInLocation(preLocation, moveLocation);
+        if (board.get(preLocation).isPawn()) {
+            checkPawnMove(preLocation, moveLocation);
+            return;
+        }
+        checkExistPiecesInRoute(preLocation, moveLocation);
+    }
+
+    private void checkExistPiecesInLocation(final Location preLocation, final Location moveLocation) {
+        if (!board.containsKey(preLocation)) {
+            throw new IllegalStateException(HAS_NOT_PIECES.getMessage());
+        }
+
+        if (board.containsKey(moveLocation) && isSameColor(preLocation, moveLocation)) {
+            throw new IllegalStateException(MOVE_LOCATION_IS_SAME_COLOR.getMessage());
+        }
+    }
+
+    private boolean isSameColor(final Location preLocation, final Location moveLocation) {
+        Pieces piecesInPreIndex = board.get(preLocation);
+        Pieces piecesInMoveIndex = board.get(moveLocation);
+        return piecesInPreIndex.isBlack() == piecesInMoveIndex.isBlack();
+    }
+
+    private void checkCanMovePiecesInLocation(final Location preLocation, final Location moveLocation) {
+        if (!board.get(preLocation).canMove(preLocation.getRank(), preLocation.getFile(), moveLocation)) {
+            throw new IllegalStateException(CAN_NOT_MOVE_RANGE.getMessage());
+        }
+
+        if (preLocation.equals(moveLocation)) {
+            throw new IllegalStateException(DO_NOT_STAY.getMessage());
+        }
+    }
+
+    private void checkPawnMove(final Location preLocation, final Location moveLocation) {
+        Direction direction = findDirection(preLocation, moveLocation);
+        if (direction.isUpOrDown()) {
+            checkRoute(direction, preLocation, moveLocation);
+            return;
+        }
+
+        if (!board.containsKey(moveLocation) || isSameColor(preLocation, moveLocation)) {
+            throw new IllegalStateException(PAWN_MOVE_DIAGONALLY_WITH_ENEMY.getMessage());
+        }
+    }
+
+    private void checkExistPiecesInRoute(final Location preLocation, final Location moveLocation) {
+        if (board.get(preLocation).isKnight()) {
+            return;
+        }
+        Direction direction = findDirection(preLocation, moveLocation);
+        checkRoute(direction, preLocation, moveLocation);
+    }
+
+    private Direction findDirection(final Location preLocation, final Location moveLocation) {
+        int rowDirection = Direction.getSubtractDirection(preLocation.getRank(), moveLocation.getRank());
+        int columnDirection = Direction.getSubtractDirection(preLocation.getFile(), moveLocation.getFile());
+
+        return Direction.from(rowDirection, columnDirection);
+    }
+
+    private void checkRoute(final Direction direction, final Location preLocation, final Location moveLocation) {
+        char nowRank = (char) (preLocation.getRank() + direction.getRow());
+        char nowFile = (char) (preLocation.getFile() + direction.getColumn());
+
+        while (!moveLocation.isSameLocation(nowRank, nowFile)) {
+            checkExistPiecesInLocation(nowRank, nowFile);
+            nowRank = (char) (nowRank + direction.getRow());
+            nowFile = (char) (nowFile + direction.getColumn());
+        }
+    }
+
+    private void checkExistPiecesInLocation(final char nowRank, final char nowFile) {
+        Location nowLocation = Location.from(nowRank, nowFile);
+        if (board.containsKey(nowLocation)) {
+            throw new IllegalStateException(CAN_NOT_MOVE_BECAUSE_OBSTACLE.getMessage());
+        }
+    }
+
+    private void move(final Location preLocation, final Location moveLocation) {
+        Pieces pieces = board.get(preLocation);
+        board.remove(preLocation);
+        board.put(moveLocation, pieces);
+    }
+}
+

src/main/java/domain/Command.java

@@ -0,0 +1,45 @@
+package domain;
+
+import java.util.Arrays;
+
+import static domain.Error.WRONG_INPUT;
+
+public enum Command {
+
+    START("start"),
+    END("end"),
+    MOVE("move");
+
+    private final String select;
+
+    Command(final String select) {
+        this.select = select;
+    }
+
+    public static Command from(final String command) {
+        return Arrays.stream(Command.values())
+            .filter(status -> command.startsWith(status.select))
+            .findAny().orElseThrow(() -> new IllegalStateException(WRONG_INPUT.getMessage()));
+    }
+
+    public static boolean isCorrectCommand(final String command) {
+        return Arrays.stream(Command.values())
+            .anyMatch(status -> command.startsWith(status.select));
+    }
+
+    public static boolean isStartCommand(final String command) {
+        return Command.START.select.equals(command);
+    }
+
+    public boolean isEnd() {
+        return this.select.equals("end");
+    }
+
+    public boolean isStart() {
+        return this.select.equals("start");
+    }
+
+    public boolean isMove() {
+        return this.select.equals("move");
+    }
+}