[체스 - 스피드런] 줄리(한승아) 미션 제출합니다.

build.gradle

@@ -9,15 +9,15 @@ repositories {
 }
 
 dependencies {
-    testImplementation platform('org.junit:junit-bom:5.9.1')
-    testImplementation platform('org.assertj:assertj-bom:3.25.1')
+    testImplementation platform('org.junit:junit-bom:5.11.4')
+    testImplementation platform('org.assertj:assertj-bom:3.27.3')
     testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation('org.assertj:assertj-core')
 }
 
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(17)
+        languageVersion = JavaLanguageVersion.of(21)
     }
 }
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/java/chess/Application.java

@@ -0,0 +1,60 @@
+package chess;
+
+import chess.piece.BlankPiece;
+import chess.piece.Piece;
+
+import java.util.Map;
+
+public class Application {
+
+    private static final Console console = new Console();
+    private static final Board board = new Board();
+    private static Color currentTurn = Color.BLACK;
+
+    public static void main(String[] args) {
+        board.setup();
+
+        while (board.containsKing()) {
+            commenceRound();
+        }
+    }
+
+    public static void commenceRound() {
+        Map<Position, Piece> pieces = board.getPieces();
+
+        console.printPieces(pieces);
+        console.printSide(currentTurn);
+
+        String positions = console.readPositions();
+        String startInput = positions.split(",")[0];
+        String endInput = positions.split(",")[1];
+
+        Position start = new Position(Column.getColumn(startInput.split("")[0]), Row.getRow(startInput.split("")[1]));
+        Position end = new Position(Column.getColumn(endInput.split("")[0]), Row.getRow(endInput.split("")[1]));
+
+        if (!pieces.containsKey(start)) throw new IllegalArgumentException();
+
+        Piece startPiece = pieces.get(start);
+
+        validateTurn(startPiece);
+
+        Piece endPiece = pieces.getOrDefault(end, new BlankPiece(Color.EMPTY));
+
+        if (!startPiece.canMove(start, end, endPiece, pieces)) throw new IllegalArgumentException();
+
+        pieces.remove(start);
+        pieces.put(end, startPiece);
+
+        currentTurn = currentTurn.opposite();
+    }
+
+    private static void validateTurn(Piece piece) {
+        if (currentTurn.isBlack() && piece.isBlack()) {
+            return;
+        }
+        if (currentTurn.isWhite() && piece.isWhite()) {
+            return;
+        }
+        throw new IllegalArgumentException();
+    }
+}

src/main/java/chess/Board.java

@@ -0,0 +1,69 @@
+package chess;
+
+import chess.piece.Bishop;
+import chess.piece.King;
+import chess.piece.Knight;
+import chess.piece.Pawn;
+import chess.piece.Piece;
+import chess.piece.Queen;
+import chess.piece.Rook;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Board {
+
+    public final Map<Position, Piece> pieces = new HashMap<>();
+
+    public void addPiece(Position position, Piece piece) {
+        pieces.put(position, piece);
+    }
+
+    public void setup() {
+        pieces.put(new Position(Column.A, Row.SEVEN), new Pawn(Color.BLACK));
+        pieces.put(new Position(Column.B, Row.SEVEN), new Pawn(Color.BLACK));
+        pieces.put(new Position(Column.C, Row.SEVEN), new Pawn(Color.BLACK));
+        pieces.put(new Position(Column.D, Row.SEVEN), new Pawn(Color.BLACK));
+        pieces.put(new Position(Column.E, Row.SEVEN), new Pawn(Color.BLACK));
+        pieces.put(new Position(Column.F, Row.SEVEN), new Pawn(Color.BLACK));
+        pieces.put(new Position(Column.G, Row.SEVEN), new Pawn(Color.BLACK));
+        pieces.put(new Position(Column.H, Row.SEVEN), new Pawn(Color.BLACK));
+        pieces.put(new Position(Column.A, Row.TWO), new Pawn(Color.WHITE));
+        pieces.put(new Position(Column.B, Row.TWO), new Pawn(Color.WHITE));
+        pieces.put(new Position(Column.C, Row.TWO), new Pawn(Color.WHITE));
+        pieces.put(new Position(Column.D, Row.TWO), new Pawn(Color.WHITE));
+        pieces.put(new Position(Column.E, Row.TWO), new Pawn(Color.WHITE));
+        pieces.put(new Position(Column.F, Row.TWO), new Pawn(Color.WHITE));
+        pieces.put(new Position(Column.G, Row.TWO), new Pawn(Color.WHITE));
+        pieces.put(new Position(Column.H, Row.TWO), new Pawn(Color.WHITE));
+        pieces.put(new Position(Column.A, Row.EIGHT), new Rook(Color.BLACK));
+        pieces.put(new Position(Column.B, Row.EIGHT), new Knight(Color.BLACK));
+        pieces.put(new Position(Column.C, Row.EIGHT), new Bishop(Color.BLACK));
+        pieces.put(new Position(Column.D, Row.EIGHT), new Queen(Color.BLACK));
+        pieces.put(new Position(Column.E, Row.EIGHT), new King(Color.BLACK));
+        pieces.put(new Position(Column.F, Row.EIGHT), new Bishop(Color.BLACK));
+        pieces.put(new Position(Column.G, Row.EIGHT), new Knight(Color.BLACK));
+        pieces.put(new Position(Column.H, Row.EIGHT), new Rook(Color.BLACK));
+        pieces.put(new Position(Column.A, Row.ONE), new Rook(Color.WHITE));
+        pieces.put(new Position(Column.B, Row.ONE), new Knight(Color.WHITE));
+        pieces.put(new Position(Column.C, Row.ONE), new Bishop(Color.WHITE));
+        pieces.put(new Position(Column.D, Row.ONE), new Queen(Color.WHITE));
+        pieces.put(new Position(Column.E, Row.ONE), new King(Color.WHITE));
+        pieces.put(new Position(Column.F, Row.ONE), new Bishop(Color.WHITE));
+        pieces.put(new Position(Column.G, Row.ONE), new Knight(Color.WHITE));
+        pieces.put(new Position(Column.H, Row.ONE), new Rook(Color.WHITE));
+    }
+
+    public Map<Position, Piece> getPieces() {
+        return pieces;
+    }
+
+    public boolean containsKing() {
+        for (Piece value : pieces.values()) {
+            if (value instanceof King) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/main/java/chess/Color.java

@@ -0,0 +1,28 @@
+package chess;
+
+public enum Color {
+
+    BLACK,
+    WHITE,
+    EMPTY;
+
+    public boolean isWhite() {
+        return this == WHITE;
+    }
+
+    public boolean isBlack() {
+        return this == BLACK;
+    }
+
+    public boolean isEmpty() {
+        return this == EMPTY;
+    }
+
+    public Color opposite() {
+        return switch (this) {
+            case BLACK -> WHITE;
+            case WHITE -> BLACK;
+            default -> EMPTY;
+        };
+    }
+}

src/main/java/chess/Column.java

@@ -0,0 +1,62 @@
+package chess;
+
+import java.util.Arrays;
+
+public enum Column {
+
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    G,
+    H;
+
+    public boolean isFarLeft() {
+        return ordinal() == 0;
+    }
+
+    public boolean isFarRight() {
+        return ordinal() + 1 == values().length;
+    }
+
+    public boolean canMoveLeft(final int step) {
+        return ordinal() - step >= 0;
+    }
+
+    public Column moveLeft() {
+        return moveLeft(1);
+    }
+
+    public Column moveLeft(final int step) {
+        if (canMoveLeft(step)) {
+            return values()[ordinal() - step];
+        }
+
+        throw new IllegalStateException("움직일 수 없는 위치입니다.");
+    }
+
+    public boolean canMoveRight(final int step) {
+        return ordinal() + step < values().length;
+    }
+
+    public Column moveRight() {
+        return moveRight(1);
+    }
+
+    public Column moveRight(final int step) {
+        if (canMoveRight(step)) {
+            return values()[ordinal() + step];
+        }
+
+        throw new IllegalStateException("움직일 수 없는 위치입니다.");
+    }
+
+    public static Column getColumn(String text) {
+        return Arrays.stream(Column.values())
+                .filter(value -> value.toString().equals(text))
+                .findFirst()
+                .orElseThrow();
+    }
+}

src/main/java/chess/Console.java

@@ -0,0 +1,35 @@
+package chess;
+
+import chess.piece.BlankPiece;
+import chess.piece.Piece;
+
+import java.util.Map;
+import java.util.Scanner;
+
+public class Console {
+
+    private final Scanner scanner = new Scanner(System.in);
+
+    public String readPositions() {
+        System.out.println("시작점과 끝점 입력 (예: A1,C3)");
+        return scanner.nextLine();
+    }
+
+    public void printPieces(Map<Position, Piece> pieces) {
+        for (Row row : Row.values()) {
+            for (Column col : Column.values()) {
+                System.out.print(pieces.getOrDefault(new Position(col, row), new BlankPiece(Color.EMPTY)) + " ");
+            }
+            System.out.println();
+        }
+    }
+
+    public void printSide(Color currentTurn) {
+        if (currentTurn.isBlack()) {
+            System.out.println("블랙의 차례입니다.");
+        }
+        if (currentTurn.isWhite()) {
+            System.out.println("화이트의 차례입니다.");
+        }
+    }
+}

src/main/java/chess/Movement.java

@@ -0,0 +1,48 @@
+package chess;
+
+public enum Movement {
+    UP(0, 1),
+    UP_UP(UP.x * 2, UP.y * 2),
+    DOWN(0, -1),
+    DOWN_DOWN(DOWN.x * 2, DOWN.y * 2),
+    LEFT(-1, 0),
+    RIGHT(1, 0),
+    LEFT_UP(LEFT.x, UP.y),
+    RIGHT_UP(RIGHT.x, UP.y),
+    LEFT_DOWN(LEFT.x, DOWN.y),
+    RIGHT_DOWN(RIGHT.x, DOWN.y),
+    UP_UP_LEFT(LEFT_DOWN.x, UP_UP.y),
+    UP_UP_RIGHT(RIGHT_DOWN.x, UP_UP.y),
+    LEFT_LEFT_UP(LEFT.x * 2, UP.y),
+    LEFT_LEFT_DOWN(LEFT.x * 2, DOWN.y),
+    RIGHT_RIGHT_UP(RIGHT.x * 2, UP.y),
+    RIGHT_RIGHT_DOWN(RIGHT.x * 2, DOWN.y),
+    DOWN_DOWN_LEFT(LEFT_DOWN.x, DOWN_DOWN.y),
+    DOWN_DOWN_RIGHT(RIGHT_DOWN.x, DOWN_DOWN.y),
+    ;
+
+    private final int x;
+
+    private final int y;
+
+    Movement(final int x, final int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public int x() {
+        return x;
+    }
+
+    public int y() {
+        return y;
+    }
+
+    public boolean isVertical() {
+        return x == 0 && y != 0;
+    }
+
+    public boolean isDiagonal() {
+        return x != 0 && y != 0 && Math.abs(x) == Math.abs(y);
+    }
+}