diff --git a/README.md b/README.md index 8102f91c87..6a19ec5829 100644 --- a/README.md +++ b/README.md @@ -5,3 +5,11 @@ ## 우아한테크코스 코드리뷰 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md) + + +# what is this +기본 위치 구조가 짜여져있을때 체스 구현하기 +- [] 첫번쨰 플레이어는 Black 두번째 플레이어는 White +- [] 플레이어는 기물을 이동시킬 수 있다 +- [] 플레이어는 체크메이트시 상대방을 이긴다 +- [] 기권 기능은 없다 diff --git a/src/main/java/Application.java b/src/main/java/Application.java new file mode 100644 index 0000000000..0f60d93cf6 --- /dev/null +++ b/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 pieces = chessGame.getPieces(); + + Map positionPieceMap = new HashMap<>(); + for(Piece piece : pieces){ + Position position = piece.getPosition(); + positionPieceMap.put(position,piece); + } + + outputView.printChessMap(positionPieceMap); + } +} diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java new file mode 100644 index 0000000000..d97bde233d --- /dev/null +++ b/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 pieces; + + public ChessGame(List pieces) { + this.pieces = new ArrayList<>(pieces); + } + + public ChessGame() { + InitiatePieces initiatePieces = new InitiatePieces(); + this.pieces = new ArrayList<>(initiatePieces.pieces()); + } + + public boolean isSomeBodyKingDoesntExist(){ + Map colorKingDead = getKingSurviveStatus(); + for(Color color : colorKingDead.keySet()){ + if(colorKingDead.get(color)){ + return true; + } + } + return false; + } + + private Map getKingSurviveStatus() { + Map 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 colorKingDead = getKingSurviveStatus(); + for(Color color : colorKingDead.keySet()){ + if(colorKingDead.get(color)){ + return color; + } + } + return Color.EMPTY; + } + + public Optional killPieceWhenExistSamePositionPiece(Piece movePiece) { + Optional 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 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 getPieces() { + return pieces; + } +} diff --git a/src/main/java/chess/Column.java b/src/main/java/chess/Column.java index b64b4dc77a..ad51629133 100644 --- a/src/main/java/chess/Column.java +++ b/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("움직일 수 없는 위치입니다."); } diff --git a/src/main/java/chess/InitiatePieces.java b/src/main/java/chess/InitiatePieces.java new file mode 100644 index 0000000000..91de43b275 --- /dev/null +++ b/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 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 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 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 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 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 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 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 pieces(){ + return pieces; + } +} + + diff --git a/src/main/java/chess/exception/InvalidMoveException.java b/src/main/java/chess/exception/InvalidMoveException.java new file mode 100644 index 0000000000..3a98e930f1 --- /dev/null +++ b/src/main/java/chess/exception/InvalidMoveException.java @@ -0,0 +1,7 @@ +package chess.exception; + +public class InvalidMoveException extends IllegalArgumentException{ + public InvalidMoveException(){ + super("유효하지 않은 기물 움직임입니다"); + } +} diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java index b14ab70f98..3f97b7e2ce 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/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 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 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 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 wantedPositionExistPiece, Position temporalPosition) { + Optional otherPieceByPosition = findOtherPieceByPosition(temporalPosition, wantedPositionExistPiece); + if(otherPieceByPosition.isEmpty()){ + return true; + } + return isOpposite(otherPieceByPosition.get()); + } + + private Optional findOtherPieceByPosition(Position temporalPosition, List wantedPositionExistPiece) { + for(Piece piece : wantedPositionExistPiece){ + if(piece.getPosition().equals(temporalPosition)){ + return Optional.of(piece); + } + } + return Optional.empty(); + } + + private boolean isSamePositionPieceExist(List 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); + } } diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java index d64210cad1..4fad2edcee 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/piece/King.java @@ -1,5 +1,98 @@ package chess.piece; -public class King { +import chess.Color; +import chess.Movement; +import chess.Position; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Objects; +public class King implements Piece{ + + private Position position; + private final Color color; + private final PieceType pieceType; + private static final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); + + public King(Position position, Color color) { + this.position = position; + this.color = color; + this.pieceType = PieceType.KING; + } + + @Override + public void move(Position wantedPosition, List wantedPositionExistPiece) { + boolean isWantedPositionExistSameColor = isWantedPositionIsNotSameColor(wantedPositionExistPiece); + + if(!isWantedPositionExistSameColor){ + throw new InvalidMoveException(); + } + for(Movement movement : movements){ + var temporalPosition = moveWhenPossible(movement); + if(temporalPosition.equals(wantedPosition)){ + position = temporalPosition; + return; + } + } + throw new InvalidMoveException(); + } + + private boolean isWantedPositionIsNotSameColor(List wantedPositionExistPiece) { + if(wantedPositionExistPiece.isEmpty()){ + return true; + } + + Piece first = wantedPositionExistPiece.getFirst(); + return this.isOpposite(first); + } + + private Position moveWhenPossible(Movement movement) { + var temporalPosition = position; + if(temporalPosition.canMove(movement)){ + return temporalPosition.move(movement); + } + return position; + } + + @Override + public Position getPosition() { + return position; + } + + @Override + public boolean isOpposite(Piece piece) { + Color oppositeColor = this.color.opposite(); + return oppositeColor.equals(piece.getColor()); + } + + @Override + public Color getColor() { + return color; + } + + @Override + public boolean isSamePosition(Piece otherPiece) { + return otherPiece.getPosition().equals(position); + } + + public PieceType pieceType() { + return pieceType; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + King king = (King) o; + return Objects.equals(position, king.position) && color == king.color; + } + + @Override + public int hashCode() { + return Objects.hash(position, color); + } } diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java index 2ee7c47a3b..5dd1433548 100644 --- a/src/main/java/chess/piece/Knight.java +++ b/src/main/java/chess/piece/Knight.java @@ -1,5 +1,102 @@ package chess.piece; -public class Knight { +import chess.Color; +import chess.Movement; +import chess.Position; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Objects; +public class Knight implements Piece{ + + private Position position; + private static final List movements = List.of( + Movement.DOWN_DOWN_LEFT, Movement.DOWN_DOWN_RIGHT, + Movement.RIGHT_RIGHT_DOWN, Movement.RIGHT_RIGHT_UP, + Movement.LEFT_LEFT_DOWN, Movement.LEFT_LEFT_UP, + Movement.UP_UP_LEFT, Movement.UP_UP_RIGHT + ); + private final Color color; + private final PieceType pieceType; + + public Knight(Position position, Color color) { + this.position = position; + this.color = color; + this.pieceType = PieceType.KNIGHT; + } + + @Override + public void move(Position wantedPosition, List wantedPositionExistPiece) { + boolean isWantedPositionExistSameColor = isWantedPositionIsNotSameColor(wantedPositionExistPiece); + if(!isWantedPositionExistSameColor){ + throw new InvalidMoveException(); + } + for(Movement movement : movements){ + var temporalPosition = moveWhenPossible(movement); + if(temporalPosition.equals(wantedPosition)){ + position = temporalPosition; + return; + } + } + throw new InvalidMoveException(); + } + + private Position moveWhenPossible(Movement movement) { + var temporalPosition = position; + if(temporalPosition.canMove(movement)){ + return temporalPosition.move(movement); + } + return position; + } + + private boolean isWantedPositionIsNotSameColor(List wantedPositionExistPiece) { + if(wantedPositionExistPiece.isEmpty()){ + return true; + } + + Piece first = wantedPositionExistPiece.getLast(); + return this.isOpposite(first); + } + + @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; + } + Knight knight = (Knight) o; + return Objects.equals(position, knight.position) && color == knight.color; + } + + @Override + public int hashCode() { + return Objects.hash(position, color); + } } diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index c8b6cafa51..400aab47b7 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -1,5 +1,127 @@ package chess.piece; -public class Pawn { +import chess.Color; +import chess.Movement; +import chess.Position; +import chess.Row; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Objects; +public class Pawn implements Piece{ + + private static final int START_MOVE_WEIGHT = 2; + private static final int NOT_START_MOVE_WEIGHT = 1; + private static final Movement BLACK_MOVEMENT = Movement.DOWN; + private static final List BLACK_ATTACK_MOVEMENTS = List.of(Movement.LEFT_DOWN,Movement.RIGHT_DOWN); + private static final Movement WHITE_MOVEMENT = Movement.UP; + private static final List WHITE_ATTACK_MOVEMENTS = List.of(Movement.LEFT_UP,Movement.RIGHT_UP); + + private final Row startRow; + private final Movement onlyMoveMovement; + private final List attackMovement; + private final Color color; + private final PieceType pieceType; + private Position position; + + + public Pawn(Position position, Color color) { + this.color = color; + this.position = position; + startRow = position.row(); + pieceType = PieceType.PAWN; + if(color == Color.BLACK){ + onlyMoveMovement = BLACK_MOVEMENT; + attackMovement = BLACK_ATTACK_MOVEMENTS; + return; + } + onlyMoveMovement = WHITE_MOVEMENT; + attackMovement = WHITE_ATTACK_MOVEMENTS; + } + + private Position attackMove(Piece wantedPositionExistPiece, Position wantedPosition) { + for(Movement movement : attackMovement){ + var temporalPosition = moveWhenPossible(movement); + if(temporalPosition.equals(wantedPositionExistPiece.getPosition()) && wantedPositionExistPiece.isOpposite(this)){ + return wantedPosition; + } + } + throw new InvalidMoveException(); + } + + private Position moveWhenPossible(Movement movement) { + if(position.canMove(movement)){ + return position.move(movement); + } + return position; + } + + private Position onlyMove(int startMoveWeight, Position wantedPosition) { + Position temporalPosition = position; + for (int i = 0; i < startMoveWeight; i++) { + temporalPosition = temporalPosition.move(onlyMoveMovement); + if(temporalPosition.equals(wantedPosition)){ + return temporalPosition; + } + } + throw new InvalidMoveException(); + } + + @Override + public void move(Position wantedPosition, List wantedPositionExistPiece) { + if(!wantedPositionExistPiece.isEmpty()){ + this.position = attackMove(wantedPositionExistPiece.getFirst(),wantedPosition); + return; + } + if(isPawnStartMove()){ + this.position = onlyMove(START_MOVE_WEIGHT,wantedPosition); + return; + } + this.position = onlyMove(NOT_START_MOVE_WEIGHT,wantedPosition); + } + + private boolean isPawnStartMove() { + return startRow.equals(position.row()); + } + + public boolean isOpposite(Piece piece) { + return color.opposite() == piece.getColor(); + } + + public Color getColor() { + return color; + } + + public Position getPosition() { + return position; + } + + @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; + } + Pawn pawn = (Pawn) o; + return startRow == pawn.startRow && onlyMoveMovement == pawn.onlyMoveMovement && Objects.equals( + attackMovement, pawn.attackMovement) && color == pawn.color && Objects.equals(position, + pawn.position); + } + + @Override + public int hashCode() { + return Objects.hash(startRow, onlyMoveMovement, attackMovement, color, position); + } } diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java new file mode 100644 index 0000000000..c7bbd77422 --- /dev/null +++ b/src/main/java/chess/piece/Piece.java @@ -0,0 +1,17 @@ +package chess.piece; + +import chess.Color; +import chess.Position; +import java.util.List; +import java.util.Optional; + +public interface Piece { + void move(Position wantedPosition, List wantedPositionExistPiece); + Position getPosition(); + boolean isOpposite(Piece piece); + Color getColor(); + + boolean isSamePosition(Piece otherPiece); + + PieceType pieceType(); +} diff --git a/src/main/java/chess/piece/PieceType.java b/src/main/java/chess/piece/PieceType.java new file mode 100644 index 0000000000..e33e234b05 --- /dev/null +++ b/src/main/java/chess/piece/PieceType.java @@ -0,0 +1,20 @@ +package chess.piece; + +public enum PieceType { + BISHOP("숍"), + KING("킹"), + KNIGHT("말"), + PAWN("폰"), + QUEEN("퀸"), + ROOK("룩"); + + final String type; + + PieceType(String type) { + this.type = type; + } + + public String getType() { + return type; + } +} diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java index 9b547261c4..65da1d27dd 100644 --- a/src/main/java/chess/piece/Queen.java +++ b/src/main/java/chess/piece/Queen.java @@ -1,5 +1,119 @@ package chess.piece; -public class Queen { +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 Queen implements Piece{ + + private Position position; + private final Color color; + private static final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT, + Movement.RIGHT_UP,Movement.RIGHT_DOWN,Movement.LEFT_UP,Movement.LEFT_DOWN); + private final PieceType pieceType; + + public Queen(Position position, Color color) { + this.position = position; + this.color = color; + pieceType = PieceType.QUEEN; + } + + public void move(Position wantedPosition, List 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 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 wantedPositionExistPiece, Position temporalPosition) { + Optional otherPieceByPosition = findOtherPieceByPosition(temporalPosition, wantedPositionExistPiece); + if(otherPieceByPosition.isEmpty()){ + return true; + } + return isOpposite(otherPieceByPosition.get()); + } + + private Optional findOtherPieceByPosition(Position temporalPosition, List wantedPositionExistPiece) { + for(Piece piece : wantedPositionExistPiece){ + if(piece.getPosition().equals(temporalPosition)){ + return Optional.of(piece); + } + } + return Optional.empty(); + } + + private boolean isSamePositionPieceExist(List wantedPositionExistPiece, Position temporalPosition) { + for(Piece piece : wantedPositionExistPiece){ + if(piece.getPosition().equals(temporalPosition)){ + return true; + } + } + return false; + } + + + @Override + public Position getPosition() { + return position; + } + + 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; + } + Queen queen = (Queen) o; + return Objects.equals(position, queen.position) && color == queen.color; + } + + @Override + public int hashCode() { + return Objects.hash(position, color); + } } diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java index 7ed4d08bf0..8354e1caf0 100644 --- a/src/main/java/chess/piece/Rook.java +++ b/src/main/java/chess/piece/Rook.java @@ -1,5 +1,117 @@ package chess.piece; -public class Rook { +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 Rook implements Piece{ + + private Position position; + private final Color color; + private static final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); + private final PieceType pieceType; + + public Rook(Position position, Color color) { + this.position = position; + this.color = color; + pieceType = PieceType.ROOK; + } + + public void move(Position wantedPosition, List 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 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 wantedPositionExistPiece, Position temporalPosition) { + Optional otherPieceByPosition = findOtherPieceByPosition(temporalPosition, wantedPositionExistPiece); + if(otherPieceByPosition.isEmpty()){ + return true; + } + return isOpposite(otherPieceByPosition.get()); + } + + private Optional findOtherPieceByPosition(Position temporalPosition, List wantedPositionExistPiece) { + for(Piece piece : wantedPositionExistPiece){ + if(piece.getPosition().equals(temporalPosition)){ + return Optional.of(piece); + } + } + return Optional.empty(); + } + + private boolean isSamePositionPieceExist(List wantedPositionExistPiece, Position temporalPosition) { + for(Piece piece : wantedPositionExistPiece){ + if(isSamePosition(piece)){ + return true; + } + } + return false; + } + + @Override + public Position getPosition() { + return position; + } + + 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; + } + Rook rook = (Rook) o; + return Objects.equals(position, rook.position) && color == rook.color; + } + + @Override + public int hashCode() { + return Objects.hash(position, color); + } } diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java new file mode 100644 index 0000000000..b6d3ba7284 --- /dev/null +++ b/src/main/java/chess/view/InputView.java @@ -0,0 +1,9 @@ +package chess.view; + +import chess.piece.Piece; +import java.util.List; + +public class InputView { + public void showPieces(List pieces) { + } +} diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java new file mode 100644 index 0000000000..9d438407e1 --- /dev/null +++ b/src/main/java/chess/view/OutputView.java @@ -0,0 +1,29 @@ +package chess.view; + +import chess.Column; +import chess.Position; +import chess.Row; +import chess.piece.Piece; +import java.util.Map; + +public class OutputView { + public void showPieces(Piece piece) { + if(piece == null){ + System.out.print(" "); + return; + } + System.out.print(piece.pieceType().getType()); + } + + public void printChessMap(Map positionPieceMap) { + for(Row row : Row.values()){ + for(Column column : Column.values()){ + Position position = new Position(row, column); + Piece piece = positionPieceMap.get(position); + showPieces(piece); + } + System.out.println(); + } + + } +} diff --git a/src/test/java/chess/ChessGameTest.java b/src/test/java/chess/ChessGameTest.java new file mode 100644 index 0000000000..91f86f8f1f --- /dev/null +++ b/src/test/java/chess/ChessGameTest.java @@ -0,0 +1,46 @@ +package chess; + +import chess.piece.King; +import chess.piece.Pawn; +import chess.piece.Piece; +import java.util.List; +import java.util.Optional; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class ChessGameTest { + + @Test + void 왕이_죽었는지_확인할_수_있다(){ + List pieces = List.of(new King(new Position(Row.FOUR, Column.C),Color.WHITE)); + ChessGame chessGame = new ChessGame(pieces); + Assertions.assertThat(chessGame.isSomeBodyKingDoesntExist()).isTrue(); + } + + @Test + void 왕이_없는_팀이_누군지_알수_있다(){ + List pieces = List.of(new King(new Position(Row.FOUR, Column.C), Color.WHITE)); + ChessGame chessGame = new ChessGame(pieces); + Assertions.assertThat(chessGame.getLoseColor()).isEqualTo(Color.BLACK); + } + + @Test + void 기물이_같은_위치에있으면_죽는_기물을_제거한다(){ + Piece movePiece = new Pawn(Fixtures.A1,Color.WHITE); + Piece deadPiece = new Pawn(Fixtures.A1,Color.BLACK); + List pieces = List.of(movePiece,deadPiece); + ChessGame chessGame = new ChessGame(pieces); + Optional resultDeadPiece = chessGame.killPieceWhenExistSamePositionPiece(movePiece); + Assertions.assertThat(resultDeadPiece.get()).isEqualTo(deadPiece); + } + + @Test + void 주근_기물이_없으면_제거하지_않는다(){ + Piece movePiece = new Pawn(Fixtures.A1,Color.WHITE); + Piece deadPiece = new Pawn(Fixtures.A2,Color.BLACK); + List pieces = List.of(movePiece,deadPiece); + ChessGame chessGame = new ChessGame(pieces); + Optional resultDeadPiece = chessGame.killPieceWhenExistSamePositionPiece(movePiece); + Assertions.assertThat(resultDeadPiece.isEmpty()).isTrue(); + } +} diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java new file mode 100644 index 0000000000..022edf5144 --- /dev/null +++ b/src/test/java/chess/piece/BishopTest.java @@ -0,0 +1,60 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Optional; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class BishopTest { + + @Test + void 비숍은_대각선으로_이동할수_있다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + bishop.move(Fixtures.D2,List.of()); + Assertions.assertThat(bishop.getPosition()).isEqualTo(Fixtures.D2); + } + + @Test + void 비숍은_이동할려는위치_이전에_다른_기물이_있으면_이동할수_없다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + Bishop enemy = new Bishop(Fixtures.D2,Color.WHITE); + Bishop enemy2 = new Bishop(Fixtures.E3,Color.BLACK); + + Assertions.assertThatThrownBy(() -> bishop.move(Fixtures.E3,List.of(enemy,enemy2))).isInstanceOf(InvalidMoveException.class); + } + + @Test + void 비숍은_직선으로_이동할수_없다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + Assertions.assertThatThrownBy(() -> bishop.move(Fixtures.C2,List.of())) + .isInstanceOf(InvalidMoveException.class); + } + + @Test + void 비숍은_적팀이_있는_대각선으로_이동할수_있다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + bishop.move(Fixtures.D2,List.of()); + Assertions.assertThat(bishop.getPosition()).isEqualTo(Fixtures.D2); + } + + @Test + void 같은팀이_있는곳으로는_이동할수_없다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + Pawn sameColorTeam = new Pawn(Fixtures.D2,Color.WHITE); + Assertions.assertThatThrownBy(() -> bishop.move(Fixtures.D2, List.of(sameColorTeam))).isInstanceOf( + InvalidMoveException.class); + } + + @Test + void 적팀이_있는곳으로는_이동할수_있다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.D2,Color.BLACK); + bishop.move(Fixtures.D2,List.of(enemy)); + Assertions.assertThat(bishop.getPosition()).isEqualTo(Fixtures.D2); + } +} + + diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/piece/KingTest.java new file mode 100644 index 0000000000..648223b35a --- /dev/null +++ b/src/test/java/chess/piece/KingTest.java @@ -0,0 +1,54 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.exception.InvalidMoveException; +import java.util.List; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class KingTest { + + @Test + void 킹은_위로_한칸_이동할수_있다(){ + King king = new King(Fixtures.A2,Color.WHITE); + king.move(Fixtures.A3, List.of()); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.A3); + } + + @Test + void 킹은_오른쪽으로_한칸_이동할수_있다(){ + King king = new King(Fixtures.A2,Color.WHITE); + king.move(Fixtures.B2, List.of()); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.B2); + } + + @Test + void 킹은_왼쪽_한칸_이동할수_있다(){ + King king = new King(Fixtures.B2,Color.WHITE); + king.move(Fixtures.A2, List.of()); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.A2); + } + + @Test + void 킹은_아래로_한칸_이동할수_있다(){ + King king = new King(Fixtures.D2,Color.WHITE); + king.move(Fixtures.D1, List.of()); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.D1); + } + + @Test + void 킹은_적팀이_있으면_잡을수_있다(){ + King king = new King(Fixtures.A2,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.A3,Color.BLACK); + king.move(Fixtures.A3, List.of(enemy)); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.A3); + } + + @Test + void 킹은_같은팀이_있는곳으로_이동할_수_없다(){ + King king = new King(Fixtures.A2,Color.WHITE); + Pawn sameTeam = new Pawn(Fixtures.A3,Color.WHITE); + Assertions.assertThatThrownBy(() -> king.move(Fixtures.A3,List.of(sameTeam))).isInstanceOf(InvalidMoveException.class); + } +} diff --git a/src/test/java/chess/piece/KnightTest.java b/src/test/java/chess/piece/KnightTest.java new file mode 100644 index 0000000000..527cb54a9f --- /dev/null +++ b/src/test/java/chess/piece/KnightTest.java @@ -0,0 +1,92 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.exception.InvalidMoveException; +import java.util.List; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class KnightTest { + + @Test + void 말은_왼쪽_두칸_위_한칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.B5,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.B5); + } + + @Test + void 말은_왼쪽_한칸_위_두칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.C6,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.C6); + } + + @Test + void 말은_오른쪽_한칸_위_두칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.E6,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.E6); + } + + @Test + void 말은_오른쪽_두칸_위_한칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.F5,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.F5); + } + + @Test + void 말은_오른쪽_두칸_아래_한칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.E2,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.E2); + } + + @Test + void 말은_오른쪽_한칸_아래_두칸_으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.E2,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.E2); + } + + @Test + void 말은_아래_한칸_왼쪽_두칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.B3,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.B3); + } + + @Test + void 말은_아래_두칸_왼쪽_한칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.C2,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.C2); + } + + @Test + void 말은_직선으로_이동할수_없다(){ + Knight knight = new Knight(Fixtures.C1,Color.WHITE); + Assertions.assertThatThrownBy(() -> knight.move (Fixtures.C2,List.of())) + .isInstanceOf(InvalidMoveException.class); + } + + @Test + void 같은팀이_있는곳으로는_이동할수_없다(){ + Knight knight = new Knight(Fixtures.C1,Color.WHITE); + Pawn sameColorTeam = new Pawn(Fixtures.D2,Color.WHITE); + Assertions.assertThatThrownBy(() -> knight.move (Fixtures.D2, List.of(sameColorTeam))).isInstanceOf( + InvalidMoveException.class); + } + + @Test + void 적팀_있는곳으로는_이동할수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.E6,Color.BLACK); + knight.move(Fixtures.E6,List.of(enemy)); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.E6); + } +} + + diff --git a/src/test/java/chess/piece/PawnTest.java b/src/test/java/chess/piece/PawnTest.java new file mode 100644 index 0000000000..26c88d2d58 --- /dev/null +++ b/src/test/java/chess/piece/PawnTest.java @@ -0,0 +1,63 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.Position; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Optional; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class PawnTest { + + @Test + void 백_폰은_처음_위치에서_두칸_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A2, Color.WHITE); + pawn.move(Fixtures.A4, List.of()); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.A4); + } + + @Test + void 백_폰은_처음_위치에서_한칸_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A2, Color.WHITE); + pawn.move(Fixtures.A3, List.of()); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.A3); + } + + @Test + void 이동할수_없는곳이면_예외가_발생한다(){ + Pawn pawn = new Pawn(Fixtures.A2, Color.WHITE); + Assertions.assertThatThrownBy(() -> pawn.move(Fixtures.A2,List.of())).isInstanceOf(InvalidMoveException.class); + } + + @Test + void 흑_폰은_처음_위치에서_두칸_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A7, Color.BLACK); + pawn.move(Fixtures.A5, List.of()); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.A5); + } + + @Test + void 흑_폰은_처음_위치에서_한칸_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A7, Color.BLACK); + pawn.move(Fixtures.A6, List.of()); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.A6); + } + + @Test + void 백_폰은_대각선의_흑폰으로_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A2, Color.WHITE); + Pawn enemyPawn = new Pawn(Fixtures.B3, Color.BLACK); + pawn.move(Fixtures.B3,List.of(enemyPawn)); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.B3); + } + + @Test + void 흑_폰은_대각선의_백폰으로_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A7, Color.BLACK); + Pawn enemyPawn = new Pawn(Fixtures.B6, Color.WHITE); + pawn.move(Fixtures.B3,List.of(enemyPawn)); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.B3); + } +} diff --git a/src/test/java/chess/piece/QueenTest.java b/src/test/java/chess/piece/QueenTest.java new file mode 100644 index 0000000000..c167ef3e17 --- /dev/null +++ b/src/test/java/chess/piece/QueenTest.java @@ -0,0 +1,95 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.exception.InvalidMoveException; +import java.util.List; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class QueenTest { + + @Test + void 퀸은_왼쪽으로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.B2,Color.WHITE); + queen.move(Fixtures.A2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.A2); + } + + @Test + void 퀸은_오른쪽으로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.C2,Color.WHITE); + queen.move(Fixtures.D2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.D2); + } + + @Test + void 퀸은_아래로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.C2,Color.WHITE); + queen.move(Fixtures.C1, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.C1); + } + + @Test + void 퀸은_위로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.C1,Color.WHITE); + queen.move(Fixtures.C2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.C2); + } + + @Test + void 퀸은_오른쪽_위로_이동할수_있다(){ + Queen queen = new Queen(Fixtures.C1,Color.WHITE); + queen.move(Fixtures.D2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.D2); + } + + @Test + void 퀸은_왼쪽_위로_이동할수_있다(){ + Queen queen = new Queen(Fixtures.C1,Color.WHITE); + queen.move(Fixtures.B2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.B2); + } + + @Test + void 퀸은_오른쪽_아래로_이동할수_있다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + queen.move(Fixtures.F2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.F2); + } + + @Test + void 퀸은_왼쪽_아래로_이동할수_있다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + queen.move(Fixtures.A1, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.A1); + } + + @Test + void 퀸은_이동할려는위치_이전에_다른_기물이_있으면_이동할수_없다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + Bishop enemy = new Bishop(Fixtures.C3,Color.WHITE); + Bishop enemy2 = new Bishop(Fixtures.B2,Color.BLACK); + + Assertions.assertThatThrownBy(() -> queen.move(Fixtures.A1, List.of(enemy,enemy2))) + .isInstanceOf(InvalidMoveException.class); + } + + @Test + void 퀸은_같은팀이_있는곳으로_이동할_수_없다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + Pawn sameTeam = new Pawn(Fixtures.D5,Color.WHITE); + Assertions.assertThatThrownBy(() -> queen.move(Fixtures.D5,List.of(sameTeam))).isInstanceOf(InvalidMoveException.class); + } + + @Test + void 퀸은_다른팀이_있는곳으로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.D5,Color.BLACK); + queen.move(Fixtures.D5,List.of(enemy)); + + Assertions.assertThat(enemy.getPosition()).isEqualTo(Fixtures.D5); + } +} + + diff --git a/src/test/java/chess/piece/RookTest.java b/src/test/java/chess/piece/RookTest.java new file mode 100644 index 0000000000..1bd1df187b --- /dev/null +++ b/src/test/java/chess/piece/RookTest.java @@ -0,0 +1,66 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.Row; +import chess.exception.InvalidMoveException; +import java.util.List; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class RookTest { + + @Test + void 룩은_위로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.A2,Color.WHITE); + rook.move(Fixtures.A3, List.of()); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.A3); + } + + @Test + void 룩은_오른쪽으로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.A2,Color.WHITE); + rook.move(Fixtures.B2, List.of()); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.B2); + } + + @Test + void 룩은_아래로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.B2,Color.WHITE); + rook.move(Fixtures.B1, List.of()); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.B1); + } + + @Test + void 룩은_왼쪽으로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.B2,Color.WHITE); + rook.move(Fixtures.A2, List.of()); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.A2); + } + + @Test + void 룩은_이동할려는위치_이전에_다른_기물이_있으면_이동할수_없다(){ + Rook rook = new Rook(Fixtures.A1,Color.WHITE); + Bishop enemy = new Bishop(Fixtures.B1,Color.WHITE); + Bishop enemy2 = new Bishop(Fixtures.C1,Color.BLACK); + + Assertions.assertThatThrownBy(() -> rook.move(Fixtures.E3,List.of(enemy,enemy2))).isInstanceOf(InvalidMoveException.class); + } + + @Test + void 룩은_같은팀이_있는곳으로_이동할_수_없다(){ + Rook rook = new Rook(Fixtures.A2,Color.WHITE); + Pawn sameTeam = new Pawn(Fixtures.A3,Color.WHITE); + Assertions.assertThatThrownBy(() -> rook.move(Fixtures.A3,List.of(sameTeam))).isInstanceOf(InvalidMoveException.class); + } + + @Test + void 룩은_다른팀이_있는곳으로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.A2,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.A3,Color.BLACK); + rook.move(Fixtures.A3, List.of(enemy)); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.A3); + } +} + +