[체스 - 스피드런] 칼리(이진) 미션 제출합니다.

src/main/java/chess/Application.java

@@ -0,0 +1,25 @@
+package chess;
+
+import chess.model.BoardFactory;
+import chess.model.ChessBoard;
+import chess.model.element.Color;
+import chess.model.position.Position;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+import java.util.List;
+
+public class Application {
+
+    public static void main(String[] args) {
+        BoardFactory boardFactory = new BoardFactory();
+        ChessBoard board = boardFactory.generateBoard();
+        Color color = Color.WHITE;
+        while (true) {
+            color = color.opposite();
+            OutputView.printChessBoard(board);
+            List<Position> inputPositions = InputView.readMovePositions();
+            board.updatePosition(inputPositions.get(0), inputPositions.get(1), color);
+        }
+    }
+}

src/main/java/chess/model/BoardFactory.java

@@ -0,0 +1,27 @@
+package chess.model;
+
+import chess.model.element.Color;
+import chess.model.piece.Piece;
+import chess.model.piece.PieceType;
+import chess.model.position.Position;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+public class BoardFactory {
+
+    public ChessBoard generateBoard() {
+        Map<Position, Piece> positionByPieceData = new HashMap<>();
+        for (PieceType pieceType : PieceType.values()) {
+            for (Color color : Color.values()) {
+                List<Position> initPositionsByColor = pieceType.getInitPositionsByColor(color);
+                for (Position position : initPositionsByColor) {
+                    positionByPieceData.put(position, pieceType.getPieceByColor(color));
+                }
+            }
+        }
+        return new ChessBoard(positionByPieceData);
+    }
+}

src/main/java/chess/model/ChessBoard.java

@@ -0,0 +1,56 @@
+package chess.model;
+
+import chess.model.element.Color;
+import chess.model.piece.Piece;
+import chess.model.position.Position;
+
+import java.util.Map;
+import java.util.Optional;
+
+public class ChessBoard {
+
+    Map<Position, Piece> positionByPieceBoard;
+
+    public ChessBoard(Map<Position, Piece> boardData) {
+        this.positionByPieceBoard = boardData;
+    }
+
+    public void updatePosition(final Position source, final Position destination, final Color teamType) {
+        validatePositionAndTeam(source, teamType);
+        validatePieceCanMove(source, destination);
+
+        movePieceToDestination(source, destination);
+    }
+
+    private void validatePositionAndTeam(final Position source, final Color color) {
+        if (!positionByPieceBoard.containsKey(source) || !positionByPieceBoard.get(source).getColor().equals(color)) {
+            throw new IllegalArgumentException("scr 좌표에 기물이 존재하지 않거나, 해당 팀의 기물이 아닙니다.");
+        }
+    }
+
+    private void validatePieceCanMove(final Position source, final Position destination) {
+        final Piece piece = positionByPieceBoard.get(source);
+
+        if (!piece.canMove(source, destination, this)) {
+            throw new IllegalArgumentException("해당 기물은 해당 위치로 이동할 수 없습니다.");
+        }
+    }
+
+    private void movePieceToDestination(final Position source, final Position destination) {
+        positionByPieceBoard.put(destination, positionByPieceBoard.get(source));
+        positionByPieceBoard.remove(source);
+    }
+
+
+    public boolean isExistPosition(Position position) {
+        return positionByPieceBoard.containsKey(position);
+    }
+
+    public Optional<Piece> findPieceByPosition(final Position position) {
+        return Optional.ofNullable(positionByPieceBoard.get(position));
+    }
+
+    public Map<Position, Piece> getPositionByPieceBoard() {
+        return positionByPieceBoard;
+    }
+}

src/main/java/chess/Color.java → src/main/java/chess/model/element/Color.java

@@ -1,10 +1,11 @@
-package chess;
+package chess.model.element;
 
 public enum Color {
 
     BLACK,
     WHITE,
-    EMPTY;
+    ;
+//    EMPTY;
 
     public boolean isWhite() {
         return this == WHITE;
@@ -14,15 +15,14 @@ public boolean isBlack() {
         return this == BLACK;
     }
 
-    public boolean isEmpty() {
-        return this == EMPTY;
-    }
+//    public boolean isEmpty() {
+//        return this == EMPTY;
+//    }
 
     public Color opposite() {
         return switch (this) {
             case BLACK -> WHITE;
             case WHITE -> BLACK;
-            default -> EMPTY;
         };
     }
 }

src/main/java/chess/Movement.java → src/main/java/chess/model/element/Movement.java

@@ -1,4 +1,4 @@
-package chess;
+package chess.model.element;
 
 public enum Movement {
     UP(0, 1),

src/main/java/chess/model/piece/Piece.java

@@ -0,0 +1,78 @@
+package chess.model.piece;
+
+import chess.model.ChessBoard;
+import chess.model.element.Color;
+import chess.model.position.Position;
+
+public abstract class Piece {
+
+    protected final Color color;
+
+    public Piece(Color color) {
+        this.color = color;
+    }
+
+    public boolean canMove(Position src, Position dest, ChessBoard board) {
+        double distanceByPositions = calculateDistanceBy(src, dest);
+
+        if (!isNotWithInDirection(src, dest)) {
+            return false;
+        }
+        if (!isWithInRangeByMovement(distanceByPositions)) {
+            return false;
+        }
+        if (!passFilter(src, dest, board)) {
+            return false;
+        }
+        return true;
+    }
+
+    protected abstract boolean isNotWithInDirection(Position src, Position dest);
+
+    private double calculateDistanceBy(Position src, Position dest) {
+        int[] srcNumber = findNumberByPosition(src);
+        int[] destNumber = findNumberByPosition(dest);
+
+        int xx = calculateSquare(srcNumber[0], destNumber[0]);
+        int yy = calculateSquare(srcNumber[1], destNumber[1]);
+
+        return Math.sqrt(xx + yy);
+    }
+
+    protected static int[] findNumberByPosition(Position position) {
+        int columnNumber = position.column().ordinal();
+        int rowNumber = position.row().ordinal();
+        return new int[]{rowNumber, columnNumber};
+    }
+
+    private static int calculateSquare(int rowNumber, int destNumber) {
+        return (int) Math.pow(calculateAbs(rowNumber, destNumber), 2);
+    }
+
+    protected static int calculateAbs(int rowNumber, int destNumber) {
+        return Math.abs(rowNumber - destNumber);
+    }
+
+    protected abstract boolean isWithInRangeByMovement(double distance);
+
+
+    protected abstract boolean passFilter(Position src, Position dest, ChessBoard board);
+
+    protected boolean isVertical(Position src, Position dest) { // 수직
+        int[] srcNumber = findNumberByPosition(src);
+        int[] destNumber = findNumberByPosition(dest);
+
+        return srcNumber[0] == destNumber[0] && srcNumber[1] != destNumber[1];
+    }
+
+    protected boolean isHorizontal(Position src, Position dest) { // 수평
+        int[] srcNumber = findNumberByPosition(src);
+        int[] destNumber = findNumberByPosition(dest);
+
+        return srcNumber[0] != destNumber[0] && srcNumber[1] == destNumber[1];
+    }
+
+    public Color getColor() {
+        return color;
+    }
+}

src/main/java/chess/model/piece/PieceType.java

@@ -0,0 +1,89 @@
+package chess.model.piece;
+
+import chess.model.element.Color;
+import chess.model.piece.types.*;
+import chess.model.position.Position;
+
+import java.util.List;
+
+import static chess.model.position.Column.*;
+
+import static chess.model.position.Row.*;
+
+public enum PieceType {
+
+    BISHOP(List.of(new Position(C, ONE), new Position(F, ONE)),
+            List.of(new Position(C, EIGHT), new Position(F, EIGHT)),
+            new Bishop(Color.BLACK),
+            new Bishop(Color.WHITE)),
+    KING(new Position(D, ONE),
+            new Position(D, EIGHT),
+            new King(Color.BLACK),
+            new King(Color.WHITE)),
+    KNIGHT(List.of(new Position(B, ONE), new Position(G, ONE)),
+            List.of(new Position(B, EIGHT), new Position(G, EIGHT)),
+            new Knight(Color.BLACK),
+            new Knight(Color.WHITE)),
+    PAWN(List.of(new Position(A, TWO), new Position(B, TWO), new Position(C, TWO), new Position(D, TWO), new Position(E, TWO), new Position(F, TWO), new Position(G, TWO), new Position(H, TWO)),
+            List.of(new Position(A, SEVEN), new Position(B, SEVEN), new Position(C, SEVEN), new Position(D, SEVEN), new Position(E, SEVEN), new Position(F, SEVEN), new Position(G, SEVEN), new Position(H, SEVEN)),
+            new Pawn(Color.BLACK),
+            new Pawn(Color.WHITE)),
+    QUEEN(new Position(E, ONE),
+            new Position(E, EIGHT),
+            new Queen(Color.BLACK),
+            new Queen(Color.WHITE)),
+    ROOK(List.of(new Position(A, ONE), new Position(H, ONE)),
+            List.of(new Position(A, EIGHT), new Position(H, EIGHT)),
+            new Rook(Color.BLACK),
+            new Rook(Color.WHITE)),
+    ;
+
+    private final List<Position> whiteInitPositions;
+    private final List<Position> blackInitPositions;
+    private final Piece pieceByBlack;
+    private final Piece pieceByWhite;
+
+    PieceType(List<Position> whiteInitPositions, List<Position> blackInitPositions, Piece pieceByBlack, Piece pieceByWhite) {
+        this.whiteInitPositions = whiteInitPositions;
+        this.blackInitPositions = blackInitPositions;
+        this.pieceByBlack = pieceByBlack;
+        this.pieceByWhite = pieceByWhite;
+    }
+
+    PieceType(Position whiteInitPosition, Position blackInitPosition, Piece pieceByBlack, Piece pieceByWhite) {
+        this.whiteInitPositions = List.of(whiteInitPosition);
+        this.blackInitPositions = List.of(blackInitPosition);
+        this.pieceByBlack = pieceByBlack;
+        this.pieceByWhite = pieceByWhite;
+    }
+
+    public List<Position> getInitPositionsByColor(final Color color) {
+        if (color.isWhite()) {
+            return getWhiteInitPositions();
+        }
+        return getBlackInitPositions();
+    }
+
+    private List<Position> getWhiteInitPositions() {
+        return whiteInitPositions;
+    }
+
+    private List<Position> getBlackInitPositions() {
+        return blackInitPositions;
+    }
+
+    public Piece getPieceByColor(Color color) {
+        if (color.isWhite()) {
+            return getPieceByWhite();
+        }
+        return getPieceByBlack();
+    }
+
+    public Piece getPieceByBlack() {
+        return pieceByBlack;
+    }
+
+    public Piece getPieceByWhite() {
+        return pieceByWhite;
+    }
+}

src/main/java/chess/model/piece/types/Bishop.java

@@ -0,0 +1,50 @@
+package chess.model.piece.types;
+
+import chess.model.ChessBoard;
+import chess.model.element.Color;
+import chess.model.piece.Piece;
+import chess.model.position.Column;
+import chess.model.position.Position;
+import chess.model.position.Row;
+
+public class Bishop extends Piece {
+
+    public Bishop(Color color) {
+        super(color);
+    }
+
+    @Override
+    protected boolean isNotWithInDirection(Position src, Position dest) {
+        // x들 차의 절대값과 y들 차의 절대값이 동일하면 4대각선 내에 존재
+        int[] srcNumber = findNumberByPosition(src);
+        int[] destNumber = findNumberByPosition(dest);
+        int absX = calculateAbs(srcNumber[0], destNumber[0]);
+        int absY = calculateAbs(srcNumber[1], destNumber[1]);
+        return absX == absY;
+    }
+
+    @Override
+    protected boolean isWithInRangeByMovement(double distance) {
+        return true;
+    }
+
+
+    @Override
+    protected boolean passFilter(Position src, Position dest, ChessBoard board) {
+        // 4방향 중 어느 방향인지 파악할 것
+        int[] srcNumber = findNumberByPosition(src);
+        int[] destNumber = findNumberByPosition(dest);
+        int DX = srcNumber[0] - destNumber[0] < 0 ? +1 : -1;
+        int DY = srcNumber[1] - destNumber[1] < 0 ? +1 : -1;
+
+        // dest까지 어떠한 장애물도 없어야 함
+        for (int loop = srcNumber[0], x = srcNumber[0], y = srcNumber[1]; loop < destNumber[0]; loop++, x = x + DX, y = y + DY) {
+            Row row = Row.findByNumber(x);
+            Column column = Column.findByNumber(y);
+            if (board.isExistPosition(new Position(row, column))) {
+                return false;
+            }
+        }
+        return true;
+    }
+}