[1, 2, 3단계 - 체스] 기론(김규철) 미션 제출합니다.

.gitignore

@@ -30,3 +30,8 @@ out/
 
 ### VS Code ###
 .vscode/
+
+### Docker ###
+docker/db/mysql/data/
+docker/db/mysql/init/*
+!docker/db/mysql/init/init.sql

README.md

@@ -5,3 +5,73 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 1단계
+
+### 입력
+
+- [x] 게임 시작할때 start를 입력받는다.
+- [x] 게임 종료할때 end를 입력받는다.
+    - [x] start와 end가 아닌 입력이 들어오면 예외가 발생한다.
+
+### 게임
+
+- [x] 체스판을 만든다.
+- [x] 체스 말들을 체스판 위에 초기화시킨다. 말이 없으면 `.`으로 초기화 시킨다.
+
+### 출력
+
+- [x] 체스판을 출력한다.
+    -  [x] 말이 있는 위치는 알파벳으로 표현한다.
+
+## 2단계
+
+### 입력
+
+- [x] 말을 움직일때는 move`(source위치 target위치)`를 입력받는다.
+    - [x] 체스판을 벗어나는 위치가 입력되면 예외가 발생한다.
+    - [x] move 입력 형식과 다른 경우 예외가 발생한다.
+    - [x] start를 입력한 후에 move가 입력되어야 한다.
+
+### 게임
+
+- [x] 말이 움직이면 source위치는 `.`이 되고 target위치에 말이 표시된다.
+- [x] `나이트`를 제외한 말들은 앞에 말들이 있으면 뛰어넘을 수 없다.
+- [x] 규칙에 벗어난 말들의 움직임은 예외가 발생한다.
+
+### 폰
+
+- [x] 폰은 처음 시작할 때, 한칸 또는 두 칸 움직일수 있다.
+- [x] 폰은 상대 말을 잡을 때, 대각선 한칸만 움직여서 잡을수 있다.
+- [x] 처음 움직임 이후로는 한 칸만 움직일 수 있다.
+- [x] 뒤로 움직일 수 없다.
+
+### 룩
+
+- [x] 상하좌우로 칸수 제한없이 움직인다.
+
+### 나이트
+
+- [x] 앞으로 두칸 전진하고 좌 또는 우로 한칸 움직인다.
+    - [x] 앞에 말들이 있어도 뛰어넘을수 있다.
+
+### 비숍
+
+- [x] 대각선으로만 칸수 제한없이 움직인다.
+
+### 퀸
+
+- [x] 상하좌우, 대각선 칸수 제한없이 움직인다.
+
+### 킹
+
+- [x] 상하좌우, 대각선 한 칸만 움직일수 있다.
+
+## 3단계
+
+### 게임
+
+- [x] 킹이 죽거나 `end`를 입력하면 게임이 끝난다.
+- [x] 남아있는 말에 대해서 점수를 계산한다.
+- [x] 게임이 끝나고 `status`를 입력하면 결과를 보여주고 우승 팀을 알려준다.
+- [x] 게임이 끝나고 아무키나 입력하면 그냥 종료된다.

build.gradle

@@ -12,6 +12,7 @@ dependencies {
     implementation 'com.sparkjava:spark-core:2.9.3'
     implementation 'com.sparkjava:spark-template-handlebars:2.7.1'
     implementation 'ch.qos.logback:logback-classic:1.2.10'
+    runtimeOnly 'mysql:mysql-connector-java:8.0.28'
     testImplementation 'org.assertj:assertj-core:3.22.0'
     testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
 }

docker/db/mysql/init/init.sql

@@ -0,0 +1,15 @@
+CREATE TABLE member
+(
+    id   varchar(10) not null,
+    name varchar(20) not null,
+    primary key (id)
+);
+
+CREATE TABLE role
+(
+    member_id varchar(10) not null,
+    role      varchar(10) not null,
+    primary key (member_id),
+    foreign key (member_id) references member (id)
+);
+

docker/docker-compose.yml

@@ -0,0 +1,18 @@
+version: "3.9"
+services:
+  db:
+    image: mysql:8.0.28
+    platform: linux/x86_64
+    restart: always
+    ports:
+      - "3306:3306"
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: chess
+      MYSQL_USER: user
+      MYSQL_PASSWORD: password
+      TZ: Asia/Seoul
+    volumes:
+      - ./db/mysql/data:/var/lib/mysql
+      - ./db/mysql/config:/etc/mysql/conf.d
+      - ./db/mysql/init:/docker-entrypoint-initdb.d

src/main/java/chess/Board.java

@@ -0,0 +1,104 @@
+package chess;
+
+import chess.piece.Empty;
+import chess.piece.Piece;
+import chess.piece.Pieces;
+import chess.piece.position.Position;
+
+import java.util.List;
+
+public final class Board {
+
+    private final Pieces pieces;
+
+    private Board(Pieces pieces) {
+        this.pieces = pieces;
+    }
+
+    public static Board create(Pieces pieces) {
+        return new Board(pieces);
+    }
+
+    public Pieces getPieces() {
+        return pieces;
+    }
+
+    public void move(List<String> commandPosition, Turn thisTurn) {
+        Position sourcePosition = getSource(commandPosition);
+        Position targetPosition = getTarget(commandPosition);
+
+        Piece sourcePiece = pieces.findByPosition(sourcePosition);
+        Piece targetPiece = pieces.findByPosition(targetPosition);
+        validateTurn(thisTurn, sourcePiece);
+        validateMovable(targetPosition, sourcePiece, targetPiece);
+        move(sourcePosition, targetPosition, sourcePiece, targetPiece);
+    }
+
+    private void validateTurn(Turn thisTurn, Piece sourcePiece) {
+        if (!sourcePiece.isCurrentTurn(thisTurn)) {
+            throw new IllegalArgumentException("[ERROR] 현재 차례가 아닙니다.");
+        }
+    }
+
+    private void validateMovable(Position targetPosition, Piece sourcePiece, Piece targetPiece) {
+        if (isNotMovable(targetPosition, sourcePiece, targetPiece)) {
+            throw new IllegalArgumentException("[ERROR] 움직일수 없습니다.");
+        }
+    }
+
+    private boolean isNotMovable(Position targetPosition, Piece sourcePiece, Piece targetPiece) {
+        return (!sourcePiece.isMovableRange(targetPosition) || hasBlock(sourcePiece, targetPiece)) &&
+                !sourcePiece.isKill(targetPiece);
+    }
+
+    private void move(Position sourcePosition, Position targetPosition, Piece sourcePiece, Piece targetPiece) {
+        sourcePiece.moveTo(targetPosition);
+        pieces.remove(targetPiece);
+        pieces.add(new Empty(sourcePosition));
+    }
+
+    private boolean hasBlock(Piece sourcePiece, Piece targetPiece) {
+        if (sourcePiece.isSameTeam(targetPiece)) {
+            return true;
+        }
+        List<Position> positions = sourcePiece.getIntervalPosition(targetPiece);
+        return positions.stream()
+                .anyMatch(position -> !pieces.findByPosition(position).equals(new Empty(position)));
+    }
+
+    private Position getSource(List<String> commandPosition) {
+        return Position.of(
+                commandPosition.get(0).charAt(0),
+                commandPosition.get(0).charAt(1));
+    }
+
+    private Position getTarget(List<String> commandPosition) {
+        return Position.of(
+                commandPosition.get(1).charAt(0),
+                commandPosition.get(1).charAt(1)
+        );
+    }
+
+    public boolean isDeadKing() {
+        return pieces.countOfKing() == 1;
+    }
+
+    public double getWhiteTeamScore() {
+        return pieces.getTotalScore(Team.WHITE);
+    }
+
+    public double getBlackTeamScore() {
+        return pieces.getTotalScore(Team.BLACK);
+    }
+
+    public Team getWinTeam() {
+        if (getWhiteTeamScore() > getBlackTeamScore()) {
+            return Team.WHITE;
+        }
+        if (getBlackTeamScore() > getWhiteTeamScore()) {
+            return Team.BLACK;
+        }
+        return Team.NONE;
+    }
+}
+

src/main/java/chess/ConsoleApplication.java

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

src/main/java/chess/Team.java

@@ -0,0 +1,18 @@
+package chess;
+
+public enum Team {
+    BLACK(-1),
+    WHITE(1),
+    NONE(0),
+    ;
+
+    private final int forwardDirection;
+
+    Team(int forwardDirection) {
+        this.forwardDirection = forwardDirection;
+    }
+
+    public int getForwardDirection() {
+        return this.forwardDirection;
+    }
+}

src/main/java/chess/Turn.java

@@ -0,0 +1,43 @@
+package chess;
+
+import java.util.Objects;
+
+public final class Turn {
+    private final Team team;
+
+    public Turn(Team team) {
+        this.team = team;
+    }
+
+    public static Turn init() {
+        return new Turn(Team.WHITE);
+    }
+
+    public boolean isCurrentTeam(Team team) {
+        return this.team.equals(team);
+    }
+
+    public Turn change() {
+        if (team.equals(Team.BLACK)) {
+            return new Turn(Team.WHITE);
+        }
+        return new Turn(Team.BLACK);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Turn turn = (Turn) o;
+        return team == turn.team;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(team);
+    }
+}

src/main/java/chess/command/Command.java

@@ -0,0 +1,44 @@
+package chess.command;
+
+import java.util.List;
+
+public abstract class Command implements State {
+
+    protected final String input;
+
+    public Command(String input) {
+        validateCommand(input);
+        this.input = input;
+    }
+
+    private void validateCommand(String input) {
+        if (!input.contains("move") && !"start".equals(input) && !"end".equals(input) && !"status".equals(input)) {
+            throw new IllegalArgumentException("[ERROR] 명령어는 start, move, end, status 중 하나여야합니다.");
+        }
+    }
+
+    @Override
+    public Command turnFinalState(String input) {
+        return new End(input);
+    }
+
+    @Override
+    public boolean isEnd() {
+        return false;
+    }
+
+    @Override
+    public boolean isMove() {
+        return false;
+    }
+
+    @Override
+    public boolean isStatus() {
+        return false;
+    }
+
+    @Override
+    public List<String> getCommandPosition() {
+        throw new IllegalStateException("[ERROR] 명령어에서 위치를 얻을수 없습니다.");
+    }
+}

src/main/java/chess/command/End.java

@@ -0,0 +1,26 @@
+package chess.command;
+
+public final class End extends Command {
+
+    public End(String input) {
+        super(input);
+    }
+
+    @Override
+    public Command turnState(String input) {
+        return this;
+    }
+
+    @Override
+    public Command turnFinalState(String input) {
+        if ("status".equals(input)) {
+            return new Status(input);
+        }
+        return new End(input);
+    }
+
+    @Override
+    public boolean isEnd() {
+        return true;
+    }
+}