[체스 - 스피드런] 코기(장재현) 미션 제출합니다.

src/main/java/Application.java

@@ -0,0 +1,10 @@
+import chess.ChessRunner;
+import view.InputView;
+import view.OutputView;
+
+public class Application {
+    public static void main(String[] args) {
+        ChessRunner chessRunner = new ChessRunner(new InputView(),new OutputView());
+        chessRunner.run();
+    }
+}

src/main/java/chess/ChessBoard.java

@@ -0,0 +1,54 @@
+package chess;
+
+import chess.piece.King;
+import chess.piece.Piece;
+import chess.piece.PieceType;
+import java.util.List;
+import java.util.Optional;
+
+public class ChessBoard {
+
+    private final List<Piece> pieces;
+
+    public ChessBoard(List<Piece> pieces) {
+        this.pieces = pieces;
+    }
+
+    public void movePiece(Position startPosition, Position endPosition, Color turn){
+        Piece startPiece = pieces.stream().filter(piece -> piece.isSamePosition(startPosition) && piece.isSameColor(turn))
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("해당 자리에는 말이 없거나 상대 말입니다."));
+        boolean canMove = startPiece.canMove(endPosition, findAlivePiece());
+
+        if(!canMove){
+            throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다.");
+        }
+
+        Optional<Piece> endPiece = pieces.stream()
+                .filter(piece -> piece.isSamePosition(endPosition) && piece.isAnotherTeam(startPiece))
+                .findAny();
+        startPiece.moveTo(endPosition,findAlivePiece());
+        endPiece.ifPresent(Piece::changePieceToDead);
+    }
+
+    public boolean isKingDead(){
+        return pieces.stream()
+                .anyMatch(piece -> piece.isSamePieceType(PieceType.KING) && !piece.isAlive());
+    }
+
+    public Color findWinColor(){
+        Optional<Piece> deadKing = pieces.stream()
+                .filter(piece -> piece.isSamePieceType(PieceType.KING) && !piece.isAlive())
+                .findAny();
+        if(deadKing.isEmpty()){
+            throw new IllegalArgumentException("게임이 아직 안끝났습니다.");
+        }
+        return deadKing.get().getColor().opposite();
+    }
+
+    public List<Piece> findAlivePiece(){
+        return pieces.stream()
+                .filter(Piece::isAlive)
+                .toList();
+    }
+}

src/main/java/chess/ChessRunner.java

@@ -0,0 +1,57 @@
+package chess;
+
+import chess.piece.Piece;
+import java.util.List;
+import view.InputView;
+import view.OutputView;
+
+public class ChessRunner {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public ChessRunner(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run(){
+        ChessBoard chessBoard = initializeBoard();
+        showBoard(chessBoard);
+        startGame(chessBoard);
+    }
+
+    private void showBoard(ChessBoard chessBoard){
+        List<Piece> alivePiece = chessBoard.findAlivePiece();
+        outputView.printBoard(alivePiece);
+    }
+
+
+    private void startGame(ChessBoard chessBoard){
+        Color turn  = Color.WHITE;
+        while (!chessBoard.isKingDead()) {
+            move(chessBoard,turn);
+            showBoard(chessBoard);
+            turn = turn.opposite();
+        }
+        Color winColor = chessBoard.findWinColor();
+        outputView.printWinner(winColor);
+    }
+
+    public void move(ChessBoard chessBoard,Color turn){
+        while(true){
+            try{
+                Position startPosition = inputView.getStartPosition(turn);
+                Position endPosition = inputView.getEndPosition();
+                chessBoard.movePiece(startPosition,endPosition,turn);
+                return;
+            }catch(IllegalArgumentException e){
+                outputView.printExceptionMessage(e.getMessage());
+            }
+        }
+    }
+
+    private ChessBoard initializeBoard(){
+        return new ChessBoard(PiecesFactory.getInitializedPieces());
+    }
+}

src/main/java/chess/Color.java

@@ -2,9 +2,13 @@
 
 public enum Color {
 
-    BLACK,
-    WHITE,
-    EMPTY;
+    BLACK("흑"),
+    WHITE("백"),
+    EMPTY("없음");
+
+    Color(String name) {
+        this.name = name;
+    }
 
     public boolean isWhite() {
         return this == WHITE;
@@ -25,4 +29,10 @@ public Color opposite() {
             default -> EMPTY;
         };
     }
+
+    private final String name;
+
+    public String getName() {
+        return name;
+    }
 }

src/main/java/chess/Column.java

@@ -1,15 +1,34 @@
 package chess;
 
+import java.util.Arrays;
+
 public enum Column {
 
-    A,
-    B,
-    C,
-    D,
-    E,
-    F,
-    G,
-    H;
+    A('A'),
+    B('B'),
+    C('C'),
+    D('D'),
+    E('E'),
+    F('F'),
+    G('G'),
+    H('H');
+
+    private final char name;
+
+    Column(char name) {
+        this.name = name;
+    }
+
+    public char getName() {
+        return name;
+    }
+
+    public static Column findColumn(char input){
+        return Arrays.stream(Column.values())
+                .filter(row -> row.name==input)
+                .findAny()
+                .orElseThrow(()->new IllegalArgumentException("A부터 H까지 열을 선택해주세요(대문자만 가능합니다)"));
+    }
 
     public boolean isFarLeft() {
         return ordinal() == 0;
@@ -50,4 +69,5 @@ public Column moveRight(final int step) {
 
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
+
 }

src/main/java/chess/PiecesFactory.java

@@ -0,0 +1,57 @@
+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.List;
+import java.util.Map;
+
+public class PiecesFactory {
+
+    private static final List<Piece> pieces;
+
+    static {
+        pieces=List.of(
+                new Pawn(Color.WHITE,new Position(Row.TWO,Column.A)),
+                new Pawn(Color.WHITE,new Position(Row.TWO,Column.B)),
+                new Pawn(Color.WHITE,new Position(Row.TWO,Column.C)),
+                new Pawn(Color.WHITE,new Position(Row.TWO,Column.D)),
+                new Pawn(Color.WHITE,new Position(Row.TWO,Column.E)),
+                new Pawn(Color.WHITE,new Position(Row.TWO,Column.F)),
+                new Pawn(Color.WHITE,new Position(Row.TWO,Column.G)),
+                new Pawn(Color.WHITE,new Position(Row.TWO,Column.H)),
+                new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.A)),
+                new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.B)),
+                new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.C)),
+                new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.D)),
+                new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.E)),
+                new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.F)),
+                new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.G)),
+                new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.H)),
+                new King(Color.WHITE,new Position(Row.ONE,Column.E)),
+                new King(Color.BLACK,new Position(Row.EIGHT,Column.E)),
+                new Queen(Color.WHITE,new Position(Row.ONE,Column.D)),
+                new Queen(Color.BLACK,new Position(Row.EIGHT,Column.D)),
+                new Rook(Color.WHITE,new Position(Row.ONE,Column.A)),
+                new Rook(Color.WHITE,new Position(Row.ONE,Column.H)),
+                new Rook(Color.BLACK,new Position(Row.EIGHT,Column.A)),
+                new Rook(Color.BLACK,new Position(Row.EIGHT,Column.H)),
+                new Knight(Color.WHITE,new Position(Row.ONE,Column.B)),
+                new Knight(Color.WHITE,new Position(Row.ONE,Column.G)),
+                new Knight(Color.BLACK,new Position(Row.EIGHT,Column.B)),
+                new Knight(Color.BLACK,new Position(Row.EIGHT,Column.G)),
+                new Bishop(Color.WHITE,new Position(Row.ONE,Column.C)),
+                new Bishop(Color.WHITE,new Position(Row.ONE,Column.F)),
+                new Bishop(Color.BLACK,new Position(Row.EIGHT,Column.C)),
+                new Bishop(Color.BLACK,new Position(Row.EIGHT,Column.F))
+        );
+    }
+
+    public static List<Piece> getInitializedPieces(){
+        return pieces;
+    }
+}

src/main/java/chess/Position.java

@@ -8,6 +8,10 @@ public Position(final Row row, final Column column) {
         this(column, row);
     }
 
+    public static Position copyOf(final Position position){
+        return new Position(position.row,position.column);
+    }
+
     public boolean canMoveUp() {
         return row.canMoveUp(1);
     }
@@ -167,4 +171,10 @@ public Position moveHorizontal(final int step) {
         }
         return this;
     }
+
+    public boolean isSamePosition(Position position){
+        return row.equals(position.row) && column.equals(position.column);
+    }
+
+
 }

src/main/java/chess/Row.java

@@ -1,15 +1,34 @@
 package chess;
 
+import java.util.Arrays;
+
 public enum Row {
 
-    EIGHT,
-    SEVEN,
-    SIX,
-    FIVE,
-    FOUR,
-    THREE,
-    TWO,
-    ONE;
+    EIGHT('8'),
+    SEVEN('7'),
+    SIX('6'),
+    FIVE('5'),
+    FOUR('4'),
+    THREE('3'),
+    TWO('2'),
+    ONE('1');
+
+    private final char name;
+
+    Row(char name) {
+        this.name = name;
+    }
+
+    public char getName() {
+        return name;
+    }
+
+    public static Row findRow(char input){
+        return Arrays.stream(Row.values())
+                .filter(row -> row.name==input)
+                .findAny()
+                .orElseThrow(()->new IllegalArgumentException("1부터 8까지 행을 선택해주세요"));
+    }
 
     public boolean isTop() {
         return ordinal() == 0;