diff --git a/README.md b/README.md index 4a9cf0f..baa82f2 100644 --- a/README.md +++ b/README.md @@ -1 +1,45 @@ # java-chess 게임 + +- [x] 체스판 + - [x]rank(세로) : 8 :1~8 + - [x]file(가로) : 8 :a~h + - [x] 말이 없는 칸은 . + - [x]초기화 + - [x] 기물 이동기능 + +- [x] 아웃풋 뷰 + - [x] 체스판 출력 기능 + - [x] 'start' 입력 시 체스판 초기화 하고 출력 + - [x] 게임 진행시 마다 체스판을 출력해준다 + - [x] 게임 시작 설명 출력 + +-[x] 인풋 뷰 + - [x] 게임 명령어 인풋 받기 + - [x] start/end/move로 시작하지 않으면 계속 묻기 + + +- [x] 기물 +- [x] 말을 넘어갈 수 없음(나이트 제외) + - [x] king + - [x] 상하좌우 중 1칸 이동범위 체크 + - [x] queen + - [x] 상하좌우 대각선 n칸 이동범위 체크 + - [x] bishop + - [x] 대각선으로 n칸 이동범위 체크 + - [x] knight + - [x] 사방중 한방향으로 한칸 & 양 대각선 중 한 방향으로 한칸 으로 이동범위 체크 + - [x] 상대 말 넘어감 + - [x] rook + - [x] 상하좌우 n칸 이동 + - [x] pawn + - [x] 첫회 한정: 2칸 상 이동 || 1칸 상 이동 + - [x] 1칸 이동 + - [x] 공격은 대각선으로만 + +- [x] 진영 + - [x] 기물 2 세트 생성 (1개는 대문자, 소문자) + +- [] 체스 게임 룰 + - [x] start : 체스판 초기화 및 진영 세팅 + - [x] end: 게임 종료 + - [] 킹을 잡으면 게임이 종료된다 \ No newline at end of file diff --git a/build.gradle b/build.gradle index d41dd5b..3cb6e48 100644 --- a/build.gradle +++ b/build.gradle @@ -18,4 +18,13 @@ dependencies { testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.1' testCompile "org.assertj:assertj-core:3.14.0" + //lombok + compileOnly 'org.projectlombok:lombok:1.18.20' + annotationProcessor 'org.projectlombok:lombok:1.18.20' + testCompileOnly 'org.projectlombok:lombok:1.18.20' + testAnnotationProcessor 'org.projectlombok:lombok:1.18.20' +} + +test { + useJUnitPlatform() } diff --git a/src/main/java/chess/ChessApplication.java b/src/main/java/chess/ChessApplication.java new file mode 100644 index 0000000..05854ee --- /dev/null +++ b/src/main/java/chess/ChessApplication.java @@ -0,0 +1,14 @@ +package chess; + +import chess.controller.ChessController; +import chess.domain.plate.ChessPlate; +import chess.view.OutputView; + +public class ChessApplication { + + public static void main(String[] args) { + ChessController chessController = new ChessController(); + chessController.play(); + } +} + diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java new file mode 100644 index 0000000..29b4235 --- /dev/null +++ b/src/main/java/chess/controller/ChessController.java @@ -0,0 +1,77 @@ +package chess.controller; + +import chess.domain.piece.Team; +import chess.domain.plate.ChessPlate; +import chess.service.ChessService; +import chess.view.InputView; +import chess.view.OutputView; + +public class ChessController { + private static final OutputView outputView = new OutputView(); + private static final InputView inputView = new InputView(); + public static final String START = "start"; + public static final String END = "end"; + public static final String MOVE = "move"; + public static final String STATUS = "status"; + + public void play() { + ChessService chessService = new ChessService(); + outputView.initPrint(); + String command = START; + while (!command.equals(END)){ + command = getUserCommand(); + checkCommadMessage(chessService, command); + gameOverIfKingDead(chessService); + } + } + + private void checkCommadMessage(ChessService chessService, String command) { + if(command.equals(START)){ + ChessPlate chessplate = chessService.start(); + outputView.printChessPlate(chessplate); + } + + if(command.startsWith(MOVE)) { + String[] position = command.split(" "); + boolean isMoved = chessService.move(position[1],position[2]); + if(isMoved) { + outputView.printChessPlate(chessService.getChessPlate()); + }else { + outputView.printCannotMoveMessage(); + } + } + + if(command.equals(STATUS)) { + printResult(chessService); + } + + } + + private static String getUserCommand() { + String command = inputView.getUserCommand(); + while(!(command.startsWith(START) || command.equals(END) || command.startsWith(MOVE) || command.equals(STATUS))){ + outputView.printInCorrectCommandMessage(); + command = inputView.getUserCommand(); + } + return command; + } + + private void printResult(ChessService chessService) { + double blackScore = chessService.getGameScore(Team.BLACK); + double whiteScore = chessService.getGameScore(Team.WHITE); + + outputView.printScoresOfTwoTeams(blackScore, whiteScore); + outputView.printWinner(blackScore, whiteScore); + } + + private void gameOverIfKingDead(ChessService chessService) { + if(chessService.isKingDead(Team.BLACK)) { + outputView.printBlackKingDeadMessage(); + System.exit(0); + } + if(chessService.isKingDead(Team.WHITE)) { + outputView.printWhiteKingDeadMessage(); + System.exit(0); + } + } +} diff --git a/src/main/java/chess/domain/PicesPositionComparator.java b/src/main/java/chess/domain/PicesPositionComparator.java new file mode 100644 index 0000000..94abe97 --- /dev/null +++ b/src/main/java/chess/domain/PicesPositionComparator.java @@ -0,0 +1,26 @@ +package chess.domain; + +import chess.domain.piece.PiecePosition; +import chess.domain.piece.Rank; + +import java.util.Comparator; + +public class PicesPositionComparator implements Comparator { + + @Override + public int compare(Object o1, Object o2) { + if(o1 instanceof PiecePosition && o2 instanceof PiecePosition) { + PiecePosition p1 = (PiecePosition) o1; + PiecePosition p2 = (PiecePosition) o2; + + int pvalue1 = p1.getRank().getRankPosition(); + int pvalue2 = p2.getRank().getRankPosition(); + + if(pvalue1 == pvalue2) { + return p1.getFile().getFilePosition() - p2.getFile().getFilePosition(); + } + return pvalue1 - pvalue2; + } + return 0; + } +} diff --git a/src/main/java/chess/domain/RankComparator.java b/src/main/java/chess/domain/RankComparator.java new file mode 100644 index 0000000..e31c993 --- /dev/null +++ b/src/main/java/chess/domain/RankComparator.java @@ -0,0 +1,19 @@ +package chess.domain; + +import chess.domain.piece.Rank; + +import java.util.Comparator; + +public class RankComparator implements Comparator { + + @Override + public int compare(Object o1, Object o2) { + if(o1 instanceof Rank && o2 instanceof Rank) { + Rank r1 = (Rank) o1; + Rank r2 = (Rank) o2; + + return r2.getRankPosition() - r1.getRankPosition(); + } + return 0; + } +} diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java new file mode 100644 index 0000000..2b44830 --- /dev/null +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -0,0 +1,21 @@ +package chess.domain.piece; + +import lombok.Getter; + +@Getter +public class Bishop extends Piece { + public Bishop(Team team, PiecePosition piecePosition) { + super("B", team, piecePosition,3); + } + + @Override + public boolean movable(PiecePosition targetPosition) { + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + return (fileGap == rankGap); + } +} diff --git a/src/main/java/chess/domain/piece/File.java b/src/main/java/chess/domain/piece/File.java new file mode 100644 index 0000000..1fa68bd --- /dev/null +++ b/src/main/java/chess/domain/piece/File.java @@ -0,0 +1,39 @@ +package chess.domain.piece; + +import lombok.Getter; + +import java.util.Arrays; + +@Getter +public enum File { + A("a", 1), + B("b", 2), + C("c", 3), + D("d", 4), + E("e", 5), + F("f", 6), + G("g", 7), + H("h", 8); + + private String fileMarker; + private int filePosition; + + File(String fileMarker, int filePosition) { + this.fileMarker = fileMarker; + this.filePosition = filePosition; + } + + public static File findBy(String fileMarker) { + return Arrays.stream(File.values()) + .filter(v -> v.fileMarker.equals(fileMarker)) + .findFirst() + .orElseThrow(() -> new IllegalAccessError("해당되는 위치가 없습니다.")); + } + + public static File findBy(int filePosition) { + return Arrays.stream(File.values()) + .filter(v -> v.filePosition==filePosition) + .findFirst() + .orElseThrow(() -> new IllegalAccessError("해당되는 위치가 없습니다.")); + } +} diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java new file mode 100644 index 0000000..379d556 --- /dev/null +++ b/src/main/java/chess/domain/piece/King.java @@ -0,0 +1,19 @@ +package chess.domain.piece; + +public class King extends Piece { + public King(Team team, PiecePosition piecePosition) { + super("K", team, piecePosition, 0); + } + + @Override + public boolean movable(PiecePosition targetPosition) { + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + //상하좌우 한칸씩 + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + return fileGap + rankGap == 1; + } +} diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java new file mode 100644 index 0000000..6e07215 --- /dev/null +++ b/src/main/java/chess/domain/piece/Knight.java @@ -0,0 +1,22 @@ +package chess.domain.piece; + +import lombok.Getter; + +@Getter +public class Knight extends Piece { + public Knight(Team team, PiecePosition piecePosition) { + super("N", team, piecePosition, 2.5); + } + + @Override + public boolean movable(PiecePosition targetPosition) { + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + //상하좌우 한칸씩 + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + return (fileGap + rankGap == 3) && (fileGap == 1 || rankGap == 1); + } +} diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java new file mode 100644 index 0000000..3ff99bc --- /dev/null +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -0,0 +1,39 @@ +package chess.domain.piece; + +import lombok.Getter; + +@Getter +public class Pawn extends Piece { + public Pawn(Team team, PiecePosition piecePosition) { + super("P", team, piecePosition,1); + } + + @Override + public boolean movable(PiecePosition targetPosition) { + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + //처음 두칸 + if (checkFirstMove()) { + if (this.getTeam().equals(Team.BLACK)) { + return ((originFile == targetFile) && (originRank - targetRank <= 2)) + || canMoveDiagonalAndOneBlock(originFile, originRank, targetFile, targetRank); + } + if (this.getTeam().equals(Team.WHITE)) { + return (originFile == targetFile) && (originRank - targetRank >= -2) + || canMoveDiagonalAndOneBlock(originFile, originRank, targetFile, targetRank); + } + } + //한칸 + return canMoveDiagonalAndOneBlock(originFile, originRank, targetFile, targetRank); + } + + private boolean canMoveDiagonalAndOneBlock(int originFile, int originRank, int targetFile, int targetRank) { + return (originRank - targetRank == 1*this.getTeam().getPawnDirection()) && Math.abs(originFile - targetFile) <= 1; + } + + private boolean checkFirstMove() { + return this.getPiecePosition().getRank().equals(this.getTeam().getPawnInitRank()); + } +} diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java new file mode 100644 index 0000000..2cbd2b3 --- /dev/null +++ b/src/main/java/chess/domain/piece/Piece.java @@ -0,0 +1,27 @@ +package chess.domain.piece; + +import lombok.Getter; + +@Getter +public abstract class Piece { + protected String name; + protected Team team; + protected PiecePosition piecePosition; + protected String displayName; + protected double score; + + public Piece(String name, Team team, PiecePosition piecePosition, double score) { + this.name = name; + this.team = team; + this.displayName = team.displayName(name); + this.piecePosition = piecePosition; + this.score = score; + } + + public abstract boolean movable(PiecePosition targetPosition); + + public void move(PiecePosition targetPosition){ + piecePosition = targetPosition; + } + +} diff --git a/src/main/java/chess/domain/piece/PiecePosition.java b/src/main/java/chess/domain/piece/PiecePosition.java new file mode 100644 index 0000000..c509f91 --- /dev/null +++ b/src/main/java/chess/domain/piece/PiecePosition.java @@ -0,0 +1,31 @@ +package chess.domain.piece; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +import java.util.Objects; + +@Getter +@RequiredArgsConstructor +public class PiecePosition { + private final File file; + private final Rank rank; + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof PiecePosition)) { + return false; + } + PiecePosition that = (PiecePosition) o; + return getFile() == that.getFile() && + getRank() == that.getRank(); + } + + @Override + public int hashCode() { + return Objects.hash(getFile(), getRank()); + } +} diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java new file mode 100644 index 0000000..4429386 --- /dev/null +++ b/src/main/java/chess/domain/piece/Queen.java @@ -0,0 +1,23 @@ +package chess.domain.piece; + +import lombok.Getter; + +@Getter +public class Queen extends Piece { + public Queen(Team team, PiecePosition pieceposition) { + super("Q", team, pieceposition, 9); + } + + @Override + public boolean movable(PiecePosition targetPosition) { + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + return (fileGap == rankGap) || (fileGap == 0 || rankGap == 0); + } + + +} diff --git a/src/main/java/chess/domain/piece/Rank.java b/src/main/java/chess/domain/piece/Rank.java new file mode 100644 index 0000000..cde096a --- /dev/null +++ b/src/main/java/chess/domain/piece/Rank.java @@ -0,0 +1,37 @@ +package chess.domain.piece; + +import lombok.Getter; + +import java.util.Arrays; + +@Getter +public enum Rank { + ONE(1), + TWO(2), + THREE(3), + FOUR(4), + FIVE(5), + SIX(6), + SEVEN(7), + EIGHT(8); + + private int rankPosition; + + Rank(int rankPosition) { + this.rankPosition = rankPosition; + } + + public static Rank findBy(String rankPosition) { + return Arrays.stream(Rank.values()) + .filter(r -> r.rankPosition == Integer.parseInt(rankPosition)) + .findFirst() + .orElseThrow(()->new IllegalAccessError("해당되는 위치가 없습니다.")); + } + + public static Rank findBy(int rankPosition) { + return Arrays.stream(Rank.values()) + .filter(r -> r.rankPosition == rankPosition) + .findFirst() + .orElseThrow(()->new IllegalAccessError("해당되는 위치가 없습니다.")); + } +} diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java new file mode 100644 index 0000000..e7dad21 --- /dev/null +++ b/src/main/java/chess/domain/piece/Rook.java @@ -0,0 +1,21 @@ +package chess.domain.piece; + +import lombok.Getter; + +@Getter +public class Rook extends Piece { + public Rook(Team team, PiecePosition piecePosition) { + super("R", team, piecePosition, 5); + } + + @Override + public boolean movable(PiecePosition targetPosition) { + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + return fileGap == 0 || rankGap == 0; + } +} diff --git a/src/main/java/chess/domain/piece/Team.java b/src/main/java/chess/domain/piece/Team.java new file mode 100644 index 0000000..44f646b --- /dev/null +++ b/src/main/java/chess/domain/piece/Team.java @@ -0,0 +1,30 @@ +package chess.domain.piece; + +import lombok.Getter; + +@Getter +public enum Team { + BLACK(1, Rank.EIGHT, Rank.SEVEN, 1), + WHITE(2, Rank.ONE, Rank.TWO,-1); + + private int marker; + private Rank piecesInitRank; + private Rank pawnInitRank; + private int pawnDirection; + + Team(int marker, Rank piecesRank, Rank pawnInitRank, int pawnDirection) { + this.marker = marker; + this.piecesInitRank = piecesRank; + this.pawnInitRank = pawnInitRank; + this.pawnDirection = pawnDirection; + } + public String displayName(String name) { + if (this.equals(BLACK)) { + return name.toUpperCase(); + } + if (this.equals(WHITE)) { + return name.toLowerCase(); + } + return name; + } +} diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java new file mode 100644 index 0000000..e666062 --- /dev/null +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -0,0 +1,194 @@ +package chess.domain.plate; + +import chess.domain.piece.*; +import chess.domain.team.Camp; +import lombok.Getter; + +import java.util.*; + +@Getter +public class ChessPlate { + private static final String BLANK = "."; + private Map plate = new HashMap<>(); + private List allPieces = new LinkedList<>(); + + public ChessPlate() { + Camp black = new Camp(Team.BLACK); + Camp white = new Camp(Team.WHITE); + allPieces.addAll(black.getPieces()); + allPieces.addAll(white.getPieces()); + arrangePieces(); + } + + public void arrangePieces() { + for (Rank rank : Rank.values()) { + for (File file : File.values()) { + plate.put(new PiecePosition(file, rank), null); + } + } + allPieces.forEach(piece -> { + plate.put(piece.getPiecePosition(), piece); + }); + } + + public boolean move(PiecePosition sourcePosition, PiecePosition targetPosition) { + //기물별 허용 움직임 범위인지 체크 + Piece sourcePiece = plate.get(sourcePosition); + if (!movable(sourcePosition, targetPosition, sourcePiece)) { + return false; + } + + //이동 위치에 상대 말인지 /내말이 아닐 경우에만 이동한다 + Piece targetPiece = plate.get(targetPosition); + if (targetPiece != null && targetPiece.getTeam().equals(sourcePiece.getTeam())) { + return false; + } + + if (sourcePiece instanceof Pawn) { + // 직선 이동 + if (isStraightMoving(sourcePosition, targetPosition) && targetPiece == null) { + executeMove(sourcePosition, targetPosition, sourcePiece); + return true; + } + + // 대각선 이동 + if (isDiagonalMoving(sourcePosition, targetPosition, sourcePiece, targetPiece)) { + executeMove(sourcePosition, targetPosition, sourcePiece); + return true; + } // end of if + return false; + } + executeMove(sourcePosition, targetPosition, sourcePiece); + return true; + } + + private void executeMove(PiecePosition sourcePosition, PiecePosition targetPosition, Piece sourcePiece) { + plate.remove(sourcePosition); + sourcePiece.move(targetPosition); + plate.put(sourcePiece.getPiecePosition(), sourcePiece); + } + + private boolean isStraightMoving(PiecePosition sourcePosition, PiecePosition targetPosition) { + return sourcePosition.getFile().equals(targetPosition.getFile()) || sourcePosition.getRank().equals(targetPosition.getRank()); + } + + private boolean isDiagonalMoving(PiecePosition sourcePosition, PiecePosition targetPosition, Piece sourcePiece, Piece targetPiece) { + int fileGapAbs = Math.abs(sourcePosition.getFile().getFilePosition() - targetPosition.getFile().getFilePosition()); + int rankGapAbs = Math.abs(sourcePosition.getRank().getRankPosition() - targetPosition.getRank().getRankPosition()); + boolean isTargetEnemy = targetPiece != null && (sourcePiece.getTeam() != targetPiece.getTeam()); + return (fileGapAbs == rankGapAbs) && (isTargetEnemy); + } + + private boolean movable(PiecePosition sourcePosition, PiecePosition targetPosition, Piece piece) { + boolean haveNoPieceOnRoad = !havePieceOnStraightPath(sourcePosition, targetPosition) && !havePieceOnDiagonalPath(sourcePosition, targetPosition); + return piece.movable(targetPosition) && haveNoPieceOnRoad; + } + + public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePosition targetPosition) { + if (plate.get(sourcePosition) instanceof Knight) { + return false; + } + int originFile = sourcePosition.getFile().getFilePosition(); + int originRank = sourcePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + + if (fileGap == 0) { + if (originRank < targetRank) { + for (int i = 1; i < rankGap; i++) { + Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(sourcePosition.getRank().getRankPosition() + i))); + if (piece != null) { + return true; + } + } + } + + if (originRank > targetRank) { + for (int i = 1; i < rankGap; i++) { + Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(sourcePosition.getRank().getRankPosition() - i))); + if (piece != null) { + return true; + } + } + } + } + + if (rankGap == 0) { + if (originFile < targetFile) { + for (int i = 1; i < fileGap; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), sourcePosition.getRank())); + if (piece != null) { + return true; + } + } + } + + if (originFile > targetFile) { + for (int i = 1; i < fileGap; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), sourcePosition.getRank())); + if (piece != null) { + return true; + } + } + } + } + + return false; + } + + public boolean havePieceOnDiagonalPath(PiecePosition sourcePosition, PiecePosition targetPosition) { + if (plate.get(sourcePosition) instanceof Knight) { + return false; + } + int originFile = sourcePosition.getFile().getFilePosition(); + int originRank = sourcePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + + //좌상 + if (fileGap == rankGap && (targetFile < originFile && targetRank > originRank)) { + for (int i = 1; i < rankGap; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); + if (piece != null) { + return true; + } + } + } + + //우상 + if (fileGap == rankGap && (targetFile > originFile && targetRank > originRank)) { + System.out.println("check right up"); + for (int i = 1; i < rankGap; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); + if (piece != null) { + return true; + } + } + } + + //우하 + if (fileGap == rankGap && (targetFile > originFile && targetRank < originRank)) { + for (int i = 1; i < rankGap; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); + if (piece != null) { + return true; + } + } + } + + //좌하 + if (fileGap == rankGap && (targetFile < originFile && targetRank < originRank)) { + for (int i = 1; i < rankGap; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); + if (piece != null) { + return true; + } + } + } + return false; + } +} diff --git a/src/main/java/chess/domain/team/Camp.java b/src/main/java/chess/domain/team/Camp.java new file mode 100644 index 0000000..3937eb6 --- /dev/null +++ b/src/main/java/chess/domain/team/Camp.java @@ -0,0 +1,53 @@ +package chess.domain.team; + +import chess.domain.piece.*; +import lombok.Getter; + +import java.util.LinkedList; +import java.util.List; + +@Getter +public class Camp { + private List pieces = new LinkedList<>(); + private Team team; + + public Camp(Team team) { + this.team = team; + //킹1/퀸1/비숍2/나이트2/룩2/폰8; + createKing(); + createQueen(); + createBishop(); + creatKnight(); + createRook(); + createPawn(); + } + + private void createKing() { + pieces.add(new King(team, new PiecePosition(File.E, team.getPiecesInitRank()))); + } + + private void createQueen() { + pieces.add(new Queen(team, new PiecePosition(File.D, team.getPiecesInitRank()))); + } + + private void createBishop() { + pieces.add(new Bishop(team, new PiecePosition(File.C, team.getPiecesInitRank()))); + pieces.add(new Bishop(team, new PiecePosition(File.F, team.getPiecesInitRank()))); + } + + private void creatKnight() { + pieces.add(new Knight(team, new PiecePosition(File.B, team.getPiecesInitRank()))); + pieces.add(new Knight(team, new PiecePosition(File.G, team.getPiecesInitRank()))); + } + + private void createRook() { + pieces.add(new Rook(team, new PiecePosition(File.A, team.getPiecesInitRank()))); + pieces.add(new Rook(team, new PiecePosition(File.H, team.getPiecesInitRank()))); + } + + private void createPawn() { + for(File file : File.values()) { + pieces.add(new Pawn(team, new PiecePosition(file, team.getPawnInitRank()))); + } + } +} diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java new file mode 100644 index 0000000..65f7de1 --- /dev/null +++ b/src/main/java/chess/service/ChessService.java @@ -0,0 +1,74 @@ +package chess.service; + +import chess.domain.piece.*; +import chess.domain.plate.ChessPlate; +import lombok.Getter; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +@Getter +public class ChessService { + private ChessPlate chessPlate; + public ChessPlate start() { + this.chessPlate = new ChessPlate(); + return chessPlate; + } + + public boolean move(String sourcePosition, String targetPosition) { + String fileString = sourcePosition.substring(0,1); + File sourceFile = File.findBy(fileString); + String rankString = sourcePosition.substring(1); + Rank sourceRank = Rank.findBy(rankString); + + String targetFileString = targetPosition.substring(0,1); + File targetFile = File.findBy(targetFileString); + String targetRankString = targetPosition.substring(1); + Rank targetRank = Rank.findBy(targetRankString); + + PiecePosition sourcePiecePosition = new PiecePosition(sourceFile, sourceRank); + PiecePosition targetPiecePosition = new PiecePosition(targetFile, targetRank); + Piece source = chessPlate.getAllPieces().stream() + .filter(piece -> piece.getPiecePosition().equals(sourcePiecePosition)) + .findFirst() + .orElseThrow(() -> new IllegalArgumentException("해당 위치에 기물이 없습니다")); + + return chessPlate.move(sourcePiecePosition, targetPiecePosition); + } + + public double getGameScore(Team team) { + + return chessPlate.getPlate().values().stream() + .filter(piece -> piece != null) + .filter(piece -> piece.getTeam().equals(team)) + .mapToDouble(piece -> piece.getScore()) + .sum() - calculatePawnScore(team); + } + + public double calculatePawnScore(Team team){ + Map> pawnAlign = + chessPlate.getPlate().values().stream() + .filter(Pawn.class::isInstance) + .filter(piece -> piece.getTeam().equals(team)) + .collect(Collectors.groupingBy(piece -> piece.getPiecePosition().getFile(), + Collectors.mapping(Piece::getName, Collectors.toList()))); + double score = 0; + for (List pawnNumberByFile : pawnAlign.values()) { + if(pawnNumberByFile.size() >= 2){ + score += pawnNumberByFile.size(); + } + } + return score * 0.5; + } + + public boolean isKingDead(Team team) { + long KingCount = chessPlate.getPlate().values().stream() + .filter(piece -> piece instanceof King) + .filter(piece -> piece.getTeam().equals(team)) + .count(); + return KingCount < 1; + } + +} diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java new file mode 100644 index 0000000..b96984b --- /dev/null +++ b/src/main/java/chess/view/InputView.java @@ -0,0 +1,13 @@ +package chess.view; + +import java.util.Scanner; + +public class InputView { + private static final Scanner SCANNER = new Scanner(System.in); + public String getUserCommand() { + String input = SCANNER.nextLine(); + return input.trim().toLowerCase(); + } + + +} diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java new file mode 100644 index 0000000..887c6a1 --- /dev/null +++ b/src/main/java/chess/view/OutputView.java @@ -0,0 +1,73 @@ +package chess.view; + +import chess.domain.RankComparator; +import chess.domain.piece.File; +import chess.domain.piece.PiecePosition; +import chess.domain.piece.Rank; +import chess.domain.piece.Team; +import chess.domain.plate.ChessPlate; +import chess.service.ChessService; + +import java.util.Arrays; + +public class OutputView { + + public void printChessPlate(ChessPlate chessPlate) { + RankComparator rankComparator = new RankComparator(); + Arrays.stream(Rank.values()) + .sorted(rankComparator::compare) + .forEach(rank -> { + for (File file : File.values()) { + if(chessPlate.getPlate().get(new PiecePosition(file, rank)) == null) { + System.out.print("."); + }else{ + System.out.print(chessPlate.getPlate().get(new PiecePosition(file, rank)).getDisplayName()); + } + } + System.out.println(); + }); + } + + public void initPrint() { + System.out.println(">체스 게임을 시작합니다."); + System.out.println(">게임 시작 : start"); + System.out.println(">게임 종료 : end"); + System.out.println(">게임 이동 : move source 위치 target 위치 - 예. move b2 b3"); + } + + public void printInCorrectCommandMessage(){ + System.out.println("start/end/move/status 중 하나를 입력해주세요"); + } + + public void printCannotMoveMessage() { + System.out.println("기물을 움직일 수 없습니다."); + } + + public void printScoresOfTwoTeams(double blackScore, double whiteScore) { + System.out.println("Black 팀 점수 : " + blackScore + "점"); + System.out.println("White 팀 점수 : " + whiteScore + "점"); + } + + public void printWinner(double blackScore, double whiteScore) { + if(blackScore > whiteScore) { + System.out.println("Black 팀 승리"); + return; + } + + if(whiteScore > blackScore) { + System.out.println("White 팀 승리"); + return; + } + + System.out.println("무승부"); + } + + public void printBlackKingDeadMessage() { + System.out.println("Black King이 잡혔습니다. White 팀 승리"); + } + + public void printWhiteKingDeadMessage() { + System.out.println("White King이 잡혔습니다. Black 팀 승리"); + } + +} diff --git a/src/test/java/chess/domain/piece/BishopTest.java b/src/test/java/chess/domain/piece/BishopTest.java new file mode 100644 index 0000000..466a25d --- /dev/null +++ b/src/test/java/chess/domain/piece/BishopTest.java @@ -0,0 +1,20 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class BishopTest { + @Test + @DisplayName("Bishop의 이동 가능한 좌표를 확인한다") + void checkKingMovable() { + //given + Bishop bishop = new Bishop(Team.BLACK, new PiecePosition(File.E, Rank.EIGHT)); + + //when//then + assertThat(bishop.movable(new PiecePosition(File.D, Rank.SEVEN))).isTrue(); + assertThat(bishop.movable(new PiecePosition(File.D, Rank.EIGHT))).isFalse(); + assertThat(bishop.movable(new PiecePosition(File.E, Rank.SEVEN))).isFalse(); + } +} diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java new file mode 100644 index 0000000..c10656c --- /dev/null +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -0,0 +1,38 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.DisplayName; + +import static org.assertj.core.api.Assertions.assertThat; + +public class KingTest { + + @Test + @DisplayName("킹을 팀을 넣어서 생성하면 1팀 위치는 e8, 2팀은 e1에 , 표시명은 1팀K, 2팀k로 리턴한다") + void testKingCreation() { + + //given + King king1 = new King(Team.BLACK, new PiecePosition(File.E, Rank.ONE)); + King king2 = new King(Team.WHITE, new PiecePosition(File.E, Rank.EIGHT)); + + //when // given + assertThat(king1.getPiecePosition()).isEqualTo(new PiecePosition(File.E, Rank.ONE)); + assertThat(king1.getDisplayName()).isEqualTo("K"); + assertThat(king2.getPiecePosition()).isEqualTo(new PiecePosition(File.E, Rank.EIGHT)); + assertThat(king2.getDisplayName()).isEqualTo("k"); + } + + @Test + @DisplayName("King의 이동 가능한 좌표를 확인한다") + void checkKingMovable() { + //given + King king = new King(Team.BLACK, new PiecePosition(File.E, Rank.EIGHT)); + + //when//then + assertThat(king.movable(new PiecePosition(File.D, Rank.EIGHT))).isTrue(); + assertThat(king.movable(new PiecePosition(File.C, Rank.EIGHT))).isFalse(); + assertThat(king.movable(new PiecePosition(File.E, Rank.SEVEN))).isTrue(); + assertThat(king.movable(new PiecePosition(File.E, Rank.SIX))).isFalse(); + } + +} diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java new file mode 100644 index 0000000..cb32952 --- /dev/null +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -0,0 +1,33 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +class KnightTest { + @Test + @DisplayName("나이트의 이동범위를 확인한다") + void testCanMoveKnight() { + //given + Knight knight = new Knight(Team.BLACK, new PiecePosition(File.D, Rank.FOUR)); + Knight knight1 = new Knight(Team.BLACK, new PiecePosition(File.G, Rank.EIGHT)); + //when + + //then + assertThat(knight.movable(new PiecePosition(File.B, Rank.FIVE))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.C, Rank.SIX))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.E, Rank.SIX))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.F, Rank.FIVE))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.F, Rank.THREE))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.E, Rank.TWO))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.C, Rank.TWO))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.B, Rank.THREE))).isTrue(); + assertThat(knight1.movable(new PiecePosition(File.F, Rank.SIX))).isTrue(); + + assertThat(knight.movable(new PiecePosition(File.B, Rank.SIX))).isFalse(); + assertThat(knight.movable(new PiecePosition(File.E, Rank.FOUR))).isFalse(); + } + +} \ No newline at end of file diff --git a/src/test/java/chess/domain/piece/PawnTest.java b/src/test/java/chess/domain/piece/PawnTest.java new file mode 100644 index 0000000..3e5896a --- /dev/null +++ b/src/test/java/chess/domain/piece/PawnTest.java @@ -0,0 +1,49 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class PawnTest { + @Test + @DisplayName("폰은 처음 위치에서 2칸 움직일 수 있다") + void testPawnCanMoveTwoBlockAtFirstMove() { + //given + Pawn pawn = new Pawn(Team.BLACK, new PiecePosition(File.C, Rank.SEVEN)); + + //when + + //then + assertThat(pawn.movable(new PiecePosition(File.C, Rank.FIVE))).isTrue(); + } + + @Test + @DisplayName("폰은 1칸 전진할 수 있다") + void testPawnCanMoveOneBlock() { + //given + Pawn pawn = new Pawn(Team.BLACK, new PiecePosition(File.C, Rank.FIVE)); + + //when + + //then + assertThat(pawn.movable(new PiecePosition(File.C, Rank.FOUR))).isTrue(); + assertThat(pawn.movable(new PiecePosition(File.C, Rank.SIX))).isFalse(); + } + + @Test + @DisplayName("폰은 공격할 때 전진방향 대각선으로만 공격할 수 있다") + void pawnMovableDiagonal() { + //given + Pawn blackPawn = new Pawn(Team.BLACK, new PiecePosition(File.C, Rank.SEVEN)); + Pawn whitePawn = new Pawn(Team.WHITE, new PiecePosition(File.D, Rank.TWO)); + + //when + + //then + assertThat(blackPawn.movable(new PiecePosition(File.D, Rank.SIX))).isTrue(); + assertThat(blackPawn.movable(new PiecePosition(File.B, Rank.SIX))).isTrue(); + assertThat(whitePawn.movable(new PiecePosition(File.C, Rank.THREE))).isTrue(); + assertThat(whitePawn.movable(new PiecePosition(File.E, Rank.THREE))).isTrue(); + } +} diff --git a/src/test/java/chess/domain/piece/QueenTest.java b/src/test/java/chess/domain/piece/QueenTest.java new file mode 100644 index 0000000..8fca186 --- /dev/null +++ b/src/test/java/chess/domain/piece/QueenTest.java @@ -0,0 +1,31 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class QueenTest { + @Test + @DisplayName("Queen의 이동 가능한 좌표를 확인한다") + void checkQueenMovable() { + //given + Queen queen = new Queen(Team.BLACK, new PiecePosition(File.D, Rank.FOUR)); + + //when//then + assertThat(queen.movable(new PiecePosition(File.D, Rank.THREE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.D, Rank.FIVE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.FOUR))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.E, Rank.FOUR))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.FIVE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.THREE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.E, Rank.FIVE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.E, Rank.THREE))).isTrue(); + + assertThat(queen.movable(new PiecePosition(File.B, Rank.FIVE))).isFalse(); + assertThat(queen.movable(new PiecePosition(File.F, Rank.FIVE))).isFalse(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.TWO))).isFalse(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.SIX))).isFalse(); + + } +} diff --git a/src/test/java/chess/domain/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java new file mode 100644 index 0000000..82d6376 --- /dev/null +++ b/src/test/java/chess/domain/piece/RookTest.java @@ -0,0 +1,20 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class RookTest { + @Test + @DisplayName("Rook의 이동 가능한 좌표를 확인한다") + void checkRookMovable() { + //given + Rook rook = new Rook(Team.BLACK, new PiecePosition(File.A, Rank.EIGHT)); + + //when//then + assertThat(rook.movable(new PiecePosition(File.A, Rank.THREE))).isTrue(); + assertThat(rook.movable(new PiecePosition(File.B, Rank.EIGHT))).isTrue(); + assertThat(rook.movable(new PiecePosition(File.C, Rank.SEVEN))).isFalse(); + } +} diff --git a/src/test/java/chess/domain/plate/ChessPlateTest.java b/src/test/java/chess/domain/plate/ChessPlateTest.java new file mode 100644 index 0000000..f1b3a87 --- /dev/null +++ b/src/test/java/chess/domain/plate/ChessPlateTest.java @@ -0,0 +1,82 @@ +package chess.domain.plate; + +import chess.domain.piece.File; +import chess.domain.piece.PiecePosition; +import chess.domain.piece.Rank; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ChessPlateTest { + + @Test + @DisplayName("체스판 생성하고 포함된 객체 개수 확인") + void testCreateChessPlate() { + //given + ChessPlate chessPlate = new ChessPlate(); + + //when,then + assertThat(chessPlate.getAllPieces()).hasSize(32); + } + + @Test + @DisplayName("직선 이동 범위 한칸 전의 경로까지 말이 있는지 확인") + void testCheckHavePieceOnStraightPath() { + //given + ChessPlate chessPlate = new ChessPlate(); + + boolean result = chessPlate.havePieceOnStraightPath(new PiecePosition(File.E, Rank.EIGHT), new PiecePosition(File.E, Rank.SIX)); + boolean result2 = chessPlate.havePieceOnStraightPath(new PiecePosition(File.A, Rank.ONE), new PiecePosition(File.A, Rank.THREE)); + boolean result3 = chessPlate.havePieceOnStraightPath(new PiecePosition(File.H, Rank.SEVEN), new PiecePosition(File.H, Rank.FIVE)); + + //when,then + assertThat(result).isTrue(); + assertThat(result2).isTrue(); + assertThat(result3).isFalse(); + } + + @Test + @DisplayName("대각선 이동 범위 한칸 전의 경로까지 말이 있는지 확인") + void testCheckHavePieceOnDiagonalPath() { + //given + ChessPlate chessPlate = new ChessPlate(); + + boolean result = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.F, Rank.EIGHT), new PiecePosition(File.D, Rank.SIX)); + boolean result2 = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.A, Rank.TWO), new PiecePosition(File.C, Rank.FOUR)); + + + //when,then + assertThat(result).isTrue(); + assertThat(result2).isFalse(); + } + + @Test + @DisplayName("체스말이 이동 가능하면 이동 후 true를 리턴한다") + void move() { + //given + ChessPlate chessPlate = new ChessPlate(); + //when + boolean result = chessPlate.move(new PiecePosition(File.A, Rank.EIGHT), new PiecePosition(File.B, Rank.EIGHT)); + boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); + boolean result3 = chessPlate.move(new PiecePosition(File.A, Rank.ONE), new PiecePosition(File.A, Rank.THREE)); + + //then + assertThat(result).isFalse(); + assertThat(result2).isTrue(); + assertThat(result3).isFalse(); + } + + @Test + @DisplayName("폰이 이동 가능하면 이동 후 true를 리턴한다") + void testPawnMove() { + //given + ChessPlate chessPlate = new ChessPlate(); + //when + boolean result = chessPlate.move(new PiecePosition(File.B, Rank.SEVEN), new PiecePosition(File.C, Rank.SIX)); + boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); + //then + assertThat(result).isFalse(); + assertThat(result2).isTrue(); + } +} diff --git a/src/test/java/chess/domain/team/CampTest.java b/src/test/java/chess/domain/team/CampTest.java new file mode 100644 index 0000000..5de9ab9 --- /dev/null +++ b/src/test/java/chess/domain/team/CampTest.java @@ -0,0 +1,26 @@ +package chess.domain.team; + +import chess.domain.piece.Team; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +class CampTest { + @Test + @DisplayName("team 별 기물 세트를 만든다") + void createPieceSetTest() { + //given + Camp blackTeam = new Camp(Team.BLACK); + Camp whiteTeam = new Camp(Team.WHITE); + + //when + + //then + assertThat(blackTeam.getPieces()) + .hasSize(16); + // .contains(new King()); + assertThat(whiteTeam.getPieces()).hasSize(16); + } + +} \ No newline at end of file diff --git a/src/test/java/chess/domain/team/RankComparatorTest.java b/src/test/java/chess/domain/team/RankComparatorTest.java new file mode 100644 index 0000000..9ed2198 --- /dev/null +++ b/src/test/java/chess/domain/team/RankComparatorTest.java @@ -0,0 +1,17 @@ +package chess.domain.team; + +import chess.domain.RankComparator; +import chess.domain.piece.Rank; + +import java.util.Arrays; + +public class RankComparatorTest { + public static void main(String[] args) { + RankComparator rankComparator = new RankComparator(); + Arrays.stream(Rank.values()) + .sorted(rankComparator::compare) + .forEach(rank -> { + System.out.println(rank.getRankPosition()); + }); + } +} diff --git a/src/test/java/chess/service/ChessServiceTest.java b/src/test/java/chess/service/ChessServiceTest.java new file mode 100644 index 0000000..f960857 --- /dev/null +++ b/src/test/java/chess/service/ChessServiceTest.java @@ -0,0 +1,92 @@ +package chess.service; + +import chess.domain.piece.*; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +class ChessServiceTest { + @Test + @DisplayName("File 생성 테스트") + void generateFileWithString() { + //given + File a = File.findBy("b"); + + //when + + //then + assertThat(a.getFileMarker()).isEqualTo("b"); + assertThat(a.getFilePosition()).isEqualTo(2); + } + + @Test + @DisplayName("진영별 점수를 계산한다") + void testGetScore() { + //given + ChessService service = new ChessService(); + service.start(); + service.move("e2","e4"); + service.move("e4","e5"); + service.move("e5","e6"); + service.move("f7","e6"); + + //when + + //then + assertThat(service.getGameScore(Team.BLACK)).isEqualTo(37); + assertThat(service.getGameScore(Team.WHITE)).isEqualTo(37); + } + + @Test + @DisplayName("같은 파일에 있는 폰의 갯수를 리턴한다") + void testCalculatePawnScore() { + //given + ChessService service = new ChessService(); + service.start(); + ChessService service2 = new ChessService(); + service2.start(); + service2.move("e2","e4"); + service2.move("e4","e5"); + service2.move("e5","e6"); + service2.move("f7","e6"); + + //when + double score = service.calculatePawnScore(Team.BLACK); + double score2 = service2.calculatePawnScore(Team.BLACK); + + //then + assertThat(score).isZero(); + assertThat(score2).isEqualTo(1); + } + + @Test + @DisplayName("Black King이 잡혔는지 확인하는 메서드 테스트") + void testDetectBlackKingIsDead() { + //given + ChessService service = new ChessService(); + service.start(); + service.getChessPlate().getPlate().remove(new PiecePosition(File.E, Rank.EIGHT)); + + //when + + //then + assertThat(service.isKingDead(Team.BLACK)).isTrue(); + assertThat(service.isKingDead(Team.WHITE)).isFalse(); + } + + @Test + @DisplayName("White King이 잡혔는지 확인하는 메서드 테스트") + void testDetectWhiteKingIsDead() { + //given + ChessService service = new ChessService(); + service.start(); + service.getChessPlate().getPlate().remove(new PiecePosition(File.E, Rank.ONE)); + + //when + + //then + assertThat(service.isKingDead(Team.BLACK)).isFalse(); + assertThat(service.isKingDead(Team.WHITE)).isTrue(); + } +} \ No newline at end of file diff --git a/src/test/java/empty.txt b/src/test/java/empty.txt deleted file mode 100644 index e69de29..0000000