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/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/chess/Starter.java

@@ -0,0 +1,10 @@
+package chess;
+
+import chess.controller.Controller;
+
+public class Starter {
+    public static void main(String[] args) {
+        Controller controller = new Controller();
+        controller.start();
+    }
+}

src/main/java/chess/controller/Controller.java

@@ -0,0 +1,86 @@
+package chess.controller;
+
+import chess.domain.additional.Command;
+import chess.domain.board.Board;
+import chess.domain.board.Location;
+import chess.domain.board.State;
+import chess.dto.BoardStatusResponse;
+import chess.service.InitBoard;
+import chess.util.Splitter;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class Controller {
+
+    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() {
+        Command command = getStartCommand();
+        initBoard();
+        OutputView.printBoardStatus(BoardStatusResponse.from(board));
+        State turn = State.WHITE_TEAM;
+
+        while (!command.isEnd()) {
+            command = getCommand(turn);
+            turn = turn.changeTurn();
+        }
+    }
+
+    private Command getStartCommand() {
+        try {
+            String input = InputView.readCommand();
+            return Command.createStartCommand(input);
+        } catch (IllegalStateException e) {
+            OutputView.printErrorMessage(e.getMessage());
+            return getStartCommand();
+        }
+    }
+
+    private void initBoard() {
+        board = new Board(new InitBoard().getInitBoard());
+    }
+
+    private Command getCommand(final State turn) {
+        try {
+            String input = InputView.readCommand();
+            Command command = Command.createCommand(input);
+            checkMoveCommand(command, input, turn);
+            return command;
+        } catch (IllegalStateException e) {
+            OutputView.printErrorMessage(e.getMessage());
+            return getCommand(turn);
+        }
+    }
+
+    private void checkMoveCommand(final Command command, final String input, final State turn) {
+        if (command.isMove()) {
+            findMoveLocation(input, turn);
+        }
+    }
+
+    private void findMoveLocation(final String input, final State turn) {
+        String preLocation = Splitter.splitString(input, PRE_INDEX);
+        String moveLocation = Splitter.splitString(input, MOVE_INDEX);
+
+        movePieces(preLocation, moveLocation, turn);
+    }
+
+    private void movePieces(final String preLocation, final String moveLocation, final State turn) {
+        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, turn);
+
+        OutputView.printBoardStatus(BoardStatusResponse.from(board));
+    }
+}

src/main/java/chess/domain/additional/Command.java

@@ -0,0 +1,100 @@
+package chess.domain.additional;
+
+import java.util.Arrays;
+
+import static chess.domain.additional.Error.CAN_START_WITH_START_COMMAND;
+import static chess.domain.additional.Error.EARLY_START_GAME;
+import static chess.domain.additional.Error.WRONG_INPUT;
+import static chess.domain.additional.Error.WRONG_MOVE_COMMAND;
+import static chess.util.Splitter.splitSize;
+import static chess.util.Splitter.splitString;
+import static chess.util.Splitter.splitStringLength;
+
+public enum Command {
+
+    START("start"),
+    END("end"),
+    MOVE("move");
+
+    private static final int COMMAND = 0;
+    private static final int CORRECT_MOVE_SIZE = 3;
+    private static final int PRE_LOCATION_INFO = 1;
+    private static final int MOVE_LOCATION_INFO = 2;
+    private static final int MOVE_INFO_LENGTH = 2;
+    private static final String START_COMMAND = "start";
+    private static final String END_COMMAND = "end";
+    private static final String MOVE_COMMAND = "move";
+
+    private final String select;
+
+    Command(final String select) {
+        this.select = select;
+    }
+
+    public static Command createStartCommand(final String input) {
+        validationFirstCommand(input);
+        return Command.START;
+    }
+
+    public static Command createCommand(final String input) {
+        validationCommand(input);
+
+        if (isMoveCommand(input)) {
+            validateMoveCommand(input);
+            return Command.MOVE;
+        }
+
+        return Command.END;
+    }
+
+    private static void validationFirstCommand(final String input) {
+        if (!isStartCommand(input)) {
+            throw new IllegalStateException(CAN_START_WITH_START_COMMAND.getMessage());
+        }
+    }
+
+    private static void validationCommand(final String input) {
+        if (!isCorrectCommand(input)) {
+            throw new IllegalStateException(WRONG_INPUT.getMessage());
+        }
+
+        if (isStartCommand(input)) {
+            throw new IllegalStateException(EARLY_START_GAME.getMessage());
+        }
+    }
+
+    private static boolean isStartCommand(final String input) {
+        return Command.START.select.equals(input);
+    }
+
+    private static boolean isCorrectCommand(final String input) {
+        return Arrays.stream(Command.values())
+            .anyMatch(command -> splitString(input, COMMAND).equals(command.select));
+    }
+
+    private static boolean isMoveCommand(final String input) {
+        return input.startsWith(Command.MOVE.select);
+    }
+
+    private static void validateMoveCommand(final String input) {
+        if (splitSize(input) != CORRECT_MOVE_SIZE) {
+            throw new IllegalStateException(WRONG_MOVE_COMMAND.getMessage());
+        }
+
+        if (splitStringLength(input, PRE_LOCATION_INFO) != MOVE_INFO_LENGTH || splitStringLength(input, MOVE_LOCATION_INFO) != MOVE_INFO_LENGTH) {
+            throw new IllegalStateException(WRONG_MOVE_COMMAND.getMessage());
+        }
+    }
+
+    public boolean isEnd() {
+        return this.select.equals(END_COMMAND);
+    }
+
+    public boolean isStart() {
+        return this.select.equals(START_COMMAND);
+    }
+
+    public boolean isMove() {
+        return this.select.equals(MOVE_COMMAND);
+    }
+}

src/main/java/chess/domain/additional/Direction.java

@@ -0,0 +1,65 @@
+package chess.domain.additional;
+
+import java.util.Arrays;
+
+import static chess.domain.additional.Error.WRONG_ROW_OR_COLUMN;
+
+public enum Direction {
+
+    UP(0, 1),
+    DOWN(0, -1),
+    RIGHT(1, 0),
+    LEFT(-1, 0),
+    FIRST_DIAGONAL(1, 1),
+    SECOND_DIAGONAL(1, -1),
+    THIRD_DIAGONAL(-1, -1),
+    FOURTH_DIAGONAL(-1, 1),
+    DOUBLE_UP(0,2),
+    DOUBLE_DOWN(0,-2),
+    FIRST_DIAGONAL_UP(1,2),
+    FIRST_DIAGONAL_RIGHT(2,1),
+    SECOND_DIAGONAL_RIGHT(2,-1),
+    SECOND_DIAGONAL_DOWN(1,-2),
+    THIRD_DIAGONAL_DOWN(-1,-2),
+    THIRD_DIAGONAL_LEFT(-2,-1),
+    FOURTH_DIAGONAL_LEFT(-2,1),
+    FOURTH_DIAGONAL_UP(-1,2);
+
+    private static final int ZERO = 0;
+
+    private final int row;
+    private final int column;
+
+    Direction(final int row, final int column) {
+        this.row = row;
+        this.column = column;
+    }
+
+    private static boolean isSameDirection(final int row, final int column, final Direction direction) {
+        return direction.row == row && direction.column == column;
+    }
+
+    public static Direction from(final int row, final int column) {
+        return Arrays.stream(Direction.values())
+            .filter(direction -> isSameDirection(row, column, direction))
+            .findAny()
+            .orElseThrow(() -> new IllegalStateException(WRONG_ROW_OR_COLUMN.getMessage()));
+    }
+
+    public static int getSubtractDirection(final char pre, final char move) {
+        int gap = move - pre;
+        return Integer.compare(gap, ZERO);
+    }
+
+    public boolean isUpOrDown() {
+        return this.equals(UP) || this.equals(DOWN);
+    }
+
+    public int getRow() {
+        return row;
+    }
+
+    public int getColumn() {
+        return column;
+    }
+}

src/main/java/chess/domain/additional/Error.java

@@ -0,0 +1,29 @@
+package chess.domain.additional;
+
+public enum Error {
+
+    WRONG_INPUT("잘못된 입력입니다."),
+    HAS_NOT_PIECES("해당 위치에는 기물이 없습니다."),
+    MOVE_LOCATION_IS_SAME_COLOR("이동하려는 위치에는 같은 색깔의 기물이 있습니다."),
+    CAN_NOT_MOVE_RANGE("기물이 움직일 수 있는 범위가 아닙니다."),
+    DO_NOT_STAY("제자리로 움직일 수 없습니다."),
+    PAWN_MOVE_DIAGONALLY_WITH_ENEMY("폰이 대각선으로 움직이려면 적군이 있어야합니다."),
+    CAN_NOT_MOVE_BECAUSE_OBSTACLE("동선에 기물이 있어서 움직일 수 없습니다."),
+    WRONG_ROW_OR_COLUMN("잘못된 row와 column입니다."),
+    WRONG_FILE_NAME("잘못된 File의 이름입니다."),
+    WRONG_RANK_NAME("잘못된 rank의 이름입니다."),
+    CAN_START_WITH_START_COMMAND("게임을 시작하려면 start를 입력해주세요"),
+    EARLY_START_GAME("이미 게임이 진행중입니다."),
+    WRONG_MOVE_COMMAND("잘못된 이동정보입니다."),
+    WRONG_TURN("이전에 움직인 기물을 색상과 현재 움직이려는 기물의 색상이 같습니다.");
+
+    private final String message;
+
+    Error(final String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}