From 91a3e2553cb094577a4573784e55e51e1d0858b8 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Tue, 26 Mar 2024 11:38:13 +0900 Subject: [PATCH 01/38] =?UTF-8?q?refactor(Team):=20=EC=88=98=EC=A0=95?= =?UTF-8?q?=EC=9D=B4=20=EC=9A=A9=EC=9D=B4=ED=95=98=EB=8F=84=EB=A1=9D=20?= =?UTF-8?q?=EB=A9=94=EC=84=9C=EB=93=9C=20=EC=9E=AC=EC=82=AC=EC=9A=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/domain/Team.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/main/java/chess/domain/Team.java b/src/main/java/chess/domain/Team.java index 938bdc55409..43c5a303e98 100644 --- a/src/main/java/chess/domain/Team.java +++ b/src/main/java/chess/domain/Team.java @@ -2,14 +2,16 @@ public enum Team { - BLACK, WHITE; + BLACK, + WHITE + ; public boolean isBlack() { return this == BLACK; } public Team nextTurn() { - if (this == BLACK) { + if (this.isBlack()) { return WHITE; } return BLACK; From 607649fb4ae1cf7df1f7304185531b27567a23b9 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Tue, 26 Mar 2024 15:59:24 +0900 Subject: [PATCH 02/38] =?UTF-8?q?refactor(PawnMovement)=20:=20=EB=A7=A4?= =?UTF-8?q?=EC=A7=81=20=EB=84=98=EB=B2=84=EC=97=90=20=EC=9D=98=EB=AF=B8=20?= =?UTF-8?q?=EB=B6=80=EC=97=AC=20=EB=B0=8F=20=EA=B0=80=EC=8B=9C=EC=84=B1=20?= =?UTF-8?q?=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/chess/domain/movement/BlackPawnDefaultMovement.java | 5 ++++- .../chess/domain/movement/BlackPawnDiagonalMovement.java | 5 ++++- .../java/chess/domain/movement/BlackPawnFirstMovement.java | 4 +++- .../java/chess/domain/movement/WhitePawnDefaultMovement.java | 5 ++++- .../chess/domain/movement/WhitePawnDiagonalMovement.java | 5 ++++- .../java/chess/domain/movement/WhitePawnFirstMovement.java | 4 +++- 6 files changed, 22 insertions(+), 6 deletions(-) diff --git a/src/main/java/chess/domain/movement/BlackPawnDefaultMovement.java b/src/main/java/chess/domain/movement/BlackPawnDefaultMovement.java index 8ea827b1f8f..93e67fe2e9d 100644 --- a/src/main/java/chess/domain/movement/BlackPawnDefaultMovement.java +++ b/src/main/java/chess/domain/movement/BlackPawnDefaultMovement.java @@ -5,13 +5,16 @@ public final class BlackPawnDefaultMovement implements MovementRule { + private static final int TO_SOUTH_ONE_BLOCK = -1; + private static final int SAME_FILE = 0; + @Override public boolean isMovable(Position start, Position end, boolean isAttack) { int rankDifference = start.calculateRankDifference(end); int fileDifference = start.calculateFileDifference(end); boolean isEmptyAtEnd = !isAttack; - boolean isMatchDifference = rankDifference == -1 && fileDifference == 0; + boolean isMatchDifference = (rankDifference == TO_SOUTH_ONE_BLOCK && fileDifference == SAME_FILE); return isEmptyAtEnd && isMatchDifference; } diff --git a/src/main/java/chess/domain/movement/BlackPawnDiagonalMovement.java b/src/main/java/chess/domain/movement/BlackPawnDiagonalMovement.java index e8c940e8a64..1f78a40f89f 100644 --- a/src/main/java/chess/domain/movement/BlackPawnDiagonalMovement.java +++ b/src/main/java/chess/domain/movement/BlackPawnDiagonalMovement.java @@ -5,12 +5,15 @@ public final class BlackPawnDiagonalMovement implements MovementRule { + private static final int TO_SOUTH_ONE_BLOCK = -1; + private static final int ONE_BLOCK = 1; + @Override public boolean isMovable(Position start, Position end, boolean isAttack) { int rankDifference = start.calculateRankDifference(end); int fileDifference = start.calculateFileDifference(end); - boolean isMatchDifference = rankDifference == -1 && Math.abs(fileDifference) == 1; + boolean isMatchDifference = (rankDifference == TO_SOUTH_ONE_BLOCK && Math.abs(fileDifference) == ONE_BLOCK); return isAttack && isMatchDifference; } diff --git a/src/main/java/chess/domain/movement/BlackPawnFirstMovement.java b/src/main/java/chess/domain/movement/BlackPawnFirstMovement.java index 8c27e09b904..b68d758c7b2 100644 --- a/src/main/java/chess/domain/movement/BlackPawnFirstMovement.java +++ b/src/main/java/chess/domain/movement/BlackPawnFirstMovement.java @@ -7,6 +7,8 @@ public final class BlackPawnFirstMovement implements MovementRule { private static final Rank BLACK_PAWN_INIT_RANK = Rank.SEVEN; + private static final int TO_SOUTH_TWO_BLOCK = -2; + private static final int SAME_FILE = 0; @Override public boolean isMovable(Position start, Position end, boolean isAttack) { @@ -15,7 +17,7 @@ public boolean isMovable(Position start, Position end, boolean isAttack) { boolean isEmptyAtEnd = !isAttack; boolean isExistInitPosition = start.isSameRank(BLACK_PAWN_INIT_RANK); - boolean isMatchDifference = rankDifference == -2 && fileDifference == 0; + boolean isMatchDifference = (rankDifference == TO_SOUTH_TWO_BLOCK && fileDifference == SAME_FILE); return isEmptyAtEnd && isExistInitPosition && isMatchDifference; } diff --git a/src/main/java/chess/domain/movement/WhitePawnDefaultMovement.java b/src/main/java/chess/domain/movement/WhitePawnDefaultMovement.java index e2c1969d012..3747a45f36e 100644 --- a/src/main/java/chess/domain/movement/WhitePawnDefaultMovement.java +++ b/src/main/java/chess/domain/movement/WhitePawnDefaultMovement.java @@ -5,13 +5,16 @@ public final class WhitePawnDefaultMovement implements MovementRule { + private static final int TO_NORTH_ONE_BLOCK = 1; + private static final int SAME_FILE = 0; + @Override public boolean isMovable(Position start, Position end, boolean isAttack) { int rankDifference = start.calculateRankDifference(end); int fileDifference = start.calculateFileDifference(end); boolean isEmptyAtEnd = !isAttack; - boolean isMatchDifference = rankDifference == 1 && fileDifference == 0; + boolean isMatchDifference = (rankDifference == TO_NORTH_ONE_BLOCK && fileDifference == SAME_FILE); return isEmptyAtEnd && isMatchDifference; } diff --git a/src/main/java/chess/domain/movement/WhitePawnDiagonalMovement.java b/src/main/java/chess/domain/movement/WhitePawnDiagonalMovement.java index 751de051131..9be70533aa2 100644 --- a/src/main/java/chess/domain/movement/WhitePawnDiagonalMovement.java +++ b/src/main/java/chess/domain/movement/WhitePawnDiagonalMovement.java @@ -5,12 +5,15 @@ public final class WhitePawnDiagonalMovement implements MovementRule { + private static final int TO_NORTH_ONE_BLOCK = 1; + private static final int ONE_BLOCK = 1; + @Override public boolean isMovable(Position start, Position end, boolean isAttack) { int rankDifference = start.calculateRankDifference(end); int fileDifference = start.calculateFileDifference(end); - boolean isMatchDifference = rankDifference == 1 && Math.abs(fileDifference) == 1; + boolean isMatchDifference = (rankDifference == TO_NORTH_ONE_BLOCK && Math.abs(fileDifference) == ONE_BLOCK); return isAttack && isMatchDifference; } diff --git a/src/main/java/chess/domain/movement/WhitePawnFirstMovement.java b/src/main/java/chess/domain/movement/WhitePawnFirstMovement.java index 40e6df668cd..c3317cf18d6 100644 --- a/src/main/java/chess/domain/movement/WhitePawnFirstMovement.java +++ b/src/main/java/chess/domain/movement/WhitePawnFirstMovement.java @@ -7,6 +7,8 @@ public final class WhitePawnFirstMovement implements MovementRule { private static final Rank WHITE_PAWN_INIT_RANK = Rank.TWO; + private static final int TO_NORTH_TWO_BLOCK = 2; + private static final int SAME_FILE = 0; @Override public boolean isMovable(Position start, Position end, boolean isAttack) { @@ -15,7 +17,7 @@ public boolean isMovable(Position start, Position end, boolean isAttack) { boolean isEmptyAtEnd = !isAttack; boolean isExistInitPosition = start.isSameRank(WHITE_PAWN_INIT_RANK); - boolean isMatchDifference = rankDifference == 2 && fileDifference == 0; + boolean isMatchDifference = (rankDifference == TO_NORTH_TWO_BLOCK && fileDifference == SAME_FILE); return isEmptyAtEnd && isExistInitPosition && isMatchDifference; } From 8ac528f1c8669676ab513d5fc8ec6161ed9e20b1 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Tue, 26 Mar 2024 17:05:27 +0900 Subject: [PATCH 03/38] =?UTF-8?q?feat(Piece):=20=EC=99=95=20=EC=97=AC?= =?UTF-8?q?=EB=B6=80=20=ED=8C=90=EB=8B=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/domain/piece/Piece.java | 14 +++++++++----- src/test/java/chess/domain/piece/PieceTest.java | 16 ++++------------ 2 files changed, 13 insertions(+), 17 deletions(-) diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index 3728507395b..9a4fb8fa6a5 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -5,7 +5,7 @@ import chess.domain.position.Position; import java.util.List; -public abstract class Piece { +public abstract sealed class Piece permits King, Queen, Rook, Bishop, Knight, Pawn { private final Team team; private final List movementRules; @@ -15,10 +15,6 @@ protected Piece(Team team, List movementRules) { this.movementRules = movementRules; } - public final boolean isBlackTeam() { - return team.isBlack(); - } - public final List findPath(Position start, Position end, boolean isAttack) { return movementRules.stream() .filter(movementRule -> movementRule.isMovable(start, end, isAttack)) @@ -27,6 +23,10 @@ public final List findPath(Position start, Position end, boolean isAtt .orElseThrow(() -> new IllegalArgumentException("불가능한 경로입니다.")); } + public final boolean isBlackTeam() { + return team.isBlack(); + } + public final boolean isSameTeam(Piece other) { return isSameTeam(other.team); } @@ -34,4 +34,8 @@ public final boolean isSameTeam(Piece other) { public final boolean isSameTeam(Team team) { return this.team == team; } + + public final boolean isKing() { + return this.getClass() == King.class; + } } diff --git a/src/test/java/chess/domain/piece/PieceTest.java b/src/test/java/chess/domain/piece/PieceTest.java index a1b15e05297..4fdad018f28 100644 --- a/src/test/java/chess/domain/piece/PieceTest.java +++ b/src/test/java/chess/domain/piece/PieceTest.java @@ -3,25 +3,17 @@ import static org.assertj.core.api.Assertions.assertThat; import chess.domain.Team; -import java.util.List; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; class PieceTest { - class ExamplePiece extends Piece { - - protected ExamplePiece(Team team) { - super(team, List.of()); - } - } - @ParameterizedTest @CsvSource({"BLACK, true", "WHITE, false"}) @DisplayName("해당 팀이 검정 팀인지 확인한다.") void isBlackTeamTest(Team team, boolean expected) { - ExamplePiece piece = new ExamplePiece(team); + Piece piece = new Pawn(team); assertThat(piece.isBlackTeam()).isEqualTo(expected); } @@ -30,7 +22,7 @@ void isBlackTeamTest(Team team, boolean expected) { @CsvSource({"BLACK, true", "WHITE, false"}) @DisplayName("기물이 해당 팀인지 확인한다.") void isSameTeamTest_whenOnePiece(Team pieceTeam, boolean expected) { - ExamplePiece piece = new ExamplePiece(pieceTeam); + Piece piece = new Pawn(pieceTeam); Team team = Team.BLACK; assertThat(piece.isSameTeam(team)).isEqualTo(expected); @@ -40,8 +32,8 @@ void isSameTeamTest_whenOnePiece(Team pieceTeam, boolean expected) { @CsvSource({"BLACK, true", "WHITE, false"}) @DisplayName("두 기물이 같은 팀인지 확인한다.") void isSameTeamTest_whenTwoPieces(Team team, boolean expected) { - ExamplePiece one = new ExamplePiece(Team.BLACK); - ExamplePiece other = new ExamplePiece(team); + Piece one = new Pawn(Team.BLACK); + Piece other = new Pawn(team); assertThat(one.isSameTeam(other)).isEqualTo(expected); } From 9abcbf850e97cedcf5463d68cbc629da9a2e61ae Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Tue, 26 Mar 2024 17:07:11 +0900 Subject: [PATCH 04/38] =?UTF-8?q?feat(Board):=20=ED=95=B4=EB=8B=B9=20?= =?UTF-8?q?=EA=B2=8C=EC=9E=84=EC=9D=98=20=EA=B3=84=EC=86=8D=20=EC=A7=84?= =?UTF-8?q?=ED=96=89=ED=95=A0=20=EC=88=98=20=EC=9E=88=EB=8A=94=EC=A7=80=20?= =?UTF-8?q?=ED=8C=90=EB=8B=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/domain/Board.java | 33 ++++++++++++++++--- src/main/java/chess/dto/ProgressStatus.java | 19 +++++++++++ src/test/java/chess/domain/BoardTest.java | 35 ++++++++++++++++----- 3 files changed, 74 insertions(+), 13 deletions(-) create mode 100644 src/main/java/chess/dto/ProgressStatus.java diff --git a/src/main/java/chess/domain/Board.java b/src/main/java/chess/domain/Board.java index 2e31f5249e8..f02820e25a0 100644 --- a/src/main/java/chess/domain/Board.java +++ b/src/main/java/chess/domain/Board.java @@ -2,6 +2,7 @@ import chess.domain.piece.Piece; import chess.domain.position.Position; +import chess.dto.ProgressStatus; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -22,15 +23,13 @@ public Optional find(Position position) { return Optional.ofNullable(piece); } - public void move(Position start, Position end) { + public ProgressStatus move(Position start, Position end) { validate(start, end); Piece piece = board.get(start); List path = piece.findPath(start, end, isExistEnemy(end)); validateEmpty(path); - board.remove(start); - board.put(end, piece); - turn = turn.nextTurn(); + return movePiece(start, end); } public void validate(Position start, Position end) { @@ -72,8 +71,32 @@ private boolean isBlocked(List path) { .anyMatch(this::isExistPiece); } + private ProgressStatus movePiece(Position start, Position end) { + Piece movingPiece = find(start).orElseThrow(); + ProgressStatus status = findStatus(end); + + board.remove(start); + board.put(end, movingPiece); + turn = turn.nextTurn(); + + return status; + } + + private ProgressStatus findStatus(Position end) { + boolean isKingCaptured = find(end).map(Piece::isKing) + .orElse(false); + + if (!isKingCaptured) { + return ProgressStatus.PROGRESS; + } + if (turn.isBlack()) { + return ProgressStatus.BLACK_WIN; + } + return ProgressStatus.WHITE_WIN; + } + private boolean isExistPiece(Position position) { - return board.get(position) != null; + return board.containsKey(position); } private boolean isNotExistPiece(Position position) { diff --git a/src/main/java/chess/dto/ProgressStatus.java b/src/main/java/chess/dto/ProgressStatus.java new file mode 100644 index 00000000000..7914d118820 --- /dev/null +++ b/src/main/java/chess/dto/ProgressStatus.java @@ -0,0 +1,19 @@ +package chess.dto; + +public enum ProgressStatus { + + WHITE_WIN(false), + BLACK_WIN(false), + PROGRESS(true), + ; + + private final boolean isContinue; + + ProgressStatus(boolean isContinue) { + this.isContinue = isContinue; + } + + public boolean isContinue() { + return isContinue; + } +} diff --git a/src/test/java/chess/domain/BoardTest.java b/src/test/java/chess/domain/BoardTest.java index c239fe9a2b3..e286ead2eb5 100644 --- a/src/test/java/chess/domain/BoardTest.java +++ b/src/test/java/chess/domain/BoardTest.java @@ -11,6 +11,7 @@ import chess.domain.position.File; import chess.domain.position.Position; import chess.domain.position.Rank; +import chess.dto.ProgressStatus; import java.util.Map; import java.util.Optional; import org.junit.jupiter.api.BeforeEach; @@ -44,13 +45,15 @@ void findTest_whenPieceNotExist() { } /* - * .R...... - * ........ - * ........ - * .q.k.... - * ........ - * ........ - * ........ + * ........ 8 + * ........ 7 + * ........ 6 + * ........ 5 + * ....k... 4 + * ........ 3 + * K...q..R 2 + * ........ 1 + * abcdefgh * */ @Nested @DisplayName("말 이동 테스트") @@ -62,8 +65,10 @@ class MovingTest { private static final Queen QUEEN = new Queen(Team.WHITE); private static final Rook ENEMY_ROOK = new Rook(Team.BLACK); private static final Position START_ENEMY_ROOK = new Position(File.H, Rank.TWO); + private static final King ENEMY_KING = new King(Team.BLACK); + private static final Position START_ENEMY_KING = new Position(File.A, Rank.TWO); private static final Map MAP = Map.of( - START_KING, KING, START_QUEEN, QUEEN, START_ENEMY_ROOK, ENEMY_ROOK); + START_KING, KING, START_QUEEN, QUEEN, START_ENEMY_ROOK, ENEMY_ROOK, START_ENEMY_KING, ENEMY_KING); private Board board; @BeforeEach @@ -143,5 +148,19 @@ void moveTest_whenNotInTurn_throwException() { .isInstanceOf(IllegalArgumentException.class) .hasMessage("해당 팀의 차례가 아닙니다."); } + + @Test + @DisplayName("상대편 왕을 잡을 경우, 해당 팀이 이긴다.") + void moveTest_whenCaptureKing_winGame() { + assertThat(board.move(START_QUEEN, START_ENEMY_KING)).isEqualTo(ProgressStatus.WHITE_WIN); + } + + @Test + @DisplayName("상대편 왕을 잡지 않은 경우, 게임이 진행된다.") + void moveTest_whenNotCaptureKing_progressGame() { + Position possiblePosition = new Position(File.E, Rank.THREE); + + assertThat(board.move(START_QUEEN, possiblePosition)).isEqualTo(ProgressStatus.PROGRESS); + } } } From edd54fae11921b1e9289220e37f8b83d82095843 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Tue, 26 Mar 2024 17:34:19 +0900 Subject: [PATCH 05/38] =?UTF-8?q?feat(ChessGame):=20=EC=99=95=EC=9D=B4=20?= =?UTF-8?q?=EC=9E=A1=ED=9E=88=EB=A9=B4=20=EA=B2=8C=EC=9E=84=EC=9D=B4=20?= =?UTF-8?q?=EC=A2=85=EB=A3=8C=EB=90=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessApplication.java | 2 +- src/main/java/chess/ChessGame.java | 36 +++++++++++++++-------- src/main/java/chess/view/OutputView.java | 15 +++++++++- 3 files changed, 39 insertions(+), 14 deletions(-) diff --git a/src/main/java/chess/ChessApplication.java b/src/main/java/chess/ChessApplication.java index a6c126dbce0..358aaf02166 100644 --- a/src/main/java/chess/ChessApplication.java +++ b/src/main/java/chess/ChessApplication.java @@ -11,7 +11,7 @@ public static void main(String[] args) { ChessGame chessGame = new ChessGame(inputView, outputView); try { - chessGame.start(); + chessGame.run(); } catch (IllegalArgumentException exception) { outputView.printExceptionMessage(exception); } diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java index 45178bfcdc4..5e93a336687 100644 --- a/src/main/java/chess/ChessGame.java +++ b/src/main/java/chess/ChessGame.java @@ -5,6 +5,7 @@ import chess.domain.piece.Piece; import chess.domain.position.Position; import chess.dto.PieceDto; +import chess.dto.ProgressStatus; import chess.view.GameCommand; import chess.view.InputView; import chess.view.OutputView; @@ -23,26 +24,32 @@ public ChessGame(InputView inputView, OutputView outputView) { this.outputView = outputView; } - public void start() { + public void run() { + Board board = startGame(); + play(board); + } + + private Board startGame() { outputView.printStartGame(); GameCommand command = inputView.readCommand(); if (command.isStart()) { Board board = BoardFactory.createInitBoard(); showBoard(board); - play(board); - } - if (command.isMove()) { - throw new IllegalArgumentException("아직 게임을 시작하지 않았습니다."); + return board; } + throw new IllegalArgumentException("아직 게임을 시작하지 않았습니다."); } private void play(Board board) { - while (true) { - processTurn(board); - } + ProgressStatus status; + do { + status = processTurn(board); + } while (status.isContinue()); + + showResult(status); } - private void processTurn(Board board) { + private ProgressStatus processTurn(Board board) { GameCommand command = inputView.readCommand(); if (command.isStart()) { throw new IllegalArgumentException("이미 게임을 시작했습니다."); @@ -50,14 +57,19 @@ private void processTurn(Board board) { if (command.isEnd()) { System.exit(0); } - executeMove(board); + return executeMove(board); } - private void executeMove(Board board) { + private ProgressStatus executeMove(Board board) { Position start = inputView.readPosition(); Position end = inputView.readPosition(); - board.move(start, end); + ProgressStatus status = board.move(start, end); showBoard(board); + return status; + } + + private void showResult(ProgressStatus status) { + outputView.printWinnerMessage(status); } private void showBoard(Board board) { diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 6ccd8dce259..0e2a769fa25 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -5,6 +5,7 @@ import chess.domain.position.Rank; import chess.dto.PieceDto; import chess.dto.PieceType; +import chess.dto.ProgressStatus; import java.util.List; import java.util.Map; import java.util.Optional; @@ -30,10 +31,10 @@ public void printStartGame() { } public void printBoard(Map board) { + System.out.println(); for (Rank rank : RANK_ORDER) { printBoardOneLine(board, rank); } - System.out.println(); } private void printBoardOneLine(Map board, Rank rank) { @@ -63,6 +64,18 @@ private void printWhitePiece(PieceType type) { System.out.print(display.toLowerCase()); } + public void printWinnerMessage(ProgressStatus status) { + if (status.isContinue()) { + throw new IllegalArgumentException("우승자가 결정되지 않았습니다."); + } + + if (status == ProgressStatus.BLACK_WIN) { + System.out.println("검정 팀이 승리했습니다."); + return; + } + System.out.println("하양 팀이 승리했습니다."); + } + public void printExceptionMessage(Exception exception) { System.out.println(ERROR_PREFIX + exception.getMessage()); } From e05d029a5c441c7b86fc799ccdd56e33106a85b0 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Wed, 27 Mar 2024 09:41:16 +0900 Subject: [PATCH 06/38] =?UTF-8?q?feat(Point):=20=EA=B8=B0=EB=AC=BC=20?= =?UTF-8?q?=EC=A0=90=EC=88=98=20=EB=8D=94=ED=95=98=EA=B8=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 9 +++++- src/main/java/chess/Point.java | 27 ++++++++++++++++ src/test/java/chess/PointTest.java | 49 ++++++++++++++++++++++++++++++ 3 files changed, 84 insertions(+), 1 deletion(-) create mode 100644 src/main/java/chess/Point.java create mode 100644 src/test/java/chess/PointTest.java diff --git a/README.md b/README.md index 294703de882..85062b8738a 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,9 @@ ### 체스 말 - [x] 무슨 팀인지 알려준다. +- [ ] 자신의 기물 점수를 알려준다. + - [ ] queen 9점, rook 5점, bishop 3점, knight 2.5점, king 0점 + - [ ] pawn은 1점, 같은 세로줄에 같은 색의 폰이 있는 경우 0.5점 ### 움직임 - [x] 이동 가능한지 판단한다. @@ -17,6 +20,9 @@ ### 팀 - [x] 흰색, 검은색을 구분한다. +### 말 점수 +- [x] 말 점수를 서로 더할 수 있다. + ### 체스 보드 - [x] 체스 말 위치 초기화를 한다. - [x] 해당 위치에 어떤 말이 있는지 알려준다. @@ -26,7 +32,8 @@ - [x] 이동 경로에 다른 말이 있을 경우 예외 - [x] 마지막 위치에 적 말이 있을 경우, 잡아먹는다. - [x] 흰색부터 번갈아가며 플레이한다. - + - [x] 상대편 왕을 잡으면, 해당 팀의 게임 승리로 게임을 종료한다. +- [ ] 현재 각 팀별 기물 점수를 구한다. ### 위치 - [x] 가로 위치(왼쪽부터 a~h)를 저장한다. diff --git a/src/main/java/chess/Point.java b/src/main/java/chess/Point.java new file mode 100644 index 00000000000..1162a85d2ef --- /dev/null +++ b/src/main/java/chess/Point.java @@ -0,0 +1,27 @@ +package chess; + +public class Point { + + public static final Point ZERO = new Point(0); + + private final double value; + + public Point(double value) { + validate(value); + this.value = value; + } + + private void validate(double value) { + if (value < 0) { + throw new IllegalArgumentException("점수로 음수를 가질 수 없습니다."); + } + } + + public Point add(Point other) { + return new Point(this.value + other.value); + } + + public double toDouble() { + return value; + } +} diff --git a/src/test/java/chess/PointTest.java b/src/test/java/chess/PointTest.java new file mode 100644 index 00000000000..96f1cb1c2eb --- /dev/null +++ b/src/test/java/chess/PointTest.java @@ -0,0 +1,49 @@ +package chess; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assertions.offset; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +class PointTest { + + @Test + @DisplayName("점수로 음수를 가질 경우, 예외를 던진다.") + void validateTest_whenPointsNegative_throwException() { + double negativeValue = -0.001; + + assertThatThrownBy(() -> new Point(negativeValue)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("점수로 음수를 가질 수 없습니다."); + } + + @ParameterizedTest + @CsvSource({"1.5, 0, 1.5", "1, 1, 2", "0.5, 0.5, 1"}) + @DisplayName("두 점수를 더할 수 있다.") + void addTest(double value1, double value2, double expected) { + Point point1 = new Point(value1); + Point point2 = new Point(value2); + + Point actual = point1.add(point2); + + assertThat(actual.toDouble()).isEqualTo(expected, offset(0.001)); + } + + @Test + @DisplayName("점수를 여러번 더할 수 있다.") + void addTest_whenAddRepeat() { + Point added = new Point(0.5); + int count = 100; + + Point actual = Point.ZERO; + for (int i = 0; i < count; i++) { + actual = actual.add(added); + } + + assertThat(actual.toDouble()).isEqualTo(0.5 * 100, offset(0.001)); + } +} From 3625575a84583c7b63972020c83761acab2446ba Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Wed, 27 Mar 2024 10:33:21 +0900 Subject: [PATCH 07/38] =?UTF-8?q?feat(Piece):=20=EC=9E=90=EC=8B=A0?= =?UTF-8?q?=EC=9D=98=20=EA=B8=B0=EB=AC=BC=20=EC=A0=90=EC=88=98=20=ED=8C=90?= =?UTF-8?q?=EB=8B=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 6 +++--- src/main/java/chess/domain/piece/Bishop.java | 8 ++++++++ src/main/java/chess/domain/piece/King.java | 7 +++++++ src/main/java/chess/domain/piece/Knight.java | 7 +++++++ src/main/java/chess/domain/piece/Pawn.java | 12 ++++++++++++ src/main/java/chess/domain/piece/Piece.java | 3 +++ src/main/java/chess/domain/piece/Queen.java | 8 ++++++++ src/main/java/chess/domain/piece/Rook.java | 7 +++++++ 8 files changed, 55 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 85062b8738a..78724fa9b28 100644 --- a/README.md +++ b/README.md @@ -9,9 +9,9 @@ ### 체스 말 - [x] 무슨 팀인지 알려준다. -- [ ] 자신의 기물 점수를 알려준다. - - [ ] queen 9점, rook 5점, bishop 3점, knight 2.5점, king 0점 - - [ ] pawn은 1점, 같은 세로줄에 같은 색의 폰이 있는 경우 0.5점 +- [x] 자신의 기물 점수를 알려준다. + - [x] queen 9점, rook 5점, bishop 3점, knight 2.5점, king 0점 + - [x] pawn은 1점, 같은 세로줄에 같은 색의 폰이 있는 경우 0.5점 ### 움직임 - [x] 이동 가능한지 판단한다. diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 12a9c016bbf..24699b54a40 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.continuous.NorthEastMovement; @@ -10,10 +11,17 @@ public final class Bishop extends Piece { + private static final Point PIECE_POINT = new Point(3.0); private static final List MOVEMENT_RULES = List.of( new NorthEastMovement(), new SouthEastMovement(), new NorthWestMovement(), new SouthWestMovement()); public Bishop(Team team) { super(team, MOVEMENT_RULES); } + + + @Override + public Point getPoint(boolean isOverlapped) { + return PIECE_POINT; + } } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index 769a5e69cb5..7251ec3639a 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.discrete.KingMovement; @@ -8,8 +9,14 @@ public final class King extends Piece { private static final List MOVEMENT_RULES = List.of(new KingMovement()); + private static final Point PIECE_POINT = Point.ZERO; public King(Team team) { super(team, MOVEMENT_RULES); } + + @Override + public Point getPoint(boolean isOverlapped) { + return PIECE_POINT; + } } diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index bfcefe0eb64..8e63dd2af3a 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.discrete.KnightMovement; @@ -8,8 +9,14 @@ public final class Knight extends Piece { private static final List MOVEMENT_RULES = List.of(new KnightMovement()); + private static final Point PIECE_POINT = new Point(2.5); public Knight(Team team) { super(team, MOVEMENT_RULES); } + + @Override + public Point getPoint(boolean isOverlapped) { + return PIECE_POINT; + } } diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 4a1214a2da4..bebafdd93ec 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.Point; import chess.domain.Team; import chess.domain.movement.BlackPawnDefaultMovement; import chess.domain.movement.BlackPawnDiagonalMovement; @@ -16,6 +17,9 @@ public final class Pawn extends Piece { new BlackPawnFirstMovement(), new BlackPawnDefaultMovement(), new BlackPawnDiagonalMovement()); private static final List WHITE_MOVEMENT_RULES = List.of( new WhitePawnFirstMovement(), new WhitePawnDefaultMovement(), new WhitePawnDiagonalMovement()); + private static final Point PIECE_BASIC_POINT = new Point(1.0); + private static final Point PIECE_OVERLAPPED_POINT = new Point(0.5); // TODO 변수명 변경 + public Pawn(Team team) { super(team, findMovementRule(team)); @@ -27,4 +31,12 @@ private static List findMovementRule(Team team) { } return WHITE_MOVEMENT_RULES; } + + @Override + public Point getPoint(boolean isOverlapped) { + if (isOverlapped) { + return PIECE_OVERLAPPED_POINT; + } + return PIECE_BASIC_POINT; + } } diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index 9a4fb8fa6a5..a308ba45dcd 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.position.Position; @@ -38,4 +39,6 @@ public final boolean isSameTeam(Team team) { public final boolean isKing() { return this.getClass() == King.class; } + + public abstract Point getPoint(boolean isOverlapped); } diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index 8c0c21c252d..3b83d7dcabb 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.continuous.EastMovement; @@ -14,6 +15,8 @@ public final class Queen extends Piece { + private static final Point PIECE_POINT = new Point(9.0); + private static final List MOVEMENT_RULES = List.of( new EastMovement(), new WestMovement(), new SouthMovement(), new NorthMovement(), new NorthEastMovement(), new SouthEastMovement(), new NorthWestMovement(), new SouthWestMovement()); @@ -21,4 +24,9 @@ public final class Queen extends Piece { public Queen(Team team) { super(team, MOVEMENT_RULES); } + + @Override + public Point getPoint(boolean isOverlapped) { + return PIECE_POINT; + } } diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index dfc4e85024a..d44412ae53c 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.continuous.EastMovement; @@ -12,8 +13,14 @@ public final class Rook extends Piece { private static final List MOVEMENT_RULES = List.of( new EastMovement(), new WestMovement(), new SouthMovement(), new NorthMovement()); + private static final Point PIECE_POINT = new Point(5.0); public Rook(Team team) { super(team, MOVEMENT_RULES); } + + @Override + public Point getPoint(boolean isOverlapped) { + return PIECE_POINT; + } } From eff640dd3644f532e21f80426f3f7a4e2b262dea Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Wed, 27 Mar 2024 10:35:13 +0900 Subject: [PATCH 08/38] =?UTF-8?q?refactor(Point):=20=ED=8C=A8=ED=82=A4?= =?UTF-8?q?=EC=A7=80=20=EC=9D=B4=EB=8F=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/{ => domain}/Point.java | 2 +- src/main/java/chess/domain/piece/Bishop.java | 2 +- src/main/java/chess/domain/piece/King.java | 2 +- src/main/java/chess/domain/piece/Knight.java | 2 +- src/main/java/chess/domain/piece/Pawn.java | 2 +- src/main/java/chess/domain/piece/Piece.java | 2 +- src/main/java/chess/domain/piece/Queen.java | 2 +- src/main/java/chess/domain/piece/Rook.java | 2 +- src/test/java/chess/{ => domain}/PointTest.java | 2 +- 9 files changed, 9 insertions(+), 9 deletions(-) rename src/main/java/chess/{ => domain}/Point.java (96%) rename src/test/java/chess/{ => domain}/PointTest.java (98%) diff --git a/src/main/java/chess/Point.java b/src/main/java/chess/domain/Point.java similarity index 96% rename from src/main/java/chess/Point.java rename to src/main/java/chess/domain/Point.java index 1162a85d2ef..9dd7ec209e1 100644 --- a/src/main/java/chess/Point.java +++ b/src/main/java/chess/domain/Point.java @@ -1,4 +1,4 @@ -package chess; +package chess.domain; public class Point { diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 24699b54a40..82ec41c7690 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -1,6 +1,6 @@ package chess.domain.piece; -import chess.Point; +import chess.domain.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.continuous.NorthEastMovement; diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index 7251ec3639a..57ea71a43dd 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -1,6 +1,6 @@ package chess.domain.piece; -import chess.Point; +import chess.domain.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.discrete.KingMovement; diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index 8e63dd2af3a..1a1f7b33299 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -1,6 +1,6 @@ package chess.domain.piece; -import chess.Point; +import chess.domain.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.discrete.KnightMovement; diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index bebafdd93ec..9a451c19097 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -1,6 +1,6 @@ package chess.domain.piece; -import chess.Point; +import chess.domain.Point; import chess.domain.Team; import chess.domain.movement.BlackPawnDefaultMovement; import chess.domain.movement.BlackPawnDiagonalMovement; diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index a308ba45dcd..bbe4c6c4fb6 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -1,6 +1,6 @@ package chess.domain.piece; -import chess.Point; +import chess.domain.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.position.Position; diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index 3b83d7dcabb..f6c98e15035 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -1,6 +1,6 @@ package chess.domain.piece; -import chess.Point; +import chess.domain.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.continuous.EastMovement; diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index d44412ae53c..b551ba4474f 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -1,6 +1,6 @@ package chess.domain.piece; -import chess.Point; +import chess.domain.Point; import chess.domain.Team; import chess.domain.movement.MovementRule; import chess.domain.movement.continuous.EastMovement; diff --git a/src/test/java/chess/PointTest.java b/src/test/java/chess/domain/PointTest.java similarity index 98% rename from src/test/java/chess/PointTest.java rename to src/test/java/chess/domain/PointTest.java index 96f1cb1c2eb..37eab36ed27 100644 --- a/src/test/java/chess/PointTest.java +++ b/src/test/java/chess/domain/PointTest.java @@ -1,4 +1,4 @@ -package chess; +package chess.domain; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; From e20e78c0e48feea9842426f960a72028b74cca05 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Wed, 27 Mar 2024 11:24:57 +0900 Subject: [PATCH 09/38] =?UTF-8?q?test(Piece):=20=EA=B0=81=20=EA=B8=B0?= =?UTF-8?q?=EB=AC=BC=EB=B3=84=20=EC=A0=90=EC=88=98=20=ED=85=8C=EC=8A=A4?= =?UTF-8?q?=ED=8A=B8=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/domain/Point.java | 19 +++++++++++++++++++ .../java/chess/domain/piece/BishopTest.java | 11 +++++++++++ .../java/chess/domain/piece/KingTest.java | 11 +++++++++++ .../java/chess/domain/piece/KnightTest.java | 11 +++++++++++ .../java/chess/domain/piece/PawnTest.java | 19 +++++++++++++++++++ .../java/chess/domain/piece/QueenTest.java | 11 +++++++++++ .../java/chess/domain/piece/RookTest.java | 11 +++++++++++ 7 files changed, 93 insertions(+) diff --git a/src/main/java/chess/domain/Point.java b/src/main/java/chess/domain/Point.java index 9dd7ec209e1..2b7d899e360 100644 --- a/src/main/java/chess/domain/Point.java +++ b/src/main/java/chess/domain/Point.java @@ -1,5 +1,7 @@ package chess.domain; +import java.util.Objects; + public class Point { public static final Point ZERO = new Point(0); @@ -24,4 +26,21 @@ public Point add(Point other) { public double toDouble() { return value; } + + @Override + public boolean equals(Object object) { + if (this == object) { + return true; + } + if (object == null || getClass() != object.getClass()) { + return false; + } + Point point = (Point) object; + return Double.compare(value, point.value) == 0; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } } diff --git a/src/test/java/chess/domain/piece/BishopTest.java b/src/test/java/chess/domain/piece/BishopTest.java index e43f7a34140..d9150475d28 100644 --- a/src/test/java/chess/domain/piece/BishopTest.java +++ b/src/test/java/chess/domain/piece/BishopTest.java @@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThatCode; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import chess.domain.Point; import chess.domain.Team; import chess.domain.position.File; import chess.domain.position.Position; @@ -12,6 +13,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; class BishopTest { @@ -55,4 +57,13 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { .isInstanceOf(IllegalArgumentException.class) .hasMessage("불가능한 경로입니다."); } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + @DisplayName("비숍의 기물 점수는 3점이다.") + void getPointTest(boolean isOverlapped) { + Bishop bishop = new Bishop(Team.WHITE); + + assertThat(bishop.getPoint(isOverlapped)).isEqualTo(new Point(3.0)); + } } diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java index 4d392f2cc0a..3a0b48a0984 100644 --- a/src/test/java/chess/domain/piece/KingTest.java +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -3,6 +3,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import chess.domain.Point; import chess.domain.Team; import chess.domain.position.File; import chess.domain.position.Position; @@ -10,6 +11,7 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; class KingTest { @@ -38,4 +40,13 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { .isInstanceOf(IllegalArgumentException.class) .hasMessage("불가능한 경로입니다."); } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + @DisplayName("킹의 기물 점수는 0점이다.") + void getPointTest(boolean isOverlapped) { + King king = new King(Team.WHITE); + + assertThat(king.getPoint(isOverlapped)).isEqualTo(Point.ZERO); + } } diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java index e6677b57a6c..07aba37b29a 100644 --- a/src/test/java/chess/domain/piece/KnightTest.java +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -3,6 +3,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import chess.domain.Point; import chess.domain.Team; import chess.domain.position.File; import chess.domain.position.Position; @@ -10,6 +11,7 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; class KnightTest { @@ -38,4 +40,13 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { .isInstanceOf(IllegalArgumentException.class) .hasMessage("불가능한 경로입니다."); } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + @DisplayName("나이트의 기물 점수는 2.5점이다.") + void getPointTest(boolean isOverlapped) { + Knight knight = new Knight(Team.WHITE); + + assertThat(knight.getPoint(isOverlapped)).isEqualTo(new Point(2.5)); + } } diff --git a/src/test/java/chess/domain/piece/PawnTest.java b/src/test/java/chess/domain/piece/PawnTest.java index 574b49a3683..44939e398f5 100644 --- a/src/test/java/chess/domain/piece/PawnTest.java +++ b/src/test/java/chess/domain/piece/PawnTest.java @@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.assertAll; +import chess.domain.Point; import chess.domain.Team; import chess.domain.position.File; import chess.domain.position.Position; @@ -116,4 +117,22 @@ void findPathTest_whenOutOfDiagonalMovement_throwException(File file, Rank rank) .isInstanceOf(IllegalArgumentException.class) .hasMessage("불가능한 경로입니다."); } + + @Test + @DisplayName("폰의 기물 점수는 1점이다.") + void getPointTest() { + Pawn pawn = new Pawn(Team.WHITE); + boolean isOverlapped = false; + + assertThat(pawn.getPoint(isOverlapped)).isEqualTo(new Point(1.0)); + } + + @Test + @DisplayName("같은 줄에 폰이 있을 경우, 폰의 기물 점수는 0.5점이다.") + void getPointTest_whenPawnIsOverlappedInSameFile() { + Pawn pawn = new Pawn(Team.WHITE); + boolean isOverlapped = true; + + assertThat(pawn.getPoint(isOverlapped)).isEqualTo(new Point(0.5)); + } } diff --git a/src/test/java/chess/domain/piece/QueenTest.java b/src/test/java/chess/domain/piece/QueenTest.java index 5d939d92f38..a9947810ef8 100644 --- a/src/test/java/chess/domain/piece/QueenTest.java +++ b/src/test/java/chess/domain/piece/QueenTest.java @@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThatCode; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import chess.domain.Point; import chess.domain.Team; import chess.domain.position.File; import chess.domain.position.Position; @@ -12,6 +13,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; class QueenTest { @@ -55,4 +57,13 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { .isInstanceOf(IllegalArgumentException.class) .hasMessage("불가능한 경로입니다."); } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + @DisplayName("퀸의 기물 점수는 9점이다.") + void getPointTest(boolean isOverlapped) { + Queen queen = new Queen(Team.WHITE); + + assertThat(queen.getPoint(isOverlapped)).isEqualTo(new Point(9.0)); + } } diff --git a/src/test/java/chess/domain/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java index 28ee9b769a2..5bbff5606a4 100644 --- a/src/test/java/chess/domain/piece/RookTest.java +++ b/src/test/java/chess/domain/piece/RookTest.java @@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThatCode; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import chess.domain.Point; import chess.domain.Team; import chess.domain.position.File; import chess.domain.position.Position; @@ -12,6 +13,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; class RookTest { @@ -55,4 +57,13 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { .isInstanceOf(IllegalArgumentException.class) .hasMessage("불가능한 경로입니다."); } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + @DisplayName("룩의 기물 점수는 5점이다.") + void getPointTest(boolean isOverlapped) { + Rook rook = new Rook(Team.WHITE); + + assertThat(rook.getPoint(isOverlapped)).isEqualTo(new Point(5.0)); + } } From 2057f0021100dcbd3f0406cc0ef9b818bfd3c3d9 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Wed, 27 Mar 2024 13:00:31 +0900 Subject: [PATCH 10/38] =?UTF-8?q?feat(Board):=20=ED=8C=80=EB=B3=84=20?= =?UTF-8?q?=EA=B8=B0=EB=AC=BC=20=EC=A0=90=EC=88=98=20=EA=B3=84=EC=82=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/domain/Board.java | 39 ++++++++++- src/main/java/chess/domain/piece/Piece.java | 4 ++ src/test/java/chess/domain/BoardTest.java | 78 +++++++++++++++++++++ 3 files changed, 120 insertions(+), 1 deletion(-) diff --git a/src/main/java/chess/domain/Board.java b/src/main/java/chess/domain/Board.java index f02820e25a0..fe485040ba9 100644 --- a/src/main/java/chess/domain/Board.java +++ b/src/main/java/chess/domain/Board.java @@ -1,12 +1,16 @@ package chess.domain; import chess.domain.piece.Piece; +import chess.domain.position.File; import chess.domain.position.Position; +import chess.domain.position.Rank; import chess.dto.ProgressStatus; +import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.stream.Collectors; public class Board { @@ -32,7 +36,7 @@ public ProgressStatus move(Position start, Position end) { return movePiece(start, end); } - public void validate(Position start, Position end) { + private void validate(Position start, Position end) { if (isNotExistPiece(start)) { throw new IllegalArgumentException("해당 위치에 말이 없습니다."); } @@ -102,4 +106,37 @@ private boolean isExistPiece(Position position) { private boolean isNotExistPiece(Position position) { return !isExistPiece(position); } + + public Map calculatePoints() { + return Arrays.stream(Team.values()) + .collect(Collectors.toMap( + team -> team, + this::calculatePoints + )); + } + + private Point calculatePoints(Team team) { + return Arrays.stream(File.values()) + .map(file -> calculatePoints(team, file)) + .reduce(Point.ZERO, Point::add); + } + + private Point calculatePoints(Team team, File file) { + List teamPieces = Arrays.stream(Rank.values()) + .map(rank -> new Position(file, rank)) + .map(this::find) + .flatMap(Optional::stream) + .filter(piece -> piece.isSameTeam(team)) + .toList(); + boolean isOverlappedPawn = isOverlappedPawn(teamPieces); + return teamPieces.stream() + .map(piece -> piece.getPoint(isOverlappedPawn)) + .reduce(Point.ZERO, Point::add); + } + + private boolean isOverlappedPawn(List pieces) { + return pieces.stream() + .filter(Piece::isPawn) + .count() >= 2; + } } diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index bbe4c6c4fb6..2316fd21a3d 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -40,5 +40,9 @@ public final boolean isKing() { return this.getClass() == King.class; } + public final boolean isPawn() { + return this.getClass() == Pawn.class; + } + public abstract Point getPoint(boolean isOverlapped); } diff --git a/src/test/java/chess/domain/BoardTest.java b/src/test/java/chess/domain/BoardTest.java index e286ead2eb5..e6aa955c07e 100644 --- a/src/test/java/chess/domain/BoardTest.java +++ b/src/test/java/chess/domain/BoardTest.java @@ -5,6 +5,7 @@ import static org.junit.jupiter.api.Assertions.assertAll; import chess.domain.piece.King; +import chess.domain.piece.Pawn; import chess.domain.piece.Piece; import chess.domain.piece.Queen; import chess.domain.piece.Rook; @@ -163,4 +164,81 @@ void moveTest_whenNotCaptureKing_progressGame() { assertThat(board.move(START_QUEEN, possiblePosition)).isEqualTo(ProgressStatus.PROGRESS); } } + + @Nested + @DisplayName("보드판에 있는 기물 점수를 계산할 수 있다.") + class CalculatingPointTest { + + /* + * ........ 8 + * ........ 7 + * ........ 6 + * ........ 5 + * ........ 4 + * ........ 3 + * ........ 2 + * r..q.... 1 + * abcdefgh + * */ + @Test + @DisplayName("팀 별로 각 기물의 점수를 더하여 계산한다.") + void calculatePointTest_whenNotExistPawn_addAll() { + Board board = new Board(Map.of( + new Position(File.A, Rank.ONE), new Rook(Team.WHITE), + new Position(File.D, Rank.ONE), new Queen(Team.WHITE))); + + assertThat(board.calculatePoints()).containsExactly( + Map.entry(Team.WHITE, new Point(5.0 + 9.0)), + Map.entry(Team.BLACK, Point.ZERO)); + } + + /* + * ........ 8 + * ....P... 7 + * ........ 6 + * ........ 5 + * ........ 4 + * ........ 3 + * ....pp.. 2 + * ........ 1 + * abcdefgh + * */ + @Test + @DisplayName("각 폰은 한 파일에 같이 없을 경우, 높은 점수로 계산한다.") + void calculatePointTest_whenExistPawnSameTeamAndDifferentFile_addHighPoint() { + Board board = new Board(Map.of( + new Position(File.E, Rank.TWO), new Pawn(Team.WHITE), + new Position(File.F, Rank.TWO), new Pawn(Team.WHITE), + new Position(File.E, Rank.SEVEN), new Pawn(Team.BLACK))); + + assertThat(board.calculatePoints()).containsExactly( + Map.entry(Team.WHITE, new Point(1.0 + 1.0)), + Map.entry(Team.BLACK, new Point(1.0))); + } + + /* + * ........ 8 + * ........ 7 + * ........ 6 + * ........ 5 + * ........ 4 + * ....p... 3 + * ....p... 2 + * ........ 1 + * abcdefgh + * */ + @Test + @DisplayName("각 폰은 한 줄에 같이 있을 경우, 낮은 점수로 계산한다.") + void calculatePointTest_whenExistPawnSameTeamAndFile_addLowPoint() { + Board board = new Board(Map.of( + new Position(File.E, Rank.TWO), new Pawn(Team.WHITE), + new Position(File.E, Rank.THREE), new Pawn(Team.WHITE))); + + assertThat(board.calculatePoints()).containsExactly( + Map.entry(Team.WHITE, new Point(0.5 + 0.5)), + Map.entry(Team.BLACK, Point.ZERO)); + } + + + } } From e7f9c78a6a5892dc0f26c319a1c8773b9cbb97fc Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Wed, 27 Mar 2024 13:26:27 +0900 Subject: [PATCH 11/38] =?UTF-8?q?feat(ChessGame):=20=ED=98=84=EC=9E=AC=20?= =?UTF-8?q?=ED=8C=80=EB=B3=84=20=EB=A7=90=20=EC=A0=90=EC=88=98=20=EC=B6=9C?= =?UTF-8?q?=EB=A0=A5=20=EA=B8=B0=EB=8A=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessGame.java | 13 +++++++++++++ src/main/java/chess/view/GameCommand.java | 8 +++++++- src/main/java/chess/view/OutputView.java | 16 ++++++++++++++++ 3 files changed, 36 insertions(+), 1 deletion(-) diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java index 5e93a336687..0e8f15c735e 100644 --- a/src/main/java/chess/ChessGame.java +++ b/src/main/java/chess/ChessGame.java @@ -2,6 +2,8 @@ import chess.domain.Board; import chess.domain.BoardFactory; +import chess.domain.Point; +import chess.domain.Team; import chess.domain.piece.Piece; import chess.domain.position.Position; import chess.dto.PieceDto; @@ -13,6 +15,7 @@ import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.stream.Collectors; public class ChessGame { @@ -57,6 +60,16 @@ private ProgressStatus processTurn(Board board) { if (command.isEnd()) { System.exit(0); } + if (command.isStatus()) { + Map status = board.calculatePoints(); + Map dto = status.entrySet().stream() + .collect(Collectors.toMap( + entry -> entry.getKey(), + entry -> entry.getValue().toDouble() + )); + outputView.printStatus(dto); + return ProgressStatus.PROGRESS; + } return executeMove(board); } diff --git a/src/main/java/chess/view/GameCommand.java b/src/main/java/chess/view/GameCommand.java index b099877116e..00826b02239 100644 --- a/src/main/java/chess/view/GameCommand.java +++ b/src/main/java/chess/view/GameCommand.java @@ -6,7 +6,9 @@ public enum GameCommand { START("start"), END("end"), - MOVE("move"); + MOVE("move"), + STATUS("status"), + ; private final String command; @@ -32,4 +34,8 @@ public boolean isEnd() { public boolean isMove() { return this == MOVE; } + + public boolean isStatus() { + return this == STATUS; + } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 0e2a769fa25..e81cb6c33eb 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -1,5 +1,6 @@ package chess.view; +import chess.domain.Team; import chess.domain.position.File; import chess.domain.position.Position; import chess.domain.position.Rank; @@ -16,6 +17,7 @@ public class OutputView { Rank.EIGHT, Rank.SEVEN, Rank.SIX, Rank.FIVE, Rank.FOUR, Rank.THREE, Rank.TWO, Rank.ONE); private static final List FILE_ORDER = List.of( File.A, File.B, File.C, File.D, File.E, File.F, File.G, File.H); + private static final List TEAM_ORDER = List.of(Team.WHITE, Team.BLACK); private static final Map PIECE_DISPLAY = Map.of( PieceType.KING, "K", PieceType.QUEEN, "Q", PieceType.KNIGHT, "N", PieceType.BISHOP, "B", PieceType.ROOK, "R", PieceType.PAWN, "P"); @@ -64,6 +66,20 @@ private void printWhitePiece(PieceType type) { System.out.print(display.toLowerCase()); } + public void printStatus(Map status) { + System.out.println(); + TEAM_ORDER.stream() + .forEach(team -> printStatus(team, status.get(team))); + } + + private void printStatus(Team team, double score) { + if (team.isBlack()) { + System.out.println("검정 팀 : %.1f".formatted(score)); + return; + } + System.out.println("하양 팀 : %.1f".formatted(score)); + } + public void printWinnerMessage(ProgressStatus status) { if (status.isContinue()) { throw new IllegalArgumentException("우승자가 결정되지 않았습니다."); From 23716a65f1e55b86c9cf0bf587c2be3fcac95c88 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Thu, 28 Mar 2024 16:26:26 +0900 Subject: [PATCH 12/38] =?UTF-8?q?refactor:=20=EB=A9=94=EC=84=9C=EB=93=9C?= =?UTF-8?q?=20=EA=B8=B8=EC=9D=B4=EB=A5=BC=20=EC=A4=84=EC=9D=B4=EA=B8=B0=20?= =?UTF-8?q?=EC=9C=84=ED=95=B4=20=EB=A6=AC=ED=8C=A9=ED=84=B0=EB=A7=81=20?= =?UTF-8?q?=EC=8B=A4=EC=8B=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessGame.java | 26 +++++++++++++++-------- src/main/java/chess/domain/Board.java | 12 +++++++---- src/test/java/chess/domain/BoardTest.java | 6 +++--- 3 files changed, 28 insertions(+), 16 deletions(-) diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java index 0e8f15c735e..10f7be5db96 100644 --- a/src/main/java/chess/ChessGame.java +++ b/src/main/java/chess/ChessGame.java @@ -14,6 +14,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Optional; import java.util.stream.Collectors; @@ -61,18 +62,26 @@ private ProgressStatus processTurn(Board board) { System.exit(0); } if (command.isStatus()) { - Map status = board.calculatePoints(); - Map dto = status.entrySet().stream() - .collect(Collectors.toMap( - entry -> entry.getKey(), - entry -> entry.getValue().toDouble() - )); - outputView.printStatus(dto); - return ProgressStatus.PROGRESS; + return executeStatus(board); } return executeMove(board); } + private ProgressStatus executeStatus(Board board) { + Map status = board.calculateTotalPoints(); + Map statusDto = toDto(status); + outputView.printStatus(statusDto); + return ProgressStatus.PROGRESS; + } + + private Map toDto(Map status) { + return status.entrySet().stream() + .collect(Collectors.toMap( + Entry::getKey, + entry -> entry.getValue().toDouble() + )); + } + private ProgressStatus executeMove(Board board) { Position start = inputView.readPosition(); Position end = inputView.readPosition(); @@ -94,7 +103,6 @@ private void showBoard(Board board) { private void addPiece(Board board, Position position, Map boardDto) { Optional optionalPiece = board.find(position); - if (optionalPiece.isEmpty()) { return; } diff --git a/src/main/java/chess/domain/Board.java b/src/main/java/chess/domain/Board.java index fe485040ba9..0f551dc1375 100644 --- a/src/main/java/chess/domain/Board.java +++ b/src/main/java/chess/domain/Board.java @@ -107,27 +107,31 @@ private boolean isNotExistPiece(Position position) { return !isExistPiece(position); } - public Map calculatePoints() { + public Map calculateTotalPoints() { return Arrays.stream(Team.values()) .collect(Collectors.toMap( team -> team, - this::calculatePoints + this::calculateTotalPoints )); } - private Point calculatePoints(Team team) { + private Point calculateTotalPoints(Team team) { return Arrays.stream(File.values()) .map(file -> calculatePoints(team, file)) .reduce(Point.ZERO, Point::add); } private Point calculatePoints(Team team, File file) { - List teamPieces = Arrays.stream(Rank.values()) + List sameFilePieces = Arrays.stream(Rank.values()) .map(rank -> new Position(file, rank)) .map(this::find) .flatMap(Optional::stream) .filter(piece -> piece.isSameTeam(team)) .toList(); + return calculatePoints(sameFilePieces); + } + + private Point calculatePoints(List teamPieces) { boolean isOverlappedPawn = isOverlappedPawn(teamPieces); return teamPieces.stream() .map(piece -> piece.getPoint(isOverlappedPawn)) diff --git a/src/test/java/chess/domain/BoardTest.java b/src/test/java/chess/domain/BoardTest.java index e6aa955c07e..b621f749f6a 100644 --- a/src/test/java/chess/domain/BoardTest.java +++ b/src/test/java/chess/domain/BoardTest.java @@ -187,7 +187,7 @@ void calculatePointTest_whenNotExistPawn_addAll() { new Position(File.A, Rank.ONE), new Rook(Team.WHITE), new Position(File.D, Rank.ONE), new Queen(Team.WHITE))); - assertThat(board.calculatePoints()).containsExactly( + assertThat(board.calculateTotalPoints()).containsExactly( Map.entry(Team.WHITE, new Point(5.0 + 9.0)), Map.entry(Team.BLACK, Point.ZERO)); } @@ -211,7 +211,7 @@ void calculatePointTest_whenExistPawnSameTeamAndDifferentFile_addHighPoint() { new Position(File.F, Rank.TWO), new Pawn(Team.WHITE), new Position(File.E, Rank.SEVEN), new Pawn(Team.BLACK))); - assertThat(board.calculatePoints()).containsExactly( + assertThat(board.calculateTotalPoints()).containsExactly( Map.entry(Team.WHITE, new Point(1.0 + 1.0)), Map.entry(Team.BLACK, new Point(1.0))); } @@ -234,7 +234,7 @@ void calculatePointTest_whenExistPawnSameTeamAndFile_addLowPoint() { new Position(File.E, Rank.TWO), new Pawn(Team.WHITE), new Position(File.E, Rank.THREE), new Pawn(Team.WHITE))); - assertThat(board.calculatePoints()).containsExactly( + assertThat(board.calculateTotalPoints()).containsExactly( Map.entry(Team.WHITE, new Point(0.5 + 0.5)), Map.entry(Team.BLACK, Point.ZERO)); } From cbc4b375cac282dab23bfc56d424ba848c3ae36b Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Fri, 29 Mar 2024 15:14:03 +0900 Subject: [PATCH 13/38] =?UTF-8?q?test(BoardTest):=20Optional=20assert=20?= =?UTF-8?q?=EA=B5=AC=EB=AC=B8=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/chess/domain/BoardTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/test/java/chess/domain/BoardTest.java b/src/test/java/chess/domain/BoardTest.java index b621f749f6a..4318c6c7c54 100644 --- a/src/test/java/chess/domain/BoardTest.java +++ b/src/test/java/chess/domain/BoardTest.java @@ -42,7 +42,7 @@ void findTest_whenPieceNotExist() { Position notExistPosition = new Position(File.D, Rank.TWO); Board board = new Board(map); - assertThat(board.find(notExistPosition)).isEqualTo(Optional.empty()); + assertThat(board.find(notExistPosition)).isEmpty(); } /* @@ -86,7 +86,7 @@ void moveTest() { assertAll( () -> assertThat(board.find(possibleEnd)).isEqualTo(Optional.of(KING)), - () -> assertThat(board.find(START_KING)).isEqualTo(Optional.empty()) + () -> assertThat(board.find(START_KING)).isEmpty() ); } @@ -135,7 +135,7 @@ void moveTest_whenExistSameTeamAtTheEnd() { board.move(START_QUEEN, START_ENEMY_ROOK); assertAll( - () -> assertThat(board.find(START_QUEEN)).isEqualTo(Optional.empty()), + () -> assertThat(board.find(START_QUEEN)).isEmpty(), () -> assertThat(board.find(START_ENEMY_ROOK)).isEqualTo(Optional.of(QUEEN)) ); } From a0db668750a0deabfd11bcc55faf9bb09854e4e2 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Fri, 29 Mar 2024 17:32:31 +0900 Subject: [PATCH 14/38] =?UTF-8?q?docs:=204=EB=8B=A8=EA=B3=84=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80=20=EC=9A=94=EA=B5=AC=EC=82=AC=ED=95=AD=20=EB=A7=9F=20?= =?UTF-8?q?db=20=EC=84=A4=EC=A0=95=20=EC=A0=95=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 3 --- README.md | 8 +++++++- database/docker-compose.yml | 18 ++++++++++++++++++ database/init.sql | 16 ++++++++++++++++ 4 files changed, 41 insertions(+), 4 deletions(-) create mode 100644 database/docker-compose.yml create mode 100644 database/init.sql diff --git a/.gitignore b/.gitignore index 5e0f049c593..6529aa8c8f9 100644 --- a/.gitignore +++ b/.gitignore @@ -30,7 +30,4 @@ out/ ### VS Code ### .vscode/ - db/ - -docker-compose.yml diff --git a/README.md b/README.md index 78724fa9b28..b3a3529724e 100644 --- a/README.md +++ b/README.md @@ -33,7 +33,7 @@ - [x] 마지막 위치에 적 말이 있을 경우, 잡아먹는다. - [x] 흰색부터 번갈아가며 플레이한다. - [x] 상대편 왕을 잡으면, 해당 팀의 게임 승리로 게임을 종료한다. -- [ ] 현재 각 팀별 기물 점수를 구한다. +- [x] 현재 각 팀별 기물 점수를 구한다. ### 위치 - [x] 가로 위치(왼쪽부터 a~h)를 저장한다. @@ -41,5 +41,11 @@ - [x] 서로 같은 위치인지 판단한다. - [x] 다음 동, 서, 남, 북쪽 위치를 알려준다. +### 저장소 +- [ ] 각 말을 한 번 움직임을 저장할 수 있다. +- [ ] 말의 전체 위치를 저장할 수 있다. +- [ ] 게임이 끝나, 저장소를 초기화할 수 있다. +- [ ] 현재 진행중인 게임이 있는지 알 수 있다. + ### 출력 - [x] 체스판에서 각 진영은 검은색(대문자)과 흰색(소문자) 편으로 구분한다. diff --git a/database/docker-compose.yml b/database/docker-compose.yml new file mode 100644 index 00000000000..558a1d5a53f --- /dev/null +++ b/database/docker-compose.yml @@ -0,0 +1,18 @@ +version: "3.9" +services: + db: + image: mysql:8.0.28 + platform: linux/x86_64 + restart: always + ports: + - "13306:3306" + environment: + MYSQL_ROOT_PASSWORD: root + MYSQL_DATABASE: chess + MYSQL_USER: user + MYSQL_PASSWORD: password + TZ: Asia/Seoul + volumes: + - ./db/mysql/data:/var/lib/mysql + - ./db/mysql/config:/etc/mysql/conf.d + - ./db/mysql/init:/docker-entrypoint-initdb.d diff --git a/database/init.sql b/database/init.sql new file mode 100644 index 00000000000..e3ab70c958d --- /dev/null +++ b/database/init.sql @@ -0,0 +1,16 @@ +CREATE DATABASE IF NOT EXISTS chess; + +USE chess; + +CREATE TABLE chess_game ( + turn VARCHAR(10) CHECK (turn IN ('BLACK', 'WHITE')), + PRIMARY KEY (turn) +); + +CREATE TABLE piece ( + board_rank VARCHAR(2) CHECK (board_rank IN ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')), + board_file VARCHAR(2) CHECK (board_file IN ('1', '2', '3', '4', '5', '6', '7', '8')), + type VARCHAR(10) CHECK (type IN ('KING', 'QUEEN', 'ROOK', 'BISHOP', 'KNIGHT', 'PAWN', 'EMPTY')), + team VARCHAR(10) CHECK (team IN ('BLACK', 'WHITE')), + PRIMARY KEY (board_rank, board_file) +); From 2d395f8d6bb079187b83a2cdff4807d077c543ce Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Sat, 30 Mar 2024 11:05:28 +0900 Subject: [PATCH 15/38] =?UTF-8?q?refactor(OutputView):=20=EA=B0=80?= =?UTF-8?q?=EB=8F=85=EC=84=B1=EC=9D=84=20=EC=9C=84=ED=95=B4=20=EB=A9=94?= =?UTF-8?q?=EC=84=9C=EB=93=9C=20=EB=B6=84=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/view/OutputView.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index e81cb6c33eb..cc8d85dba2d 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -43,7 +43,7 @@ private void printBoardOneLine(Map board, Rank rank) { for (File file : FILE_ORDER) { PieceDto piece = board.get(new Position(file, rank)); Optional optional = Optional.ofNullable(piece); - optional.ifPresentOrElse(this::printPiece, () -> System.out.print(EMPTY_SPACE)); + optional.ifPresentOrElse(this::printPiece, this::printEmptySpace); } System.out.println(); } @@ -56,6 +56,10 @@ private void printPiece(PieceDto piece) { printWhitePiece(piece.type()); } + private void printEmptySpace() { + System.out.print(EMPTY_SPACE); + } + private void printBlackPiece(PieceType type) { String display = PIECE_DISPLAY.get(type); System.out.print(display.toUpperCase()); From e955a9e923602ae10796c77d02e98ffd43d18284 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Sat, 30 Mar 2024 11:09:51 +0900 Subject: [PATCH 16/38] =?UTF-8?q?feat(Type):=20=EB=8D=B0=EC=9D=B4=ED=84=B0?= =?UTF-8?q?=EB=B2=A0=EC=9D=B4=EC=8A=A4=20=EA=B4=80=EB=A6=AC=EC=9D=98=20?= =?UTF-8?q?=ED=8E=B8=EC=9D=98=EC=84=B1=EC=9D=84=20=EC=9C=84=ED=95=B4=20nul?= =?UTF-8?q?l=20=EA=B0=9D=EC=B2=B4=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- database/init.sql | 2 +- src/main/java/chess/dto/PieceType.java | 8 ++++++- src/main/java/chess/dto/TeamType.java | 29 ++++++++++++++++++++++++++ 3 files changed, 37 insertions(+), 2 deletions(-) create mode 100644 src/main/java/chess/dto/TeamType.java diff --git a/database/init.sql b/database/init.sql index e3ab70c958d..d5ce5880dc3 100644 --- a/database/init.sql +++ b/database/init.sql @@ -11,6 +11,6 @@ CREATE TABLE piece ( board_rank VARCHAR(2) CHECK (board_rank IN ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')), board_file VARCHAR(2) CHECK (board_file IN ('1', '2', '3', '4', '5', '6', '7', '8')), type VARCHAR(10) CHECK (type IN ('KING', 'QUEEN', 'ROOK', 'BISHOP', 'KNIGHT', 'PAWN', 'EMPTY')), - team VARCHAR(10) CHECK (team IN ('BLACK', 'WHITE')), + team VARCHAR(10) CHECK (team IN ('BLACK', 'WHITE', 'EMPTY')), PRIMARY KEY (board_rank, board_file) ); diff --git a/src/main/java/chess/dto/PieceType.java b/src/main/java/chess/dto/PieceType.java index 9427ec01a70..289b7823366 100644 --- a/src/main/java/chess/dto/PieceType.java +++ b/src/main/java/chess/dto/PieceType.java @@ -16,7 +16,9 @@ public enum PieceType { ROOK(Rook.class), BISHOP(Bishop.class), KNIGHT(Knight.class), - PAWN(Pawn.class); + PAWN(Pawn.class), + EMPTY(null), + ; private final Class category; @@ -30,4 +32,8 @@ public static PieceType from(Piece piece) { .findAny() .orElseThrow(() -> new IllegalArgumentException("해당 기물이 존재하지 않습니다.")); } + + public static PieceType getEmptyType() { + return EMPTY; + } } diff --git a/src/main/java/chess/dto/TeamType.java b/src/main/java/chess/dto/TeamType.java new file mode 100644 index 00000000000..89805dbc60a --- /dev/null +++ b/src/main/java/chess/dto/TeamType.java @@ -0,0 +1,29 @@ +package chess.dto; + +import chess.domain.Team; +import java.util.Arrays; + +public enum TeamType { + + BLACK(Team.BLACK), + WHITE(Team.WHITE), + EMPTY(null), + ; + + private final Team team; + + TeamType(Team team) { + this.team = team; + } + + public static TeamType from(Team team) { + return Arrays.stream(TeamType.values()) + .filter(type -> type.team == team) + .findAny() + .orElseThrow(() -> new IllegalArgumentException("해당 타입이 없습니다.")); + } + + public static TeamType getEmptyType() { + return EMPTY; + } +} From ba2012bfb9c196618e7223b17d92f12cb4fda94b Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Sat, 30 Mar 2024 11:14:16 +0900 Subject: [PATCH 17/38] =?UTF-8?q?feat(ChessDao):=20=EB=8D=B0=EC=9D=B4?= =?UTF-8?q?=ED=84=B0=EB=B2=A0=EC=9D=B4=EC=8A=A4=20=EC=A0=80=EC=9E=A5?= =?UTF-8?q?=EC=9D=84=20=EC=9C=84=ED=95=9C=20Dao=20=EA=B3=84=EC=B8=B5=20?= =?UTF-8?q?=EC=83=9D=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/dao/ChessDao.java | 42 ++++++++++++++++ .../java/chess/dao/ChessGameRepository.java | 12 +++++ src/main/java/chess/dao/PieceEntity.java | 49 +++++++++++++++++++ src/main/java/chess/dao/PieceRepository.java | 14 ++++++ src/main/java/chess/domain/Team.java | 2 +- .../java/chess/domain/position/Position.java | 8 +++ 6 files changed, 126 insertions(+), 1 deletion(-) create mode 100644 src/main/java/chess/dao/ChessDao.java create mode 100644 src/main/java/chess/dao/ChessGameRepository.java create mode 100644 src/main/java/chess/dao/PieceEntity.java create mode 100644 src/main/java/chess/dao/PieceRepository.java diff --git a/src/main/java/chess/dao/ChessDao.java b/src/main/java/chess/dao/ChessDao.java new file mode 100644 index 00000000000..643a1bad241 --- /dev/null +++ b/src/main/java/chess/dao/ChessDao.java @@ -0,0 +1,42 @@ +package chess.dao; + +import chess.domain.Team; +import chess.domain.position.Position; +import java.util.List; + +public class ChessDao { + + private final ChessGameRepository chessGameRepository; + private final PieceRepository pieceRepository; + + public ChessDao(ChessGameRepository chessGameRepository, PieceRepository pieceRepository) { + this.chessGameRepository = chessGameRepository; + this.pieceRepository = pieceRepository; + } + + public boolean isExistSavingGame() { + return chessGameRepository.isExistGame(); + } + + public List findAllPieces() { + return pieceRepository.findAll(); + } + + public void saveBoard(List pieces, Team currentTurn) { + pieceRepository.saveAll(pieces); + chessGameRepository.update(currentTurn); + } + + public void saveMoving(PieceEntity piece, Position previous, Team currentTurn) { + PieceEntity emptyPiece = PieceEntity.createEmptyPiece(previous); + + pieceRepository.update(piece); + pieceRepository.update(emptyPiece); + chessGameRepository.update(currentTurn); + } + + public void deleteAll() { + pieceRepository.deleteAll(); + chessGameRepository.deleteAll(); + } +} diff --git a/src/main/java/chess/dao/ChessGameRepository.java b/src/main/java/chess/dao/ChessGameRepository.java new file mode 100644 index 00000000000..595421151ab --- /dev/null +++ b/src/main/java/chess/dao/ChessGameRepository.java @@ -0,0 +1,12 @@ +package chess.dao; + +import chess.domain.Team; + +public interface ChessGameRepository { + + boolean isExistGame(); + + void update(Team turn); + + void deleteAll(); +} diff --git a/src/main/java/chess/dao/PieceEntity.java b/src/main/java/chess/dao/PieceEntity.java new file mode 100644 index 00000000000..214ac8660e5 --- /dev/null +++ b/src/main/java/chess/dao/PieceEntity.java @@ -0,0 +1,49 @@ +package chess.dao; + +import chess.domain.Team; +import chess.domain.piece.Piece; +import chess.domain.position.File; +import chess.domain.position.Position; +import chess.domain.position.Rank; +import chess.dto.PieceType; +import chess.dto.TeamType; + +public class PieceEntity { + + private final Position position; + private final PieceType pieceType; + private final TeamType teamType; + + public PieceEntity(Position position, Piece piece, Team team) { + this(position, PieceType.from(piece), TeamType.from(team)); + } + + private PieceEntity(Position position, PieceType pieceType, TeamType teamType) { + this.position = position; + this.pieceType = pieceType; + this.teamType = teamType; + } + + public static PieceEntity createEmptyPiece(Position position) { + PieceType pieceType = PieceType.getEmptyType(); + TeamType teamType = TeamType.getEmptyType(); + + return new PieceEntity(position, pieceType, teamType); + } + + public Rank getRank() { + return position.getRank(); + } + + public File getFile() { + return position.getFile(); + } + + public PieceType getPieceType() { + return pieceType; + } + + public TeamType getTeamType() { + return teamType; + } +} diff --git a/src/main/java/chess/dao/PieceRepository.java b/src/main/java/chess/dao/PieceRepository.java new file mode 100644 index 00000000000..bae3453f32d --- /dev/null +++ b/src/main/java/chess/dao/PieceRepository.java @@ -0,0 +1,14 @@ +package chess.dao; + +import java.util.List; + +public interface PieceRepository { + + List findAll(); + + List saveAll(List pieces); + + void update(PieceEntity piece); + + void deleteAll(); +} diff --git a/src/main/java/chess/domain/Team.java b/src/main/java/chess/domain/Team.java index 43c5a303e98..89dddda6a7f 100644 --- a/src/main/java/chess/domain/Team.java +++ b/src/main/java/chess/domain/Team.java @@ -3,7 +3,7 @@ public enum Team { BLACK, - WHITE + WHITE, ; public boolean isBlack() { diff --git a/src/main/java/chess/domain/position/Position.java b/src/main/java/chess/domain/position/Position.java index 8e6b99e1643..5dfebbfeb5d 100644 --- a/src/main/java/chess/domain/position/Position.java +++ b/src/main/java/chess/domain/position/Position.java @@ -47,6 +47,14 @@ public Position moveToSouth() { return new Position(file, rank.toSouth()); } + public File getFile() { + return file; + } + + public Rank getRank() { + return rank; + } + @Override public boolean equals(Object o) { if (this == o) { From 710bf816e2c035cd5ec6ec6defd4a934a2af54fe Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Sat, 30 Mar 2024 13:15:48 +0900 Subject: [PATCH 18/38] =?UTF-8?q?feat(TurnType)=20:=20TeamType=EA=B4=B4?= =?UTF-8?q?=EC=9D=98=20=EA=B5=AC=EB=B6=84=EC=9D=84=20=EC=9C=84=ED=95=B4=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/dao/ChessDao.java | 6 ++--- .../java/chess/dao/ChessGameRepository.java | 4 ++-- src/main/java/chess/dto/TurnType.java | 24 +++++++++++++++++++ 3 files changed, 29 insertions(+), 5 deletions(-) create mode 100644 src/main/java/chess/dto/TurnType.java diff --git a/src/main/java/chess/dao/ChessDao.java b/src/main/java/chess/dao/ChessDao.java index 643a1bad241..a223d9bff7c 100644 --- a/src/main/java/chess/dao/ChessDao.java +++ b/src/main/java/chess/dao/ChessDao.java @@ -1,7 +1,7 @@ package chess.dao; -import chess.domain.Team; import chess.domain.position.Position; +import chess.dto.TurnType; import java.util.List; public class ChessDao { @@ -22,12 +22,12 @@ public List findAllPieces() { return pieceRepository.findAll(); } - public void saveBoard(List pieces, Team currentTurn) { + public void saveBoard(List pieces, TurnType currentTurn) { pieceRepository.saveAll(pieces); chessGameRepository.update(currentTurn); } - public void saveMoving(PieceEntity piece, Position previous, Team currentTurn) { + public void saveMoving(PieceEntity piece, Position previous, TurnType currentTurn) { PieceEntity emptyPiece = PieceEntity.createEmptyPiece(previous); pieceRepository.update(piece); diff --git a/src/main/java/chess/dao/ChessGameRepository.java b/src/main/java/chess/dao/ChessGameRepository.java index 595421151ab..b984f921e95 100644 --- a/src/main/java/chess/dao/ChessGameRepository.java +++ b/src/main/java/chess/dao/ChessGameRepository.java @@ -1,12 +1,12 @@ package chess.dao; -import chess.domain.Team; +import chess.dto.TurnType; public interface ChessGameRepository { boolean isExistGame(); - void update(Team turn); + void update(TurnType turn); void deleteAll(); } diff --git a/src/main/java/chess/dto/TurnType.java b/src/main/java/chess/dto/TurnType.java new file mode 100644 index 00000000000..c1ff66eca18 --- /dev/null +++ b/src/main/java/chess/dto/TurnType.java @@ -0,0 +1,24 @@ +package chess.dto; + +import chess.domain.Team; +import java.util.Arrays; + +public enum TurnType { + + BLACK(Team.BLACK), + WHITE(Team.WHITE), + ; + + private final Team team; + + TurnType(Team team) { + this.team = team; + } + + public static TurnType from(Team team) { + return Arrays.stream(TurnType.values()) + .filter(teamType -> teamType.team == team) + .findAny() + .orElseThrow(() -> new IllegalArgumentException("해당 턴 타입이 없습니다.")); + } +} From 3cf4dc0fb538d222e08659984043e4f9f08a7da2 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Sat, 30 Mar 2024 13:59:36 +0900 Subject: [PATCH 19/38] =?UTF-8?q?test(BoardTest):=20entry=20=EC=88=9C?= =?UTF-8?q?=EC=84=9C=EC=97=90=20=EC=98=81=ED=96=A5=EC=9D=84=20=EB=B0=9B?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8F=84=EB=A1=9D=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/chess/domain/BoardTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/test/java/chess/domain/BoardTest.java b/src/test/java/chess/domain/BoardTest.java index 4318c6c7c54..7a0be3ac880 100644 --- a/src/test/java/chess/domain/BoardTest.java +++ b/src/test/java/chess/domain/BoardTest.java @@ -187,7 +187,7 @@ void calculatePointTest_whenNotExistPawn_addAll() { new Position(File.A, Rank.ONE), new Rook(Team.WHITE), new Position(File.D, Rank.ONE), new Queen(Team.WHITE))); - assertThat(board.calculateTotalPoints()).containsExactly( + assertThat(board.calculateTotalPoints()).containsOnly( Map.entry(Team.WHITE, new Point(5.0 + 9.0)), Map.entry(Team.BLACK, Point.ZERO)); } @@ -211,7 +211,7 @@ void calculatePointTest_whenExistPawnSameTeamAndDifferentFile_addHighPoint() { new Position(File.F, Rank.TWO), new Pawn(Team.WHITE), new Position(File.E, Rank.SEVEN), new Pawn(Team.BLACK))); - assertThat(board.calculateTotalPoints()).containsExactly( + assertThat(board.calculateTotalPoints()).containsOnly( Map.entry(Team.WHITE, new Point(1.0 + 1.0)), Map.entry(Team.BLACK, new Point(1.0))); } @@ -234,7 +234,7 @@ void calculatePointTest_whenExistPawnSameTeamAndFile_addLowPoint() { new Position(File.E, Rank.TWO), new Pawn(Team.WHITE), new Position(File.E, Rank.THREE), new Pawn(Team.WHITE))); - assertThat(board.calculateTotalPoints()).containsExactly( + assertThat(board.calculateTotalPoints()).containsOnly( Map.entry(Team.WHITE, new Point(0.5 + 0.5)), Map.entry(Team.BLACK, Point.ZERO)); } From 8c7e15b4b26f2669d2135077732e6feb2df16826 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Sat, 30 Mar 2024 14:02:30 +0900 Subject: [PATCH 20/38] =?UTF-8?q?feat(ChessGameRepository):=20=EC=B2=B4?= =?UTF-8?q?=ED=81=AC=20=EA=B2=8C=EC=9E=84=EC=9D=98=20=ED=84=B4=20=EC=83=81?= =?UTF-8?q?=ED=99=A9=20CRUD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- build.gradle | 2 + .../java/chess/dao/ChessGameRepository.java | 2 + .../java/chess/dao/ConnectionManager.java | 31 +++++++ .../chess/dao/MysqlChessGameRepository.java | 81 +++++++++++++++++++ 4 files changed, 116 insertions(+) create mode 100644 src/main/java/chess/dao/ConnectionManager.java create mode 100644 src/main/java/chess/dao/MysqlChessGameRepository.java diff --git a/build.gradle b/build.gradle index 3697236c6fb..20ad08a5a5e 100644 --- a/build.gradle +++ b/build.gradle @@ -13,6 +13,8 @@ dependencies { testImplementation platform('org.assertj:assertj-bom:3.25.1') testImplementation('org.junit.jupiter:junit-jupiter') testImplementation('org.assertj:assertj-core') + + runtimeOnly("com.mysql:mysql-connector-j:8.3.0") } java { diff --git a/src/main/java/chess/dao/ChessGameRepository.java b/src/main/java/chess/dao/ChessGameRepository.java index b984f921e95..50b2787f38e 100644 --- a/src/main/java/chess/dao/ChessGameRepository.java +++ b/src/main/java/chess/dao/ChessGameRepository.java @@ -6,6 +6,8 @@ public interface ChessGameRepository { boolean isExistGame(); + TurnType find(); + void update(TurnType turn); void deleteAll(); diff --git a/src/main/java/chess/dao/ConnectionManager.java b/src/main/java/chess/dao/ConnectionManager.java new file mode 100644 index 00000000000..fbdf79b2f7e --- /dev/null +++ b/src/main/java/chess/dao/ConnectionManager.java @@ -0,0 +1,31 @@ +package chess.dao; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +public class ConnectionManager { + + private static final String SERVER = "localhost:13306"; + private static final String DATABASE = "chess"; + private static final String OPTION = "?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC"; + + private static final String URL = "jdbc:mysql://" + SERVER + "/" + DATABASE + OPTION; + private static final String USERNAME = "root"; + private static final String PASSWORD = "root"; + + private static final Connection SINGLE_CONNECTION = createConnection(); + + private static Connection createConnection() { + try { + return DriverManager.getConnection(URL, USERNAME, PASSWORD); + } catch (final SQLException e) { + System.err.println("DB 연결 오류:" + e.getMessage()); + throw new IllegalStateException("DB와 연결할 수 없습니다.", e); + } + } + + public Connection getConnection() { + return SINGLE_CONNECTION; + } +} diff --git a/src/main/java/chess/dao/MysqlChessGameRepository.java b/src/main/java/chess/dao/MysqlChessGameRepository.java new file mode 100644 index 00000000000..0e198cc524a --- /dev/null +++ b/src/main/java/chess/dao/MysqlChessGameRepository.java @@ -0,0 +1,81 @@ +package chess.dao; + +import chess.dto.TurnType; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Map; + +public class MysqlChessGameRepository implements ChessGameRepository { + + private static final Map TURN_TO_STING = Map.of( + TurnType.BLACK, "BLACK", TurnType.WHITE, "WHITE"); + private static final Map STRING_TO_TURN = Map.of( + "BLACK", TurnType.BLACK, "WHITE", TurnType.WHITE); + + private final ConnectionManager connectionManager; + + public MysqlChessGameRepository(ConnectionManager connectionManager) { + this.connectionManager = connectionManager; + } + + @Override + public boolean isExistGame() { + return countRow() >= 1; + } + + private int countRow() { + Connection connection = connectionManager.getConnection(); + String query = "SELECT COUNT(*) FROM chess_game"; + try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { + ResultSet resultSet = preparedStatement.executeQuery(); + resultSet.next(); + return resultSet.getInt(1); + } catch (SQLException e) { + throw new IllegalStateException(e); + } + } + + @Override + public TurnType find() { + Connection connection = connectionManager.getConnection(); + String query = "SELECT turn FROM chess_game"; + try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { + ResultSet resultSet = preparedStatement.executeQuery(); + resultSet.next(); + String turn = resultSet.getString(1); + return STRING_TO_TURN.get(turn); + } catch (SQLException e) { + throw new IllegalStateException(e); + } + } + + @Override + public void update(TurnType turn) { + deleteAll(); + save(turn); + } + + private void save(TurnType team) { + Connection connection = connectionManager.getConnection(); + String query = "INSERT INTO chess_game (turn) VALUES (?)"; + try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { + preparedStatement.setString(1, TURN_TO_STING.get(team)); + preparedStatement.executeUpdate(); + } catch (SQLException e) { + throw new IllegalStateException(e); + } + } + + @Override + public void deleteAll() { + Connection connection = connectionManager.getConnection(); + String query = "DELETE FROM chess_game;"; + try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { + preparedStatement.executeUpdate(); + } catch (SQLException e) { + throw new IllegalStateException(e); + } + } +} From 8fd21fe57cce36ef26d763289534cbee698f3b00 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Sat, 30 Mar 2024 16:59:05 +0900 Subject: [PATCH 21/38] =?UTF-8?q?feat(MysqlPieceRepository):=20=EA=B8=B0?= =?UTF-8?q?=EB=AC=BC=20=EC=83=81=ED=99=A9=20CRUD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- database/init.sql | 10 +- .../java/chess/dao/MysqlPieceRepository.java | 143 ++++++++++++++++++ src/main/java/chess/dao/PieceEntity.java | 2 +- 3 files changed, 149 insertions(+), 6 deletions(-) create mode 100644 src/main/java/chess/dao/MysqlPieceRepository.java diff --git a/database/init.sql b/database/init.sql index d5ce5880dc3..73a27c45e45 100644 --- a/database/init.sql +++ b/database/init.sql @@ -3,14 +3,14 @@ CREATE DATABASE IF NOT EXISTS chess; USE chess; CREATE TABLE chess_game ( - turn VARCHAR(10) CHECK (turn IN ('BLACK', 'WHITE')), + turn VARCHAR(10) CHECK (turn IN ('BLACK', 'WHITE')) not null, PRIMARY KEY (turn) ); CREATE TABLE piece ( - board_rank VARCHAR(2) CHECK (board_rank IN ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')), - board_file VARCHAR(2) CHECK (board_file IN ('1', '2', '3', '4', '5', '6', '7', '8')), - type VARCHAR(10) CHECK (type IN ('KING', 'QUEEN', 'ROOK', 'BISHOP', 'KNIGHT', 'PAWN', 'EMPTY')), - team VARCHAR(10) CHECK (team IN ('BLACK', 'WHITE', 'EMPTY')), + board_file VARCHAR(2) CHECK (board_file IN ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')) not null, + board_rank VARCHAR(2) CHECK (board_rank IN ('1', '2', '3', '4', '5', '6', '7', '8')) not null, + type VARCHAR(10) CHECK (type IN ('KING', 'QUEEN', 'ROOK', 'BISHOP', 'KNIGHT', 'PAWN', 'EMPTY')) not null, + team VARCHAR(10) CHECK (team IN ('BLACK', 'WHITE', 'EMPTY')) not null, PRIMARY KEY (board_rank, board_file) ); diff --git a/src/main/java/chess/dao/MysqlPieceRepository.java b/src/main/java/chess/dao/MysqlPieceRepository.java new file mode 100644 index 00000000000..7b1abcf5cb6 --- /dev/null +++ b/src/main/java/chess/dao/MysqlPieceRepository.java @@ -0,0 +1,143 @@ +package chess.dao; + +import chess.domain.position.File; +import chess.domain.position.Position; +import chess.domain.position.Rank; +import chess.dto.PieceType; +import chess.dto.TeamType; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +public class MysqlPieceRepository implements PieceRepository { + + private static final Map FILE_TO_STRING = Map.of( + File.A, "A", File.B, "B", File.C, "C", File.D, "D", + File.E, "E", File.F, "F", File.G, "G", File.H, "H"); + private static final Map STRING_TO_FILE = Map.of( + "A", File.A, "B", File.B, "C", File.C, "D", File.D, + "E", File.E, "F", File.F, "G", File.G, "H", File.H); + private static final Map RANK_TO_STRING = Map.of( + Rank.ONE, "1", Rank.TWO, "2", Rank.THREE, "3", Rank.FOUR, "4", + Rank.FIVE, "5", Rank.SIX, "6", Rank.SEVEN, "7", Rank.EIGHT, "8"); + private static final Map STRING_TO_RANK = Map.of( + "1", Rank.ONE, "2", Rank.TWO, "3", Rank.THREE, "4", Rank.FOUR, + "5", Rank.FIVE, "6", Rank.SIX, "7", Rank.SEVEN, "8", Rank.EIGHT); + private static final Map PIECE_TYPE_TO_STRING = Map.of( + PieceType.KING, "KING", PieceType.QUEEN, "QUEEN", PieceType.ROOK, "ROOK", PieceType.BISHOP, "BISHOP", + PieceType.KNIGHT, "KNIGHT", PieceType.PAWN, "PAWN", PieceType.EMPTY, "EMPTY"); + private static final Map STRING_TO_PIECE_TYPE = Map.of( + "KING", PieceType.KING, "QUEEN", PieceType.QUEEN, "ROOK", PieceType.ROOK, "BISHOP", PieceType.BISHOP, + "KNIGHT", PieceType.KNIGHT, "PAWN", PieceType.PAWN, "EMPTY", PieceType.EMPTY); + private static final Map TEAM_TYPE_TO_STRING = Map.of( + TeamType.WHITE, "WHITE", TeamType.BLACK, "BLACK", TeamType.EMPTY, "EMPTY"); + private static final Map STRING_TO_TEAM_TYPE = Map.of( + "WHITE", TeamType.WHITE, "BLACK", TeamType.BLACK, "EMPTY", TeamType.EMPTY); + + private final ConnectionManager connectionManager; + + public MysqlPieceRepository(ConnectionManager connectionManager) { + this.connectionManager = connectionManager; + } + + @Override + public List findAll() { + Connection connection = connectionManager.getConnection(); + String query = "SELECT board_file, board_rank, type, team FROM piece"; + try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { + ResultSet resultSet = preparedStatement.executeQuery(); + + List result = new ArrayList<>(); + while (resultSet.next()) { + String fileString = resultSet.getString(1); + String rankString = resultSet.getString(2); + String pieceString = resultSet.getString(3); + String teamString = resultSet.getString(4); + + File file = STRING_TO_FILE.get(fileString); + Rank rank = STRING_TO_RANK.get(rankString); + Position position = new Position(file, rank); + PieceType pieceType = STRING_TO_PIECE_TYPE.get(pieceString); + TeamType teamType = STRING_TO_TEAM_TYPE.get(teamString); + + result.add(new PieceEntity(position, pieceType, teamType)); + } + return result; + } catch (SQLException e) { + throw new IllegalStateException(e); + } + } + + @Override + public List saveAll(List pieces) { + Connection connection = connectionManager.getConnection(); + String query = "INSERT INTO piece(board_file, board_rank, type, team) VALUES (?, ?, ?, ?)"; + try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { + addBatch(pieces, preparedStatement); + preparedStatement.executeBatch(); + return pieces; + } catch (SQLException e) { + throw new IllegalStateException(e); + } + } + + private void addBatch(List pieces, PreparedStatement preparedStatement) throws SQLException { + for (PieceEntity entity : pieces) { + setPreparedStatementForInsert(entity, preparedStatement); + preparedStatement.addBatch(); + } + } + + private void setPreparedStatementForInsert(PieceEntity entity, PreparedStatement preparedStatement) + throws SQLException { + String fileString = FILE_TO_STRING.get(entity.getFile()); + String rankString = RANK_TO_STRING.get(entity.getRank()); + String pieceString = PIECE_TYPE_TO_STRING.get(entity.getPieceType()); + String teamString = TEAM_TYPE_TO_STRING.get(entity.getTeamType()); + + preparedStatement.setString(1, fileString); + preparedStatement.setString(2, rankString); + preparedStatement.setString(3, pieceString); + preparedStatement.setString(4, teamString); + } + + @Override + public void update(PieceEntity piece) { + Connection connection = connectionManager.getConnection(); + String query = "UPDATE piece SET type = ?, team = ? WHERE board_file = ? AND board_rank = ?"; + try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { + setPreparedStatementForUpdate(piece, preparedStatement); + preparedStatement.executeUpdate(); + } catch (SQLException e) { + throw new IllegalStateException(e); + } + } + + private void setPreparedStatementForUpdate(PieceEntity entity, PreparedStatement preparedStatement) + throws SQLException { + String pieceString = PIECE_TYPE_TO_STRING.get(entity.getPieceType()); + String teamString = TEAM_TYPE_TO_STRING.get(entity.getTeamType()); + String fileString = FILE_TO_STRING.get(entity.getFile()); + String rankString = RANK_TO_STRING.get(entity.getRank()); + + preparedStatement.setString(1, pieceString); + preparedStatement.setString(2, teamString); + preparedStatement.setString(3, fileString); + preparedStatement.setString(4, rankString); + } + + @Override + public void deleteAll() { + Connection connection = connectionManager.getConnection(); + String query = "DELETE FROM piece"; + try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { + preparedStatement.executeUpdate(); + } catch (SQLException e) { + throw new IllegalStateException(e); + } + } +} diff --git a/src/main/java/chess/dao/PieceEntity.java b/src/main/java/chess/dao/PieceEntity.java index 214ac8660e5..bad55de6c19 100644 --- a/src/main/java/chess/dao/PieceEntity.java +++ b/src/main/java/chess/dao/PieceEntity.java @@ -18,7 +18,7 @@ public PieceEntity(Position position, Piece piece, Team team) { this(position, PieceType.from(piece), TeamType.from(team)); } - private PieceEntity(Position position, PieceType pieceType, TeamType teamType) { + public PieceEntity(Position position, PieceType pieceType, TeamType teamType) { this.position = position; this.pieceType = pieceType; this.teamType = teamType; From 56f54513669898d99ca9887a1bce3db3dcdf00fd Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Sun, 31 Mar 2024 22:34:52 +0900 Subject: [PATCH 22/38] =?UTF-8?q?feat(BoardService):=20=EB=B3=B4=EB=93=9C?= =?UTF-8?q?=20=EC=B4=88=EA=B8=B0=ED=99=94=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessService.java | 70 +++++++++++++++++++++ src/main/java/chess/dao/ChessDao.java | 4 ++ src/main/java/chess/dao/PieceEntity.java | 13 +++- src/main/java/chess/domain/Board.java | 17 ++++- src/main/java/chess/domain/piece/Piece.java | 4 ++ src/main/java/chess/dto/PieceType.java | 31 ++++++--- src/main/java/chess/dto/TeamType.java | 4 ++ src/main/java/chess/dto/TurnType.java | 4 ++ 8 files changed, 135 insertions(+), 12 deletions(-) create mode 100644 src/main/java/chess/ChessService.java diff --git a/src/main/java/chess/ChessService.java b/src/main/java/chess/ChessService.java new file mode 100644 index 00000000000..4199081af8c --- /dev/null +++ b/src/main/java/chess/ChessService.java @@ -0,0 +1,70 @@ +package chess; + +import chess.dao.ChessDao; +import chess.dao.PieceEntity; +import chess.domain.Board; +import chess.domain.BoardFactory; +import chess.domain.Team; +import chess.domain.piece.Piece; +import chess.domain.position.Position; +import chess.dto.TurnType; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +public class ChessService { + + private Board board; + private final ChessDao chessDao; + + public ChessService(ChessDao chessDao) { + this.chessDao = chessDao; + } + + public void init() { + validateInitState(); + if (chessDao.isExistSavingGame()) { + List pieceEntities = chessDao.findAllPieces(); + TurnType turn = chessDao.findCurrentTurn(); + board = toBoard(pieceEntities, turn); + return; + } + board = BoardFactory.createInitBoard(); + saveBoard(); + } + + private void validateInitState() { + if (board != null) { + throw new IllegalStateException("보드가 이미 초기화 되었습니다."); + } + } + + private void saveBoard() { + List entities = toEntities(board); + TurnType turn = TurnType.from(board.getTurn()); + chessDao.saveBoard(entities, turn); + } + + private Board toBoard(List pieceEntities, TurnType turnType) { + Map board = pieceEntities.stream() + .filter(piece -> !piece.getPieceType().isEmpty()) + .collect(Collectors.toMap( + PieceEntity::getPosition, + PieceEntity::toPiece + )); + Team turn = turnType.getTeam(); + return new Board(board, turn); + } + + private List toEntities(Board board) { + return Position.ALL_POSITIONS.stream() + .map(this::findPieceToEntity) + .toList(); + } + + private PieceEntity findPieceToEntity(Position position) { + return board.find(position) + .map(piece -> new PieceEntity(position, piece)) + .orElse(PieceEntity.createEmptyPiece(position)); + } +} diff --git a/src/main/java/chess/dao/ChessDao.java b/src/main/java/chess/dao/ChessDao.java index a223d9bff7c..cc22f51b8f3 100644 --- a/src/main/java/chess/dao/ChessDao.java +++ b/src/main/java/chess/dao/ChessDao.java @@ -18,6 +18,10 @@ public boolean isExistSavingGame() { return chessGameRepository.isExistGame(); } + public TurnType findCurrentTurn() { + return chessGameRepository.find(); + } + public List findAllPieces() { return pieceRepository.findAll(); } diff --git a/src/main/java/chess/dao/PieceEntity.java b/src/main/java/chess/dao/PieceEntity.java index bad55de6c19..eee5cb6048f 100644 --- a/src/main/java/chess/dao/PieceEntity.java +++ b/src/main/java/chess/dao/PieceEntity.java @@ -14,8 +14,8 @@ public class PieceEntity { private final PieceType pieceType; private final TeamType teamType; - public PieceEntity(Position position, Piece piece, Team team) { - this(position, PieceType.from(piece), TeamType.from(team)); + public PieceEntity(Position position, Piece piece) { + this(position, PieceType.from(piece), TeamType.from(piece.getTeam())); } public PieceEntity(Position position, PieceType pieceType, TeamType teamType) { @@ -31,6 +31,11 @@ public static PieceEntity createEmptyPiece(Position position) { return new PieceEntity(position, pieceType, teamType); } + public Piece toPiece() { + Team team = teamType.getTeam(); + return pieceType.createPiece(team); + } + public Rank getRank() { return position.getRank(); } @@ -39,6 +44,10 @@ public File getFile() { return position.getFile(); } + public Position getPosition() { + return position; + } + public PieceType getPieceType() { return pieceType; } diff --git a/src/main/java/chess/domain/Board.java b/src/main/java/chess/domain/Board.java index 0f551dc1375..49a2a3cb2e3 100644 --- a/src/main/java/chess/domain/Board.java +++ b/src/main/java/chess/domain/Board.java @@ -6,6 +6,7 @@ import chess.domain.position.Rank; import chess.dto.ProgressStatus; import java.util.Arrays; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -17,9 +18,13 @@ public class Board { private final Map board; private Team turn; - public Board(Map board) { + public Board(Map board, Team turn) { this.board = new HashMap<>(board); - this.turn = Team.WHITE; + this.turn = turn; + } + + public Board(Map board) { + this(board, Team.WHITE); } public Optional find(Position position) { @@ -143,4 +148,12 @@ private boolean isOverlappedPawn(List pieces) { .filter(Piece::isPawn) .count() >= 2; } + + public Map getBoard() { + return Collections.unmodifiableMap(board); + } + + public Team getTurn() { + return turn; + } } diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index 2316fd21a3d..ecafd1116e2 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -44,5 +44,9 @@ public final boolean isPawn() { return this.getClass() == Pawn.class; } + public Team getTeam() { + return team; + } + public abstract Point getPoint(boolean isOverlapped); } diff --git a/src/main/java/chess/dto/PieceType.java b/src/main/java/chess/dto/PieceType.java index 289b7823366..1133ca76021 100644 --- a/src/main/java/chess/dto/PieceType.java +++ b/src/main/java/chess/dto/PieceType.java @@ -1,5 +1,6 @@ package chess.dto; +import chess.domain.Team; import chess.domain.piece.Bishop; import chess.domain.piece.King; import chess.domain.piece.Knight; @@ -8,22 +9,25 @@ import chess.domain.piece.Queen; import chess.domain.piece.Rook; import java.util.Arrays; +import java.util.function.Function; public enum PieceType { - KING(King.class), - QUEEN(Queen.class), - ROOK(Rook.class), - BISHOP(Bishop.class), - KNIGHT(Knight.class), - PAWN(Pawn.class), - EMPTY(null), + KING(King.class, King::new), + QUEEN(Queen.class, Queen::new), + ROOK(Rook.class, Rook::new), + BISHOP(Bishop.class, Bishop::new), + KNIGHT(Knight.class, King::new), + PAWN(Pawn.class, Pawn::new), + EMPTY(null, null), ; private final Class category; + private final Function pieceFunction; - PieceType(Class category) { + PieceType(Class category, Function pieceFunction) { this.category = category; + this.pieceFunction = pieceFunction; } public static PieceType from(Piece piece) { @@ -36,4 +40,15 @@ public static PieceType from(Piece piece) { public static PieceType getEmptyType() { return EMPTY; } + + public Piece createPiece(Team team) { + if (isEmpty()) { + throw new IllegalStateException("빈 객체는 말을 만들 수 없습니다."); + } + return pieceFunction.apply(team); + } + + public boolean isEmpty() { + return this == EMPTY; + } } diff --git a/src/main/java/chess/dto/TeamType.java b/src/main/java/chess/dto/TeamType.java index 89805dbc60a..72e87139794 100644 --- a/src/main/java/chess/dto/TeamType.java +++ b/src/main/java/chess/dto/TeamType.java @@ -26,4 +26,8 @@ public static TeamType from(Team team) { public static TeamType getEmptyType() { return EMPTY; } + + public Team getTeam() { + return team; + } } diff --git a/src/main/java/chess/dto/TurnType.java b/src/main/java/chess/dto/TurnType.java index c1ff66eca18..9b8d4e53638 100644 --- a/src/main/java/chess/dto/TurnType.java +++ b/src/main/java/chess/dto/TurnType.java @@ -21,4 +21,8 @@ public static TurnType from(Team team) { .findAny() .orElseThrow(() -> new IllegalArgumentException("해당 턴 타입이 없습니다.")); } + + public Team getTeam() { + return team; + } } From 4e47860825c928abf1d13c8a3d73b6997d28ad86 Mon Sep 17 00:00:00 2001 From: leegwichan Date: Mon, 1 Apr 2024 00:45:32 +0900 Subject: [PATCH 23/38] =?UTF-8?q?feat(ChessService)=20:=20=EC=84=9C?= =?UTF-8?q?=EB=B9=84=EC=8A=A4=20=EB=A0=88=EC=9D=B4=EC=96=B4=20=EA=B5=AC?= =?UTF-8?q?=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessService.java | 63 ++++++++++++++++++++++++--- src/main/java/chess/domain/Board.java | 5 --- 2 files changed, 56 insertions(+), 12 deletions(-) diff --git a/src/main/java/chess/ChessService.java b/src/main/java/chess/ChessService.java index 4199081af8c..837e5c79cbe 100644 --- a/src/main/java/chess/ChessService.java +++ b/src/main/java/chess/ChessService.java @@ -4,12 +4,16 @@ import chess.dao.PieceEntity; import chess.domain.Board; import chess.domain.BoardFactory; +import chess.domain.Point; import chess.domain.Team; import chess.domain.piece.Piece; import chess.domain.position.Position; +import chess.dto.PieceDto; +import chess.dto.ProgressStatus; import chess.dto.TurnType; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.stream.Collectors; public class ChessService { @@ -39,12 +43,6 @@ private void validateInitState() { } } - private void saveBoard() { - List entities = toEntities(board); - TurnType turn = TurnType.from(board.getTurn()); - chessDao.saveBoard(entities, turn); - } - private Board toBoard(List pieceEntities, TurnType turnType) { Map board = pieceEntities.stream() .filter(piece -> !piece.getPieceType().isEmpty()) @@ -56,12 +54,63 @@ private Board toBoard(List pieceEntities, TurnType turnType) { return new Board(board, turn); } - private List toEntities(Board board) { + private void saveBoard() { + List entities = findEntities(); + TurnType turn = TurnType.from(board.getTurn()); + chessDao.saveBoard(entities, turn); + } + + private List findEntities() { return Position.ALL_POSITIONS.stream() .map(this::findPieceToEntity) .toList(); } + public ProgressStatus moveTo(Position start, Position end) { + ProgressStatus progressStatus = board.move(start, end); + + if (progressStatus.isContinue()) { + saveMoving(start, end); + return progressStatus; + } + chessDao.deleteAll(); + return progressStatus; + } + + private void saveMoving(Position start, Position end) { + PieceEntity movedPiece = findPieceToEntity(end); + TurnType turnType = TurnType.from(board.getTurn()); + chessDao.saveMoving(movedPiece, start, turnType); + } + + public Map calculatePiecePoints() { + Map status = board.calculateTotalPoints(); + return toDto(status); + } + + private Map toDto(Map status) { + return status.entrySet().stream() + .collect(Collectors.toMap( + Entry::getKey, + entry -> entry.getValue().toDouble() + )); + } + + public Map findTotalBoard() { + + return Position.ALL_POSITIONS.stream() + .filter(position -> board.find(position).isPresent()) + .map(this::toEntry) + .collect(Collectors.toMap(Entry::getKey, Entry::getValue)); + } + + private Entry toEntry(Position position) { + Piece piece = board.find(position) + .orElseThrow(); + PieceDto pieceDto = PieceDto.from(piece); + return Map.entry(position, pieceDto); + } + private PieceEntity findPieceToEntity(Position position) { return board.find(position) .map(piece -> new PieceEntity(position, piece)) diff --git a/src/main/java/chess/domain/Board.java b/src/main/java/chess/domain/Board.java index 49a2a3cb2e3..f31a41f0c2d 100644 --- a/src/main/java/chess/domain/Board.java +++ b/src/main/java/chess/domain/Board.java @@ -6,7 +6,6 @@ import chess.domain.position.Rank; import chess.dto.ProgressStatus; import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -149,10 +148,6 @@ private boolean isOverlappedPawn(List pieces) { .count() >= 2; } - public Map getBoard() { - return Collections.unmodifiableMap(board); - } - public Team getTurn() { return turn; } From e5e006c7b3328e8771f82cee877837836958c31d Mon Sep 17 00:00:00 2001 From: leegwichan Date: Mon, 1 Apr 2024 01:07:02 +0900 Subject: [PATCH 24/38] =?UTF-8?q?feat(ChessGame):=20ChessService=EC=99=80?= =?UTF-8?q?=20=EC=97=B0=EA=B2=B0=EB=90=98=EB=8F=84=EB=A1=9D=20=EA=B5=AC?= =?UTF-8?q?=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessApplication.java | 24 +++++- src/main/java/chess/ChessGame.java | 83 ++++++++------------- src/main/java/chess/dto/ProgressStatus.java | 5 ++ 3 files changed, 55 insertions(+), 57 deletions(-) diff --git a/src/main/java/chess/ChessApplication.java b/src/main/java/chess/ChessApplication.java index 358aaf02166..fe9461b6d58 100644 --- a/src/main/java/chess/ChessApplication.java +++ b/src/main/java/chess/ChessApplication.java @@ -1,19 +1,35 @@ package chess; +import chess.dao.ChessDao; +import chess.dao.ChessGameRepository; +import chess.dao.ConnectionManager; +import chess.dao.MysqlChessGameRepository; +import chess.dao.MysqlPieceRepository; +import chess.dao.PieceRepository; import chess.view.InputView; import chess.view.OutputView; public class ChessApplication { + private static final InputView INPUT_VIEW = new InputView(); + private static final OutputView OUTPUT_VIEW = new OutputView(); + public static void main(String[] args) { - InputView inputView = new InputView(); - OutputView outputView = new OutputView(); - ChessGame chessGame = new ChessGame(inputView, outputView); + ConnectionManager connectionManager = new ConnectionManager(); + ChessGameRepository chessGameRepository = new MysqlChessGameRepository(connectionManager); + PieceRepository pieceRepository = new MysqlPieceRepository(connectionManager); + ChessDao chessDao = new ChessDao(chessGameRepository, pieceRepository); + ChessService chessService = new ChessService(chessDao); + + ChessGame chessGame = new ChessGame(INPUT_VIEW, OUTPUT_VIEW, chessService); + run(chessGame); + } + private static void run(ChessGame chessGame) { try { chessGame.run(); } catch (IllegalArgumentException exception) { - outputView.printExceptionMessage(exception); + OUTPUT_VIEW.printExceptionMessage(exception); } } } diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java index 10f7be5db96..a68eb6d8636 100644 --- a/src/main/java/chess/ChessGame.java +++ b/src/main/java/chess/ChessGame.java @@ -1,114 +1,91 @@ package chess; -import chess.domain.Board; -import chess.domain.BoardFactory; -import chess.domain.Point; import chess.domain.Team; -import chess.domain.piece.Piece; import chess.domain.position.Position; import chess.dto.PieceDto; import chess.dto.ProgressStatus; import chess.view.GameCommand; import chess.view.InputView; import chess.view.OutputView; -import java.util.HashMap; -import java.util.List; import java.util.Map; -import java.util.Map.Entry; -import java.util.Optional; -import java.util.stream.Collectors; public class ChessGame { private final InputView inputView; private final OutputView outputView; + private final ChessService chessService; - public ChessGame(InputView inputView, OutputView outputView) { + public ChessGame(InputView inputView, OutputView outputView, ChessService chessService) { this.inputView = inputView; this.outputView = outputView; + this.chessService = chessService; } public void run() { - Board board = startGame(); - play(board); + startGame(); + play(); } - private Board startGame() { + private void startGame() { outputView.printStartGame(); GameCommand command = inputView.readCommand(); if (command.isStart()) { - Board board = BoardFactory.createInitBoard(); - showBoard(board); - return board; + initBoard(); + showBoard(); + return; } throw new IllegalArgumentException("아직 게임을 시작하지 않았습니다."); } - private void play(Board board) { + private void initBoard() { + chessService.init(); + } + + private void play() { ProgressStatus status; do { - status = processTurn(board); + status = processTurn(); } while (status.isContinue()); - showResult(status); } - private ProgressStatus processTurn(Board board) { + private ProgressStatus processTurn() { GameCommand command = inputView.readCommand(); if (command.isStart()) { throw new IllegalArgumentException("이미 게임을 시작했습니다."); } - if (command.isEnd()) { - System.exit(0); + if (command.isMove()) { + return executeMove(); } if (command.isStatus()) { - return executeStatus(board); + return executeStatus(); } - return executeMove(board); + return ProgressStatus.END_GAME; } - private ProgressStatus executeStatus(Board board) { - Map status = board.calculateTotalPoints(); - Map statusDto = toDto(status); + private ProgressStatus executeStatus() { + Map statusDto = chessService.calculatePiecePoints(); outputView.printStatus(statusDto); return ProgressStatus.PROGRESS; } - private Map toDto(Map status) { - return status.entrySet().stream() - .collect(Collectors.toMap( - Entry::getKey, - entry -> entry.getValue().toDouble() - )); - } - - private ProgressStatus executeMove(Board board) { + private ProgressStatus executeMove() { Position start = inputView.readPosition(); Position end = inputView.readPosition(); - ProgressStatus status = board.move(start, end); - showBoard(board); + ProgressStatus status = chessService.moveTo(start, end); + showBoard(); return status; } private void showResult(ProgressStatus status) { + if (status.isInputEndCommand()) { + return; + } outputView.printWinnerMessage(status); } - private void showBoard(Board board) { - List positions = Position.ALL_POSITIONS; - Map boardDto = new HashMap<>(); - positions.forEach(position -> addPiece(board, position, boardDto)); + private void showBoard() { + Map boardDto = chessService.findTotalBoard(); outputView.printBoard(boardDto); } - - private void addPiece(Board board, Position position, Map boardDto) { - Optional optionalPiece = board.find(position); - if (optionalPiece.isEmpty()) { - return; - } - - Piece piece = optionalPiece.get(); - PieceDto pieceDto = PieceDto.from(piece); - boardDto.put(position, pieceDto); - } } diff --git a/src/main/java/chess/dto/ProgressStatus.java b/src/main/java/chess/dto/ProgressStatus.java index 7914d118820..154c21761c5 100644 --- a/src/main/java/chess/dto/ProgressStatus.java +++ b/src/main/java/chess/dto/ProgressStatus.java @@ -5,6 +5,7 @@ public enum ProgressStatus { WHITE_WIN(false), BLACK_WIN(false), PROGRESS(true), + END_GAME(false), ; private final boolean isContinue; @@ -16,4 +17,8 @@ public enum ProgressStatus { public boolean isContinue() { return isContinue; } + + public boolean isInputEndCommand() { + return this == END_GAME; + } } From da3bbf18cebf5374f18512e76735a6cd8000f28d Mon Sep 17 00:00:00 2001 From: leegwichan Date: Mon, 1 Apr 2024 01:07:46 +0900 Subject: [PATCH 25/38] =?UTF-8?q?refactor(OutputView):=20printf=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=EC=9D=84=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EB=8F=84=EB=A1=9D=20=EB=A6=AC=ED=8C=A9=ED=84=B0=EB=A7=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/view/OutputView.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index cc8d85dba2d..5951c7fe596 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -78,10 +78,10 @@ public void printStatus(Map status) { private void printStatus(Team team, double score) { if (team.isBlack()) { - System.out.println("검정 팀 : %.1f".formatted(score)); + System.out.printf("검정 팀 : %.1f%n", score); return; } - System.out.println("하양 팀 : %.1f".formatted(score)); + System.out.printf("하양 팀 : %.1f%n", score); } public void printWinnerMessage(ProgressStatus status) { From db1b6c3a5d33ac7bb3a0a1bf39d1d3c92d1d6818 Mon Sep 17 00:00:00 2001 From: leegwichan Date: Mon, 1 Apr 2024 01:24:47 +0900 Subject: [PATCH 26/38] =?UTF-8?q?feat(ChessGame):=20=EC=8B=9C=EC=9E=91=20?= =?UTF-8?q?=EC=8B=9C=EC=97=90=20=ED=98=84=EC=9E=AC=20=EB=88=84=EA=B5=AC?= =?UTF-8?q?=EC=9D=98=20=EC=B0=A8=EB=A1=80=EC=9D=B8=EC=A7=80=20=EC=95=88?= =?UTF-8?q?=EB=82=B4=ED=95=98=EB=8A=94=20=EB=AC=B8=EA=B5=AC=20=EC=B6=9C?= =?UTF-8?q?=EB=A0=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 8 ++++---- src/main/java/chess/ChessGame.java | 6 ++++++ src/main/java/chess/ChessService.java | 4 ++++ src/main/java/chess/view/OutputView.java | 8 ++++++++ 4 files changed, 22 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index b3a3529724e..b3891fc7004 100644 --- a/README.md +++ b/README.md @@ -42,10 +42,10 @@ - [x] 다음 동, 서, 남, 북쪽 위치를 알려준다. ### 저장소 -- [ ] 각 말을 한 번 움직임을 저장할 수 있다. -- [ ] 말의 전체 위치를 저장할 수 있다. -- [ ] 게임이 끝나, 저장소를 초기화할 수 있다. -- [ ] 현재 진행중인 게임이 있는지 알 수 있다. +- [x] 각 말을 한 번 움직임을 저장할 수 있다. +- [x] 말의 전체 위치를 저장할 수 있다. +- [x] 게임이 끝나, 저장소를 초기화할 수 있다. +- [x] 현재 진행중인 게임이 있는지 알 수 있다. ### 출력 - [x] 체스판에서 각 진영은 검은색(대문자)과 흰색(소문자) 편으로 구분한다. diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java index a68eb6d8636..051e8996b36 100644 --- a/src/main/java/chess/ChessGame.java +++ b/src/main/java/chess/ChessGame.java @@ -31,6 +31,7 @@ private void startGame() { GameCommand command = inputView.readCommand(); if (command.isStart()) { initBoard(); + showCurrentTeam(); showBoard(); return; } @@ -41,6 +42,11 @@ private void initBoard() { chessService.init(); } + private void showCurrentTeam() { + Team turn = chessService.findCurrentTeam(); + outputView.printCurrentTurn(turn); + } + private void play() { ProgressStatus status; do { diff --git a/src/main/java/chess/ChessService.java b/src/main/java/chess/ChessService.java index 837e5c79cbe..373a3060ea1 100644 --- a/src/main/java/chess/ChessService.java +++ b/src/main/java/chess/ChessService.java @@ -116,4 +116,8 @@ private PieceEntity findPieceToEntity(Position position) { .map(piece -> new PieceEntity(position, piece)) .orElse(PieceEntity.createEmptyPiece(position)); } + + public Team findCurrentTeam() { + return board.getTurn(); + } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 5951c7fe596..e854d284dbf 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -32,6 +32,14 @@ public void printStartGame() { > 게임 이동 : move source위치 target위치 - 예. move b2 b3"""); } + public void printCurrentTurn(Team turn) { + if (turn.isBlack()) { + System.out.println("현재 검은 팀 차례입니다."); + return; + } + System.out.println("현재 흰 팀 차례입니다."); + } + public void printBoard(Map board) { System.out.println(); for (Rank rank : RANK_ORDER) { From f7cf3fff20b4d4640d09d4fa4830619a39be28bf Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 09:38:57 +0900 Subject: [PATCH 27/38] =?UTF-8?q?fix(OutputView):=20=EC=B6=94=EA=B0=80=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EC=B6=9C=EB=A0=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/view/OutputView.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index e854d284dbf..f992db2ac24 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -29,7 +29,9 @@ public void printStartGame() { > 체스 게임을 시작합니다. > 게임 시작 : start > 게임 종료 : end - > 게임 이동 : move source위치 target위치 - 예. move b2 b3"""); + > 게임 이동 : move source위치 target위치 - 예. move b2 b3 + > 팀 별 기물 점수 조회 : status + """); } public void printCurrentTurn(Team turn) { From e50ea69a54db01250e1d546a032b653725ba0172 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 09:48:17 +0900 Subject: [PATCH 28/38] =?UTF-8?q?refactor=20(ChessService)=20:=20null=20?= =?UTF-8?q?=EA=B0=9D=EC=B2=B4=EB=A5=BC=20=EC=9D=B4=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=97=AC=20=EC=B6=9C=EB=A0=A5=ED=95=98=EB=8F=84=EB=A1=9D=20?= =?UTF-8?q?=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessService.java | 37 ++++++++++++------------ src/main/java/chess/dto/PieceDto.java | 8 +++++ src/main/java/chess/view/OutputView.java | 12 ++------ 3 files changed, 30 insertions(+), 27 deletions(-) diff --git a/src/main/java/chess/ChessService.java b/src/main/java/chess/ChessService.java index 373a3060ea1..d1e0fc07b87 100644 --- a/src/main/java/chess/ChessService.java +++ b/src/main/java/chess/ChessService.java @@ -14,6 +14,7 @@ import java.util.List; import java.util.Map; import java.util.Map.Entry; +import java.util.Optional; import java.util.stream.Collectors; public class ChessService { @@ -83,31 +84,18 @@ private void saveMoving(Position start, Position end) { chessDao.saveMoving(movedPiece, start, turnType); } - public Map calculatePiecePoints() { - Map status = board.calculateTotalPoints(); - return toDto(status); - } - - private Map toDto(Map status) { - return status.entrySet().stream() - .collect(Collectors.toMap( - Entry::getKey, - entry -> entry.getValue().toDouble() - )); - } - public Map findTotalBoard() { - return Position.ALL_POSITIONS.stream() - .filter(position -> board.find(position).isPresent()) .map(this::toEntry) .collect(Collectors.toMap(Entry::getKey, Entry::getValue)); } private Entry toEntry(Position position) { - Piece piece = board.find(position) - .orElseThrow(); - PieceDto pieceDto = PieceDto.from(piece); + Optional optionalPiece = board.find(position); + if (optionalPiece.isEmpty()) { + return Map.entry(position, PieceDto.createEmptyPiece()); + } + PieceDto pieceDto = PieceDto.from(optionalPiece.get()); return Map.entry(position, pieceDto); } @@ -117,6 +105,19 @@ private PieceEntity findPieceToEntity(Position position) { .orElse(PieceEntity.createEmptyPiece(position)); } + public Map calculatePiecePoints() { + Map status = board.calculateTotalPoints(); + return toDto(status); + } + + private Map toDto(Map status) { + return status.entrySet().stream() + .collect(Collectors.toMap( + Entry::getKey, + entry -> entry.getValue().toDouble() + )); + } + public Team findCurrentTeam() { return board.getTurn(); } diff --git a/src/main/java/chess/dto/PieceDto.java b/src/main/java/chess/dto/PieceDto.java index 24d76a8a4bb..9358f1089b5 100644 --- a/src/main/java/chess/dto/PieceDto.java +++ b/src/main/java/chess/dto/PieceDto.java @@ -10,4 +10,12 @@ public static PieceDto from(Piece piece) { return new PieceDto(type, isBlackTeam); } + + public static PieceDto createEmptyPiece() { + return new PieceDto(PieceType.getEmptyType(), true); + } + + public boolean isEmpty() { + return type.isEmpty(); + } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index f992db2ac24..ba9876ce0e7 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -9,7 +9,6 @@ import chess.dto.ProgressStatus; import java.util.List; import java.util.Map; -import java.util.Optional; public class OutputView { @@ -19,8 +18,8 @@ public class OutputView { File.A, File.B, File.C, File.D, File.E, File.F, File.G, File.H); private static final List TEAM_ORDER = List.of(Team.WHITE, Team.BLACK); private static final Map PIECE_DISPLAY = Map.of( - PieceType.KING, "K", PieceType.QUEEN, "Q", PieceType.KNIGHT, "N", - PieceType.BISHOP, "B", PieceType.ROOK, "R", PieceType.PAWN, "P"); + PieceType.KING, "K", PieceType.QUEEN, "Q", PieceType.KNIGHT, "N", PieceType.BISHOP, "B", + PieceType.ROOK, "R", PieceType.PAWN, "P", PieceType.EMPTY, "."); private static final String EMPTY_SPACE = "."; private static final String ERROR_PREFIX = "[ERROR] "; @@ -52,8 +51,7 @@ public void printBoard(Map board) { private void printBoardOneLine(Map board, Rank rank) { for (File file : FILE_ORDER) { PieceDto piece = board.get(new Position(file, rank)); - Optional optional = Optional.ofNullable(piece); - optional.ifPresentOrElse(this::printPiece, this::printEmptySpace); + printPiece(piece); } System.out.println(); } @@ -66,10 +64,6 @@ private void printPiece(PieceDto piece) { printWhitePiece(piece.type()); } - private void printEmptySpace() { - System.out.print(EMPTY_SPACE); - } - private void printBlackPiece(PieceType type) { String display = PIECE_DISPLAY.get(type); System.out.print(display.toUpperCase()); From 2df6c3136957199cdd38eeab6cdfd11ba27ac1c4 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 09:58:32 +0900 Subject: [PATCH 29/38] =?UTF-8?q?refactor(ChessService):=20Optional?= =?UTF-8?q?=EC=9D=98=20=ED=8E=B8=EC=9D=98=20=EB=A9=94=EC=84=9C=EB=93=9C?= =?UTF-8?q?=EB=A5=BC=20=EC=9D=B4=EC=9A=A9=ED=95=98=EC=97=AC=20if=EB=AC=B8?= =?UTF-8?q?=20=EC=A0=9C=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessService.java | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/src/main/java/chess/ChessService.java b/src/main/java/chess/ChessService.java index d1e0fc07b87..e603aeebe93 100644 --- a/src/main/java/chess/ChessService.java +++ b/src/main/java/chess/ChessService.java @@ -14,7 +14,6 @@ import java.util.List; import java.util.Map; import java.util.Map.Entry; -import java.util.Optional; import java.util.stream.Collectors; public class ChessService { @@ -86,16 +85,14 @@ private void saveMoving(Position start, Position end) { public Map findTotalBoard() { return Position.ALL_POSITIONS.stream() - .map(this::toEntry) + .map(this::toResultEntry) .collect(Collectors.toMap(Entry::getKey, Entry::getValue)); } - private Entry toEntry(Position position) { - Optional optionalPiece = board.find(position); - if (optionalPiece.isEmpty()) { - return Map.entry(position, PieceDto.createEmptyPiece()); - } - PieceDto pieceDto = PieceDto.from(optionalPiece.get()); + private Entry toResultEntry(Position position) { + PieceDto pieceDto = board.find(position) + .map(PieceDto::from) + .orElse(PieceDto.createEmptyPiece()); return Map.entry(position, pieceDto); } From bcf5d2617165f561c1956f42a1dd344cf4e96e89 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 10:06:36 +0900 Subject: [PATCH 30/38] =?UTF-8?q?style(ChessService):=20=ED=98=84=EC=9E=AC?= =?UTF-8?q?=20=ED=84=B4=EC=9D=84=20=EC=B0=BE=EB=8A=94=EB=8B=A4=EB=8A=94=20?= =?UTF-8?q?=EB=82=B4=EC=9A=A9=EC=9D=84=20=EA=B0=95=EC=A1=B0=ED=95=98?= =?UTF-8?q?=EA=B8=B0=20=EC=9C=84=ED=95=B4=20=EB=A9=94=EC=84=9C=EB=93=9C=20?= =?UTF-8?q?=EC=9D=B4=EB=A6=84=20=EB=B3=80=EA=B2=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessGame.java | 2 +- src/main/java/chess/ChessService.java | 8 ++++---- src/main/java/chess/domain/Board.java | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java index 051e8996b36..8be9c577a94 100644 --- a/src/main/java/chess/ChessGame.java +++ b/src/main/java/chess/ChessGame.java @@ -43,7 +43,7 @@ private void initBoard() { } private void showCurrentTeam() { - Team turn = chessService.findCurrentTeam(); + Team turn = chessService.findCurrentTurn(); outputView.printCurrentTurn(turn); } diff --git a/src/main/java/chess/ChessService.java b/src/main/java/chess/ChessService.java index e603aeebe93..92826b82690 100644 --- a/src/main/java/chess/ChessService.java +++ b/src/main/java/chess/ChessService.java @@ -56,7 +56,7 @@ private Board toBoard(List pieceEntities, TurnType turnType) { private void saveBoard() { List entities = findEntities(); - TurnType turn = TurnType.from(board.getTurn()); + TurnType turn = TurnType.from(board.findCurrentTurn()); chessDao.saveBoard(entities, turn); } @@ -79,7 +79,7 @@ public ProgressStatus moveTo(Position start, Position end) { private void saveMoving(Position start, Position end) { PieceEntity movedPiece = findPieceToEntity(end); - TurnType turnType = TurnType.from(board.getTurn()); + TurnType turnType = TurnType.from(board.findCurrentTurn()); chessDao.saveMoving(movedPiece, start, turnType); } @@ -115,7 +115,7 @@ private Map toDto(Map status) { )); } - public Team findCurrentTeam() { - return board.getTurn(); + public Team findCurrentTurn() { + return board.findCurrentTurn(); } } diff --git a/src/main/java/chess/domain/Board.java b/src/main/java/chess/domain/Board.java index f31a41f0c2d..b9c82ea40d7 100644 --- a/src/main/java/chess/domain/Board.java +++ b/src/main/java/chess/domain/Board.java @@ -148,7 +148,7 @@ private boolean isOverlappedPawn(List pieces) { .count() >= 2; } - public Team getTurn() { + public Team findCurrentTurn() { return turn; } } From 2317cc335234850048465ca5824f8114376bcb22 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 10:07:27 +0900 Subject: [PATCH 31/38] =?UTF-8?q?refactor(ChessService):=20=EA=B0=80?= =?UTF-8?q?=EB=8F=85=EC=84=B1=EC=9D=84=20=EC=9C=84=ED=95=B4=20PieceEntity?= =?UTF-8?q?=EC=9D=98=20=EB=A9=94=EC=84=9C=EB=93=9C=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessService.java | 2 +- src/main/java/chess/dao/PieceEntity.java | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/main/java/chess/ChessService.java b/src/main/java/chess/ChessService.java index 92826b82690..0b353f1e42f 100644 --- a/src/main/java/chess/ChessService.java +++ b/src/main/java/chess/ChessService.java @@ -45,7 +45,7 @@ private void validateInitState() { private Board toBoard(List pieceEntities, TurnType turnType) { Map board = pieceEntities.stream() - .filter(piece -> !piece.getPieceType().isEmpty()) + .filter(PieceEntity::isExistPiece) .collect(Collectors.toMap( PieceEntity::getPosition, PieceEntity::toPiece diff --git a/src/main/java/chess/dao/PieceEntity.java b/src/main/java/chess/dao/PieceEntity.java index eee5cb6048f..df895400eb4 100644 --- a/src/main/java/chess/dao/PieceEntity.java +++ b/src/main/java/chess/dao/PieceEntity.java @@ -36,6 +36,10 @@ public Piece toPiece() { return pieceType.createPiece(team); } + public boolean isExistPiece() { + return !pieceType.isEmpty(); + } + public Rank getRank() { return position.getRank(); } From 4564d64757e191408cea38e13b3d4fb8de96b31f Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 12:06:14 +0900 Subject: [PATCH 32/38] =?UTF-8?q?refactor(PawnMovement):=20=ED=8F=B0=20?= =?UTF-8?q?=EC=9B=80=EC=A7=81=EC=9E=84=20=EC=B6=94=EC=83=81=ED=99=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../movement/BlackPawnDefaultMovement.java | 30 ---------------- .../movement/BlackPawnDiagonalMovement.java | 28 --------------- .../movement/BlackPawnFirstMovement.java | 34 ------------------- .../movement/WhitePawnDefaultMovement.java | 30 ---------------- .../movement/WhitePawnDiagonalMovement.java | 28 --------------- .../movement/WhitePawnFirstMovement.java | 34 ------------------- .../pawn/BlackPawnDefaultMovement.java | 25 ++++++++++++++ .../pawn/BlackPawnDiagonalMovement.java | 12 +++++++ .../movement/pawn/BlackPawnFirstMovement.java | 28 +++++++++++++++ .../movement/pawn/PawnDiagonalMovement.java | 29 ++++++++++++++++ .../movement/pawn/PawnForwardMovement.java | 33 ++++++++++++++++++ .../pawn/WhitePawnDefaultMovement.java | 25 ++++++++++++++ .../pawn/WhitePawnDiagonalMovement.java | 12 +++++++ .../movement/pawn/WhitePawnFirstMovement.java | 28 +++++++++++++++ src/main/java/chess/domain/piece/Pawn.java | 12 +++---- src/main/java/chess/dto/PieceDto.java | 4 --- .../BlackPawnDefaultMovementTest.java | 2 +- .../BlackPawnDiagonalMovementTest.java | 2 +- .../BlackPawnFirstMovementTest.java | 2 +- .../WhitePawnDefaultMovementTest.java | 2 +- .../WhitePawnDiagonalMovementTest.java | 2 +- .../WhitePawnFirstMovementTest.java | 2 +- 22 files changed, 204 insertions(+), 200 deletions(-) delete mode 100644 src/main/java/chess/domain/movement/BlackPawnDefaultMovement.java delete mode 100644 src/main/java/chess/domain/movement/BlackPawnDiagonalMovement.java delete mode 100644 src/main/java/chess/domain/movement/BlackPawnFirstMovement.java delete mode 100644 src/main/java/chess/domain/movement/WhitePawnDefaultMovement.java delete mode 100644 src/main/java/chess/domain/movement/WhitePawnDiagonalMovement.java delete mode 100644 src/main/java/chess/domain/movement/WhitePawnFirstMovement.java create mode 100644 src/main/java/chess/domain/movement/pawn/BlackPawnDefaultMovement.java create mode 100644 src/main/java/chess/domain/movement/pawn/BlackPawnDiagonalMovement.java create mode 100644 src/main/java/chess/domain/movement/pawn/BlackPawnFirstMovement.java create mode 100644 src/main/java/chess/domain/movement/pawn/PawnDiagonalMovement.java create mode 100644 src/main/java/chess/domain/movement/pawn/PawnForwardMovement.java create mode 100644 src/main/java/chess/domain/movement/pawn/WhitePawnDefaultMovement.java create mode 100644 src/main/java/chess/domain/movement/pawn/WhitePawnDiagonalMovement.java create mode 100644 src/main/java/chess/domain/movement/pawn/WhitePawnFirstMovement.java rename src/test/java/chess/domain/movement/{ => pawn}/BlackPawnDefaultMovementTest.java (98%) rename src/test/java/chess/domain/movement/{ => pawn}/BlackPawnDiagonalMovementTest.java (98%) rename src/test/java/chess/domain/movement/{ => pawn}/BlackPawnFirstMovementTest.java (98%) rename src/test/java/chess/domain/movement/{ => pawn}/WhitePawnDefaultMovementTest.java (98%) rename src/test/java/chess/domain/movement/{ => pawn}/WhitePawnDiagonalMovementTest.java (98%) rename src/test/java/chess/domain/movement/{ => pawn}/WhitePawnFirstMovementTest.java (98%) diff --git a/src/main/java/chess/domain/movement/BlackPawnDefaultMovement.java b/src/main/java/chess/domain/movement/BlackPawnDefaultMovement.java deleted file mode 100644 index 93e67fe2e9d..00000000000 --- a/src/main/java/chess/domain/movement/BlackPawnDefaultMovement.java +++ /dev/null @@ -1,30 +0,0 @@ -package chess.domain.movement; - -import chess.domain.position.Position; -import java.util.List; - -public final class BlackPawnDefaultMovement implements MovementRule { - - private static final int TO_SOUTH_ONE_BLOCK = -1; - private static final int SAME_FILE = 0; - - @Override - public boolean isMovable(Position start, Position end, boolean isAttack) { - int rankDifference = start.calculateRankDifference(end); - int fileDifference = start.calculateFileDifference(end); - - boolean isEmptyAtEnd = !isAttack; - boolean isMatchDifference = (rankDifference == TO_SOUTH_ONE_BLOCK && fileDifference == SAME_FILE); - - return isEmptyAtEnd && isMatchDifference; - } - - @Override - public List findPath(Position start, Position end, boolean isAttack) { - if (!isMovable(start, end, isAttack)) { - throw new IllegalArgumentException("경로가 존재하지 않습니다."); - } - - return List.of(end); - } -} diff --git a/src/main/java/chess/domain/movement/BlackPawnDiagonalMovement.java b/src/main/java/chess/domain/movement/BlackPawnDiagonalMovement.java deleted file mode 100644 index 1f78a40f89f..00000000000 --- a/src/main/java/chess/domain/movement/BlackPawnDiagonalMovement.java +++ /dev/null @@ -1,28 +0,0 @@ -package chess.domain.movement; - -import chess.domain.position.Position; -import java.util.List; - -public final class BlackPawnDiagonalMovement implements MovementRule { - - private static final int TO_SOUTH_ONE_BLOCK = -1; - private static final int ONE_BLOCK = 1; - - @Override - public boolean isMovable(Position start, Position end, boolean isAttack) { - int rankDifference = start.calculateRankDifference(end); - int fileDifference = start.calculateFileDifference(end); - - boolean isMatchDifference = (rankDifference == TO_SOUTH_ONE_BLOCK && Math.abs(fileDifference) == ONE_BLOCK); - return isAttack && isMatchDifference; - } - - @Override - public List findPath(Position start, Position end, boolean isAttack) { - if (!isMovable(start, end, isAttack)) { - throw new IllegalArgumentException("경로가 존재하지 않습니다."); - } - - return List.of(end); - } -} diff --git a/src/main/java/chess/domain/movement/BlackPawnFirstMovement.java b/src/main/java/chess/domain/movement/BlackPawnFirstMovement.java deleted file mode 100644 index b68d758c7b2..00000000000 --- a/src/main/java/chess/domain/movement/BlackPawnFirstMovement.java +++ /dev/null @@ -1,34 +0,0 @@ -package chess.domain.movement; - -import chess.domain.position.Position; -import chess.domain.position.Rank; -import java.util.List; - -public final class BlackPawnFirstMovement implements MovementRule { - - private static final Rank BLACK_PAWN_INIT_RANK = Rank.SEVEN; - private static final int TO_SOUTH_TWO_BLOCK = -2; - private static final int SAME_FILE = 0; - - @Override - public boolean isMovable(Position start, Position end, boolean isAttack) { - int rankDifference = start.calculateRankDifference(end); - int fileDifference = start.calculateFileDifference(end); - - boolean isEmptyAtEnd = !isAttack; - boolean isExistInitPosition = start.isSameRank(BLACK_PAWN_INIT_RANK); - boolean isMatchDifference = (rankDifference == TO_SOUTH_TWO_BLOCK && fileDifference == SAME_FILE); - - return isEmptyAtEnd && isExistInitPosition && isMatchDifference; - } - - @Override - public List findPath(Position start, Position end, boolean isAttack) { - if (!isMovable(start, end, isAttack)) { - throw new IllegalArgumentException("경로가 존재하지 않습니다."); - } - - Position middle = start.moveToSouth(); - return List.of(middle, end); - } -} diff --git a/src/main/java/chess/domain/movement/WhitePawnDefaultMovement.java b/src/main/java/chess/domain/movement/WhitePawnDefaultMovement.java deleted file mode 100644 index 3747a45f36e..00000000000 --- a/src/main/java/chess/domain/movement/WhitePawnDefaultMovement.java +++ /dev/null @@ -1,30 +0,0 @@ -package chess.domain.movement; - -import chess.domain.position.Position; -import java.util.List; - -public final class WhitePawnDefaultMovement implements MovementRule { - - private static final int TO_NORTH_ONE_BLOCK = 1; - private static final int SAME_FILE = 0; - - @Override - public boolean isMovable(Position start, Position end, boolean isAttack) { - int rankDifference = start.calculateRankDifference(end); - int fileDifference = start.calculateFileDifference(end); - - boolean isEmptyAtEnd = !isAttack; - boolean isMatchDifference = (rankDifference == TO_NORTH_ONE_BLOCK && fileDifference == SAME_FILE); - - return isEmptyAtEnd && isMatchDifference; - } - - @Override - public List findPath(Position start, Position end, boolean isAttack) { - if (!isMovable(start, end, isAttack)) { - throw new IllegalArgumentException("경로가 존재하지 않습니다."); - } - - return List.of(end); - } -} diff --git a/src/main/java/chess/domain/movement/WhitePawnDiagonalMovement.java b/src/main/java/chess/domain/movement/WhitePawnDiagonalMovement.java deleted file mode 100644 index 9be70533aa2..00000000000 --- a/src/main/java/chess/domain/movement/WhitePawnDiagonalMovement.java +++ /dev/null @@ -1,28 +0,0 @@ -package chess.domain.movement; - -import chess.domain.position.Position; -import java.util.List; - -public final class WhitePawnDiagonalMovement implements MovementRule { - - private static final int TO_NORTH_ONE_BLOCK = 1; - private static final int ONE_BLOCK = 1; - - @Override - public boolean isMovable(Position start, Position end, boolean isAttack) { - int rankDifference = start.calculateRankDifference(end); - int fileDifference = start.calculateFileDifference(end); - - boolean isMatchDifference = (rankDifference == TO_NORTH_ONE_BLOCK && Math.abs(fileDifference) == ONE_BLOCK); - return isAttack && isMatchDifference; - } - - @Override - public List findPath(Position start, Position end, boolean isAttack) { - if (!isMovable(start, end, isAttack)) { - throw new IllegalArgumentException("경로가 존재하지 않습니다."); - } - - return List.of(end); - } -} diff --git a/src/main/java/chess/domain/movement/WhitePawnFirstMovement.java b/src/main/java/chess/domain/movement/WhitePawnFirstMovement.java deleted file mode 100644 index c3317cf18d6..00000000000 --- a/src/main/java/chess/domain/movement/WhitePawnFirstMovement.java +++ /dev/null @@ -1,34 +0,0 @@ -package chess.domain.movement; - -import chess.domain.position.Position; -import chess.domain.position.Rank; -import java.util.List; - -public final class WhitePawnFirstMovement implements MovementRule { - - private static final Rank WHITE_PAWN_INIT_RANK = Rank.TWO; - private static final int TO_NORTH_TWO_BLOCK = 2; - private static final int SAME_FILE = 0; - - @Override - public boolean isMovable(Position start, Position end, boolean isAttack) { - int rankDifference = start.calculateRankDifference(end); - int fileDifference = start.calculateFileDifference(end); - - boolean isEmptyAtEnd = !isAttack; - boolean isExistInitPosition = start.isSameRank(WHITE_PAWN_INIT_RANK); - boolean isMatchDifference = (rankDifference == TO_NORTH_TWO_BLOCK && fileDifference == SAME_FILE); - - return isEmptyAtEnd && isExistInitPosition && isMatchDifference; - } - - @Override - public List findPath(Position start, Position end, boolean isAttack) { - if (!isMovable(start, end, isAttack)) { - throw new IllegalArgumentException("경로가 존재하지 않습니다."); - } - - Position middle = start.moveToNorth(); - return List.of(middle, end); - } -} diff --git a/src/main/java/chess/domain/movement/pawn/BlackPawnDefaultMovement.java b/src/main/java/chess/domain/movement/pawn/BlackPawnDefaultMovement.java new file mode 100644 index 00000000000..ea749607c76 --- /dev/null +++ b/src/main/java/chess/domain/movement/pawn/BlackPawnDefaultMovement.java @@ -0,0 +1,25 @@ +package chess.domain.movement.pawn; + +import chess.domain.position.Position; +import java.util.List; + +public final class BlackPawnDefaultMovement extends PawnForwardMovement { + + private static final int TO_SOUTH_ONE_BLOCK = -1; + private static final int SAME_FILE = 0; + + @Override + protected boolean isMovablePath(int rankDifference, int fileDifference) { + return (rankDifference == TO_SOUTH_ONE_BLOCK && fileDifference == SAME_FILE); + } + + @Override + protected boolean isSatisfyStart(Position start) { + return true; + } + + @Override + protected List findPath(Position start, Position end) { + return List.of(end); + } +} diff --git a/src/main/java/chess/domain/movement/pawn/BlackPawnDiagonalMovement.java b/src/main/java/chess/domain/movement/pawn/BlackPawnDiagonalMovement.java new file mode 100644 index 00000000000..fc3b85f5187 --- /dev/null +++ b/src/main/java/chess/domain/movement/pawn/BlackPawnDiagonalMovement.java @@ -0,0 +1,12 @@ +package chess.domain.movement.pawn; + +public final class BlackPawnDiagonalMovement extends PawnDiagonalMovement { + + private static final int TO_SOUTH_ONE_BLOCK = -1; + private static final int ONE_BLOCK = 1; + + @Override + protected boolean isMovable(int rankDifference, int fileDifference) { + return (rankDifference == TO_SOUTH_ONE_BLOCK && Math.abs(fileDifference) == ONE_BLOCK); + } +} diff --git a/src/main/java/chess/domain/movement/pawn/BlackPawnFirstMovement.java b/src/main/java/chess/domain/movement/pawn/BlackPawnFirstMovement.java new file mode 100644 index 00000000000..60a828d3569 --- /dev/null +++ b/src/main/java/chess/domain/movement/pawn/BlackPawnFirstMovement.java @@ -0,0 +1,28 @@ +package chess.domain.movement.pawn; + +import chess.domain.position.Position; +import chess.domain.position.Rank; +import java.util.List; + +public final class BlackPawnFirstMovement extends PawnForwardMovement { + + private static final Rank BLACK_PAWN_INIT_RANK = Rank.SEVEN; + private static final int TO_SOUTH_TWO_BLOCK = -2; + private static final int SAME_FILE = 0; + + @Override + protected boolean isMovablePath(int rankDifference, int fileDifference) { + return (rankDifference == TO_SOUTH_TWO_BLOCK && fileDifference == SAME_FILE); + } + + @Override + protected boolean isSatisfyStart(Position start) { + return start.isSameRank(BLACK_PAWN_INIT_RANK); + } + + @Override + protected List findPath(Position start, Position end) { + Position middle = start.moveToSouth(); + return List.of(middle, end); + } +} diff --git a/src/main/java/chess/domain/movement/pawn/PawnDiagonalMovement.java b/src/main/java/chess/domain/movement/pawn/PawnDiagonalMovement.java new file mode 100644 index 00000000000..164e4815632 --- /dev/null +++ b/src/main/java/chess/domain/movement/pawn/PawnDiagonalMovement.java @@ -0,0 +1,29 @@ +package chess.domain.movement.pawn; + +import chess.domain.movement.MovementRule; +import chess.domain.position.Position; +import java.util.List; + +public abstract class PawnDiagonalMovement implements MovementRule { + + @Override + public final boolean isMovable(Position start, Position end, boolean isAttack) { + if (!isAttack) { + return false; + } + + int rankDifference = start.calculateRankDifference(end); + int fileDifference = start.calculateFileDifference(end); + return isMovable(rankDifference, fileDifference); + } + + @Override + public final List findPath(Position start, Position end, boolean isAttack) { + if (!isMovable(start, end, isAttack)) { + throw new IllegalArgumentException("경로가 존재하지 않습니다."); + } + return List.of(end); + } + + protected abstract boolean isMovable(int rankDifference, int fileDifference); +} diff --git a/src/main/java/chess/domain/movement/pawn/PawnForwardMovement.java b/src/main/java/chess/domain/movement/pawn/PawnForwardMovement.java new file mode 100644 index 00000000000..df9f11fe7a2 --- /dev/null +++ b/src/main/java/chess/domain/movement/pawn/PawnForwardMovement.java @@ -0,0 +1,33 @@ +package chess.domain.movement.pawn; + +import chess.domain.movement.MovementRule; +import chess.domain.position.Position; +import java.util.List; + +public abstract class PawnForwardMovement implements MovementRule { + + @Override + public final boolean isMovable(Position start, Position end, boolean isAttack) { + if (isAttack) { + return false; + } + + int rankDifference = start.calculateRankDifference(end); + int fileDifference = start.calculateFileDifference(end); + return isMovablePath(rankDifference, fileDifference) && isSatisfyStart(start); + } + + @Override + public final List findPath(Position start, Position end, boolean isAttack) { + if (!isMovable(start, end, isAttack)) { + throw new IllegalArgumentException("경로가 존재하지 않습니다."); + } + return findPath(start, end); + } + + protected abstract boolean isMovablePath(int rankDifference, int fileDifference); + + protected abstract boolean isSatisfyStart(Position start); + + protected abstract List findPath(Position start, Position end); +} diff --git a/src/main/java/chess/domain/movement/pawn/WhitePawnDefaultMovement.java b/src/main/java/chess/domain/movement/pawn/WhitePawnDefaultMovement.java new file mode 100644 index 00000000000..400909e69ee --- /dev/null +++ b/src/main/java/chess/domain/movement/pawn/WhitePawnDefaultMovement.java @@ -0,0 +1,25 @@ +package chess.domain.movement.pawn; + +import chess.domain.position.Position; +import java.util.List; + +public final class WhitePawnDefaultMovement extends PawnForwardMovement { + + private static final int TO_NORTH_ONE_BLOCK = 1; + private static final int SAME_FILE = 0; + + @Override + protected boolean isMovablePath(int rankDifference, int fileDifference) { + return (rankDifference == TO_NORTH_ONE_BLOCK && fileDifference == SAME_FILE); + } + + @Override + protected boolean isSatisfyStart(Position start) { + return true; + } + + @Override + protected List findPath(Position start, Position end) { + return List.of(end); + } +} diff --git a/src/main/java/chess/domain/movement/pawn/WhitePawnDiagonalMovement.java b/src/main/java/chess/domain/movement/pawn/WhitePawnDiagonalMovement.java new file mode 100644 index 00000000000..ed1811b208e --- /dev/null +++ b/src/main/java/chess/domain/movement/pawn/WhitePawnDiagonalMovement.java @@ -0,0 +1,12 @@ +package chess.domain.movement.pawn; + +public final class WhitePawnDiagonalMovement extends PawnDiagonalMovement { + + private static final int TO_NORTH_ONE_BLOCK = 1; + private static final int ONE_BLOCK = 1; + + @Override + protected boolean isMovable(int rankDifference, int fileDifference) { + return (rankDifference == TO_NORTH_ONE_BLOCK && Math.abs(fileDifference) == ONE_BLOCK); + } +} diff --git a/src/main/java/chess/domain/movement/pawn/WhitePawnFirstMovement.java b/src/main/java/chess/domain/movement/pawn/WhitePawnFirstMovement.java new file mode 100644 index 00000000000..202a6ad0865 --- /dev/null +++ b/src/main/java/chess/domain/movement/pawn/WhitePawnFirstMovement.java @@ -0,0 +1,28 @@ +package chess.domain.movement.pawn; + +import chess.domain.position.Position; +import chess.domain.position.Rank; +import java.util.List; + +public final class WhitePawnFirstMovement extends PawnForwardMovement { + + private static final Rank WHITE_PAWN_INIT_RANK = Rank.TWO; + private static final int TO_NORTH_TWO_BLOCK = 2; + private static final int SAME_FILE = 0; + + @Override + protected boolean isMovablePath(int rankDifference, int fileDifference) { + return (rankDifference == TO_NORTH_TWO_BLOCK && fileDifference == SAME_FILE); + } + + @Override + protected boolean isSatisfyStart(Position start) { + return start.isSameRank(WHITE_PAWN_INIT_RANK); + } + + @Override + protected List findPath(Position start, Position end) { + Position middle = start.moveToNorth(); + return List.of(middle, end); + } +} diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 9a451c19097..80bfda7697e 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -2,13 +2,13 @@ import chess.domain.Point; import chess.domain.Team; -import chess.domain.movement.BlackPawnDefaultMovement; -import chess.domain.movement.BlackPawnDiagonalMovement; -import chess.domain.movement.BlackPawnFirstMovement; import chess.domain.movement.MovementRule; -import chess.domain.movement.WhitePawnDefaultMovement; -import chess.domain.movement.WhitePawnDiagonalMovement; -import chess.domain.movement.WhitePawnFirstMovement; +import chess.domain.movement.pawn.BlackPawnDefaultMovement; +import chess.domain.movement.pawn.BlackPawnDiagonalMovement; +import chess.domain.movement.pawn.BlackPawnFirstMovement; +import chess.domain.movement.pawn.WhitePawnDefaultMovement; +import chess.domain.movement.pawn.WhitePawnDiagonalMovement; +import chess.domain.movement.pawn.WhitePawnFirstMovement; import java.util.List; public final class Pawn extends Piece { diff --git a/src/main/java/chess/dto/PieceDto.java b/src/main/java/chess/dto/PieceDto.java index 9358f1089b5..b3947df6767 100644 --- a/src/main/java/chess/dto/PieceDto.java +++ b/src/main/java/chess/dto/PieceDto.java @@ -14,8 +14,4 @@ public static PieceDto from(Piece piece) { public static PieceDto createEmptyPiece() { return new PieceDto(PieceType.getEmptyType(), true); } - - public boolean isEmpty() { - return type.isEmpty(); - } } diff --git a/src/test/java/chess/domain/movement/BlackPawnDefaultMovementTest.java b/src/test/java/chess/domain/movement/pawn/BlackPawnDefaultMovementTest.java similarity index 98% rename from src/test/java/chess/domain/movement/BlackPawnDefaultMovementTest.java rename to src/test/java/chess/domain/movement/pawn/BlackPawnDefaultMovementTest.java index 95275b96553..9e289613b80 100644 --- a/src/test/java/chess/domain/movement/BlackPawnDefaultMovementTest.java +++ b/src/test/java/chess/domain/movement/pawn/BlackPawnDefaultMovementTest.java @@ -1,4 +1,4 @@ -package chess.domain.movement; +package chess.domain.movement.pawn; import static org.assertj.core.api.Assertions.assertThat; diff --git a/src/test/java/chess/domain/movement/BlackPawnDiagonalMovementTest.java b/src/test/java/chess/domain/movement/pawn/BlackPawnDiagonalMovementTest.java similarity index 98% rename from src/test/java/chess/domain/movement/BlackPawnDiagonalMovementTest.java rename to src/test/java/chess/domain/movement/pawn/BlackPawnDiagonalMovementTest.java index 5c28d2af576..8b68cd4c821 100644 --- a/src/test/java/chess/domain/movement/BlackPawnDiagonalMovementTest.java +++ b/src/test/java/chess/domain/movement/pawn/BlackPawnDiagonalMovementTest.java @@ -1,4 +1,4 @@ -package chess.domain.movement; +package chess.domain.movement.pawn; import static org.assertj.core.api.Assertions.assertThat; diff --git a/src/test/java/chess/domain/movement/BlackPawnFirstMovementTest.java b/src/test/java/chess/domain/movement/pawn/BlackPawnFirstMovementTest.java similarity index 98% rename from src/test/java/chess/domain/movement/BlackPawnFirstMovementTest.java rename to src/test/java/chess/domain/movement/pawn/BlackPawnFirstMovementTest.java index 6bbf3f6345a..97560f9e63e 100644 --- a/src/test/java/chess/domain/movement/BlackPawnFirstMovementTest.java +++ b/src/test/java/chess/domain/movement/pawn/BlackPawnFirstMovementTest.java @@ -1,4 +1,4 @@ -package chess.domain.movement; +package chess.domain.movement.pawn; import static org.assertj.core.api.Assertions.assertThat; diff --git a/src/test/java/chess/domain/movement/WhitePawnDefaultMovementTest.java b/src/test/java/chess/domain/movement/pawn/WhitePawnDefaultMovementTest.java similarity index 98% rename from src/test/java/chess/domain/movement/WhitePawnDefaultMovementTest.java rename to src/test/java/chess/domain/movement/pawn/WhitePawnDefaultMovementTest.java index 2fb4fc4d7e6..e694ec2f7a8 100644 --- a/src/test/java/chess/domain/movement/WhitePawnDefaultMovementTest.java +++ b/src/test/java/chess/domain/movement/pawn/WhitePawnDefaultMovementTest.java @@ -1,4 +1,4 @@ -package chess.domain.movement; +package chess.domain.movement.pawn; import static org.assertj.core.api.Assertions.assertThat; diff --git a/src/test/java/chess/domain/movement/WhitePawnDiagonalMovementTest.java b/src/test/java/chess/domain/movement/pawn/WhitePawnDiagonalMovementTest.java similarity index 98% rename from src/test/java/chess/domain/movement/WhitePawnDiagonalMovementTest.java rename to src/test/java/chess/domain/movement/pawn/WhitePawnDiagonalMovementTest.java index de9f459bd5e..4086ccf7539 100644 --- a/src/test/java/chess/domain/movement/WhitePawnDiagonalMovementTest.java +++ b/src/test/java/chess/domain/movement/pawn/WhitePawnDiagonalMovementTest.java @@ -1,4 +1,4 @@ -package chess.domain.movement; +package chess.domain.movement.pawn; import static org.assertj.core.api.Assertions.assertThat; diff --git a/src/test/java/chess/domain/movement/WhitePawnFirstMovementTest.java b/src/test/java/chess/domain/movement/pawn/WhitePawnFirstMovementTest.java similarity index 98% rename from src/test/java/chess/domain/movement/WhitePawnFirstMovementTest.java rename to src/test/java/chess/domain/movement/pawn/WhitePawnFirstMovementTest.java index 2b39acfb211..0a91d36d2c5 100644 --- a/src/test/java/chess/domain/movement/WhitePawnFirstMovementTest.java +++ b/src/test/java/chess/domain/movement/pawn/WhitePawnFirstMovementTest.java @@ -1,4 +1,4 @@ -package chess.domain.movement; +package chess.domain.movement.pawn; import static org.assertj.core.api.Assertions.assertThat; From 7d6b0832753ccd9d40e61dad3c07227d2490941c Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 12:19:16 +0900 Subject: [PATCH 33/38] =?UTF-8?q?refactor(MysqlPieceRepository):=20?= =?UTF-8?q?=EC=9D=B8=EB=8D=B4=ED=8A=B8=20=EC=A1=B0=EA=B1=B4=EC=9D=84=20?= =?UTF-8?q?=EC=A7=80=ED=82=A4=EA=B8=B0=20=EC=9C=84=ED=95=B4=20=EB=A9=94?= =?UTF-8?q?=EC=84=9C=EB=93=9C=20=EB=B6=84=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/chess/dao/MysqlPieceRepository.java | 42 +++++++++++-------- 1 file changed, 25 insertions(+), 17 deletions(-) diff --git a/src/main/java/chess/dao/MysqlPieceRepository.java b/src/main/java/chess/dao/MysqlPieceRepository.java index 7b1abcf5cb6..d5a16de9b24 100644 --- a/src/main/java/chess/dao/MysqlPieceRepository.java +++ b/src/main/java/chess/dao/MysqlPieceRepository.java @@ -50,28 +50,36 @@ public List findAll() { String query = "SELECT board_file, board_rank, type, team FROM piece"; try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { ResultSet resultSet = preparedStatement.executeQuery(); - - List result = new ArrayList<>(); - while (resultSet.next()) { - String fileString = resultSet.getString(1); - String rankString = resultSet.getString(2); - String pieceString = resultSet.getString(3); - String teamString = resultSet.getString(4); - - File file = STRING_TO_FILE.get(fileString); - Rank rank = STRING_TO_RANK.get(rankString); - Position position = new Position(file, rank); - PieceType pieceType = STRING_TO_PIECE_TYPE.get(pieceString); - TeamType teamType = STRING_TO_TEAM_TYPE.get(teamString); - - result.add(new PieceEntity(position, pieceType, teamType)); - } - return result; + return toPieceEntities(resultSet); } catch (SQLException e) { throw new IllegalStateException(e); } } + private List toPieceEntities(ResultSet resultSet) throws SQLException { + List result = new ArrayList<>(); + while (resultSet.next()) { + PieceEntity pieceEntity = toPieceEntity(resultSet); + result.add(pieceEntity); + } + return result; + } + + private PieceEntity toPieceEntity(ResultSet resultSet) throws SQLException { + String fileString = resultSet.getString(1); + String rankString = resultSet.getString(2); + String pieceString = resultSet.getString(3); + String teamString = resultSet.getString(4); + + File file = STRING_TO_FILE.get(fileString); + Rank rank = STRING_TO_RANK.get(rankString); + Position position = new Position(file, rank); + PieceType pieceType = STRING_TO_PIECE_TYPE.get(pieceString); + TeamType teamType = STRING_TO_TEAM_TYPE.get(teamString); + + return new PieceEntity(position, pieceType, teamType); + } + @Override public List saveAll(List pieces) { Connection connection = connectionManager.getConnection(); From bffe03fb3338fe0d7f026bbc9d220b53a4d58c51 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 15:01:34 +0900 Subject: [PATCH 34/38] =?UTF-8?q?style(sql):=20=ED=85=8C=EC=9D=B4=EB=B8=94?= =?UTF-8?q?=20=EC=9D=B4=EB=A6=84=20=EB=B3=B5=EC=88=98=ED=98=95=EC=9C=BC?= =?UTF-8?q?=EB=A1=9C=20=EB=B3=80=EA=B2=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- database/init.sql | 2 +- src/main/java/chess/dao/MysqlPieceRepository.java | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/database/init.sql b/database/init.sql index 73a27c45e45..a264767b107 100644 --- a/database/init.sql +++ b/database/init.sql @@ -7,7 +7,7 @@ CREATE TABLE chess_game ( PRIMARY KEY (turn) ); -CREATE TABLE piece ( +CREATE TABLE pieces ( board_file VARCHAR(2) CHECK (board_file IN ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')) not null, board_rank VARCHAR(2) CHECK (board_rank IN ('1', '2', '3', '4', '5', '6', '7', '8')) not null, type VARCHAR(10) CHECK (type IN ('KING', 'QUEEN', 'ROOK', 'BISHOP', 'KNIGHT', 'PAWN', 'EMPTY')) not null, diff --git a/src/main/java/chess/dao/MysqlPieceRepository.java b/src/main/java/chess/dao/MysqlPieceRepository.java index d5a16de9b24..d7a31878ae5 100644 --- a/src/main/java/chess/dao/MysqlPieceRepository.java +++ b/src/main/java/chess/dao/MysqlPieceRepository.java @@ -47,7 +47,7 @@ public MysqlPieceRepository(ConnectionManager connectionManager) { @Override public List findAll() { Connection connection = connectionManager.getConnection(); - String query = "SELECT board_file, board_rank, type, team FROM piece"; + String query = "SELECT board_file, board_rank, type, team FROM pieces"; try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { ResultSet resultSet = preparedStatement.executeQuery(); return toPieceEntities(resultSet); @@ -83,7 +83,7 @@ private PieceEntity toPieceEntity(ResultSet resultSet) throws SQLException { @Override public List saveAll(List pieces) { Connection connection = connectionManager.getConnection(); - String query = "INSERT INTO piece(board_file, board_rank, type, team) VALUES (?, ?, ?, ?)"; + String query = "INSERT INTO pieces(board_file, board_rank, type, team) VALUES (?, ?, ?, ?)"; try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { addBatch(pieces, preparedStatement); preparedStatement.executeBatch(); @@ -116,7 +116,7 @@ private void setPreparedStatementForInsert(PieceEntity entity, PreparedStatement @Override public void update(PieceEntity piece) { Connection connection = connectionManager.getConnection(); - String query = "UPDATE piece SET type = ?, team = ? WHERE board_file = ? AND board_rank = ?"; + String query = "UPDATE pieces SET type = ?, team = ? WHERE board_file = ? AND board_rank = ?"; try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { setPreparedStatementForUpdate(piece, preparedStatement); preparedStatement.executeUpdate(); @@ -141,7 +141,7 @@ private void setPreparedStatementForUpdate(PieceEntity entity, PreparedStatement @Override public void deleteAll() { Connection connection = connectionManager.getConnection(); - String query = "DELETE FROM piece"; + String query = "DELETE FROM pieces"; try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { preparedStatement.executeUpdate(); } catch (SQLException e) { From c3bbcf11b5feb775827315b8946b1c4f7542fa8a Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 15:17:16 +0900 Subject: [PATCH 35/38] =?UTF-8?q?refactor(Repository):=20=EC=88=AB?= =?UTF-8?q?=EC=9E=90=EA=B0=80=20=EC=95=84=EB=8B=8C=20=ED=95=84=EB=93=9C?= =?UTF-8?q?=EC=9D=98=20=EC=9D=B4=EB=A6=84=EC=9C=BC=EB=A1=9C=20=EC=A1=B0?= =?UTF-8?q?=ED=9A=8C=ED=95=98=EB=8F=84=EB=A1=9D=20=EB=B3=80=EA=B2=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/dao/MysqlChessGameRepository.java | 2 +- src/main/java/chess/dao/MysqlPieceRepository.java | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/chess/dao/MysqlChessGameRepository.java b/src/main/java/chess/dao/MysqlChessGameRepository.java index 0e198cc524a..f31cc2774f2 100644 --- a/src/main/java/chess/dao/MysqlChessGameRepository.java +++ b/src/main/java/chess/dao/MysqlChessGameRepository.java @@ -44,7 +44,7 @@ public TurnType find() { try (PreparedStatement preparedStatement = connection.prepareStatement(query)) { ResultSet resultSet = preparedStatement.executeQuery(); resultSet.next(); - String turn = resultSet.getString(1); + String turn = resultSet.getString("turn"); return STRING_TO_TURN.get(turn); } catch (SQLException e) { throw new IllegalStateException(e); diff --git a/src/main/java/chess/dao/MysqlPieceRepository.java b/src/main/java/chess/dao/MysqlPieceRepository.java index d7a31878ae5..a77984187cd 100644 --- a/src/main/java/chess/dao/MysqlPieceRepository.java +++ b/src/main/java/chess/dao/MysqlPieceRepository.java @@ -66,10 +66,10 @@ private List toPieceEntities(ResultSet resultSet) throws SQLExcepti } private PieceEntity toPieceEntity(ResultSet resultSet) throws SQLException { - String fileString = resultSet.getString(1); - String rankString = resultSet.getString(2); - String pieceString = resultSet.getString(3); - String teamString = resultSet.getString(4); + String fileString = resultSet.getString("board_file"); + String rankString = resultSet.getString("board_rank"); + String pieceString = resultSet.getString("type"); + String teamString = resultSet.getString("team"); File file = STRING_TO_FILE.get(fileString); Rank rank = STRING_TO_RANK.get(rankString); From b241845cf8b77a42408e9e8e7c2b97b0b80f95b6 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 15:18:00 +0900 Subject: [PATCH 36/38] =?UTF-8?q?refactor(Piece)=20:=20getter=EB=A1=9C=20T?= =?UTF-8?q?eam=EC=9D=84=20=EC=A0=9C=EA=B3=B5=ED=95=98=EA=B8=B0=20=EB=95=8C?= =?UTF-8?q?=EB=AC=B8=EC=97=90,=20isBlack()=20=EB=A9=94=EC=84=9C=EB=93=9C?= =?UTF-8?q?=20=EC=A0=9C=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/domain/piece/Piece.java | 4 ---- src/main/java/chess/dto/PieceDto.java | 14 +++++++++----- src/main/java/chess/dto/TeamType.java | 4 ++++ src/main/java/chess/view/OutputView.java | 4 ++-- src/test/java/chess/domain/piece/PieceTest.java | 9 --------- 5 files changed, 15 insertions(+), 20 deletions(-) diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index ecafd1116e2..9b0e3796ba7 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -24,10 +24,6 @@ public final List findPath(Position start, Position end, boolean isAtt .orElseThrow(() -> new IllegalArgumentException("불가능한 경로입니다.")); } - public final boolean isBlackTeam() { - return team.isBlack(); - } - public final boolean isSameTeam(Piece other) { return isSameTeam(other.team); } diff --git a/src/main/java/chess/dto/PieceDto.java b/src/main/java/chess/dto/PieceDto.java index b3947df6767..a3a48fc3b5c 100644 --- a/src/main/java/chess/dto/PieceDto.java +++ b/src/main/java/chess/dto/PieceDto.java @@ -2,16 +2,20 @@ import chess.domain.piece.Piece; -public record PieceDto(PieceType type, boolean isBlack) { +public record PieceDto(PieceType pieceType, TeamType teamType) { public static PieceDto from(Piece piece) { - PieceType type = PieceType.from(piece); - boolean isBlackTeam = piece.isBlackTeam(); + PieceType pieceType = PieceType.from(piece); + TeamType teamType = TeamType.from(piece.getTeam()); - return new PieceDto(type, isBlackTeam); + return new PieceDto(pieceType, teamType); } public static PieceDto createEmptyPiece() { - return new PieceDto(PieceType.getEmptyType(), true); + return new PieceDto(PieceType.getEmptyType(), TeamType.EMPTY); + } + + public boolean isBlack() { + return teamType.isBlackTeam(); } } diff --git a/src/main/java/chess/dto/TeamType.java b/src/main/java/chess/dto/TeamType.java index 72e87139794..890c80f490c 100644 --- a/src/main/java/chess/dto/TeamType.java +++ b/src/main/java/chess/dto/TeamType.java @@ -30,4 +30,8 @@ public static TeamType getEmptyType() { public Team getTeam() { return team; } + + public boolean isBlackTeam() { + return this == BLACK; + } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index ba9876ce0e7..44c9c0b77a4 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -58,10 +58,10 @@ private void printBoardOneLine(Map board, Rank rank) { private void printPiece(PieceDto piece) { if (piece.isBlack()) { - printBlackPiece(piece.type()); + printBlackPiece(piece.pieceType()); return; } - printWhitePiece(piece.type()); + printWhitePiece(piece.pieceType()); } private void printBlackPiece(PieceType type) { diff --git a/src/test/java/chess/domain/piece/PieceTest.java b/src/test/java/chess/domain/piece/PieceTest.java index 4fdad018f28..4807bc78b4d 100644 --- a/src/test/java/chess/domain/piece/PieceTest.java +++ b/src/test/java/chess/domain/piece/PieceTest.java @@ -9,15 +9,6 @@ class PieceTest { - @ParameterizedTest - @CsvSource({"BLACK, true", "WHITE, false"}) - @DisplayName("해당 팀이 검정 팀인지 확인한다.") - void isBlackTeamTest(Team team, boolean expected) { - Piece piece = new Pawn(team); - - assertThat(piece.isBlackTeam()).isEqualTo(expected); - } - @ParameterizedTest @CsvSource({"BLACK, true", "WHITE, false"}) @DisplayName("기물이 해당 팀인지 확인한다.") From 00e8d614983d82855a92fcbd40d6ffcf3c82d7a4 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 15:24:31 +0900 Subject: [PATCH 37/38] =?UTF-8?q?docs(README):=20=EC=8B=A4=ED=96=89=20?= =?UTF-8?q?=EB=B0=A9=EB=B2=95=20=EC=84=9C=EC=88=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index b3891fc7004..7eb97509e33 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,10 @@ # java-chess -## 페어와 지킬 컨벤션 -1. 클래스 정의 다음 줄은 공백으로 한다. -2. test code에 사용하는 메서드는 `static import`한다. -3. `this`는 같은 클래스의 객체가 파라미터로 넘어왔을 때, 파라미터 변수 명이 필드의 변수 명과 겹칠 때 사용한다. +## 실행 방법 +1. [database](./database) 폴더로 이동한다. +2. [docker-compose.yml](./database/docker-compose.yml)를 통하여 docker를 실행한다. +3. [init.sql](./database/init.sql)의 명령어를 docker 내부에서 차례로 실행한다. +4. IDE를 통해 ChessApplication를 실행한다. ## 기능 요구 사항 From a2f0d0c9a1ec59abfed8c65c5b6dcbdc93c821c5 Mon Sep 17 00:00:00 2001 From: "DESKTOP-E5VRH4Q\\cnddk" Date: Mon, 1 Apr 2024 19:01:00 +0900 Subject: [PATCH 38/38] =?UTF-8?q?style(Piece):=20=EC=A1=B0=EA=B1=B4?= =?UTF-8?q?=EC=9D=84=20=EB=AA=85=ED=99=95=ED=95=98=EA=B2=8C=20=ED=95=98?= =?UTF-8?q?=EA=B8=B0=20=EC=9C=84=ED=95=B4=20=EB=B3=80=EC=88=98=EB=AA=85=20?= =?UTF-8?q?=EB=B3=80=EA=B2=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/ChessGame.java | 12 ++++++------ src/main/java/chess/domain/Board.java | 4 ++-- src/main/java/chess/domain/piece/Bishop.java | 2 +- src/main/java/chess/domain/piece/King.java | 2 +- src/main/java/chess/domain/piece/Knight.java | 2 +- src/main/java/chess/domain/piece/Pawn.java | 4 ++-- src/main/java/chess/domain/piece/Piece.java | 2 +- src/main/java/chess/domain/piece/Queen.java | 2 +- src/main/java/chess/domain/piece/Rook.java | 2 +- src/test/java/chess/domain/piece/BishopTest.java | 4 ++-- src/test/java/chess/domain/piece/KingTest.java | 4 ++-- src/test/java/chess/domain/piece/KnightTest.java | 4 ++-- src/test/java/chess/domain/piece/PawnTest.java | 10 +++++----- src/test/java/chess/domain/piece/QueenTest.java | 4 ++-- src/test/java/chess/domain/piece/RookTest.java | 4 ++-- 15 files changed, 31 insertions(+), 31 deletions(-) diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java index 8be9c577a94..a35c4cbbddb 100644 --- a/src/main/java/chess/ChessGame.java +++ b/src/main/java/chess/ChessGame.java @@ -69,12 +69,6 @@ private ProgressStatus processTurn() { return ProgressStatus.END_GAME; } - private ProgressStatus executeStatus() { - Map statusDto = chessService.calculatePiecePoints(); - outputView.printStatus(statusDto); - return ProgressStatus.PROGRESS; - } - private ProgressStatus executeMove() { Position start = inputView.readPosition(); Position end = inputView.readPosition(); @@ -83,6 +77,12 @@ private ProgressStatus executeMove() { return status; } + private ProgressStatus executeStatus() { + Map statusDto = chessService.calculatePiecePoints(); + outputView.printStatus(statusDto); + return ProgressStatus.PROGRESS; + } + private void showResult(ProgressStatus status) { if (status.isInputEndCommand()) { return; diff --git a/src/main/java/chess/domain/Board.java b/src/main/java/chess/domain/Board.java index b9c82ea40d7..3cd1459b06a 100644 --- a/src/main/java/chess/domain/Board.java +++ b/src/main/java/chess/domain/Board.java @@ -136,9 +136,9 @@ private Point calculatePoints(Team team, File file) { } private Point calculatePoints(List teamPieces) { - boolean isOverlappedPawn = isOverlappedPawn(teamPieces); + boolean isPawnOverlappedInFilePawn = isOverlappedPawn(teamPieces); return teamPieces.stream() - .map(piece -> piece.getPoint(isOverlappedPawn)) + .map(piece -> piece.getPoint(isPawnOverlappedInFilePawn)) .reduce(Point.ZERO, Point::add); } diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 82ec41c7690..a468dfb7811 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -21,7 +21,7 @@ public Bishop(Team team) { @Override - public Point getPoint(boolean isOverlapped) { + public Point getPoint(boolean isPawnOverlappedInFile) { return PIECE_POINT; } } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index 57ea71a43dd..de38d1235ec 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -16,7 +16,7 @@ public King(Team team) { } @Override - public Point getPoint(boolean isOverlapped) { + public Point getPoint(boolean isPawnOverlappedInFile) { return PIECE_POINT; } } diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index 1a1f7b33299..35a3f427e9d 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -16,7 +16,7 @@ public Knight(Team team) { } @Override - public Point getPoint(boolean isOverlapped) { + public Point getPoint(boolean isPawnOverlappedIn) { return PIECE_POINT; } } diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 80bfda7697e..054c9f442de 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -33,8 +33,8 @@ private static List findMovementRule(Team team) { } @Override - public Point getPoint(boolean isOverlapped) { - if (isOverlapped) { + public Point getPoint(boolean isPawnOverlappedInFile) { + if (isPawnOverlappedInFile) { return PIECE_OVERLAPPED_POINT; } return PIECE_BASIC_POINT; diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index 9b0e3796ba7..d2b00c7f462 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -44,5 +44,5 @@ public Team getTeam() { return team; } - public abstract Point getPoint(boolean isOverlapped); + public abstract Point getPoint(boolean isPawnOverlappedInFile); } diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index f6c98e15035..4120e8d2efd 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -26,7 +26,7 @@ public Queen(Team team) { } @Override - public Point getPoint(boolean isOverlapped) { + public Point getPoint(boolean isPawnOverlappedInFile) { return PIECE_POINT; } } diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index b551ba4474f..532c367a26e 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -20,7 +20,7 @@ public Rook(Team team) { } @Override - public Point getPoint(boolean isOverlapped) { + public Point getPoint(boolean isPawnOverlappedInFile) { return PIECE_POINT; } } diff --git a/src/test/java/chess/domain/piece/BishopTest.java b/src/test/java/chess/domain/piece/BishopTest.java index d9150475d28..428b539f896 100644 --- a/src/test/java/chess/domain/piece/BishopTest.java +++ b/src/test/java/chess/domain/piece/BishopTest.java @@ -61,9 +61,9 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { @ParameterizedTest @ValueSource(booleans = {true, false}) @DisplayName("비숍의 기물 점수는 3점이다.") - void getPointTest(boolean isOverlapped) { + void getPointTest(boolean isPawnOverlappedInFile) { Bishop bishop = new Bishop(Team.WHITE); - assertThat(bishop.getPoint(isOverlapped)).isEqualTo(new Point(3.0)); + assertThat(bishop.getPoint(isPawnOverlappedInFile)).isEqualTo(new Point(3.0)); } } diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java index 3a0b48a0984..bb477b39dd3 100644 --- a/src/test/java/chess/domain/piece/KingTest.java +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -44,9 +44,9 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { @ParameterizedTest @ValueSource(booleans = {true, false}) @DisplayName("킹의 기물 점수는 0점이다.") - void getPointTest(boolean isOverlapped) { + void getPointTest(boolean isPawnOverlappedInFile) { King king = new King(Team.WHITE); - assertThat(king.getPoint(isOverlapped)).isEqualTo(Point.ZERO); + assertThat(king.getPoint(isPawnOverlappedInFile)).isEqualTo(Point.ZERO); } } diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java index 07aba37b29a..82f24b94ae3 100644 --- a/src/test/java/chess/domain/piece/KnightTest.java +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -44,9 +44,9 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { @ParameterizedTest @ValueSource(booleans = {true, false}) @DisplayName("나이트의 기물 점수는 2.5점이다.") - void getPointTest(boolean isOverlapped) { + void getPointTest(boolean isPawnOverlappedInFile) { Knight knight = new Knight(Team.WHITE); - assertThat(knight.getPoint(isOverlapped)).isEqualTo(new Point(2.5)); + assertThat(knight.getPoint(isPawnOverlappedInFile)).isEqualTo(new Point(2.5)); } } diff --git a/src/test/java/chess/domain/piece/PawnTest.java b/src/test/java/chess/domain/piece/PawnTest.java index 44939e398f5..adc0fc5783a 100644 --- a/src/test/java/chess/domain/piece/PawnTest.java +++ b/src/test/java/chess/domain/piece/PawnTest.java @@ -122,17 +122,17 @@ void findPathTest_whenOutOfDiagonalMovement_throwException(File file, Rank rank) @DisplayName("폰의 기물 점수는 1점이다.") void getPointTest() { Pawn pawn = new Pawn(Team.WHITE); - boolean isOverlapped = false; + boolean isPawnOverlappedInFile = false; - assertThat(pawn.getPoint(isOverlapped)).isEqualTo(new Point(1.0)); + assertThat(pawn.getPoint(isPawnOverlappedInFile)).isEqualTo(new Point(1.0)); } @Test @DisplayName("같은 줄에 폰이 있을 경우, 폰의 기물 점수는 0.5점이다.") - void getPointTest_whenPawnIsOverlappedInSameFile() { + void getPointTest_whenPawnisPawnOverlappedInFileInSameFile() { Pawn pawn = new Pawn(Team.WHITE); - boolean isOverlapped = true; + boolean isPawnOverlappedInFile = true; - assertThat(pawn.getPoint(isOverlapped)).isEqualTo(new Point(0.5)); + assertThat(pawn.getPoint(isPawnOverlappedInFile)).isEqualTo(new Point(0.5)); } } diff --git a/src/test/java/chess/domain/piece/QueenTest.java b/src/test/java/chess/domain/piece/QueenTest.java index a9947810ef8..ed7eb6a9c52 100644 --- a/src/test/java/chess/domain/piece/QueenTest.java +++ b/src/test/java/chess/domain/piece/QueenTest.java @@ -61,9 +61,9 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { @ParameterizedTest @ValueSource(booleans = {true, false}) @DisplayName("퀸의 기물 점수는 9점이다.") - void getPointTest(boolean isOverlapped) { + void getPointTest(boolean isPawnOverlappedInFile) { Queen queen = new Queen(Team.WHITE); - assertThat(queen.getPoint(isOverlapped)).isEqualTo(new Point(9.0)); + assertThat(queen.getPoint(isPawnOverlappedInFile)).isEqualTo(new Point(9.0)); } } diff --git a/src/test/java/chess/domain/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java index 5bbff5606a4..8bae4be6398 100644 --- a/src/test/java/chess/domain/piece/RookTest.java +++ b/src/test/java/chess/domain/piece/RookTest.java @@ -61,9 +61,9 @@ void findPathTest_whenOutOfMovement_throwException(File file, Rank rank) { @ParameterizedTest @ValueSource(booleans = {true, false}) @DisplayName("룩의 기물 점수는 5점이다.") - void getPointTest(boolean isOverlapped) { + void getPointTest(boolean isPawnOverlappedInFile) { Rook rook = new Rook(Team.WHITE); - assertThat(rook.getPoint(isOverlapped)).isEqualTo(new Point(5.0)); + assertThat(rook.getPoint(isPawnOverlappedInFile)).isEqualTo(new Point(5.0)); } }