[체스- 스피드?] 투다 제출합니다

README.md

@@ -5,3 +5,11 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+
+# what is this
+기본 위치 구조가 짜여져있을때 체스 구현하기
+- [] 첫번쨰 플레이어는 Black 두번째 플레이어는 White
+- [] 플레이어는 기물을 이동시킬 수 있다
+- [] 플레이어는 체크메이트시 상대방을 이긴다
+- [] 기권 기능은 없다

src/main/java/Application.java

@@ -0,0 +1,35 @@
+import chess.ChessGame;
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import chess.piece.Piece;
+import chess.view.InputView;
+import chess.view.OutputView;
+import java.nio.file.LinkPermission;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Application {
+
+    private static final InputView inputView = new InputView();
+    private static final OutputView outputView = new OutputView();
+
+    public static void main(String[] args) {
+        ChessGame chessGame = new ChessGame();
+        play(chessGame);
+    }
+
+    private static void play(ChessGame chessGame) {
+        List<Piece> pieces = chessGame.getPieces();
+
+        Map<Position,Piece> positionPieceMap = new HashMap<>();
+        for(Piece piece : pieces){
+            Position position = piece.getPosition();
+            positionPieceMap.put(position,piece);
+        }
+
+        outputView.printChessMap(positionPieceMap);
+    }
+}

src/main/java/chess/ChessGame.java

@@ -0,0 +1,91 @@
+package chess;
+
+import chess.piece.King;
+import chess.piece.Piece;
+import chess.view.InputView;
+import chess.view.OutputView;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class ChessGame {
+
+    private final List<Piece> pieces;
+
+    public ChessGame(List<Piece> pieces) {
+        this.pieces = new ArrayList<>(pieces);
+    }
+
+    public ChessGame() {
+        InitiatePieces initiatePieces = new InitiatePieces();
+        this.pieces = new ArrayList<>(initiatePieces.pieces());
+    }
+
+    public boolean isSomeBodyKingDoesntExist(){
+        Map<Color,Boolean> colorKingDead = getKingSurviveStatus();
+        for(Color color : colorKingDead.keySet()){
+            if(colorKingDead.get(color)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private Map<Color, Boolean> getKingSurviveStatus() {
+        Map<Color,Boolean> colorKingDead = new HashMap<>(Map.of(Color.BLACK,true,Color.WHITE,true));
+        for(Piece piece : pieces){
+            if(piece instanceof King){
+                colorKingDead.put(piece.getColor(),false);
+            }
+        }
+        return colorKingDead;
+    }
+
+    public Color getLoseColor(){
+        Map<Color,Boolean> colorKingDead = getKingSurviveStatus();
+        for(Color color : colorKingDead.keySet()){
+            if(colorKingDead.get(color)){
+                return color;
+            }
+        }
+        return Color.EMPTY;
+    }
+
+    public Optional<Piece> killPieceWhenExistSamePositionPiece(Piece movePiece) {
+        Optional<Piece> samePositionOtherPiece = findSamePositionPiece(movePiece);
+        if(samePositionOtherPiece.isEmpty()){
+            return samePositionOtherPiece;
+        }
+
+        Piece otherPiece = samePositionOtherPiece.get();
+        if(movePiece.isSamePosition(otherPiece) && movePiece.isOpposite(otherPiece)){
+            killPiece(otherPiece);
+            return Optional.of(otherPiece);
+        }
+        return Optional.empty();
+    }
+
+    private Optional<Piece> findSamePositionPiece(Piece movePiece) {
+        for(Piece piece : pieces){
+            if(piece.isSamePosition(movePiece) && movePiece.isOpposite(piece)){
+                return Optional.of(piece);
+            }
+        }
+        return Optional.empty();
+    }
+
+    private void killPiece(Piece deadPiece) {
+        for (int i = 0; i < pieces.size(); i++) {
+            Piece piece = pieces.get(i);
+            if(piece.equals(deadPiece)){
+                pieces.remove(piece);
+            }
+        }
+    }
+
+    public List<Piece> getPieces() {
+        return pieces;
+    }
+}

src/main/java/chess/Column.java

@@ -31,7 +31,6 @@ public Column moveLeft(final int step) {
         if (canMoveLeft(step)) {
             return values()[ordinal() - step];
         }
-
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
 

src/main/java/chess/InitiatePieces.java

@@ -0,0 +1,81 @@
+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.Rook;
+import java.util.ArrayList;
+import java.util.List;
+
+public class InitiatePieces {
+
+    private final List<Piece> pieces = new ArrayList<>();
+
+    public InitiatePieces(){
+        pieces.addAll(pawns);
+        pieces.addAll(kings);
+        pieces.addAll(queens);
+        pieces.addAll(rooks);
+        pieces.addAll(bishops);
+        pieces.addAll(knights);
+    }
+
+    private final List<Piece> pawns = List.of(
+            new Pawn(new Position(Row.TWO,Column.A),Color.WHITE),
+            new Pawn(new Position(Row.TWO,Column.B),Color.WHITE),
+            new Pawn(new Position(Row.TWO,Column.C),Color.WHITE),
+            new Pawn(new Position(Row.TWO,Column.D),Color.WHITE),
+            new Pawn(new Position(Row.TWO,Column.E),Color.WHITE),
+            new Pawn(new Position(Row.TWO,Column.F),Color.WHITE),
+            new Pawn(new Position(Row.TWO,Column.G),Color.WHITE),
+            new Pawn(new Position(Row.TWO,Column.H),Color.WHITE),
+
+            new Pawn(new Position(Row.SEVEN,Column.A),Color.BLACK),
+            new Pawn(new Position(Row.SEVEN,Column.B),Color.BLACK),
+            new Pawn(new Position(Row.SEVEN,Column.C),Color.BLACK),
+            new Pawn(new Position(Row.SEVEN,Column.D),Color.BLACK),
+            new Pawn(new Position(Row.SEVEN,Column.E),Color.BLACK),
+            new Pawn(new Position(Row.SEVEN,Column.F),Color.BLACK),
+            new Pawn(new Position(Row.SEVEN,Column.G),Color.BLACK),
+            new Pawn(new Position(Row.SEVEN,Column.H),Color.BLACK)
+    );
+
+    private final List<Piece> kings = List.of(
+            new King(new Position(Row.EIGHT,Column.E),Color.BLACK),
+            new King(new Position(Row.ONE,Column.E),Color.BLACK)
+    );
+
+    private final List<Piece> queens = List.of(
+            new King(new Position(Row.EIGHT,Column.D),Color.BLACK),
+            new King(new Position(Row.ONE,Column.D),Color.WHITE)
+    );
+
+    private final List<Piece> rooks = List.of(
+            new Rook(new Position(Row.ONE,Column.A),Color.WHITE),
+            new Rook(new Position(Row.ONE,Column.H),Color.WHITE),
+            new Rook(new Position(Row.EIGHT,Column.A),Color.BLACK),
+            new Rook(new Position(Row.EIGHT,Column.H),Color.BLACK)
+    );
+
+    private final List<Piece> bishops = List.of(
+            new Bishop(new Position(Row.ONE,Column.C),Color.WHITE),
+            new Bishop(new Position(Row.ONE,Column.F),Color.WHITE),
+            new Bishop(new Position(Row.EIGHT,Column.C),Color.BLACK),
+            new Bishop(new Position(Row.EIGHT,Column.F),Color.BLACK)
+    );
+
+    private final List<Piece> knights = List.of(
+            new Knight(new Position(Row.ONE,Column.B),Color.WHITE),
+            new Knight(new Position(Row.ONE,Column.G),Color.WHITE),
+            new Knight(new Position(Row.EIGHT,Column.B),Color.BLACK),
+            new Knight(new Position(Row.EIGHT,Column.G),Color.BLACK)
+    );
+
+    public List<Piece> pieces(){
+        return pieces;
+    }
+}
+
+

src/main/java/chess/exception/InvalidMoveException.java

@@ -0,0 +1,7 @@
+package chess.exception;
+
+public class InvalidMoveException extends IllegalArgumentException{
+    public InvalidMoveException(){
+        super("유효하지 않은 기물 움직임입니다");
+    }
+}

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

@@ -1,5 +1,119 @@
 package chess.piece;
 
-public class Bishop {
+import chess.Color;
+import chess.Movement;
+import chess.Position;
+import chess.exception.InvalidMoveException;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
 
+public class Bishop implements Piece{
+
+    private Position position;
+    private final Color color;
+    private final PieceType pieceType;
+    private static final List<Movement> movements = List.of(Movement.RIGHT_UP,Movement.LEFT_UP,Movement.RIGHT_DOWN,Movement.LEFT_DOWN);
+
+
+    public Bishop(Position position, Color color) {
+        this.position = position;
+        this.color = color;
+        pieceType = PieceType.BISHOP;
+    }
+
+    public void move(Position wantedPosition, List<Piece> wantedPositionExistPieces) {
+        for (Movement movement : movements){
+            this.position = movementWhenPossible(movement,wantedPosition,wantedPositionExistPieces);
+            if(position.equals(wantedPosition)) {
+                return;
+            }
+        }
+        if(!position.equals(wantedPosition)){
+            throw new InvalidMoveException();
+        }
+    }
+
+    private Position movementWhenPossible(Movement movement, Position wantedPosition,
+                                          List<Piece> wantedPositionExistPiece) {
+        Position temporalPosition = position;
+        while (temporalPosition.canMove(movement)){
+            temporalPosition = temporalPosition.move(movement);
+            if(temporalPosition.equals(wantedPosition) && isPositionDoesntExistSameColor(wantedPositionExistPiece, temporalPosition)){
+                return temporalPosition;
+            }
+            if(isSamePositionPieceExist(wantedPositionExistPiece, temporalPosition)){
+                throw new InvalidMoveException();
+            }
+        }
+        return position;
+    }
+
+    private boolean isPositionDoesntExistSameColor(List<Piece> wantedPositionExistPiece, Position temporalPosition) {
+        Optional<Piece> otherPieceByPosition = findOtherPieceByPosition(temporalPosition, wantedPositionExistPiece);
+        if(otherPieceByPosition.isEmpty()){
+            return true;
+        }
+        return isOpposite(otherPieceByPosition.get());
+    }
+
+    private Optional<Piece> findOtherPieceByPosition(Position temporalPosition, List<Piece> wantedPositionExistPiece) {
+        for(Piece piece : wantedPositionExistPiece){
+            if(piece.getPosition().equals(temporalPosition)){
+                return Optional.of(piece);
+            }
+        }
+        return Optional.empty();
+    }
+
+    private boolean isSamePositionPieceExist(List<Piece> wantedPositionExistPiece, Position temporalPosition) {
+        for(Piece piece : wantedPositionExistPiece){
+            if(piece.getPosition().equals(temporalPosition)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public boolean isOpposite(Piece piece) {
+        return color.opposite() == piece.getColor();
+    }
+
+    @Override
+    public Color getColor() {
+        return color;
+    }
+
+    @Override
+    public boolean isSamePosition(Piece otherPiece) {
+        return otherPiece.getPosition().equals(position);
+    }
+
+    @Override
+    public PieceType pieceType() {
+        return pieceType;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Bishop bishop = (Bishop) o;
+        return Objects.equals(position, bishop.position) && color == bishop.color;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(position, color);
+    }
 }