From 39f868904158a695edd195b085dcfaef74a20d93 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 13:33:19 +0900 Subject: [PATCH 01/19] =?UTF-8?q?docs(README.md):=20=EA=B8=B0=EB=8A=A5=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84=20=EB=AA=A9=EB=A1=9D=20=EC=9E=91=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/README.md b/README.md index 8102f91c870..480e3ae5859 100644 --- a/README.md +++ b/README.md @@ -5,3 +5,35 @@ ## 우아한테크코스 코드리뷰 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md) + + +# 체스 +체스 기물의 움직임을 구현한다. + +## 체스 판 +- [ ] 행은 1~8, 열은 a~h로 표현된다.(8x8) +- [ ] 특정 위치의 말을 원하는 위치로 움직일 수 있다. + +## 체스 기물 + +### king +- [ ] 상, 하, 좌, 우, 대각선으로 1칸 이동할 수 있다. +- [ ] 잡히면 게임이 종료된다. + +### bishop +- [ ] 대각선으로 여러 칸 이동할 수 있다. + +### knight +- [ ] 상, 하, 좌, 우로 1칸 이동 후 대각선으로 1칸 이동할 수 있다. +- [ ] 다른 기물을 뛰어넘을 수 있다. + +### Pawn +- [ ] 앞으로 1칸 이동할 수 있다. +- [ ] 초기 위치에서는 앞으로 2칸까지 이동할 수 있다. +- [ ] 대각선 한 칸 앞에 위치한 기물을 잡을 수 있다. + +### Queen +- [ ] 수직, 수평, 대각선으로 여러 칸 이동할 수 있다. + +### Rook +- [ ] 수직, 수평으로 여러 칸 이동할 수 있다. From e7906040809b55f79e33e8350ac528b8a43b5261 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 13:43:46 +0900 Subject: [PATCH 02/19] =?UTF-8?q?feat:=20=EC=B2=B4=EC=8A=A4=ED=8C=90=20?= =?UTF-8?q?=EC=B4=88=EA=B8=B0=ED=99=94=20=EA=B8=B0=EB=8A=A5=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 --- README.md | 3 +- src/main/java/chess/Application.java | 8 +++ src/main/java/chess/ChessBoard.java | 60 +++++++++++++++++++++++ src/main/java/chess/ChessController.java | 4 ++ src/main/java/chess/piece/Bishop.java | 2 +- src/main/java/chess/piece/ChessPiece.java | 6 +++ src/main/java/chess/piece/King.java | 2 +- src/main/java/chess/piece/Knight.java | 2 +- src/main/java/chess/piece/Pawn.java | 2 +- src/main/java/chess/piece/Queen.java | 2 +- src/main/java/chess/piece/Rook.java | 2 +- 11 files changed, 86 insertions(+), 7 deletions(-) create mode 100644 src/main/java/chess/Application.java create mode 100644 src/main/java/chess/ChessBoard.java create mode 100644 src/main/java/chess/ChessController.java create mode 100644 src/main/java/chess/piece/ChessPiece.java diff --git a/README.md b/README.md index 480e3ae5859..cb80cdc1aa6 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,8 @@ 체스 기물의 움직임을 구현한다. ## 체스 판 -- [ ] 행은 1~8, 열은 a~h로 표현된다.(8x8) +- [x] 행은 1~8, 열은 a~h로 표현된다.(8x8) +- [x] 체스 판을 초기화할 수 있다. - [ ] 특정 위치의 말을 원하는 위치로 움직일 수 있다. ## 체스 기물 diff --git a/src/main/java/chess/Application.java b/src/main/java/chess/Application.java new file mode 100644 index 00000000000..ff6b55ef980 --- /dev/null +++ b/src/main/java/chess/Application.java @@ -0,0 +1,8 @@ +package chess; + +public class Application { + + public static void main(String[] args) { + + } +} diff --git a/src/main/java/chess/ChessBoard.java b/src/main/java/chess/ChessBoard.java new file mode 100644 index 00000000000..b45524584e6 --- /dev/null +++ b/src/main/java/chess/ChessBoard.java @@ -0,0 +1,60 @@ +package chess; + +import chess.piece.Bishop; +import chess.piece.ChessPiece; +import chess.piece.King; +import chess.piece.Knight; +import chess.piece.Pawn; +import chess.piece.Queen; +import chess.piece.Rook; +import java.util.HashMap; +import java.util.Map; + +public class ChessBoard { + + private final Map board = new HashMap<>(); + + public ChessBoard() { + for (Row row : Row.values()) { + for (Column column : Column.values()) { + board.put(new Position(row, column), null); + } + } + + board.put(new Position(Row.EIGHT, Column.A), new Rook()); + board.put(new Position(Row.EIGHT, Column.B), new Knight()); + board.put(new Position(Row.EIGHT, Column.C), new Bishop()); + board.put(new Position(Row.EIGHT, Column.D), new Queen()); + board.put(new Position(Row.EIGHT, Column.E), new King()); + board.put(new Position(Row.EIGHT, Column.F), new Bishop()); + board.put(new Position(Row.EIGHT, Column.G), new Knight()); + board.put(new Position(Row.EIGHT, Column.H), new Rook()); + + board.put(new Position(Row.SEVEN, Column.A), new Pawn()); + board.put(new Position(Row.SEVEN, Column.B), new Pawn()); + board.put(new Position(Row.SEVEN, Column.C), new Pawn()); + board.put(new Position(Row.SEVEN, Column.D), new Pawn()); + board.put(new Position(Row.SEVEN, Column.E), new Pawn()); + board.put(new Position(Row.SEVEN, Column.F), new Pawn()); + board.put(new Position(Row.SEVEN, Column.G), new Pawn()); + board.put(new Position(Row.SEVEN, Column.H), new Pawn()); + + board.put(new Position(Row.ONE, Column.A), new Rook()); + board.put(new Position(Row.ONE, Column.B), new Knight()); + board.put(new Position(Row.ONE, Column.C), new Bishop()); + board.put(new Position(Row.ONE, Column.D), new Queen()); + board.put(new Position(Row.ONE, Column.E), new King()); + board.put(new Position(Row.ONE, Column.F), new Bishop()); + board.put(new Position(Row.ONE, Column.G), new Knight()); + board.put(new Position(Row.ONE, Column.H), new Rook()); + + board.put(new Position(Row.TWO, Column.A), new Pawn()); + board.put(new Position(Row.TWO, Column.B), new Pawn()); + board.put(new Position(Row.TWO, Column.C), new Pawn()); + board.put(new Position(Row.TWO, Column.D), new Pawn()); + board.put(new Position(Row.TWO, Column.E), new Pawn()); + board.put(new Position(Row.TWO, Column.F), new Pawn()); + board.put(new Position(Row.TWO, Column.G), new Pawn()); + board.put(new Position(Row.TWO, Column.H), new Pawn()); + } +} diff --git a/src/main/java/chess/ChessController.java b/src/main/java/chess/ChessController.java new file mode 100644 index 00000000000..b6c2552a70f --- /dev/null +++ b/src/main/java/chess/ChessController.java @@ -0,0 +1,4 @@ +package chess; + +public class ChessController { +} diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java index b14ab70f981..4ad8ea15d7a 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/src/main/java/chess/piece/Bishop.java @@ -1,5 +1,5 @@ package chess.piece; -public class Bishop { +public class Bishop extends ChessPiece{ } diff --git a/src/main/java/chess/piece/ChessPiece.java b/src/main/java/chess/piece/ChessPiece.java new file mode 100644 index 00000000000..0deaf13b143 --- /dev/null +++ b/src/main/java/chess/piece/ChessPiece.java @@ -0,0 +1,6 @@ +package chess.piece; + +public abstract class ChessPiece { + + +} diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java index d64210cad13..dde23d70355 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/piece/King.java @@ -1,5 +1,5 @@ package chess.piece; -public class King { +public class King extends ChessPiece{ } diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java index 2ee7c47a3bc..02c053ba5f7 100644 --- a/src/main/java/chess/piece/Knight.java +++ b/src/main/java/chess/piece/Knight.java @@ -1,5 +1,5 @@ package chess.piece; -public class Knight { +public class Knight extends ChessPiece{ } diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index c8b6cafa51e..b003d1df6d9 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -1,5 +1,5 @@ package chess.piece; -public class Pawn { +public class Pawn extends ChessPiece{ } diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java index 9b547261c4b..8ec009b52c0 100644 --- a/src/main/java/chess/piece/Queen.java +++ b/src/main/java/chess/piece/Queen.java @@ -1,5 +1,5 @@ package chess.piece; -public class Queen { +public class Queen extends ChessPiece{ } diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java index 7ed4d08bf03..437c8f8c2fe 100644 --- a/src/main/java/chess/piece/Rook.java +++ b/src/main/java/chess/piece/Rook.java @@ -1,5 +1,5 @@ package chess.piece; -public class Rook { +public class Rook extends ChessPiece{ } From 8811017bef6ef17054f26484bba44aafcdfcace1 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 13:48:42 +0900 Subject: [PATCH 03/19] =?UTF-8?q?chore:=20=ED=8C=A8=ED=82=A4=EC=A7=80=20?= =?UTF-8?q?=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/Application.java | 6 ++++++ src/main/java/chess/ChessController.java | 4 ---- .../chess/controller/ChessController.java | 20 +++++++++++++++++++ .../java/chess/{ => domain}/ChessBoard.java | 20 ++++++++++--------- src/main/java/chess/{ => domain}/Color.java | 2 +- src/main/java/chess/{ => domain}/Column.java | 2 +- .../java/chess/{ => domain}/Movement.java | 2 +- .../java/chess/{ => domain}/Position.java | 2 +- src/main/java/chess/{ => domain}/Row.java | 2 +- .../java/chess/{ => domain}/piece/Bishop.java | 2 +- .../chess/{ => domain}/piece/ChessPiece.java | 2 +- .../java/chess/{ => domain}/piece/King.java | 2 +- .../java/chess/{ => domain}/piece/Knight.java | 2 +- .../java/chess/{ => domain}/piece/Pawn.java | 2 +- .../java/chess/{ => domain}/piece/Queen.java | 2 +- .../java/chess/{ => domain}/piece/Rook.java | 2 +- src/main/java/chess/view/InputView.java | 4 ++++ src/main/java/chess/view/OutputView.java | 4 ++++ src/test/java/chess/ColumnTest.java | 1 + src/test/java/chess/Fixtures.java | 4 ++++ src/test/java/chess/PositionTest.java | 2 ++ src/test/java/chess/RowTest.java | 1 + 22 files changed, 65 insertions(+), 25 deletions(-) delete mode 100644 src/main/java/chess/ChessController.java create mode 100644 src/main/java/chess/controller/ChessController.java rename src/main/java/chess/{ => domain}/ChessBoard.java (90%) rename src/main/java/chess/{ => domain}/Color.java (95%) rename src/main/java/chess/{ => domain}/Column.java (97%) rename src/main/java/chess/{ => domain}/Movement.java (97%) rename src/main/java/chess/{ => domain}/Position.java (99%) rename src/main/java/chess/{ => domain}/Row.java (97%) rename src/main/java/chess/{ => domain}/piece/Bishop.java (61%) rename src/main/java/chess/{ => domain}/piece/ChessPiece.java (58%) rename src/main/java/chess/{ => domain}/piece/King.java (60%) rename src/main/java/chess/{ => domain}/piece/Knight.java (61%) rename src/main/java/chess/{ => domain}/piece/Pawn.java (60%) rename src/main/java/chess/{ => domain}/piece/Queen.java (60%) rename src/main/java/chess/{ => domain}/piece/Rook.java (60%) create mode 100644 src/main/java/chess/view/InputView.java create mode 100644 src/main/java/chess/view/OutputView.java diff --git a/src/main/java/chess/Application.java b/src/main/java/chess/Application.java index ff6b55ef980..0ffb0857a58 100644 --- a/src/main/java/chess/Application.java +++ b/src/main/java/chess/Application.java @@ -1,8 +1,14 @@ package chess; +import chess.controller.ChessController; +import chess.view.InputView; +import chess.view.OutputView; + public class Application { public static void main(String[] args) { + ChessController chessController = new ChessController(new InputView(), new OutputView()); + chessController.run(); } } diff --git a/src/main/java/chess/ChessController.java b/src/main/java/chess/ChessController.java deleted file mode 100644 index b6c2552a70f..00000000000 --- a/src/main/java/chess/ChessController.java +++ /dev/null @@ -1,4 +0,0 @@ -package chess; - -public class ChessController { -} diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java new file mode 100644 index 00000000000..07167e5cbdd --- /dev/null +++ b/src/main/java/chess/controller/ChessController.java @@ -0,0 +1,20 @@ +package chess.controller; + +import chess.domain.ChessBoard; +import chess.view.InputView; +import chess.view.OutputView; + +public class ChessController { + + private final InputView inputView; + private final OutputView outputView; + + public ChessController(InputView inputView, OutputView outputView) { + this.inputView = inputView; + this.outputView = outputView; + } + + public void run() { + ChessBoard chessBoard = new ChessBoard(); + } +} diff --git a/src/main/java/chess/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java similarity index 90% rename from src/main/java/chess/ChessBoard.java rename to src/main/java/chess/domain/ChessBoard.java index b45524584e6..2b8b4ee149d 100644 --- a/src/main/java/chess/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -1,12 +1,12 @@ -package chess; - -import chess.piece.Bishop; -import chess.piece.ChessPiece; -import chess.piece.King; -import chess.piece.Knight; -import chess.piece.Pawn; -import chess.piece.Queen; -import chess.piece.Rook; +package chess.domain; + +import chess.domain.piece.Bishop; +import chess.domain.piece.ChessPiece; +import chess.domain.piece.King; +import chess.domain.piece.Knight; +import chess.domain.piece.Pawn; +import chess.domain.piece.Queen; +import chess.domain.piece.Rook; import java.util.HashMap; import java.util.Map; @@ -57,4 +57,6 @@ public ChessBoard() { board.put(new Position(Row.TWO, Column.G), new Pawn()); board.put(new Position(Row.TWO, Column.H), new Pawn()); } + + } diff --git a/src/main/java/chess/Color.java b/src/main/java/chess/domain/Color.java similarity index 95% rename from src/main/java/chess/Color.java rename to src/main/java/chess/domain/Color.java index 55cd020b681..1a29e732d1a 100644 --- a/src/main/java/chess/Color.java +++ b/src/main/java/chess/domain/Color.java @@ -1,4 +1,4 @@ -package chess; +package chess.domain; public enum Color { diff --git a/src/main/java/chess/Column.java b/src/main/java/chess/domain/Column.java similarity index 97% rename from src/main/java/chess/Column.java rename to src/main/java/chess/domain/Column.java index b64b4dc77a3..96ba2f41610 100644 --- a/src/main/java/chess/Column.java +++ b/src/main/java/chess/domain/Column.java @@ -1,4 +1,4 @@ -package chess; +package chess.domain; public enum Column { diff --git a/src/main/java/chess/Movement.java b/src/main/java/chess/domain/Movement.java similarity index 97% rename from src/main/java/chess/Movement.java rename to src/main/java/chess/domain/Movement.java index e57c6e91bb9..07b5d153f67 100644 --- a/src/main/java/chess/Movement.java +++ b/src/main/java/chess/domain/Movement.java @@ -1,4 +1,4 @@ -package chess; +package chess.domain; public enum Movement { UP(0, 1), diff --git a/src/main/java/chess/Position.java b/src/main/java/chess/domain/Position.java similarity index 99% rename from src/main/java/chess/Position.java rename to src/main/java/chess/domain/Position.java index 3ebeb0ea185..1097b5a6a35 100644 --- a/src/main/java/chess/Position.java +++ b/src/main/java/chess/domain/Position.java @@ -1,4 +1,4 @@ -package chess; +package chess.domain; public record Position( Column column, diff --git a/src/main/java/chess/Row.java b/src/main/java/chess/domain/Row.java similarity index 97% rename from src/main/java/chess/Row.java rename to src/main/java/chess/domain/Row.java index 126ed048daa..128c77db39a 100644 --- a/src/main/java/chess/Row.java +++ b/src/main/java/chess/domain/Row.java @@ -1,4 +1,4 @@ -package chess; +package chess.domain; public enum Row { diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java similarity index 61% rename from src/main/java/chess/piece/Bishop.java rename to src/main/java/chess/domain/piece/Bishop.java index 4ad8ea15d7a..562b159af52 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -1,4 +1,4 @@ -package chess.piece; +package chess.domain.piece; public class Bishop extends ChessPiece{ diff --git a/src/main/java/chess/piece/ChessPiece.java b/src/main/java/chess/domain/piece/ChessPiece.java similarity index 58% rename from src/main/java/chess/piece/ChessPiece.java rename to src/main/java/chess/domain/piece/ChessPiece.java index 0deaf13b143..1af5292d4b0 100644 --- a/src/main/java/chess/piece/ChessPiece.java +++ b/src/main/java/chess/domain/piece/ChessPiece.java @@ -1,4 +1,4 @@ -package chess.piece; +package chess.domain.piece; public abstract class ChessPiece { diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/domain/piece/King.java similarity index 60% rename from src/main/java/chess/piece/King.java rename to src/main/java/chess/domain/piece/King.java index dde23d70355..9f4d2858936 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -1,4 +1,4 @@ -package chess.piece; +package chess.domain.piece; public class King extends ChessPiece{ diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java similarity index 61% rename from src/main/java/chess/piece/Knight.java rename to src/main/java/chess/domain/piece/Knight.java index 02c053ba5f7..9ae070bd10b 100644 --- a/src/main/java/chess/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -1,4 +1,4 @@ -package chess.piece; +package chess.domain.piece; public class Knight extends ChessPiece{ diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java similarity index 60% rename from src/main/java/chess/piece/Pawn.java rename to src/main/java/chess/domain/piece/Pawn.java index b003d1df6d9..39c50dc97f7 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -1,4 +1,4 @@ -package chess.piece; +package chess.domain.piece; public class Pawn extends ChessPiece{ diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java similarity index 60% rename from src/main/java/chess/piece/Queen.java rename to src/main/java/chess/domain/piece/Queen.java index 8ec009b52c0..fc6d20aa78a 100644 --- a/src/main/java/chess/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -1,4 +1,4 @@ -package chess.piece; +package chess.domain.piece; public class Queen extends ChessPiece{ diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java similarity index 60% rename from src/main/java/chess/piece/Rook.java rename to src/main/java/chess/domain/piece/Rook.java index 437c8f8c2fe..1dbbd6b3420 100644 --- a/src/main/java/chess/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -1,4 +1,4 @@ -package chess.piece; +package chess.domain.piece; public class Rook extends ChessPiece{ diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java new file mode 100644 index 00000000000..d9666f96fdb --- /dev/null +++ b/src/main/java/chess/view/InputView.java @@ -0,0 +1,4 @@ +package chess.view; + +public class InputView { +} diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java new file mode 100644 index 00000000000..90860218457 --- /dev/null +++ b/src/main/java/chess/view/OutputView.java @@ -0,0 +1,4 @@ +package chess.view; + +public class OutputView { +} diff --git a/src/test/java/chess/ColumnTest.java b/src/test/java/chess/ColumnTest.java index e43523240f7..73225bfe923 100644 --- a/src/test/java/chess/ColumnTest.java +++ b/src/test/java/chess/ColumnTest.java @@ -1,5 +1,6 @@ package chess; +import chess.domain.Column; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/chess/Fixtures.java b/src/test/java/chess/Fixtures.java index f940ab37137..c1b135539fd 100644 --- a/src/test/java/chess/Fixtures.java +++ b/src/test/java/chess/Fixtures.java @@ -1,5 +1,9 @@ package chess; +import chess.domain.Column; +import chess.domain.Position; +import chess.domain.Row; + @SuppressWarnings("unused") public final class Fixtures { diff --git a/src/test/java/chess/PositionTest.java b/src/test/java/chess/PositionTest.java index 3ad7cc64084..031fdd196a9 100644 --- a/src/test/java/chess/PositionTest.java +++ b/src/test/java/chess/PositionTest.java @@ -1,5 +1,7 @@ package chess; +import chess.domain.Movement; +import chess.domain.Position; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; diff --git a/src/test/java/chess/RowTest.java b/src/test/java/chess/RowTest.java index fcb65485410..feeb0883429 100644 --- a/src/test/java/chess/RowTest.java +++ b/src/test/java/chess/RowTest.java @@ -1,5 +1,6 @@ package chess; +import chess.domain.Row; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; From 993839e7dc0da90c83976d2f620c3bd9cc0d8c2b Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 14:00:55 +0900 Subject: [PATCH 04/19] =?UTF-8?q?feat:=20=EA=B0=81=20=EC=B2=B4=EC=8A=A4=20?= =?UTF-8?q?=EA=B8=B0=EB=AC=BC=EC=9D=98=20=EC=9D=B4=EB=8F=99=20=EA=B2=BD?= =?UTF-8?q?=EB=A1=9C=20=EC=A0=80=EC=9E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 15 ++++---- src/main/java/chess/domain/ChessBoard.java | 35 ++++++++++--------- src/main/java/chess/domain/piece/Bishop.java | 10 +++++- .../java/chess/domain/piece/BlackPawn.java | 12 +++++++ .../java/chess/domain/piece/ChessPiece.java | 4 +-- src/main/java/chess/domain/piece/King.java | 11 +++++- src/main/java/chess/domain/piece/Knight.java | 13 ++++++- .../domain/piece/LimitedMovingChessPiece.java | 18 ++++++++++ .../domain/piece/LinearMovingChessPiece.java | 18 ++++++++++ src/main/java/chess/domain/piece/Pawn.java | 5 --- src/main/java/chess/domain/piece/Queen.java | 10 +++++- src/main/java/chess/domain/piece/Rook.java | 10 +++++- .../java/chess/domain/piece/WhitePawn.java | 12 +++++++ 13 files changed, 138 insertions(+), 35 deletions(-) create mode 100644 src/main/java/chess/domain/piece/BlackPawn.java create mode 100644 src/main/java/chess/domain/piece/LimitedMovingChessPiece.java create mode 100644 src/main/java/chess/domain/piece/LinearMovingChessPiece.java delete mode 100644 src/main/java/chess/domain/piece/Pawn.java create mode 100644 src/main/java/chess/domain/piece/WhitePawn.java diff --git a/README.md b/README.md index cb80cdc1aa6..d1b8b9c3800 100644 --- a/README.md +++ b/README.md @@ -17,24 +17,27 @@ ## 체스 기물 +- [ ] 경로에 기물이 존재하는 경우 움직일 수 없다.(knight 제외) +- [ ] 도착지에 상대 기물이 존재하는 경우 잡을 수 있다. + ### king -- [ ] 상, 하, 좌, 우, 대각선으로 1칸 이동할 수 있다. +- [x] 상, 하, 좌, 우, 대각선으로 1칸 이동할 수 있다. - [ ] 잡히면 게임이 종료된다. ### bishop -- [ ] 대각선으로 여러 칸 이동할 수 있다. +- [x] 대각선으로 여러 칸 이동할 수 있다. ### knight -- [ ] 상, 하, 좌, 우로 1칸 이동 후 대각선으로 1칸 이동할 수 있다. +- [x] 상, 하, 좌, 우로 1칸 이동 후 대각선으로 1칸 이동할 수 있다. - [ ] 다른 기물을 뛰어넘을 수 있다. ### Pawn -- [ ] 앞으로 1칸 이동할 수 있다. +- [x] 앞으로 1칸 이동할 수 있다. - [ ] 초기 위치에서는 앞으로 2칸까지 이동할 수 있다. - [ ] 대각선 한 칸 앞에 위치한 기물을 잡을 수 있다. ### Queen -- [ ] 수직, 수평, 대각선으로 여러 칸 이동할 수 있다. +- [x] 수직, 수평, 대각선으로 여러 칸 이동할 수 있다. ### Rook -- [ ] 수직, 수평으로 여러 칸 이동할 수 있다. +- [x] 수직, 수평으로 여러 칸 이동할 수 있다. diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index 2b8b4ee149d..e2d498deb00 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -1,12 +1,13 @@ package chess.domain; import chess.domain.piece.Bishop; +import chess.domain.piece.BlackPawn; import chess.domain.piece.ChessPiece; import chess.domain.piece.King; import chess.domain.piece.Knight; -import chess.domain.piece.Pawn; import chess.domain.piece.Queen; import chess.domain.piece.Rook; +import chess.domain.piece.WhitePawn; import java.util.HashMap; import java.util.Map; @@ -30,14 +31,14 @@ public ChessBoard() { board.put(new Position(Row.EIGHT, Column.G), new Knight()); board.put(new Position(Row.EIGHT, Column.H), new Rook()); - board.put(new Position(Row.SEVEN, Column.A), new Pawn()); - board.put(new Position(Row.SEVEN, Column.B), new Pawn()); - board.put(new Position(Row.SEVEN, Column.C), new Pawn()); - board.put(new Position(Row.SEVEN, Column.D), new Pawn()); - board.put(new Position(Row.SEVEN, Column.E), new Pawn()); - board.put(new Position(Row.SEVEN, Column.F), new Pawn()); - board.put(new Position(Row.SEVEN, Column.G), new Pawn()); - board.put(new Position(Row.SEVEN, Column.H), new Pawn()); + board.put(new Position(Row.SEVEN, Column.A), new BlackPawn()); + board.put(new Position(Row.SEVEN, Column.B), new BlackPawn()); + board.put(new Position(Row.SEVEN, Column.C), new BlackPawn()); + board.put(new Position(Row.SEVEN, Column.D), new BlackPawn()); + board.put(new Position(Row.SEVEN, Column.E), new BlackPawn()); + board.put(new Position(Row.SEVEN, Column.F), new BlackPawn()); + board.put(new Position(Row.SEVEN, Column.G), new BlackPawn()); + board.put(new Position(Row.SEVEN, Column.H), new BlackPawn()); board.put(new Position(Row.ONE, Column.A), new Rook()); board.put(new Position(Row.ONE, Column.B), new Knight()); @@ -48,14 +49,14 @@ public ChessBoard() { board.put(new Position(Row.ONE, Column.G), new Knight()); board.put(new Position(Row.ONE, Column.H), new Rook()); - board.put(new Position(Row.TWO, Column.A), new Pawn()); - board.put(new Position(Row.TWO, Column.B), new Pawn()); - board.put(new Position(Row.TWO, Column.C), new Pawn()); - board.put(new Position(Row.TWO, Column.D), new Pawn()); - board.put(new Position(Row.TWO, Column.E), new Pawn()); - board.put(new Position(Row.TWO, Column.F), new Pawn()); - board.put(new Position(Row.TWO, Column.G), new Pawn()); - board.put(new Position(Row.TWO, Column.H), new Pawn()); + board.put(new Position(Row.TWO, Column.A), new WhitePawn()); + board.put(new Position(Row.TWO, Column.B), new WhitePawn()); + board.put(new Position(Row.TWO, Column.C), new WhitePawn()); + board.put(new Position(Row.TWO, Column.D), new WhitePawn()); + board.put(new Position(Row.TWO, Column.E), new WhitePawn()); + board.put(new Position(Row.TWO, Column.F), new WhitePawn()); + board.put(new Position(Row.TWO, Column.G), new WhitePawn()); + board.put(new Position(Row.TWO, Column.H), new WhitePawn()); } diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 562b159af52..7fd9c043932 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -1,5 +1,13 @@ package chess.domain.piece; -public class Bishop extends ChessPiece{ +import chess.domain.Movement; +import java.util.List; +public class Bishop extends LinearMovingChessPiece { + + public Bishop() { + super(List.of( + Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP + )); + } } diff --git a/src/main/java/chess/domain/piece/BlackPawn.java b/src/main/java/chess/domain/piece/BlackPawn.java new file mode 100644 index 00000000000..f898880ecaa --- /dev/null +++ b/src/main/java/chess/domain/piece/BlackPawn.java @@ -0,0 +1,12 @@ +package chess.domain.piece; + +import chess.domain.Movement; +import java.util.List; + +public class BlackPawn extends LimitedMovingChessPiece { + + // TODO: 색깔에 따라 방향 달라지고, 초기 위치인가에 따라 UP_UP 가능 / 불가능, 대각선 기물 먹기 가능 + public BlackPawn() { + super(List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.LEFT_UP)); + } +} diff --git a/src/main/java/chess/domain/piece/ChessPiece.java b/src/main/java/chess/domain/piece/ChessPiece.java index 1af5292d4b0..f9f7690e143 100644 --- a/src/main/java/chess/domain/piece/ChessPiece.java +++ b/src/main/java/chess/domain/piece/ChessPiece.java @@ -1,6 +1,6 @@ package chess.domain.piece; -public abstract class ChessPiece { - +public interface ChessPiece { + void move(); } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index 9f4d2858936..ff35db10609 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -1,5 +1,14 @@ package chess.domain.piece; -public class King extends ChessPiece{ +import chess.domain.Movement; +import java.util.List; +public class King extends LimitedMovingChessPiece { + + public King() { + super(List.of( + Movement.LEFT, Movement.LEFT_DOWN, Movement.UP, Movement.RIGHT, + Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP + )); + } } diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index 9ae070bd10b..08f1fb9ef28 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -1,5 +1,16 @@ package chess.domain.piece; -public class Knight extends ChessPiece{ +import chess.domain.Movement; +import java.util.List; +public class Knight extends LimitedMovingChessPiece { + + public Knight() { + super(List.of( + Movement.DOWN_DOWN_LEFT, Movement.DOWN_DOWN_RIGHT, + Movement.RIGHT_RIGHT_DOWN, Movement.RIGHT_RIGHT_UP, + Movement.UP_UP_LEFT, Movement.UP_UP_RIGHT, + Movement.LEFT_LEFT_DOWN, Movement.LEFT_LEFT_UP + )); + } } diff --git a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java new file mode 100644 index 00000000000..97c827c407a --- /dev/null +++ b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java @@ -0,0 +1,18 @@ +package chess.domain.piece; + +import chess.domain.Movement; +import java.util.List; + +public abstract class LimitedMovingChessPiece implements ChessPiece { + + protected final List movements; + + public LimitedMovingChessPiece(List movements) { + this.movements = movements; + } + + @Override + public void move() { + + } +} diff --git a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java new file mode 100644 index 00000000000..55c1b2ca149 --- /dev/null +++ b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java @@ -0,0 +1,18 @@ +package chess.domain.piece; + +import chess.domain.Movement; +import java.util.List; + +public abstract class LinearMovingChessPiece implements ChessPiece { + + protected final List directions; + + public LinearMovingChessPiece(List directions) { + this.directions = directions; + } + + @Override + public void move() { + + } +} diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java deleted file mode 100644 index 39c50dc97f7..00000000000 --- a/src/main/java/chess/domain/piece/Pawn.java +++ /dev/null @@ -1,5 +0,0 @@ -package chess.domain.piece; - -public class Pawn extends ChessPiece{ - -} diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index fc6d20aa78a..31d96d03fe2 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -1,5 +1,13 @@ package chess.domain.piece; -public class Queen extends ChessPiece{ +import chess.domain.Movement; +import java.util.List; +public class Queen extends LinearMovingChessPiece { + + public Queen() { + super(List.of( + Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT, + Movement.RIGHT_DOWN, Movement.LEFT_DOWN, Movement.RIGHT_UP, Movement.LEFT_UP)); + } } diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index 1dbbd6b3420..0b1ee4acfa9 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -1,5 +1,13 @@ package chess.domain.piece; -public class Rook extends ChessPiece{ +import chess.domain.Movement; +import java.util.List; +public class Rook extends LinearMovingChessPiece { + + public Rook() { + super(List.of( + Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT + )); + } } diff --git a/src/main/java/chess/domain/piece/WhitePawn.java b/src/main/java/chess/domain/piece/WhitePawn.java new file mode 100644 index 00000000000..e4686b98b73 --- /dev/null +++ b/src/main/java/chess/domain/piece/WhitePawn.java @@ -0,0 +1,12 @@ +package chess.domain.piece; + +import chess.domain.Movement; +import java.util.List; + +public class WhitePawn extends LimitedMovingChessPiece { + + // TODO: 색깔에 따라 방향 달라지고, 초기 위치인가에 따라 UP_UP 가능 / 불가능, 대각선 기물 먹기 가능 + public WhitePawn() { + super(List.of(Movement.UP_UP, Movement.UP, Movement.LEFT_UP, Movement.RIGHT_UP)); + } +} From 3f0ddba967add26eb8d43aec74c351c48e78a0b1 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 14:07:41 +0900 Subject: [PATCH 05/19] =?UTF-8?q?feat:=20=EC=B2=B4=EC=8A=A4=ED=8C=90=20?= =?UTF-8?q?=EC=B4=88=EA=B8=B0=ED=99=94=20=EA=B8=B0=EB=8A=A5=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 --- README.md | 20 +++++++++++-------- .../chess/controller/ChessController.java | 1 + src/main/java/chess/domain/ChessBoard.java | 9 ++++++++- src/main/java/chess/domain/piece/Bishop.java | 5 +++++ .../java/chess/domain/piece/BlackPawn.java | 5 +++++ .../java/chess/domain/piece/ChessPiece.java | 1 + src/main/java/chess/domain/piece/King.java | 5 +++++ src/main/java/chess/domain/piece/Knight.java | 5 +++++ src/main/java/chess/domain/piece/None.java | 14 +++++++++++++ src/main/java/chess/domain/piece/Queen.java | 5 +++++ src/main/java/chess/domain/piece/Rook.java | 5 +++++ .../java/chess/domain/piece/WhitePawn.java | 5 +++++ src/main/java/chess/view/OutputView.java | 17 ++++++++++++++++ 13 files changed, 88 insertions(+), 9 deletions(-) create mode 100644 src/main/java/chess/domain/piece/None.java diff --git a/README.md b/README.md index d1b8b9c3800..e1d07e86096 100644 --- a/README.md +++ b/README.md @@ -10,34 +10,38 @@ # 체스 체스 기물의 움직임을 구현한다. -## 체스 판 +## view +- [x] 체스 판을 출력할 수 있다. + +## domain +### 체스 판 - [x] 행은 1~8, 열은 a~h로 표현된다.(8x8) - [x] 체스 판을 초기화할 수 있다. - [ ] 특정 위치의 말을 원하는 위치로 움직일 수 있다. -## 체스 기물 +### 체스 기물 - [ ] 경로에 기물이 존재하는 경우 움직일 수 없다.(knight 제외) - [ ] 도착지에 상대 기물이 존재하는 경우 잡을 수 있다. -### king +#### king - [x] 상, 하, 좌, 우, 대각선으로 1칸 이동할 수 있다. - [ ] 잡히면 게임이 종료된다. -### bishop +#### bishop - [x] 대각선으로 여러 칸 이동할 수 있다. -### knight +#### knight - [x] 상, 하, 좌, 우로 1칸 이동 후 대각선으로 1칸 이동할 수 있다. - [ ] 다른 기물을 뛰어넘을 수 있다. -### Pawn +#### Pawn - [x] 앞으로 1칸 이동할 수 있다. - [ ] 초기 위치에서는 앞으로 2칸까지 이동할 수 있다. - [ ] 대각선 한 칸 앞에 위치한 기물을 잡을 수 있다. -### Queen +#### Queen - [x] 수직, 수평, 대각선으로 여러 칸 이동할 수 있다. -### Rook +#### Rook - [x] 수직, 수평으로 여러 칸 이동할 수 있다. diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index 07167e5cbdd..7fbf703b2ad 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -16,5 +16,6 @@ public ChessController(InputView inputView, OutputView outputView) { public void run() { ChessBoard chessBoard = new ChessBoard(); + outputView.printChessBoard(chessBoard); } } diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index e2d498deb00..3c88d1703f4 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -5,6 +5,7 @@ import chess.domain.piece.ChessPiece; import chess.domain.piece.King; import chess.domain.piece.Knight; +import chess.domain.piece.None; import chess.domain.piece.Queen; import chess.domain.piece.Rook; import chess.domain.piece.WhitePawn; @@ -18,7 +19,7 @@ public class ChessBoard { public ChessBoard() { for (Row row : Row.values()) { for (Column column : Column.values()) { - board.put(new Position(row, column), null); + board.put(new Position(row, column), new None()); } } @@ -59,5 +60,11 @@ public ChessBoard() { board.put(new Position(Row.TWO, Column.H), new WhitePawn()); } + public Map getBoard() { + return this.board; + } + public ChessPiece getPieceOfPosition(Position position) { + return board.get(position); + } } diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 7fd9c043932..27d91f99d28 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -10,4 +10,9 @@ public Bishop() { Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP )); } + + @Override + public String name() { + return "B"; + } } diff --git a/src/main/java/chess/domain/piece/BlackPawn.java b/src/main/java/chess/domain/piece/BlackPawn.java index f898880ecaa..faa46ad38a5 100644 --- a/src/main/java/chess/domain/piece/BlackPawn.java +++ b/src/main/java/chess/domain/piece/BlackPawn.java @@ -9,4 +9,9 @@ public class BlackPawn extends LimitedMovingChessPiece { public BlackPawn() { super(List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.LEFT_UP)); } + + @Override + public String name() { + return "P"; + } } diff --git a/src/main/java/chess/domain/piece/ChessPiece.java b/src/main/java/chess/domain/piece/ChessPiece.java index f9f7690e143..aa1e1e7d0dc 100644 --- a/src/main/java/chess/domain/piece/ChessPiece.java +++ b/src/main/java/chess/domain/piece/ChessPiece.java @@ -3,4 +3,5 @@ public interface ChessPiece { void move(); + String name(); } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index ff35db10609..81e063d3250 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -11,4 +11,9 @@ public King() { Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP )); } + + @Override + public String name() { + return "K"; + } } diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index 08f1fb9ef28..993e220ec67 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -13,4 +13,9 @@ public Knight() { Movement.LEFT_LEFT_DOWN, Movement.LEFT_LEFT_UP )); } + + @Override + public String name() { + return "N"; + } } diff --git a/src/main/java/chess/domain/piece/None.java b/src/main/java/chess/domain/piece/None.java new file mode 100644 index 00000000000..94d2d15f887 --- /dev/null +++ b/src/main/java/chess/domain/piece/None.java @@ -0,0 +1,14 @@ +package chess.domain.piece; + +public class None implements ChessPiece { + + @Override + public void move() { + + } + + @Override + public String name() { + return "-"; + } +} diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index 31d96d03fe2..fae09acbfdb 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -10,4 +10,9 @@ public Queen() { Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT, Movement.RIGHT_DOWN, Movement.LEFT_DOWN, Movement.RIGHT_UP, Movement.LEFT_UP)); } + + @Override + public String name() { + return "Q"; + } } diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index 0b1ee4acfa9..1d0460aea70 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -10,4 +10,9 @@ public Rook() { Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT )); } + + @Override + public String name() { + return "R"; + } } diff --git a/src/main/java/chess/domain/piece/WhitePawn.java b/src/main/java/chess/domain/piece/WhitePawn.java index e4686b98b73..021e1636d3a 100644 --- a/src/main/java/chess/domain/piece/WhitePawn.java +++ b/src/main/java/chess/domain/piece/WhitePawn.java @@ -9,4 +9,9 @@ public class WhitePawn extends LimitedMovingChessPiece { public WhitePawn() { super(List.of(Movement.UP_UP, Movement.UP, Movement.LEFT_UP, Movement.RIGHT_UP)); } + + @Override + public String name() { + return "P"; + } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 90860218457..f1ee4ee12f8 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -1,4 +1,21 @@ package chess.view; +import chess.domain.ChessBoard; +import chess.domain.Column; +import chess.domain.Position; +import chess.domain.Row; +import chess.domain.piece.ChessPiece; +import java.util.Map; + public class OutputView { + public void printChessBoard(ChessBoard chessBoard) { + + for (Row row : Row.values()) { + for (Column column : Column.values()) { + ChessPiece piece = chessBoard.getPieceOfPosition(new Position(row, column)); + System.out.print(piece.name()); + } + System.out.println(); + } + } } From aaa29bdfb2a3eeb67fc13aa36f979788395dbbdc Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 14:27:23 +0900 Subject: [PATCH 06/19] =?UTF-8?q?feat:=20=EA=B0=81=20=EA=B8=B0=EB=AC=BC?= =?UTF-8?q?=EC=9D=B4=20=ED=95=B4=EB=8B=B9=20=EA=B2=BD=EB=A1=9C=EB=A1=9C=20?= =?UTF-8?q?=EA=B0=88=20=EC=88=98=20=EC=9E=88=EB=8A=94=EC=A7=80=20=EC=8A=A4?= =?UTF-8?q?=EC=8A=A4=EB=A1=9C=20=ED=99=95=EC=9D=B8=ED=95=98=EB=8A=94=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 1 + .../java/chess/controller/InputProcessor.java | 17 ++++++++++ src/main/java/chess/domain/ChessBoard.java | 21 ++++++++++-- .../java/chess/domain/piece/BlackPawn.java | 7 +--- .../java/chess/domain/piece/ChessPiece.java | 3 ++ .../domain/piece/LimitedMovingChessPiece.java | 11 +++++++ .../domain/piece/LinearMovingChessPiece.java | 15 +++++++++ src/main/java/chess/domain/piece/None.java | 9 +++++- src/main/java/chess/domain/piece/Pawn.java | 16 ++++++++++ src/main/java/chess/domain/piece/Rook.java | 1 + .../java/chess/domain/piece/WhitePawn.java | 7 +--- .../java/chess/domain/piece/KnightTest.java | 32 +++++++++++++++++++ .../java/chess/domain/piece/RookTest.java | 32 +++++++++++++++++++ 13 files changed, 157 insertions(+), 15 deletions(-) create mode 100644 src/main/java/chess/controller/InputProcessor.java create mode 100644 src/main/java/chess/domain/piece/Pawn.java create mode 100644 src/test/java/chess/domain/piece/KnightTest.java create mode 100644 src/test/java/chess/domain/piece/RookTest.java diff --git a/README.md b/README.md index e1d07e86096..230b5082ac6 100644 --- a/README.md +++ b/README.md @@ -21,6 +21,7 @@ ### 체스 기물 +- [x] 출발지와 도착지를 기반으로, 각 기물이 해당 경로로 갈 수 있는지 스스로 확인할 수 있다. - [ ] 경로에 기물이 존재하는 경우 움직일 수 없다.(knight 제외) - [ ] 도착지에 상대 기물이 존재하는 경우 잡을 수 있다. diff --git a/src/main/java/chess/controller/InputProcessor.java b/src/main/java/chess/controller/InputProcessor.java new file mode 100644 index 00000000000..7c7d0494896 --- /dev/null +++ b/src/main/java/chess/controller/InputProcessor.java @@ -0,0 +1,17 @@ +package chess.controller; + +import java.util.function.Consumer; + +public class InputProcessor { + + public static void processUntilSuccess(Runnable runnable, Consumer printer) { + while(true) { + try { + runnable.run(); + return; + } catch(Exception e) { + printer.accept(e.getMessage()); + } + } + } +} diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index 3c88d1703f4..5199c711940 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -6,6 +6,7 @@ import chess.domain.piece.King; import chess.domain.piece.Knight; import chess.domain.piece.None; +import chess.domain.piece.Pawn; import chess.domain.piece.Queen; import chess.domain.piece.Rook; import chess.domain.piece.WhitePawn; @@ -60,8 +61,24 @@ public ChessBoard() { board.put(new Position(Row.TWO, Column.H), new WhitePawn()); } - public Map getBoard() { - return this.board; + // 1. 도착지 자체가 말이 갈 수 있는 도착지인지 확인(Piece.canMove에 출발, 도착지 넘겨줌) + // 2. 장애물 있는지 확인 + // 3. 도착지 말 색 확인 + public void movePiece(Position origin, Position destination) { + ChessPiece movePiece = getPieceOfPosition(origin); + + if (movePiece.getClass().equals(Knight.class)) { + // 장애물 있어도 됨 + } + else if (movePiece.getClass().equals(BlackPawn.class) || movePiece.getClass().equals(WhitePawn.class)) { + // 경로 달라짐 + } + else { + // 장애물 있는지 확인 + + } + + // 도착지 } public ChessPiece getPieceOfPosition(Position position) { diff --git a/src/main/java/chess/domain/piece/BlackPawn.java b/src/main/java/chess/domain/piece/BlackPawn.java index faa46ad38a5..284973895bf 100644 --- a/src/main/java/chess/domain/piece/BlackPawn.java +++ b/src/main/java/chess/domain/piece/BlackPawn.java @@ -3,15 +3,10 @@ import chess.domain.Movement; import java.util.List; -public class BlackPawn extends LimitedMovingChessPiece { +public class BlackPawn extends Pawn { // TODO: 색깔에 따라 방향 달라지고, 초기 위치인가에 따라 UP_UP 가능 / 불가능, 대각선 기물 먹기 가능 public BlackPawn() { super(List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.LEFT_UP)); } - - @Override - public String name() { - return "P"; - } } diff --git a/src/main/java/chess/domain/piece/ChessPiece.java b/src/main/java/chess/domain/piece/ChessPiece.java index aa1e1e7d0dc..8a65a5030b7 100644 --- a/src/main/java/chess/domain/piece/ChessPiece.java +++ b/src/main/java/chess/domain/piece/ChessPiece.java @@ -1,7 +1,10 @@ package chess.domain.piece; +import chess.domain.Position; + public interface ChessPiece { void move(); String name(); + boolean canMove(Position origin, Position destination); } diff --git a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java index 97c827c407a..ec892fde522 100644 --- a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java @@ -1,6 +1,7 @@ package chess.domain.piece; import chess.domain.Movement; +import chess.domain.Position; import java.util.List; public abstract class LimitedMovingChessPiece implements ChessPiece { @@ -11,6 +12,16 @@ public LimitedMovingChessPiece(List movements) { this.movements = movements; } + @Override + public boolean canMove(Position origin, Position destination) { + for (Movement movement : movements) { + if (origin.move(movement).equals(destination)) { + return true; + } + } + return false; + } + @Override public void move() { diff --git a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java index 55c1b2ca149..67e5815b0c6 100644 --- a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java @@ -1,6 +1,7 @@ package chess.domain.piece; import chess.domain.Movement; +import chess.domain.Position; import java.util.List; public abstract class LinearMovingChessPiece implements ChessPiece { @@ -11,6 +12,20 @@ public LinearMovingChessPiece(List directions) { this.directions = directions; } + @Override + public boolean canMove(Position origin, Position destination) { + for (Movement direction : directions) { + Position origin2 = origin; + while (origin2.canMove(direction)) { + origin2 = origin2.move(direction); + if (origin2.equals(destination)) { + return true; + } + } + } + return false; + } + @Override public void move() { diff --git a/src/main/java/chess/domain/piece/None.java b/src/main/java/chess/domain/piece/None.java index 94d2d15f887..47a3f3331ee 100644 --- a/src/main/java/chess/domain/piece/None.java +++ b/src/main/java/chess/domain/piece/None.java @@ -1,10 +1,17 @@ package chess.domain.piece; +import chess.domain.Position; + public class None implements ChessPiece { @Override - public void move() { + public boolean canMove(Position origin, Position destination) { + throw new IllegalStateException("움직일 말이 존재하지 않습니다."); + } + @Override + public void move() { + throw new IllegalStateException("움직일 말이 존재하지 않습니다."); } @Override diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java new file mode 100644 index 00000000000..3be96867fb9 --- /dev/null +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -0,0 +1,16 @@ +package chess.domain.piece; + +import chess.domain.Movement; +import java.util.List; + +public abstract class Pawn extends LimitedMovingChessPiece { + + public Pawn(List movements) { + super(movements); + } + + @Override + public String name() { + return "P"; + } +} diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index 1d0460aea70..ab858742111 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -1,6 +1,7 @@ package chess.domain.piece; import chess.domain.Movement; +import chess.domain.Position; import java.util.List; public class Rook extends LinearMovingChessPiece { diff --git a/src/main/java/chess/domain/piece/WhitePawn.java b/src/main/java/chess/domain/piece/WhitePawn.java index 021e1636d3a..8eb925a0865 100644 --- a/src/main/java/chess/domain/piece/WhitePawn.java +++ b/src/main/java/chess/domain/piece/WhitePawn.java @@ -3,15 +3,10 @@ import chess.domain.Movement; import java.util.List; -public class WhitePawn extends LimitedMovingChessPiece { +public class WhitePawn extends Pawn { // TODO: 색깔에 따라 방향 달라지고, 초기 위치인가에 따라 UP_UP 가능 / 불가능, 대각선 기물 먹기 가능 public WhitePawn() { super(List.of(Movement.UP_UP, Movement.UP, Movement.LEFT_UP, Movement.RIGHT_UP)); } - - @Override - public String name() { - return "P"; - } } diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java new file mode 100644 index 00000000000..e4f786f3197 --- /dev/null +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -0,0 +1,32 @@ +package chess.domain.piece; + +import static org.junit.jupiter.api.Assertions.*; + +import chess.domain.Column; +import chess.domain.Position; +import chess.domain.Row; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +class KnightTest { + + @Test + void 말이_움직일_수_있는_경로인지_확인할_수_있다() { + ChessPiece knight = new Knight(); + Position origin = new Position(Row.FOUR, Column.D); + Position destination = new Position(Row.FIVE, Column.F); + + Assertions.assertThat(knight.canMove(origin, destination)) + .isTrue(); + } + + @Test + void 말이_움직일_수_없는_경로인지_확인할_수_있다() { + ChessPiece knight = new Knight(); + Position origin = new Position(Row.FOUR, Column.D); + Position destination = new Position(Row.SIX, Column.F); + + Assertions.assertThat(knight.canMove(origin, destination)) + .isFalse(); + } +} diff --git a/src/test/java/chess/domain/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java new file mode 100644 index 00000000000..7860bb9005f --- /dev/null +++ b/src/test/java/chess/domain/piece/RookTest.java @@ -0,0 +1,32 @@ +package chess.domain.piece; + +import static org.junit.jupiter.api.Assertions.*; + +import chess.domain.Column; +import chess.domain.Position; +import chess.domain.Row; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +class RookTest { + + @Test + void 룩이_움직일_수_있는_경로인지_확인할_수_있다() { + ChessPiece rook = new Rook(); + Position origin = new Position(Row.FOUR, Column.B); + Position destination = new Position(Row.FOUR, Column.G); + + Assertions.assertThat(rook.canMove(origin, destination)) + .isTrue(); + } + + @Test + void 룩이_움직일_수_없는_경로인지_확인할_수_있다() { + ChessPiece rook = new Rook(); + Position origin = new Position(Row.FOUR, Column.B); + Position destination = new Position(Row.SIX, Column.F); + + Assertions.assertThat(rook.canMove(origin, destination)) + .isFalse(); + } +} From 55cbbfe3ea9f1e2238a6fcfcac6003be7f3c94bd Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 14:42:59 +0900 Subject: [PATCH 07/19] =?UTF-8?q?feat:=20=EA=B2=BD=EB=A1=9C=EC=97=90=20?= =?UTF-8?q?=EC=9E=A5=EC=95=A0=EB=AC=BC=EC=9D=B4=20=EC=A1=B4=EC=9E=AC?= =?UTF-8?q?=ED=95=98=EB=8A=94=EC=A7=80=20=ED=99=95=EC=9D=B8=ED=95=98?= =?UTF-8?q?=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- src/main/java/chess/domain/ChessBoard.java | 24 +++++++++++++---- .../java/chess/domain/piece/ChessPiece.java | 8 +++++- .../domain/piece/LimitedMovingChessPiece.java | 20 +++++++++++--- .../domain/piece/LinearMovingChessPiece.java | 27 ++++++++++++++++--- src/main/java/chess/domain/piece/None.java | 14 +++++++++- .../java/chess/domain/piece/KnightTest.java | 19 ++++++++++--- .../java/chess/domain/piece/RookTest.java | 20 +++++++++++--- 8 files changed, 112 insertions(+), 22 deletions(-) diff --git a/README.md b/README.md index 230b5082ac6..9600a019a8c 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,7 @@ ### 체스 기물 - [x] 출발지와 도착지를 기반으로, 각 기물이 해당 경로로 갈 수 있는지 스스로 확인할 수 있다. -- [ ] 경로에 기물이 존재하는 경우 움직일 수 없다.(knight 제외) +- [x] 경로에 기물이 존재하는 경우 움직일 수 없다.(knight 제외) - [ ] 도착지에 상대 기물이 존재하는 경우 잡을 수 있다. #### king diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index 5199c711940..bcb1bbbd792 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -6,11 +6,11 @@ import chess.domain.piece.King; import chess.domain.piece.Knight; import chess.domain.piece.None; -import chess.domain.piece.Pawn; import chess.domain.piece.Queen; import chess.domain.piece.Rook; import chess.domain.piece.WhitePawn; import java.util.HashMap; +import java.util.List; import java.util.Map; public class ChessBoard { @@ -61,27 +61,41 @@ public ChessBoard() { board.put(new Position(Row.TWO, Column.H), new WhitePawn()); } + public ChessPiece getPieceOfPosition(Position position) { + return board.get(position); + } + // 1. 도착지 자체가 말이 갈 수 있는 도착지인지 확인(Piece.canMove에 출발, 도착지 넘겨줌) // 2. 장애물 있는지 확인 // 3. 도착지 말 색 확인 public void movePiece(Position origin, Position destination) { ChessPiece movePiece = getPieceOfPosition(origin); + movePiece.validateCanMove(origin, destination); // 움직일 수 있는 경로에 있는지 확인 if (movePiece.getClass().equals(Knight.class)) { // 장애물 있어도 됨 } else if (movePiece.getClass().equals(BlackPawn.class) || movePiece.getClass().equals(WhitePawn.class)) { // 경로 달라짐 + + validateExistHurdle(movePiece, origin, destination); } else { // 장애물 있는지 확인 + validateExistHurdle(movePiece, origin, destination); } - - // 도착지 } - public ChessPiece getPieceOfPosition(Position position) { - return board.get(position); + private void validateExistHurdle(ChessPiece piece, Position origin, Position destination) { + List route = piece.findRoute(origin, destination); + List routeWithoutDestination = route.subList(0, route.size() - 1); + Position origin2 = origin; + for (Movement movement : routeWithoutDestination) { + origin2 = origin2.move(movement); + if (!getPieceOfPosition(origin2).isEmpty()) { + throw new IllegalStateException("경로에 장애물이 존재하여 움직일 수 없습니다."); + } + } } } diff --git a/src/main/java/chess/domain/piece/ChessPiece.java b/src/main/java/chess/domain/piece/ChessPiece.java index 8a65a5030b7..51375c433ed 100644 --- a/src/main/java/chess/domain/piece/ChessPiece.java +++ b/src/main/java/chess/domain/piece/ChessPiece.java @@ -1,10 +1,16 @@ package chess.domain.piece; +import chess.domain.Movement; import chess.domain.Position; +import java.util.List; public interface ChessPiece { void move(); String name(); - boolean canMove(Position origin, Position destination); + void validateCanMove(Position origin, Position destination); + List findRoute(Position origin, Position destination); + default boolean isEmpty() { + return false; + } } diff --git a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java index ec892fde522..53af723c6e4 100644 --- a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java @@ -13,13 +13,27 @@ public LimitedMovingChessPiece(List movements) { } @Override - public boolean canMove(Position origin, Position destination) { + public void validateCanMove(Position origin, Position destination) { + boolean canMove = false; for (Movement movement : movements) { if (origin.move(movement).equals(destination)) { - return true; + canMove = true; + break; } } - return false; + if (!canMove) { + throw new IllegalStateException("해당 기물은 해당 경로로 이동할 수 없습니다."); + } + } + + @Override + public List findRoute(Position origin, Position destination) { + for (Movement movement : movements) { + if (origin.move(movement).equals(destination)) { + return List.of(movement); + } + } + return List.of(); } @Override diff --git a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java index 67e5815b0c6..341985daf62 100644 --- a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java @@ -2,6 +2,7 @@ import chess.domain.Movement; import chess.domain.Position; +import java.util.Collections; import java.util.List; public abstract class LinearMovingChessPiece implements ChessPiece { @@ -13,17 +14,37 @@ public LinearMovingChessPiece(List directions) { } @Override - public boolean canMove(Position origin, Position destination) { + public void validateCanMove(Position origin, Position destination) { + boolean canMove = false; for (Movement direction : directions) { Position origin2 = origin; while (origin2.canMove(direction)) { origin2 = origin2.move(direction); if (origin2.equals(destination)) { - return true; + canMove = true; + break; } } } - return false; + if (!canMove) { + throw new IllegalStateException("해당 기물은 해당 경로로 이동할 수 없습니다."); + } + } + + @Override + public List findRoute(Position origin, Position destination) { + for (Movement direction : directions) { + Position origin2 = origin; + int i = 0; + while (origin2.canMove(direction)) { + origin2 = origin2.move(direction); + i++; + if (origin2.equals(destination)) { + return Collections.nCopies(i, direction); + } + } + } + return List.of(); } @Override diff --git a/src/main/java/chess/domain/piece/None.java b/src/main/java/chess/domain/piece/None.java index 47a3f3331ee..27cd5a6db2d 100644 --- a/src/main/java/chess/domain/piece/None.java +++ b/src/main/java/chess/domain/piece/None.java @@ -1,11 +1,18 @@ package chess.domain.piece; +import chess.domain.Movement; import chess.domain.Position; +import java.util.List; public class None implements ChessPiece { @Override - public boolean canMove(Position origin, Position destination) { + public void validateCanMove(Position origin, Position destination) { + throw new IllegalStateException("움직일 말이 존재하지 않습니다."); + } + + @Override + public List findRoute(Position origin, Position destination) { throw new IllegalStateException("움직일 말이 존재하지 않습니다."); } @@ -18,4 +25,9 @@ public void move() { public String name() { return "-"; } + + @Override + public boolean isEmpty() { + return true; + } } diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java index e4f786f3197..f9eb198f7b2 100644 --- a/src/test/java/chess/domain/piece/KnightTest.java +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -1,8 +1,11 @@ package chess.domain.piece; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.*; import chess.domain.Column; +import chess.domain.Movement; import chess.domain.Position; import chess.domain.Row; import org.assertj.core.api.Assertions; @@ -16,8 +19,7 @@ class KnightTest { Position origin = new Position(Row.FOUR, Column.D); Position destination = new Position(Row.FIVE, Column.F); - Assertions.assertThat(knight.canMove(origin, destination)) - .isTrue(); + assertDoesNotThrow(() -> knight.validateCanMove(origin, destination)); } @Test @@ -26,7 +28,16 @@ class KnightTest { Position origin = new Position(Row.FOUR, Column.D); Position destination = new Position(Row.SIX, Column.F); - Assertions.assertThat(knight.canMove(origin, destination)) - .isFalse(); + assertThatThrownBy(() -> knight.validateCanMove(origin, destination)); + } + + @Test + void 경로를_찾을_수_있다() { + ChessPiece knight = new Knight(); + Position origin = new Position(Row.FOUR, Column.D); + Position destination = new Position(Row.FIVE, Column.F); + + assertThat(knight.findRoute(origin, destination)) + .containsExactly(Movement.RIGHT_RIGHT_UP); } } diff --git a/src/test/java/chess/domain/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java index 7860bb9005f..b8a74cc7754 100644 --- a/src/test/java/chess/domain/piece/RookTest.java +++ b/src/test/java/chess/domain/piece/RookTest.java @@ -1,8 +1,11 @@ package chess.domain.piece; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.*; import chess.domain.Column; +import chess.domain.Movement; import chess.domain.Position; import chess.domain.Row; import org.assertj.core.api.Assertions; @@ -16,8 +19,7 @@ class RookTest { Position origin = new Position(Row.FOUR, Column.B); Position destination = new Position(Row.FOUR, Column.G); - Assertions.assertThat(rook.canMove(origin, destination)) - .isTrue(); + assertDoesNotThrow(() -> rook.validateCanMove(origin, destination)); } @Test @@ -26,7 +28,17 @@ class RookTest { Position origin = new Position(Row.FOUR, Column.B); Position destination = new Position(Row.SIX, Column.F); - Assertions.assertThat(rook.canMove(origin, destination)) - .isFalse(); + assertThatThrownBy(() -> rook.validateCanMove(origin, destination)) + .isInstanceOf(IllegalStateException.class); + } + + @Test + void 경로를_찾을_수_있다() { + ChessPiece rook = new Rook(); + Position origin = new Position(Row.FOUR, Column.B); + Position destination = new Position(Row.FOUR, Column.G); + + assertThat(rook.findRoute(origin, destination)) + .containsExactly(Movement.RIGHT, Movement.RIGHT, Movement.RIGHT, Movement.RIGHT, Movement.RIGHT); } } From e84054341cafc1be66468f1b0bf8001efe9dd8db Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 14:47:16 +0900 Subject: [PATCH 08/19] =?UTF-8?q?feat:=20=EC=B2=B4=EC=8A=A4=20=EA=B8=B0?= =?UTF-8?q?=EB=AC=BC=EC=97=90=20Color=20=ED=95=84=EB=93=9C=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 1 + src/main/java/chess/domain/ChessBoard.java | 32 +++++++++---------- src/main/java/chess/domain/piece/Bishop.java | 5 +-- .../java/chess/domain/piece/BlackPawn.java | 3 +- src/main/java/chess/domain/piece/King.java | 5 +-- src/main/java/chess/domain/piece/Knight.java | 5 +-- .../domain/piece/LimitedMovingChessPiece.java | 5 ++- .../domain/piece/LinearMovingChessPiece.java | 5 ++- src/main/java/chess/domain/piece/Pawn.java | 5 +-- src/main/java/chess/domain/piece/Queen.java | 6 ++-- src/main/java/chess/domain/piece/Rook.java | 5 +-- .../java/chess/domain/piece/WhitePawn.java | 3 +- 12 files changed, 48 insertions(+), 32 deletions(-) diff --git a/README.md b/README.md index 9600a019a8c..36a3a759499 100644 --- a/README.md +++ b/README.md @@ -24,6 +24,7 @@ - [x] 출발지와 도착지를 기반으로, 각 기물이 해당 경로로 갈 수 있는지 스스로 확인할 수 있다. - [x] 경로에 기물이 존재하는 경우 움직일 수 없다.(knight 제외) - [ ] 도착지에 상대 기물이 존재하는 경우 잡을 수 있다. +- [x] 본인의 색깔이 무엇인지 알고 있다. #### king - [x] 상, 하, 좌, 우, 대각선으로 1칸 이동할 수 있다. diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index bcb1bbbd792..cbc16c3749d 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -24,14 +24,14 @@ public ChessBoard() { } } - board.put(new Position(Row.EIGHT, Column.A), new Rook()); - board.put(new Position(Row.EIGHT, Column.B), new Knight()); - board.put(new Position(Row.EIGHT, Column.C), new Bishop()); - board.put(new Position(Row.EIGHT, Column.D), new Queen()); - board.put(new Position(Row.EIGHT, Column.E), new King()); - board.put(new Position(Row.EIGHT, Column.F), new Bishop()); - board.put(new Position(Row.EIGHT, Column.G), new Knight()); - board.put(new Position(Row.EIGHT, Column.H), new Rook()); + board.put(new Position(Row.EIGHT, Column.A), new Rook(Color.BLACK)); + board.put(new Position(Row.EIGHT, Column.B), new Knight(Color.BLACK)); + board.put(new Position(Row.EIGHT, Column.C), new Bishop(Color.BLACK)); + board.put(new Position(Row.EIGHT, Column.D), new Queen(Color.BLACK)); + board.put(new Position(Row.EIGHT, Column.E), new King(Color.BLACK)); + board.put(new Position(Row.EIGHT, Column.F), new Bishop(Color.BLACK)); + board.put(new Position(Row.EIGHT, Column.G), new Knight(Color.BLACK)); + board.put(new Position(Row.EIGHT, Column.H), new Rook(Color.BLACK)); board.put(new Position(Row.SEVEN, Column.A), new BlackPawn()); board.put(new Position(Row.SEVEN, Column.B), new BlackPawn()); @@ -42,14 +42,14 @@ public ChessBoard() { board.put(new Position(Row.SEVEN, Column.G), new BlackPawn()); board.put(new Position(Row.SEVEN, Column.H), new BlackPawn()); - board.put(new Position(Row.ONE, Column.A), new Rook()); - board.put(new Position(Row.ONE, Column.B), new Knight()); - board.put(new Position(Row.ONE, Column.C), new Bishop()); - board.put(new Position(Row.ONE, Column.D), new Queen()); - board.put(new Position(Row.ONE, Column.E), new King()); - board.put(new Position(Row.ONE, Column.F), new Bishop()); - board.put(new Position(Row.ONE, Column.G), new Knight()); - board.put(new Position(Row.ONE, Column.H), new Rook()); + board.put(new Position(Row.ONE, Column.A), new Rook(Color.WHITE)); + board.put(new Position(Row.ONE, Column.B), new Knight(Color.WHITE)); + board.put(new Position(Row.ONE, Column.C), new Bishop(Color.WHITE)); + board.put(new Position(Row.ONE, Column.D), new Queen(Color.WHITE)); + board.put(new Position(Row.ONE, Column.E), new King(Color.WHITE)); + board.put(new Position(Row.ONE, Column.F), new Bishop(Color.WHITE)); + board.put(new Position(Row.ONE, Column.G), new Knight(Color.WHITE)); + board.put(new Position(Row.ONE, Column.H), new Rook(Color.WHITE)); board.put(new Position(Row.TWO, Column.A), new WhitePawn()); board.put(new Position(Row.TWO, Column.B), new WhitePawn()); diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 27d91f99d28..eeafcec8807 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -1,14 +1,15 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import java.util.List; public class Bishop extends LinearMovingChessPiece { - public Bishop() { + public Bishop(Color side) { super(List.of( Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP - )); + ), side); } @Override diff --git a/src/main/java/chess/domain/piece/BlackPawn.java b/src/main/java/chess/domain/piece/BlackPawn.java index 284973895bf..37b8f22094f 100644 --- a/src/main/java/chess/domain/piece/BlackPawn.java +++ b/src/main/java/chess/domain/piece/BlackPawn.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import java.util.List; @@ -7,6 +8,6 @@ public class BlackPawn extends Pawn { // TODO: 색깔에 따라 방향 달라지고, 초기 위치인가에 따라 UP_UP 가능 / 불가능, 대각선 기물 먹기 가능 public BlackPawn() { - super(List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.LEFT_UP)); + super(List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.LEFT_UP), Color.BLACK); } } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index 81e063d3250..1e8f4bfa985 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -1,15 +1,16 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import java.util.List; public class King extends LimitedMovingChessPiece { - public King() { + public King(Color side) { super(List.of( Movement.LEFT, Movement.LEFT_DOWN, Movement.UP, Movement.RIGHT, Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP - )); + ), side); } @Override diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index 993e220ec67..f2e31f5cf8b 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -1,17 +1,18 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import java.util.List; public class Knight extends LimitedMovingChessPiece { - public Knight() { + public Knight(Color side) { super(List.of( Movement.DOWN_DOWN_LEFT, Movement.DOWN_DOWN_RIGHT, Movement.RIGHT_RIGHT_DOWN, Movement.RIGHT_RIGHT_UP, Movement.UP_UP_LEFT, Movement.UP_UP_RIGHT, Movement.LEFT_LEFT_DOWN, Movement.LEFT_LEFT_UP - )); + ), side); } @Override diff --git a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java index 53af723c6e4..438518b94bf 100644 --- a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import chess.domain.Position; import java.util.List; @@ -7,9 +8,11 @@ public abstract class LimitedMovingChessPiece implements ChessPiece { protected final List movements; + protected final Color side; - public LimitedMovingChessPiece(List movements) { + public LimitedMovingChessPiece(List movements, Color side) { this.movements = movements; + this.side = side; } @Override diff --git a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java index 341985daf62..7a029e42043 100644 --- a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import chess.domain.Position; import java.util.Collections; @@ -8,9 +9,11 @@ public abstract class LinearMovingChessPiece implements ChessPiece { protected final List directions; + protected final Color side; - public LinearMovingChessPiece(List directions) { + public LinearMovingChessPiece(List directions, Color side) { this.directions = directions; + this.side = side; } @Override diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 3be96867fb9..17423f8dc5c 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -1,12 +1,13 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import java.util.List; public abstract class Pawn extends LimitedMovingChessPiece { - public Pawn(List movements) { - super(movements); + public Pawn(List movements, Color side) { + super(movements, side); } @Override diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index fae09acbfdb..76078c3f5e2 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -1,14 +1,16 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import java.util.List; public class Queen extends LinearMovingChessPiece { - public Queen() { + public Queen(Color side) { super(List.of( Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT, - Movement.RIGHT_DOWN, Movement.LEFT_DOWN, Movement.RIGHT_UP, Movement.LEFT_UP)); + Movement.RIGHT_DOWN, Movement.LEFT_DOWN, Movement.RIGHT_UP, Movement.LEFT_UP) + , side); } @Override diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index ab858742111..c371c43b3a1 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -1,15 +1,16 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import chess.domain.Position; import java.util.List; public class Rook extends LinearMovingChessPiece { - public Rook() { + public Rook(Color side) { super(List.of( Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT - )); + ), side); } @Override diff --git a/src/main/java/chess/domain/piece/WhitePawn.java b/src/main/java/chess/domain/piece/WhitePawn.java index 8eb925a0865..928f86df2bc 100644 --- a/src/main/java/chess/domain/piece/WhitePawn.java +++ b/src/main/java/chess/domain/piece/WhitePawn.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import java.util.List; @@ -7,6 +8,6 @@ public class WhitePawn extends Pawn { // TODO: 색깔에 따라 방향 달라지고, 초기 위치인가에 따라 UP_UP 가능 / 불가능, 대각선 기물 먹기 가능 public WhitePawn() { - super(List.of(Movement.UP_UP, Movement.UP, Movement.LEFT_UP, Movement.RIGHT_UP)); + super(List.of(Movement.UP_UP, Movement.UP, Movement.LEFT_UP, Movement.RIGHT_UP), Color.WHITE); } } From 5e73ff8e224c240a65738e02fe8d7a3cba2213a8 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 14:52:29 +0900 Subject: [PATCH 09/19] =?UTF-8?q?feat:=20=EC=83=81=EB=8C=80=20=EA=B8=B0?= =?UTF-8?q?=EB=AC=BC=EC=9D=84=20=EC=9E=A1=EB=8A=94=20=EA=B8=B0=EB=8A=A5=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 --- README.md | 3 ++- src/main/java/chess/domain/ChessBoard.java | 10 ++++++++++ src/main/java/chess/domain/piece/ChessPiece.java | 3 +++ .../chess/domain/piece/LimitedMovingChessPiece.java | 12 ++++++++++++ .../chess/domain/piece/LinearMovingChessPiece.java | 12 ++++++++++++ 5 files changed, 39 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 36a3a759499..a304ede5d6b 100644 --- a/README.md +++ b/README.md @@ -23,8 +23,9 @@ - [x] 출발지와 도착지를 기반으로, 각 기물이 해당 경로로 갈 수 있는지 스스로 확인할 수 있다. - [x] 경로에 기물이 존재하는 경우 움직일 수 없다.(knight 제외) -- [ ] 도착지에 상대 기물이 존재하는 경우 잡을 수 있다. +- [x] 도착지에 상대 기물이 존재하는 경우 잡을 수 있다. - [x] 본인의 색깔이 무엇인지 알고 있다. +- [x] 본인이 잡혔는지 알고 있다. #### king - [x] 상, 하, 좌, 우, 대각선으로 1칸 이동할 수 있다. diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index cbc16c3749d..ba213a6d8bc 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -83,8 +83,18 @@ else if (movePiece.getClass().equals(BlackPawn.class) || movePiece.getClass().eq else { // 장애물 있는지 확인 validateExistHurdle(movePiece, origin, destination); + } + ChessPiece targetPiece = getPieceOfPosition(destination); + if (movePiece.getColor().opposite() == targetPiece.getColor()) { + targetPiece.capture(); + } + else if (movePiece.getColor() == targetPiece.getColor()) { + throw new IllegalStateException("도착지에 같은 편의 기물이 존재하기 때문에 움직일 수 없습니다."); } + + board.put(origin, new None()); + board.put(destination, movePiece); } private void validateExistHurdle(ChessPiece piece, Position origin, Position destination) { diff --git a/src/main/java/chess/domain/piece/ChessPiece.java b/src/main/java/chess/domain/piece/ChessPiece.java index 51375c433ed..617f31201bf 100644 --- a/src/main/java/chess/domain/piece/ChessPiece.java +++ b/src/main/java/chess/domain/piece/ChessPiece.java @@ -1,5 +1,6 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import chess.domain.Position; import java.util.List; @@ -13,4 +14,6 @@ public interface ChessPiece { default boolean isEmpty() { return false; } + Color getColor(); + void capture(); } diff --git a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java index 438518b94bf..f11776f02d2 100644 --- a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java @@ -9,10 +9,12 @@ public abstract class LimitedMovingChessPiece implements ChessPiece { protected final List movements; protected final Color side; + protected boolean isCaptured; public LimitedMovingChessPiece(List movements, Color side) { this.movements = movements; this.side = side; + this.isCaptured = false; } @Override @@ -43,4 +45,14 @@ public List findRoute(Position origin, Position destination) { public void move() { } + + @Override + public Color getColor() { + return side; + } + + @Override + public void capture() { + this.isCaptured = true; + } } diff --git a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java index 7a029e42043..55b07dd6856 100644 --- a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java @@ -10,10 +10,12 @@ public abstract class LinearMovingChessPiece implements ChessPiece { protected final List directions; protected final Color side; + protected boolean isCaptured; public LinearMovingChessPiece(List directions, Color side) { this.directions = directions; this.side = side; + this.isCaptured = false; } @Override @@ -54,4 +56,14 @@ public List findRoute(Position origin, Position destination) { public void move() { } + + @Override + public Color getColor() { + return side; + } + + @Override + public void capture() { + this.isCaptured = true; + } } From eebe84c48ef613310cc069558a56d96476f2d840 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 16:02:32 +0900 Subject: [PATCH 10/19] =?UTF-8?q?feat:=20=EC=B2=B4=EC=8A=A4=20=EA=B8=B0?= =?UTF-8?q?=EB=AC=BC=20=EC=9D=B4=EB=8F=99=20=EA=B8=B0=EB=8A=A5=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 --- README.md | 8 +- .../chess/controller/ChessController.java | 18 ++++- .../java/chess/controller/InputProcessor.java | 11 +++ src/main/java/chess/domain/ChessBoard.java | 56 ++++++++++--- src/main/java/chess/domain/Color.java | 6 ++ src/main/java/chess/domain/Column.java | 5 +- src/main/java/chess/domain/Movement.java | 4 + src/main/java/chess/domain/Position.java | 8 ++ src/main/java/chess/domain/Row.java | 4 +- .../domain/piece/LimitedMovingChessPiece.java | 4 +- src/main/java/chess/domain/piece/None.java | 18 +++++ src/main/java/chess/domain/piece/Pawn.java | 29 +++++++ src/main/java/chess/view/InputView.java | 81 +++++++++++++++++++ src/main/java/chess/view/OutputView.java | 73 ++++++++++++++++- 14 files changed, 303 insertions(+), 22 deletions(-) diff --git a/README.md b/README.md index a304ede5d6b..074b34c8e63 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ ### 체스 판 - [x] 행은 1~8, 열은 a~h로 표현된다.(8x8) - [x] 체스 판을 초기화할 수 있다. -- [ ] 특정 위치의 말을 원하는 위치로 움직일 수 있다. +- [x] 특정 위치의 말을 원하는 위치로 움직일 수 있다. ### 체스 기물 @@ -36,12 +36,12 @@ #### knight - [x] 상, 하, 좌, 우로 1칸 이동 후 대각선으로 1칸 이동할 수 있다. -- [ ] 다른 기물을 뛰어넘을 수 있다. +- [x] 다른 기물을 뛰어넘을 수 있다. #### Pawn - [x] 앞으로 1칸 이동할 수 있다. -- [ ] 초기 위치에서는 앞으로 2칸까지 이동할 수 있다. -- [ ] 대각선 한 칸 앞에 위치한 기물을 잡을 수 있다. +- [x] 초기 위치에서는 앞으로 2칸까지 이동할 수 있다. +- [x] 대각선 한 칸 앞에 위치한 기물을 잡을 수 있다. #### Queen - [x] 수직, 수평, 대각선으로 여러 칸 이동할 수 있다. diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index 7fbf703b2ad..56de7eafca8 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -1,8 +1,11 @@ package chess.controller; import chess.domain.ChessBoard; +import chess.domain.Color; +import chess.domain.Position; import chess.view.InputView; import chess.view.OutputView; +import java.util.List; public class ChessController { @@ -16,6 +19,19 @@ public ChessController(InputView inputView, OutputView outputView) { public void run() { ChessBoard chessBoard = new ChessBoard(); - outputView.printChessBoard(chessBoard); + + while (true) { + outputView.printChessBoard(chessBoard); + InputProcessor.processUntilSuccess(() -> { + List originAndDestination = inputView.getMoveInput(); + chessBoard.movePiece(originAndDestination.get(0), originAndDestination.get(1)); + }, OutputView::printErrorMessage); + + +// List colors = Color.getGameColors(); +// for (Color color : colors) { +// outputView.printTurnMessage(color); +// } + } } } diff --git a/src/main/java/chess/controller/InputProcessor.java b/src/main/java/chess/controller/InputProcessor.java index 7c7d0494896..9f9f4289976 100644 --- a/src/main/java/chess/controller/InputProcessor.java +++ b/src/main/java/chess/controller/InputProcessor.java @@ -1,6 +1,7 @@ package chess.controller; import java.util.function.Consumer; +import java.util.function.Supplier; public class InputProcessor { @@ -14,4 +15,14 @@ public static void processUntilSuccess(Runnable runnable, Consumer print } } } + + public static T processUntilSuccess(Supplier supplier, Consumer printer) { + while(true) { + try { + return supplier.get(); + } catch(Exception e) { + printer.accept(e.getMessage()); + } + } + } } diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index ba213a6d8bc..d37c5e0346e 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -6,6 +6,7 @@ import chess.domain.piece.King; import chess.domain.piece.Knight; import chess.domain.piece.None; +import chess.domain.piece.Pawn; import chess.domain.piece.Queen; import chess.domain.piece.Rook; import chess.domain.piece.WhitePawn; @@ -65,24 +66,44 @@ public ChessPiece getPieceOfPosition(Position position) { return board.get(position); } - // 1. 도착지 자체가 말이 갈 수 있는 도착지인지 확인(Piece.canMove에 출발, 도착지 넘겨줌) - // 2. 장애물 있는지 확인 - // 3. 도착지 말 색 확인 + // 1. 도착지 자체가 말이 갈 수 있는 도착지인지 확인(Piece.canMove에 출발, 도착지 넘겨줌) O + // 2. 장애물 있는지 확인 O + // 3. 도착지 말 색 확인 O public void movePiece(Position origin, Position destination) { + ChessPiece movePiece = getPieceOfPosition(origin); movePiece.validateCanMove(origin, destination); // 움직일 수 있는 경로에 있는지 확인 + + // 나이트 if (movePiece.getClass().equals(Knight.class)) { // 장애물 있어도 됨 } + // 폰 else if (movePiece.getClass().equals(BlackPawn.class) || movePiece.getClass().equals(WhitePawn.class)) { - // 경로 달라짐 + // 첫 움직임 -> 앞으로 두칸까지 가능 + Pawn pawn = (Pawn) movePiece; + Movement route = pawn.findRoute(origin, destination).get(0); + + // if route가 대각선 -> 도착지에 상대 말 있어야 움직일 수 있음 -> 무조건 먹음이 일어남 + if (route.isDiagonal()) { + if (pawn.getColor() != getPieceOfPosition(destination).getColor().opposite()) { + throw new IllegalStateException("대각선 위치에 상대 말이 없기 때문에 움직일 수 없습니다."); + } + getPieceOfPosition(destination).capture(); + } + // 앞으로 움직임 -> 도착지와 경로에 장애물 없으면 가능F + else { + validateExistHurdleOnRouteWithDestination(pawn, origin, destination); + } - validateExistHurdle(movePiece, origin, destination); + pawn.isMoved(); } + + // 나머지 말 else { // 장애물 있는지 확인 - validateExistHurdle(movePiece, origin, destination); + validateExistHurdleOnRouteWithoutDestination(movePiece, origin, destination); } ChessPiece targetPiece = getPieceOfPosition(destination); @@ -97,14 +118,29 @@ else if (movePiece.getColor() == targetPiece.getColor()) { board.put(destination, movePiece); } - private void validateExistHurdle(ChessPiece piece, Position origin, Position destination) { + private void validateExistHurdleOnRouteWithoutDestination(ChessPiece piece, Position origin, Position destination) { List route = piece.findRoute(origin, destination); List routeWithoutDestination = route.subList(0, route.size() - 1); Position origin2 = origin; for (Movement movement : routeWithoutDestination) { - origin2 = origin2.move(movement); - if (!getPieceOfPosition(origin2).isEmpty()) { - throw new IllegalStateException("경로에 장애물이 존재하여 움직일 수 없습니다."); + if (origin2.canMove(movement)) { + origin2 = origin2.move(movement); + if (!getPieceOfPosition(origin2).isEmpty()) { + throw new IllegalStateException("경로에 장애물이 존재하여 움직일 수 없습니다."); + } + } + } + } + + private void validateExistHurdleOnRouteWithDestination(ChessPiece piece, Position origin, Position destination) { + List route = piece.findRoute(origin, destination); + Position origin2 = origin; + for (Movement movement : route) { + if (origin2.canMove(movement)) { + origin2 = origin2.move(movement); + if (!getPieceOfPosition(origin2).isEmpty()) { + throw new IllegalStateException("경로 및 도착지에 장애물이 존재하여 움직일 수 없습니다."); + } } } } diff --git a/src/main/java/chess/domain/Color.java b/src/main/java/chess/domain/Color.java index 1a29e732d1a..553be44b7d9 100644 --- a/src/main/java/chess/domain/Color.java +++ b/src/main/java/chess/domain/Color.java @@ -1,5 +1,7 @@ package chess.domain; +import java.util.List; + public enum Color { BLACK, @@ -25,4 +27,8 @@ public Color opposite() { default -> EMPTY; }; } + + public static List getGameColors() { + return List.of(WHITE, BLACK); + } } diff --git a/src/main/java/chess/domain/Column.java b/src/main/java/chess/domain/Column.java index 96ba2f41610..63efc8e8d1e 100644 --- a/src/main/java/chess/domain/Column.java +++ b/src/main/java/chess/domain/Column.java @@ -15,6 +15,7 @@ public boolean isFarLeft() { return ordinal() == 0; } + public boolean isFarRight() { return ordinal() + 1 == values().length; } @@ -32,7 +33,7 @@ public Column moveLeft(final int step) { return values()[ordinal() - step]; } - throw new IllegalStateException("움직일 수 없는 위치입니다."); + throw new IllegalStateException("움직일 수 없는 위치입니다. column left"); } public boolean canMoveRight(final int step) { @@ -48,6 +49,6 @@ public Column moveRight(final int step) { return values()[ordinal() + step]; } - throw new IllegalStateException("움직일 수 없는 위치입니다."); + throw new IllegalStateException("움직일 수 없는 위치입니다. column right"); } } diff --git a/src/main/java/chess/domain/Movement.java b/src/main/java/chess/domain/Movement.java index 07b5d153f67..818676ef475 100644 --- a/src/main/java/chess/domain/Movement.java +++ b/src/main/java/chess/domain/Movement.java @@ -45,4 +45,8 @@ public boolean isVertical() { public boolean isDiagonal() { return x != 0 && y != 0 && Math.abs(x) == Math.abs(y); } + + public boolean isTwoTimeVerticalMove() { + return this == UP_UP || this == DOWN_DOWN; + } } diff --git a/src/main/java/chess/domain/Position.java b/src/main/java/chess/domain/Position.java index 1097b5a6a35..ef91e35086a 100644 --- a/src/main/java/chess/domain/Position.java +++ b/src/main/java/chess/domain/Position.java @@ -167,4 +167,12 @@ public Position moveHorizontal(final int step) { } return this; } + + @Override + public String toString() { + return "Position{" + + "column=" + column + + ", row=" + row + + '}'; + } } diff --git a/src/main/java/chess/domain/Row.java b/src/main/java/chess/domain/Row.java index 128c77db39a..a056c6f047e 100644 --- a/src/main/java/chess/domain/Row.java +++ b/src/main/java/chess/domain/Row.java @@ -32,7 +32,7 @@ public Row moveUp(final int step) { return values()[ordinal() - step]; } - throw new IllegalStateException("움직일 수 없는 위치입니다."); + throw new IllegalStateException("움직일 수 없는 위치입니다. row up"); } public boolean canMoveDown(final int step) { @@ -48,6 +48,6 @@ public Row moveDown(final int step) { return values()[ordinal() + step]; } - throw new IllegalStateException("움직일 수 없는 위치입니다."); + throw new IllegalStateException("움직일 수 없는 위치입니다. row down"); } } diff --git a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java index f11776f02d2..360df8645f5 100644 --- a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java @@ -21,7 +21,7 @@ public LimitedMovingChessPiece(List movements, Color side) { public void validateCanMove(Position origin, Position destination) { boolean canMove = false; for (Movement movement : movements) { - if (origin.move(movement).equals(destination)) { + if (origin.canMove(movement) && origin.move(movement).equals(destination)) { canMove = true; break; } @@ -34,7 +34,7 @@ public void validateCanMove(Position origin, Position destination) { @Override public List findRoute(Position origin, Position destination) { for (Movement movement : movements) { - if (origin.move(movement).equals(destination)) { + if (origin.canMove(movement) && origin.move(movement).equals(destination)) { return List.of(movement); } } diff --git a/src/main/java/chess/domain/piece/None.java b/src/main/java/chess/domain/piece/None.java index 27cd5a6db2d..a7812fc6028 100644 --- a/src/main/java/chess/domain/piece/None.java +++ b/src/main/java/chess/domain/piece/None.java @@ -1,11 +1,18 @@ package chess.domain.piece; +import chess.domain.Color; import chess.domain.Movement; import chess.domain.Position; import java.util.List; public class None implements ChessPiece { + protected final Color side; + + public None() { + this.side = Color.EMPTY; + } + @Override public void validateCanMove(Position origin, Position destination) { throw new IllegalStateException("움직일 말이 존재하지 않습니다."); @@ -30,4 +37,15 @@ public String name() { public boolean isEmpty() { return true; } + + @Override + public Color getColor() { + return side; + } + + @Override + public void capture() { + throw new IllegalStateException("말이 존재하지 않습니다."); + + } } diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 17423f8dc5c..8372423796b 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -2,16 +2,45 @@ import chess.domain.Color; import chess.domain.Movement; +import chess.domain.Position; import java.util.List; public abstract class Pawn extends LimitedMovingChessPiece { + protected boolean isFirstMove; + public Pawn(List movements, Color side) { super(movements, side); + this.isFirstMove = true; } @Override public String name() { return "P"; } + + public boolean isFirstMove() { + return isFirstMove; + } + + @Override + public void move() { + + } + + public List findRoute(Position origin, Position destination) { + for (Movement movement : movements) { + if (origin.canMove(movement) && origin.move(movement).equals(destination)) { + if (movement.isTwoTimeVerticalMove() && !isFirstMove) { + throw new IllegalStateException("폰은 처음 움직일 때만 두 칸 움직일 수 있습니다."); + } + return List.of(movement); + } + } + return List.of(); + } + + public void isMoved() { + this.isFirstMove = false; + } } diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java index d9666f96fdb..1a65de46902 100644 --- a/src/main/java/chess/view/InputView.java +++ b/src/main/java/chess/view/InputView.java @@ -1,4 +1,85 @@ package chess.view; +import chess.domain.Column; +import chess.domain.Position; +import chess.domain.Row; +import java.util.List; +import java.util.Scanner; + public class InputView { + + private static final Scanner scanner = new Scanner(System.in); + + public List getMoveInput() { + System.out.println("움직일 말의 위치와 도착지를 입력하세요.(ex. a1 b2)"); + + try { + String positions = scanner.nextLine(); + Position origin = parseToPosition(String.valueOf(positions.charAt(0)), String.valueOf(positions.charAt(1))); + Position destination = parseToPosition(String.valueOf(positions.charAt(3)), String.valueOf(positions.charAt(4))); + return List.of(origin, destination); + } catch (Exception e) { + throw new IllegalArgumentException("올바르지 않은 위치 입력입니다."); + } + } + + private Position parseToPosition(String column, String row) { + return new Position(parseToRow(row), parseToColumn(column)); + } + + private Column parseToColumn(String columnRaw) { + if (columnRaw.equals("a")) { + return Column.A; + } + if (columnRaw.equals("b")) { + return Column.B; + } + if (columnRaw.equals("c")) { + return Column.C; + } + if (columnRaw.equals("d")) { + return Column.D; + } + if (columnRaw.equals("e")) { + return Column.E; + } + if (columnRaw.equals("f")) { + return Column.F; + } + if (columnRaw.equals("g")) { + return Column.G; + } + if (columnRaw.equals("h")) { + return Column.H; + } + throw new IllegalArgumentException("존재하지 않는 열입니다."); + } + + private Row parseToRow(String rowRaw) { + if (rowRaw.equals("1")) { + return Row.ONE; + } + if (rowRaw.equals("2")) { + return Row.TWO; + } + if (rowRaw.equals("3")) { + return Row.THREE; + } + if (rowRaw.equals("4")) { + return Row.FOUR; + } + if (rowRaw.equals("5")) { + return Row.FIVE; + } + if (rowRaw.equals("6")) { + return Row.SIX; + } + if (rowRaw.equals("7")) { + return Row.SEVEN; + } + if (rowRaw.equals("8")) { + return Row.EIGHT; + } + throw new IllegalArgumentException("존재하지 않는 행입니다."); + } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index f1ee4ee12f8..edb63e85467 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -1,16 +1,23 @@ package chess.view; import chess.domain.ChessBoard; +import chess.domain.Color; import chess.domain.Column; import chess.domain.Position; import chess.domain.Row; import chess.domain.piece.ChessPiece; -import java.util.Map; public class OutputView { public void printChessBoard(ChessBoard chessBoard) { + System.out.print(" "); + for (Column column : Column.values()) { + System.out.print(parseColumn(column)); + } + + System.out.println(); for (Row row : Row.values()) { + System.out.print(parseRow(row)); for (Column column : Column.values()) { ChessPiece piece = chessBoard.getPieceOfPosition(new Position(row, column)); System.out.print(piece.name()); @@ -18,4 +25,68 @@ public void printChessBoard(ChessBoard chessBoard) { System.out.println(); } } + + public void printTurnMessage(Color color) { + System.out.println(color.name() + "의 차례입니다."); + } + + private String parseColumn(Column column) { + if (column == Column.A) { + return "a"; + } + if (column == Column.B) { + return "b"; + } + if (column == Column.C) { + return "c"; + } + if (column == Column.D) { + return "d"; + } + if (column == Column.E) { + return "e"; + } + if (column == Column.F) { + return "f"; + } + if (column == Column.G) { + return "g"; + } + if (column == Column.H) { + return "h"; + } + return null; + } + + private String parseRow(Row row) { + if (row == Row.ONE) { + return "1"; + } + if (row == Row.TWO) { + return "2"; + } + if (row == Row.THREE) { + return "3"; + } + if (row == Row.FOUR) { + return "4"; + } + if (row == Row.FIVE) { + return "5"; + } + if (row == Row.SIX) { + return "6"; + } + if (row == Row.SEVEN) { + return "7"; + } + if (row == Row.EIGHT) { + return "8"; + } + return null; + } + + public static void printErrorMessage(String message) { + System.out.println(message); + } } From 3190eb16069f427ba03f486f916e48a0da3693b2 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 16:32:36 +0900 Subject: [PATCH 11/19] =?UTF-8?q?feat:=20=EC=99=95=EC=9D=B4=20=EC=9E=A1?= =?UTF-8?q?=ED=9E=88=EB=A9=B4=20=EA=B2=8C=EC=9E=84=EC=9D=B4=20=EC=A2=85?= =?UTF-8?q?=EB=A3=8C=EB=90=98=EB=8A=94=20=EB=A1=9C=EC=A7=81=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 --- README.md | 2 +- .../chess/controller/ChessController.java | 35 +++++++++++++------ .../java/chess/controller/InputProcessor.java | 10 ++++++ src/main/java/chess/domain/ChessBoard.java | 19 ++++++++-- .../java/chess/domain/piece/ChessPiece.java | 1 + .../domain/piece/LimitedMovingChessPiece.java | 5 +++ .../domain/piece/LinearMovingChessPiece.java | 5 +++ src/main/java/chess/domain/piece/None.java | 5 +++ src/main/java/chess/view/InputView.java | 3 +- src/main/java/chess/view/OutputView.java | 32 ++++++++++++----- 10 files changed, 95 insertions(+), 22 deletions(-) diff --git a/README.md b/README.md index 074b34c8e63..98b471a3d77 100644 --- a/README.md +++ b/README.md @@ -29,7 +29,7 @@ #### king - [x] 상, 하, 좌, 우, 대각선으로 1칸 이동할 수 있다. -- [ ] 잡히면 게임이 종료된다. +- [x] 잡히면 게임이 종료된다. #### bishop - [x] 대각선으로 여러 칸 이동할 수 있다. diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index 56de7eafca8..a2766fd69c4 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -19,19 +19,34 @@ public ChessController(InputView inputView, OutputView outputView) { public void run() { ChessBoard chessBoard = new ChessBoard(); + List colors = Color.getGameColors(); + Color nowTurn = colors.get(0); - while (true) { + boolean isKingCaptured = false; + while (!isKingCaptured) { outputView.printChessBoard(chessBoard); - InputProcessor.processUntilSuccess(() -> { - List originAndDestination = inputView.getMoveInput(); - chessBoard.movePiece(originAndDestination.get(0), originAndDestination.get(1)); - }, OutputView::printErrorMessage); + outputView.printTurnMessage(nowTurn); - -// List colors = Color.getGameColors(); -// for (Color color : colors) { -// outputView.printTurnMessage(color); -// } + processChessTurn(chessBoard, nowTurn); + if (chessBoard.checkOppositeKingCaptured(nowTurn)) { + break; + } + nowTurn = nowTurn.opposite(); } + + outputView.printWinningMessage(nowTurn); + } + + private void processChessTurn(ChessBoard chessBoard, Color nowTurn) { + InputProcessor.processUntilSuccess(() -> { + List originAndDestination = inputView.getMoveInput(); + Position origin = originAndDestination.get(0); + if (chessBoard.getPieceOfPosition(origin).getColor() != nowTurn) { + throw new IllegalArgumentException("현재는 %s의 차례입니다.".formatted(nowTurn.name())); + } + Position destination = originAndDestination.get(1); + + chessBoard.movePiece(origin, destination); + }, OutputView::printErrorMessage); } } diff --git a/src/main/java/chess/controller/InputProcessor.java b/src/main/java/chess/controller/InputProcessor.java index 9f9f4289976..1640aa54cb0 100644 --- a/src/main/java/chess/controller/InputProcessor.java +++ b/src/main/java/chess/controller/InputProcessor.java @@ -16,6 +16,16 @@ public static void processUntilSuccess(Runnable runnable, Consumer print } } + public static void processUntilSuccess(Consumer consumer, Consumer printer, T t) { + while(true) { + try { + consumer.accept(t); + } catch(Exception e) { + printer.accept(e.getMessage()); + } + } + } + public static T processUntilSuccess(Supplier supplier, Consumer printer) { while(true) { try { diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index d37c5e0346e..22fa55292ac 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -17,8 +17,13 @@ public class ChessBoard { private final Map board = new HashMap<>(); + private final ChessPiece blackKing; + private final ChessPiece whiteKing; public ChessBoard() { + blackKing = new King(Color.BLACK); + whiteKing = new King(Color.WHITE); + for (Row row : Row.values()) { for (Column column : Column.values()) { board.put(new Position(row, column), new None()); @@ -29,7 +34,7 @@ public ChessBoard() { board.put(new Position(Row.EIGHT, Column.B), new Knight(Color.BLACK)); board.put(new Position(Row.EIGHT, Column.C), new Bishop(Color.BLACK)); board.put(new Position(Row.EIGHT, Column.D), new Queen(Color.BLACK)); - board.put(new Position(Row.EIGHT, Column.E), new King(Color.BLACK)); + board.put(new Position(Row.EIGHT, Column.E), blackKing); board.put(new Position(Row.EIGHT, Column.F), new Bishop(Color.BLACK)); board.put(new Position(Row.EIGHT, Column.G), new Knight(Color.BLACK)); board.put(new Position(Row.EIGHT, Column.H), new Rook(Color.BLACK)); @@ -47,7 +52,7 @@ public ChessBoard() { board.put(new Position(Row.ONE, Column.B), new Knight(Color.WHITE)); board.put(new Position(Row.ONE, Column.C), new Bishop(Color.WHITE)); board.put(new Position(Row.ONE, Column.D), new Queen(Color.WHITE)); - board.put(new Position(Row.ONE, Column.E), new King(Color.WHITE)); + board.put(new Position(Row.ONE, Column.E), whiteKing); board.put(new Position(Row.ONE, Column.F), new Bishop(Color.WHITE)); board.put(new Position(Row.ONE, Column.G), new Knight(Color.WHITE)); board.put(new Position(Row.ONE, Column.H), new Rook(Color.WHITE)); @@ -144,4 +149,14 @@ private void validateExistHurdleOnRouteWithDestination(ChessPiece piece, Positio } } } + + public boolean checkOppositeKingCaptured(Color color) { + if (color == Color.BLACK) { + return whiteKing.isCaptured(); + } + if (color == Color.WHITE) { + return blackKing.isCaptured(); + } + return false; + } } diff --git a/src/main/java/chess/domain/piece/ChessPiece.java b/src/main/java/chess/domain/piece/ChessPiece.java index 617f31201bf..49d11cea5e2 100644 --- a/src/main/java/chess/domain/piece/ChessPiece.java +++ b/src/main/java/chess/domain/piece/ChessPiece.java @@ -16,4 +16,5 @@ default boolean isEmpty() { } Color getColor(); void capture(); + boolean isCaptured(); } diff --git a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java index 360df8645f5..6d850271454 100644 --- a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java @@ -55,4 +55,9 @@ public Color getColor() { public void capture() { this.isCaptured = true; } + + @Override + public boolean isCaptured() { + return isCaptured; + } } diff --git a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java index 55b07dd6856..809134e62ec 100644 --- a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java @@ -66,4 +66,9 @@ public Color getColor() { public void capture() { this.isCaptured = true; } + + @Override + public boolean isCaptured() { + return isCaptured; + } } diff --git a/src/main/java/chess/domain/piece/None.java b/src/main/java/chess/domain/piece/None.java index a7812fc6028..5b634d69873 100644 --- a/src/main/java/chess/domain/piece/None.java +++ b/src/main/java/chess/domain/piece/None.java @@ -48,4 +48,9 @@ public void capture() { throw new IllegalStateException("말이 존재하지 않습니다."); } + + @Override + public boolean isCaptured() { + return false; + } } diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java index 1a65de46902..0c2aa7826fb 100644 --- a/src/main/java/chess/view/InputView.java +++ b/src/main/java/chess/view/InputView.java @@ -9,9 +9,10 @@ public class InputView { private static final Scanner scanner = new Scanner(System.in); + private static final String LINE_SEPARATOR = System.lineSeparator(); public List getMoveInput() { - System.out.println("움직일 말의 위치와 도착지를 입력하세요.(ex. a1 b2)"); + System.out.println(LINE_SEPARATOR + "움직일 말의 위치와 도착지를 입력하세요.(ex. a1 b2)"); try { String positions = scanner.nextLine(); diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index edb63e85467..157b83be994 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -8,26 +8,36 @@ import chess.domain.piece.ChessPiece; public class OutputView { - public void printChessBoard(ChessBoard chessBoard) { - System.out.print(" "); + private static final String LINE_SEPARATOR = System.lineSeparator(); + + public void printChessBoard(ChessBoard chessBoard) { + System.out.print(" "); for (Column column : Column.values()) { - System.out.print(parseColumn(column)); + System.out.print(parseColumn(column) + " "); } System.out.println(); for (Row row : Row.values()) { - System.out.print(parseRow(row)); + System.out.print(parseRow(row) + " "); for (Column column : Column.values()) { ChessPiece piece = chessBoard.getPieceOfPosition(new Position(row, column)); - System.out.print(piece.name()); + System.out.print(colorMessage(piece.name(), piece.getColor()) + " "); } System.out.println(); } } public void printTurnMessage(Color color) { - System.out.println(color.name() + "의 차례입니다."); + System.out.println(LINE_SEPARATOR + colorMessage(color.name(), color) + "의 차례입니다."); + } + + public void printWinningMessage(Color winner) { + System.out.println(LINE_SEPARATOR + colorMessage(winner.name(), winner) + "의 승리입니다!"); + } + + public static void printErrorMessage(String message) { + System.out.println(message); } private String parseColumn(Column column) { @@ -86,7 +96,13 @@ private String parseRow(Row row) { return null; } - public static void printErrorMessage(String message) { - System.out.println(message); + private String colorMessage(String message, Color color) { + if (color == Color.BLACK) { + return "\u001B[90m" + message + "\u001B[0m"; + } + if (color == Color.WHITE) { + return "\u001B[97m" + message + "\u001B[0m"; + } + return "\u001B[34m" + message + "\u001B[0m"; } } From 794b0da0701a24c831dd0745216413f6745434da Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 16:38:38 +0900 Subject: [PATCH 12/19] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=EB=A9=94=EC=84=9C=EB=93=9C=20?= =?UTF-8?q?=EC=82=AD=EC=A0=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/domain/piece/ChessPiece.java | 1 - .../chess/domain/piece/LimitedMovingChessPiece.java | 5 ----- .../chess/domain/piece/LinearMovingChessPiece.java | 5 ----- src/main/java/chess/domain/piece/None.java | 5 ----- .../piece/{ => limited_moving_chess_piece}/Pawn.java | 11 +---------- 5 files changed, 1 insertion(+), 26 deletions(-) rename src/main/java/chess/domain/piece/{ => limited_moving_chess_piece}/Pawn.java (87%) diff --git a/src/main/java/chess/domain/piece/ChessPiece.java b/src/main/java/chess/domain/piece/ChessPiece.java index 49d11cea5e2..ed800fe7dd7 100644 --- a/src/main/java/chess/domain/piece/ChessPiece.java +++ b/src/main/java/chess/domain/piece/ChessPiece.java @@ -7,7 +7,6 @@ public interface ChessPiece { - void move(); String name(); void validateCanMove(Position origin, Position destination); List findRoute(Position origin, Position destination); diff --git a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java index 6d850271454..bdaa62766df 100644 --- a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java @@ -41,11 +41,6 @@ public List findRoute(Position origin, Position destination) { return List.of(); } - @Override - public void move() { - - } - @Override public Color getColor() { return side; diff --git a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java index 809134e62ec..d0761e6673f 100644 --- a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/LinearMovingChessPiece.java @@ -52,11 +52,6 @@ public List findRoute(Position origin, Position destination) { return List.of(); } - @Override - public void move() { - - } - @Override public Color getColor() { return side; diff --git a/src/main/java/chess/domain/piece/None.java b/src/main/java/chess/domain/piece/None.java index 5b634d69873..db7368df083 100644 --- a/src/main/java/chess/domain/piece/None.java +++ b/src/main/java/chess/domain/piece/None.java @@ -23,11 +23,6 @@ public List findRoute(Position origin, Position destination) { throw new IllegalStateException("움직일 말이 존재하지 않습니다."); } - @Override - public void move() { - throw new IllegalStateException("움직일 말이 존재하지 않습니다."); - } - @Override public String name() { return "-"; diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Pawn.java similarity index 87% rename from src/main/java/chess/domain/piece/Pawn.java rename to src/main/java/chess/domain/piece/limited_moving_chess_piece/Pawn.java index 8372423796b..f3a34780fcc 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Pawn.java @@ -1,4 +1,4 @@ -package chess.domain.piece; +package chess.domain.piece.limited_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; @@ -19,15 +19,6 @@ public String name() { return "P"; } - public boolean isFirstMove() { - return isFirstMove; - } - - @Override - public void move() { - - } - public List findRoute(Position origin, Position destination) { for (Movement movement : movements) { if (origin.canMove(movement) && origin.move(movement).equals(destination)) { From a3b1dba5df577af62265fff4c1d477fe2df3ce5f Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 16:42:23 +0900 Subject: [PATCH 13/19] =?UTF-8?q?refactor:=20domain=20=EA=B5=AC=EC=A1=B0?= =?UTF-8?q?=20=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/domain/ChessBoard.java | 18 +++++++++--------- .../BlackPawn.java | 3 +-- .../{ => limited_moving_chess_piece}/King.java | 2 +- .../Knight.java | 2 +- .../LimitedMovingChessPiece.java | 3 ++- .../{ => limited_moving_chess_piece}/None.java | 4 ++-- .../WhitePawn.java | 3 +-- .../Bishop.java | 2 +- .../LinearMovingChessPiece.java | 3 ++- .../{ => linear_moving_chess_piece}/Queen.java | 2 +- .../{ => linear_moving_chess_piece}/Rook.java | 3 +-- .../java/chess/domain/piece/KnightTest.java | 2 +- src/test/java/chess/domain/piece/RookTest.java | 2 +- 13 files changed, 24 insertions(+), 25 deletions(-) rename src/main/java/chess/domain/piece/{ => limited_moving_chess_piece}/BlackPawn.java (61%) rename src/main/java/chess/domain/piece/{ => limited_moving_chess_piece}/King.java (89%) rename src/main/java/chess/domain/piece/{ => limited_moving_chess_piece}/Knight.java (90%) rename src/main/java/chess/domain/piece/{ => limited_moving_chess_piece}/LimitedMovingChessPiece.java (94%) rename src/main/java/chess/domain/piece/{ => limited_moving_chess_piece}/None.java (91%) rename src/main/java/chess/domain/piece/{ => limited_moving_chess_piece}/WhitePawn.java (60%) rename src/main/java/chess/domain/piece/{ => linear_moving_chess_piece}/Bishop.java (87%) rename src/main/java/chess/domain/piece/{ => linear_moving_chess_piece}/LinearMovingChessPiece.java (95%) rename src/main/java/chess/domain/piece/{ => linear_moving_chess_piece}/Queen.java (89%) rename src/main/java/chess/domain/piece/{ => linear_moving_chess_piece}/Rook.java (85%) diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index 22fa55292ac..d17a96d4b51 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -1,15 +1,15 @@ package chess.domain; -import chess.domain.piece.Bishop; -import chess.domain.piece.BlackPawn; +import chess.domain.piece.linear_moving_chess_piece.Bishop; +import chess.domain.piece.limited_moving_chess_piece.BlackPawn; import chess.domain.piece.ChessPiece; -import chess.domain.piece.King; -import chess.domain.piece.Knight; -import chess.domain.piece.None; -import chess.domain.piece.Pawn; -import chess.domain.piece.Queen; -import chess.domain.piece.Rook; -import chess.domain.piece.WhitePawn; +import chess.domain.piece.limited_moving_chess_piece.King; +import chess.domain.piece.limited_moving_chess_piece.Knight; +import chess.domain.piece.limited_moving_chess_piece.None; +import chess.domain.piece.limited_moving_chess_piece.Pawn; +import chess.domain.piece.linear_moving_chess_piece.Queen; +import chess.domain.piece.linear_moving_chess_piece.Rook; +import chess.domain.piece.limited_moving_chess_piece.WhitePawn; import java.util.HashMap; import java.util.List; import java.util.Map; diff --git a/src/main/java/chess/domain/piece/BlackPawn.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java similarity index 61% rename from src/main/java/chess/domain/piece/BlackPawn.java rename to src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java index 37b8f22094f..1920d7fa7fc 100644 --- a/src/main/java/chess/domain/piece/BlackPawn.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java @@ -1,4 +1,4 @@ -package chess.domain.piece; +package chess.domain.piece.limited_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; @@ -6,7 +6,6 @@ public class BlackPawn extends Pawn { - // TODO: 색깔에 따라 방향 달라지고, 초기 위치인가에 따라 UP_UP 가능 / 불가능, 대각선 기물 먹기 가능 public BlackPawn() { super(List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.LEFT_UP), Color.BLACK); } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/King.java similarity index 89% rename from src/main/java/chess/domain/piece/King.java rename to src/main/java/chess/domain/piece/limited_moving_chess_piece/King.java index 1e8f4bfa985..316df95232a 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/King.java @@ -1,4 +1,4 @@ -package chess.domain.piece; +package chess.domain.piece.limited_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java similarity index 90% rename from src/main/java/chess/domain/piece/Knight.java rename to src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java index f2e31f5cf8b..b4979f230df 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java @@ -1,4 +1,4 @@ -package chess.domain.piece; +package chess.domain.piece.limited_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; diff --git a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/LimitedMovingChessPiece.java similarity index 94% rename from src/main/java/chess/domain/piece/LimitedMovingChessPiece.java rename to src/main/java/chess/domain/piece/limited_moving_chess_piece/LimitedMovingChessPiece.java index bdaa62766df..e28db7d9bd9 100644 --- a/src/main/java/chess/domain/piece/LimitedMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/LimitedMovingChessPiece.java @@ -1,8 +1,9 @@ -package chess.domain.piece; +package chess.domain.piece.limited_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; import chess.domain.Position; +import chess.domain.piece.ChessPiece; import java.util.List; public abstract class LimitedMovingChessPiece implements ChessPiece { diff --git a/src/main/java/chess/domain/piece/None.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/None.java similarity index 91% rename from src/main/java/chess/domain/piece/None.java rename to src/main/java/chess/domain/piece/limited_moving_chess_piece/None.java index db7368df083..38428572d71 100644 --- a/src/main/java/chess/domain/piece/None.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/None.java @@ -1,8 +1,9 @@ -package chess.domain.piece; +package chess.domain.piece.limited_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; import chess.domain.Position; +import chess.domain.piece.ChessPiece; import java.util.List; public class None implements ChessPiece { @@ -41,7 +42,6 @@ public Color getColor() { @Override public void capture() { throw new IllegalStateException("말이 존재하지 않습니다."); - } @Override diff --git a/src/main/java/chess/domain/piece/WhitePawn.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/WhitePawn.java similarity index 60% rename from src/main/java/chess/domain/piece/WhitePawn.java rename to src/main/java/chess/domain/piece/limited_moving_chess_piece/WhitePawn.java index 928f86df2bc..1822479f145 100644 --- a/src/main/java/chess/domain/piece/WhitePawn.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/WhitePawn.java @@ -1,4 +1,4 @@ -package chess.domain.piece; +package chess.domain.piece.limited_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; @@ -6,7 +6,6 @@ public class WhitePawn extends Pawn { - // TODO: 색깔에 따라 방향 달라지고, 초기 위치인가에 따라 UP_UP 가능 / 불가능, 대각선 기물 먹기 가능 public WhitePawn() { super(List.of(Movement.UP_UP, Movement.UP, Movement.LEFT_UP, Movement.RIGHT_UP), Color.WHITE); } diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Bishop.java similarity index 87% rename from src/main/java/chess/domain/piece/Bishop.java rename to src/main/java/chess/domain/piece/linear_moving_chess_piece/Bishop.java index eeafcec8807..0dd18d9de11 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Bishop.java @@ -1,4 +1,4 @@ -package chess.domain.piece; +package chess.domain.piece.linear_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; diff --git a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java b/src/main/java/chess/domain/piece/linear_moving_chess_piece/LinearMovingChessPiece.java similarity index 95% rename from src/main/java/chess/domain/piece/LinearMovingChessPiece.java rename to src/main/java/chess/domain/piece/linear_moving_chess_piece/LinearMovingChessPiece.java index d0761e6673f..f8dca6b6e9e 100644 --- a/src/main/java/chess/domain/piece/LinearMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/linear_moving_chess_piece/LinearMovingChessPiece.java @@ -1,8 +1,9 @@ -package chess.domain.piece; +package chess.domain.piece.linear_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; import chess.domain.Position; +import chess.domain.piece.ChessPiece; import java.util.Collections; import java.util.List; diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Queen.java similarity index 89% rename from src/main/java/chess/domain/piece/Queen.java rename to src/main/java/chess/domain/piece/linear_moving_chess_piece/Queen.java index 76078c3f5e2..d88a9fc7f7d 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Queen.java @@ -1,4 +1,4 @@ -package chess.domain.piece; +package chess.domain.piece.linear_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Rook.java similarity index 85% rename from src/main/java/chess/domain/piece/Rook.java rename to src/main/java/chess/domain/piece/linear_moving_chess_piece/Rook.java index c371c43b3a1..e62392ace39 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Rook.java @@ -1,8 +1,7 @@ -package chess.domain.piece; +package chess.domain.piece.linear_moving_chess_piece; import chess.domain.Color; import chess.domain.Movement; -import chess.domain.Position; import java.util.List; public class Rook extends LinearMovingChessPiece { diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java index f9eb198f7b2..e7f264cc480 100644 --- a/src/test/java/chess/domain/piece/KnightTest.java +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -8,7 +8,7 @@ import chess.domain.Movement; import chess.domain.Position; import chess.domain.Row; -import org.assertj.core.api.Assertions; +import chess.domain.piece.limited_moving_chess_piece.Knight; import org.junit.jupiter.api.Test; class KnightTest { diff --git a/src/test/java/chess/domain/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java index b8a74cc7754..eba505ffb16 100644 --- a/src/test/java/chess/domain/piece/RookTest.java +++ b/src/test/java/chess/domain/piece/RookTest.java @@ -8,7 +8,7 @@ import chess.domain.Movement; import chess.domain.Position; import chess.domain.Row; -import org.assertj.core.api.Assertions; +import chess.domain.piece.linear_moving_chess_piece.Rook; import org.junit.jupiter.api.Test; class RookTest { From 3459fcb9c3084855c0375c4c4cdcda1b7d92a37a Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 16:43:25 +0900 Subject: [PATCH 14/19] =?UTF-8?q?test:=20=EA=B9=A8=EC=A7=80=EB=8A=94=20?= =?UTF-8?q?=ED=85=8C=EC=8A=A4=ED=8A=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/piece/KnightTest.java | 7 ++++--- src/test/java/chess/domain/piece/RookTest.java | 7 ++++--- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java index e7f264cc480..4afd958c809 100644 --- a/src/test/java/chess/domain/piece/KnightTest.java +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.*; +import chess.domain.Color; import chess.domain.Column; import chess.domain.Movement; import chess.domain.Position; @@ -15,7 +16,7 @@ class KnightTest { @Test void 말이_움직일_수_있는_경로인지_확인할_수_있다() { - ChessPiece knight = new Knight(); + ChessPiece knight = new Knight(Color.BLACK); Position origin = new Position(Row.FOUR, Column.D); Position destination = new Position(Row.FIVE, Column.F); @@ -24,7 +25,7 @@ class KnightTest { @Test void 말이_움직일_수_없는_경로인지_확인할_수_있다() { - ChessPiece knight = new Knight(); + ChessPiece knight = new Knight(Color.BLACK); Position origin = new Position(Row.FOUR, Column.D); Position destination = new Position(Row.SIX, Column.F); @@ -33,7 +34,7 @@ class KnightTest { @Test void 경로를_찾을_수_있다() { - ChessPiece knight = new Knight(); + ChessPiece knight = new Knight(Color.WHITE); Position origin = new Position(Row.FOUR, Column.D); Position destination = new Position(Row.FIVE, Column.F); diff --git a/src/test/java/chess/domain/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java index eba505ffb16..ac75d785766 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.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.*; +import chess.domain.Color; import chess.domain.Column; import chess.domain.Movement; import chess.domain.Position; @@ -15,7 +16,7 @@ class RookTest { @Test void 룩이_움직일_수_있는_경로인지_확인할_수_있다() { - ChessPiece rook = new Rook(); + ChessPiece rook = new Rook(Color.BLACK); Position origin = new Position(Row.FOUR, Column.B); Position destination = new Position(Row.FOUR, Column.G); @@ -24,7 +25,7 @@ class RookTest { @Test void 룩이_움직일_수_없는_경로인지_확인할_수_있다() { - ChessPiece rook = new Rook(); + ChessPiece rook = new Rook(Color.WHITE); Position origin = new Position(Row.FOUR, Column.B); Position destination = new Position(Row.SIX, Column.F); @@ -34,7 +35,7 @@ class RookTest { @Test void 경로를_찾을_수_있다() { - ChessPiece rook = new Rook(); + ChessPiece rook = new Rook(Color.BLACK); Position origin = new Position(Row.FOUR, Column.B); Position destination = new Position(Row.FOUR, Column.G); From b18941d508c666f4b0d467e921dc8b27b37094cf Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 17:12:06 +0900 Subject: [PATCH 15/19] =?UTF-8?q?refactor:=20=EC=9B=80=EC=A7=81=EC=9D=BC?= =?UTF-8?q?=20=EC=88=98=20=EC=9E=88=EB=8A=94=EC=A7=80=20=EA=B2=80=EC=A6=9D?= =?UTF-8?q?=ED=95=98=EB=8A=94=20=EA=B8=B0=EB=8A=A5=EC=9D=84=20ChessPiece?= =?UTF-8?q?=EB=A1=9C=20=EC=9D=B4=EB=8F=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../chess/controller/ChessController.java | 2 +- src/main/java/chess/domain/ChessBoard.java | 70 +++---------------- .../java/chess/domain/piece/ChessPiece.java | 2 +- .../limited_moving_chess_piece/BlackPawn.java | 2 +- .../limited_moving_chess_piece/Knight.java | 8 +++ .../LimitedMovingChessPiece.java | 16 ++--- .../limited_moving_chess_piece/None.java | 12 ++-- .../limited_moving_chess_piece/Pawn.java | 16 ++++- .../LinearMovingChessPiece.java | 20 ++---- .../java/chess/domain/piece/KnightTest.java | 4 +- .../java/chess/domain/piece/RookTest.java | 4 +- 11 files changed, 59 insertions(+), 97 deletions(-) diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index a2766fd69c4..c0b20477f82 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -46,7 +46,7 @@ private void processChessTurn(ChessBoard chessBoard, Color nowTurn) { } Position destination = originAndDestination.get(1); - chessBoard.movePiece(origin, destination); + chessBoard.moveAndCapturePiece(origin, destination); }, OutputView::printErrorMessage); } } diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java index d17a96d4b51..c66d0128339 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/ChessBoard.java @@ -71,83 +71,35 @@ public ChessPiece getPieceOfPosition(Position position) { return board.get(position); } - // 1. 도착지 자체가 말이 갈 수 있는 도착지인지 확인(Piece.canMove에 출발, 도착지 넘겨줌) O - // 2. 장애물 있는지 확인 O - // 3. 도착지 말 색 확인 O - public void movePiece(Position origin, Position destination) { + public void moveAndCapturePiece(Position origin, Position destination) { ChessPiece movePiece = getPieceOfPosition(origin); - movePiece.validateCanMove(origin, destination); // 움직일 수 있는 경로에 있는지 확인 - - - // 나이트 - if (movePiece.getClass().equals(Knight.class)) { - // 장애물 있어도 됨 - } - // 폰 - else if (movePiece.getClass().equals(BlackPawn.class) || movePiece.getClass().equals(WhitePawn.class)) { - // 첫 움직임 -> 앞으로 두칸까지 가능 - Pawn pawn = (Pawn) movePiece; - Movement route = pawn.findRoute(origin, destination).get(0); - - // if route가 대각선 -> 도착지에 상대 말 있어야 움직일 수 있음 -> 무조건 먹음이 일어남 - if (route.isDiagonal()) { - if (pawn.getColor() != getPieceOfPosition(destination).getColor().opposite()) { - throw new IllegalStateException("대각선 위치에 상대 말이 없기 때문에 움직일 수 없습니다."); - } - getPieceOfPosition(destination).capture(); - } - // 앞으로 움직임 -> 도착지와 경로에 장애물 없으면 가능F - else { - validateExistHurdleOnRouteWithDestination(pawn, origin, destination); - } - - pawn.isMoved(); - } - - // 나머지 말 - else { - // 장애물 있는지 확인 - validateExistHurdleOnRouteWithoutDestination(movePiece, origin, destination); - } - + List route = movePiece.findRoute(origin, destination); + boolean isExistHurdleOnRoute = checkHurdleExistOnRouteWithoutDestination(origin, route); ChessPiece targetPiece = getPieceOfPosition(destination); - if (movePiece.getColor().opposite() == targetPiece.getColor()) { - targetPiece.capture(); - } - else if (movePiece.getColor() == targetPiece.getColor()) { - throw new IllegalStateException("도착지에 같은 편의 기물이 존재하기 때문에 움직일 수 없습니다."); + movePiece.validateCanMove(route, isExistHurdleOnRoute, targetPiece); + + if (movePiece.getClass().equals(BlackPawn.class) || movePiece.getClass().equals(WhitePawn.class)) { + ((Pawn) movePiece).isMoved(); } + targetPiece.capture(); board.put(origin, new None()); board.put(destination, movePiece); } - private void validateExistHurdleOnRouteWithoutDestination(ChessPiece piece, Position origin, Position destination) { - List route = piece.findRoute(origin, destination); + private boolean checkHurdleExistOnRouteWithoutDestination(Position origin, List route) { List routeWithoutDestination = route.subList(0, route.size() - 1); Position origin2 = origin; for (Movement movement : routeWithoutDestination) { if (origin2.canMove(movement)) { origin2 = origin2.move(movement); if (!getPieceOfPosition(origin2).isEmpty()) { - throw new IllegalStateException("경로에 장애물이 존재하여 움직일 수 없습니다."); - } - } - } - } - - private void validateExistHurdleOnRouteWithDestination(ChessPiece piece, Position origin, Position destination) { - List route = piece.findRoute(origin, destination); - Position origin2 = origin; - for (Movement movement : route) { - if (origin2.canMove(movement)) { - origin2 = origin2.move(movement); - if (!getPieceOfPosition(origin2).isEmpty()) { - throw new IllegalStateException("경로 및 도착지에 장애물이 존재하여 움직일 수 없습니다."); + return true; } } } + return false; } public boolean checkOppositeKingCaptured(Color color) { diff --git a/src/main/java/chess/domain/piece/ChessPiece.java b/src/main/java/chess/domain/piece/ChessPiece.java index ed800fe7dd7..cce0b24a784 100644 --- a/src/main/java/chess/domain/piece/ChessPiece.java +++ b/src/main/java/chess/domain/piece/ChessPiece.java @@ -8,7 +8,7 @@ public interface ChessPiece { String name(); - void validateCanMove(Position origin, Position destination); + void validateCanMove(List route, boolean isExistHurdleOnRoute, ChessPiece targetPiece); List findRoute(Position origin, Position destination); default boolean isEmpty() { return false; diff --git a/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java index 1920d7fa7fc..d4dca2ed8d1 100644 --- a/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java @@ -7,6 +7,6 @@ public class BlackPawn extends Pawn { public BlackPawn() { - super(List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.LEFT_UP), Color.BLACK); + super(List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.RIGHT_DOWN), Color.BLACK); } } diff --git a/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java index b4979f230df..ef83e016305 100644 --- a/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java @@ -2,6 +2,7 @@ import chess.domain.Color; import chess.domain.Movement; +import chess.domain.piece.ChessPiece; import java.util.List; public class Knight extends LimitedMovingChessPiece { @@ -15,6 +16,13 @@ public Knight(Color side) { ), side); } + @Override + public void validateCanMove(List route, boolean isExistHurdleOnRoute, ChessPiece targetPiece) { + if (this.getColor() == targetPiece.getColor()) { + throw new IllegalStateException("도착지에 같은 팀의 말이 존재하기 때문에 이동할 수 없습니다."); + } + } + @Override public String name() { return "N"; diff --git a/src/main/java/chess/domain/piece/limited_moving_chess_piece/LimitedMovingChessPiece.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/LimitedMovingChessPiece.java index e28db7d9bd9..a4bae6d82e3 100644 --- a/src/main/java/chess/domain/piece/limited_moving_chess_piece/LimitedMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/LimitedMovingChessPiece.java @@ -19,16 +19,12 @@ public LimitedMovingChessPiece(List movements, Color side) { } @Override - public void validateCanMove(Position origin, Position destination) { - boolean canMove = false; - for (Movement movement : movements) { - if (origin.canMove(movement) && origin.move(movement).equals(destination)) { - canMove = true; - break; - } + public void validateCanMove(List route, boolean isExistHurdleOnRoute, ChessPiece targetPiece) { + if (isExistHurdleOnRoute) { + throw new IllegalStateException("경로에 장애물이 존재하기 때문에 이동할 수 없습니다."); } - if (!canMove) { - throw new IllegalStateException("해당 기물은 해당 경로로 이동할 수 없습니다."); + if (this.getColor() == targetPiece.getColor()) { + throw new IllegalStateException("도착지에 같은 팀의 말이 존재하기 때문에 이동할 수 없습니다."); } } @@ -39,7 +35,7 @@ public List findRoute(Position origin, Position destination) { return List.of(movement); } } - return List.of(); + throw new IllegalStateException("해당 기물은 해당 경로로 이동할 수 없습니다."); } @Override diff --git a/src/main/java/chess/domain/piece/limited_moving_chess_piece/None.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/None.java index 38428572d71..8e938e6d9c6 100644 --- a/src/main/java/chess/domain/piece/limited_moving_chess_piece/None.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/None.java @@ -14,11 +14,6 @@ public None() { this.side = Color.EMPTY; } - @Override - public void validateCanMove(Position origin, Position destination) { - throw new IllegalStateException("움직일 말이 존재하지 않습니다."); - } - @Override public List findRoute(Position origin, Position destination) { throw new IllegalStateException("움직일 말이 존재하지 않습니다."); @@ -29,6 +24,11 @@ public String name() { return "-"; } + @Override + public void validateCanMove(List route, boolean isExistHurdleOnRoute, ChessPiece targetPiece) { + throw new IllegalStateException("움직일 말이 존재하지 않습니다."); + } + @Override public boolean isEmpty() { return true; @@ -41,7 +41,7 @@ public Color getColor() { @Override public void capture() { - throw new IllegalStateException("말이 존재하지 않습니다."); + } @Override diff --git a/src/main/java/chess/domain/piece/limited_moving_chess_piece/Pawn.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Pawn.java index f3a34780fcc..7498236b518 100644 --- a/src/main/java/chess/domain/piece/limited_moving_chess_piece/Pawn.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Pawn.java @@ -3,6 +3,7 @@ import chess.domain.Color; import chess.domain.Movement; import chess.domain.Position; +import chess.domain.piece.ChessPiece; import java.util.List; public abstract class Pawn extends LimitedMovingChessPiece { @@ -14,6 +15,19 @@ public Pawn(List movements, Color side) { this.isFirstMove = true; } + @Override + public void validateCanMove(List route, boolean isExistHurdleOnRoute, ChessPiece targetPiece) { + if (isExistHurdleOnRoute) { + throw new IllegalStateException("경로에 장애물이 존재하기 때문에 이동할 수 없습니다."); + } + if (route.getFirst().isDiagonal() && (side.opposite() != targetPiece.getColor())) { + throw new IllegalStateException("대각선 위치에 상대 말이 없기 때문에 움직일 수 없습니다."); + } + if (!route.getFirst().isDiagonal() && !targetPiece.isEmpty()) { + throw new IllegalStateException("도착지에 말이 존재하기 때문에 움직일 수 없습니다."); + } + } + @Override public String name() { return "P"; @@ -28,7 +42,7 @@ public List findRoute(Position origin, Position destination) { return List.of(movement); } } - return List.of(); + throw new IllegalStateException("해당 말은 해당 위치로 움직일 수 없습니다."); } public void isMoved() { diff --git a/src/main/java/chess/domain/piece/linear_moving_chess_piece/LinearMovingChessPiece.java b/src/main/java/chess/domain/piece/linear_moving_chess_piece/LinearMovingChessPiece.java index f8dca6b6e9e..6096a35c356 100644 --- a/src/main/java/chess/domain/piece/linear_moving_chess_piece/LinearMovingChessPiece.java +++ b/src/main/java/chess/domain/piece/linear_moving_chess_piece/LinearMovingChessPiece.java @@ -20,20 +20,12 @@ public LinearMovingChessPiece(List directions, Color side) { } @Override - public void validateCanMove(Position origin, Position destination) { - boolean canMove = false; - for (Movement direction : directions) { - Position origin2 = origin; - while (origin2.canMove(direction)) { - origin2 = origin2.move(direction); - if (origin2.equals(destination)) { - canMove = true; - break; - } - } + public void validateCanMove(List route, boolean isExistHurdleOnRoute, ChessPiece targetPiece) { + if (isExistHurdleOnRoute) { + throw new IllegalStateException("경로에 장애물이 존재하기 때문에 이동할 수 없습니다."); } - if (!canMove) { - throw new IllegalStateException("해당 기물은 해당 경로로 이동할 수 없습니다."); + if (this.getColor() == targetPiece.getColor()) { + throw new IllegalStateException("도착지에 같은 팀의 말이 존재하기 때문에 이동할 수 없습니다."); } } @@ -50,7 +42,7 @@ public List findRoute(Position origin, Position destination) { } } } - return List.of(); + throw new IllegalStateException("해당 기물은 해당 경로로 이동할 수 없습니다."); } @Override diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java index 4afd958c809..cf1b8127376 100644 --- a/src/test/java/chess/domain/piece/KnightTest.java +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -20,7 +20,7 @@ class KnightTest { Position origin = new Position(Row.FOUR, Column.D); Position destination = new Position(Row.FIVE, Column.F); - assertDoesNotThrow(() -> knight.validateCanMove(origin, destination)); + assertDoesNotThrow(() -> knight.findRoute(origin, destination)); } @Test @@ -29,7 +29,7 @@ class KnightTest { Position origin = new Position(Row.FOUR, Column.D); Position destination = new Position(Row.SIX, Column.F); - assertThatThrownBy(() -> knight.validateCanMove(origin, destination)); + assertThatThrownBy(() -> knight.findRoute(origin, destination)); } @Test diff --git a/src/test/java/chess/domain/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java index ac75d785766..1472558cfa0 100644 --- a/src/test/java/chess/domain/piece/RookTest.java +++ b/src/test/java/chess/domain/piece/RookTest.java @@ -20,7 +20,7 @@ class RookTest { Position origin = new Position(Row.FOUR, Column.B); Position destination = new Position(Row.FOUR, Column.G); - assertDoesNotThrow(() -> rook.validateCanMove(origin, destination)); + assertDoesNotThrow(() -> rook.findRoute(origin, destination)); } @Test @@ -29,7 +29,7 @@ class RookTest { Position origin = new Position(Row.FOUR, Column.B); Position destination = new Position(Row.SIX, Column.F); - assertThatThrownBy(() -> rook.validateCanMove(origin, destination)) + assertThatThrownBy(() -> rook.findRoute(origin, destination)) .isInstanceOf(IllegalStateException.class); } From 74a843b6eeb681879f496602a4841a5329881841 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 17:15:43 +0900 Subject: [PATCH 16/19] =?UTF-8?q?refactor:=20=EC=B2=B4=EC=8A=A4=ED=8C=90?= =?UTF-8?q?=20=EC=B4=88=EA=B8=B0=ED=99=94=20=EA=B8=B0=EB=8A=A5=20=EB=B6=84?= =?UTF-8?q?=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../chess/controller/ChessController.java | 5 +- .../java/chess/domain/board/ChessBoard.java | 71 ++++++++++++++++++ .../ChessBoardBasicInitializer.java} | 72 ++++--------------- .../domain/board/ChessBoardInitializer.java | 10 +++ src/main/java/chess/view/OutputView.java | 2 +- 5 files changed, 98 insertions(+), 62 deletions(-) create mode 100644 src/main/java/chess/domain/board/ChessBoard.java rename src/main/java/chess/domain/{ChessBoard.java => board/ChessBoardBasicInitializer.java} (59%) create mode 100644 src/main/java/chess/domain/board/ChessBoardInitializer.java diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index c0b20477f82..064063cb6fa 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -1,8 +1,9 @@ package chess.controller; -import chess.domain.ChessBoard; +import chess.domain.board.ChessBoard; import chess.domain.Color; import chess.domain.Position; +import chess.domain.board.ChessBoardBasicInitializer; import chess.view.InputView; import chess.view.OutputView; import java.util.List; @@ -18,7 +19,7 @@ public ChessController(InputView inputView, OutputView outputView) { } public void run() { - ChessBoard chessBoard = new ChessBoard(); + ChessBoard chessBoard = new ChessBoard(new ChessBoardBasicInitializer()); List colors = Color.getGameColors(); Color nowTurn = colors.get(0); diff --git a/src/main/java/chess/domain/board/ChessBoard.java b/src/main/java/chess/domain/board/ChessBoard.java new file mode 100644 index 00000000000..a88195ae62a --- /dev/null +++ b/src/main/java/chess/domain/board/ChessBoard.java @@ -0,0 +1,71 @@ +package chess.domain.board; + +import chess.domain.Color; +import chess.domain.Movement; +import chess.domain.Position; +import chess.domain.piece.limited_moving_chess_piece.BlackPawn; +import chess.domain.piece.ChessPiece; +import chess.domain.piece.limited_moving_chess_piece.King; +import chess.domain.piece.limited_moving_chess_piece.None; +import chess.domain.piece.limited_moving_chess_piece.Pawn; +import chess.domain.piece.limited_moving_chess_piece.WhitePawn; +import java.util.List; +import java.util.Map; + +public class ChessBoard { + + private final Map board; + private final ChessPiece blackKing; + private final ChessPiece whiteKing; + + public ChessBoard(ChessBoardInitializer initializer) { + blackKing = new King(Color.BLACK); + whiteKing = new King(Color.WHITE); + board = initializer.initialize(blackKing, whiteKing); + } + + public ChessPiece getPieceOfPosition(Position position) { + return board.get(position); + } + + public void moveAndCapturePiece(Position origin, Position destination) { + + ChessPiece movePiece = getPieceOfPosition(origin); + List route = movePiece.findRoute(origin, destination); + boolean isExistHurdleOnRoute = checkHurdleExistOnRouteWithoutDestination(origin, route); + ChessPiece targetPiece = getPieceOfPosition(destination); + movePiece.validateCanMove(route, isExistHurdleOnRoute, targetPiece); + + if (movePiece.getClass().equals(BlackPawn.class) || movePiece.getClass().equals(WhitePawn.class)) { + ((Pawn) movePiece).isMoved(); + } + + targetPiece.capture(); + board.put(origin, new None()); + board.put(destination, movePiece); + } + + private boolean checkHurdleExistOnRouteWithoutDestination(Position origin, List route) { + List routeWithoutDestination = route.subList(0, route.size() - 1); + Position origin2 = origin; + for (Movement movement : routeWithoutDestination) { + if (origin2.canMove(movement)) { + origin2 = origin2.move(movement); + if (!getPieceOfPosition(origin2).isEmpty()) { + return true; + } + } + } + return false; + } + + public boolean checkOppositeKingCaptured(Color color) { + if (color == Color.BLACK) { + return whiteKing.isCaptured(); + } + if (color == Color.WHITE) { + return blackKing.isCaptured(); + } + return false; + } +} diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/board/ChessBoardBasicInitializer.java similarity index 59% rename from src/main/java/chess/domain/ChessBoard.java rename to src/main/java/chess/domain/board/ChessBoardBasicInitializer.java index c66d0128339..fd30e501174 100644 --- a/src/main/java/chess/domain/ChessBoard.java +++ b/src/main/java/chess/domain/board/ChessBoardBasicInitializer.java @@ -1,28 +1,25 @@ -package chess.domain; +package chess.domain.board; -import chess.domain.piece.linear_moving_chess_piece.Bishop; -import chess.domain.piece.limited_moving_chess_piece.BlackPawn; +import chess.domain.Color; +import chess.domain.Column; +import chess.domain.Position; +import chess.domain.Row; import chess.domain.piece.ChessPiece; -import chess.domain.piece.limited_moving_chess_piece.King; +import chess.domain.piece.limited_moving_chess_piece.BlackPawn; import chess.domain.piece.limited_moving_chess_piece.Knight; import chess.domain.piece.limited_moving_chess_piece.None; -import chess.domain.piece.limited_moving_chess_piece.Pawn; +import chess.domain.piece.limited_moving_chess_piece.WhitePawn; +import chess.domain.piece.linear_moving_chess_piece.Bishop; import chess.domain.piece.linear_moving_chess_piece.Queen; import chess.domain.piece.linear_moving_chess_piece.Rook; -import chess.domain.piece.limited_moving_chess_piece.WhitePawn; import java.util.HashMap; -import java.util.List; import java.util.Map; -public class ChessBoard { +public class ChessBoardBasicInitializer implements ChessBoardInitializer { - private final Map board = new HashMap<>(); - private final ChessPiece blackKing; - private final ChessPiece whiteKing; - - public ChessBoard() { - blackKing = new King(Color.BLACK); - whiteKing = new King(Color.WHITE); + @Override + public Map initialize(ChessPiece blackKing, ChessPiece whiteKing) { + Map board = new HashMap<>(); for (Row row : Row.values()) { for (Column column : Column.values()) { @@ -65,50 +62,7 @@ public ChessBoard() { board.put(new Position(Row.TWO, Column.F), new WhitePawn()); board.put(new Position(Row.TWO, Column.G), new WhitePawn()); board.put(new Position(Row.TWO, Column.H), new WhitePawn()); - } - - public ChessPiece getPieceOfPosition(Position position) { - return board.get(position); - } - - public void moveAndCapturePiece(Position origin, Position destination) { - ChessPiece movePiece = getPieceOfPosition(origin); - List route = movePiece.findRoute(origin, destination); - boolean isExistHurdleOnRoute = checkHurdleExistOnRouteWithoutDestination(origin, route); - ChessPiece targetPiece = getPieceOfPosition(destination); - movePiece.validateCanMove(route, isExistHurdleOnRoute, targetPiece); - - if (movePiece.getClass().equals(BlackPawn.class) || movePiece.getClass().equals(WhitePawn.class)) { - ((Pawn) movePiece).isMoved(); - } - - targetPiece.capture(); - board.put(origin, new None()); - board.put(destination, movePiece); - } - - private boolean checkHurdleExistOnRouteWithoutDestination(Position origin, List route) { - List routeWithoutDestination = route.subList(0, route.size() - 1); - Position origin2 = origin; - for (Movement movement : routeWithoutDestination) { - if (origin2.canMove(movement)) { - origin2 = origin2.move(movement); - if (!getPieceOfPosition(origin2).isEmpty()) { - return true; - } - } - } - return false; - } - - public boolean checkOppositeKingCaptured(Color color) { - if (color == Color.BLACK) { - return whiteKing.isCaptured(); - } - if (color == Color.WHITE) { - return blackKing.isCaptured(); - } - return false; + return board; } } diff --git a/src/main/java/chess/domain/board/ChessBoardInitializer.java b/src/main/java/chess/domain/board/ChessBoardInitializer.java new file mode 100644 index 00000000000..1765611b5e3 --- /dev/null +++ b/src/main/java/chess/domain/board/ChessBoardInitializer.java @@ -0,0 +1,10 @@ +package chess.domain.board; + +import chess.domain.Position; +import chess.domain.piece.ChessPiece; +import java.util.Map; + +public interface ChessBoardInitializer { + + Map initialize(ChessPiece blackKing, ChessPiece whiteKing); +} diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 157b83be994..704ed872063 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -1,6 +1,6 @@ package chess.view; -import chess.domain.ChessBoard; +import chess.domain.board.ChessBoard; import chess.domain.Color; import chess.domain.Column; import chess.domain.Position; From 0ce2f939a265a27a18843a088539b75d263be5a9 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 17:16:48 +0900 Subject: [PATCH 17/19] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=EB=B3=80=EC=88=98=20=EC=A0=9C?= =?UTF-8?q?=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/controller/ChessController.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index 064063cb6fa..a837c2567b3 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -21,10 +21,9 @@ public ChessController(InputView inputView, OutputView outputView) { public void run() { ChessBoard chessBoard = new ChessBoard(new ChessBoardBasicInitializer()); List colors = Color.getGameColors(); - Color nowTurn = colors.get(0); + Color nowTurn = colors.getFirst(); - boolean isKingCaptured = false; - while (!isKingCaptured) { + while (true) { outputView.printChessBoard(chessBoard); outputView.printTurnMessage(nowTurn); From 9bdb2eb4e3069dd72b1e52314f766b67336cb761 Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 17:20:16 +0900 Subject: [PATCH 18/19] =?UTF-8?q?refactor:=20=EB=A9=94=EC=84=9C=EB=93=9C?= =?UTF-8?q?=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/controller/ChessController.java | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index a837c2567b3..cd929ec5283 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -20,8 +20,7 @@ public ChessController(InputView inputView, OutputView outputView) { public void run() { ChessBoard chessBoard = new ChessBoard(new ChessBoardBasicInitializer()); - List colors = Color.getGameColors(); - Color nowTurn = colors.getFirst(); + Color nowTurn = Color.WHITE; while (true) { outputView.printChessBoard(chessBoard); @@ -41,12 +40,16 @@ private void processChessTurn(ChessBoard chessBoard, Color nowTurn) { InputProcessor.processUntilSuccess(() -> { List originAndDestination = inputView.getMoveInput(); Position origin = originAndDestination.get(0); - if (chessBoard.getPieceOfPosition(origin).getColor() != nowTurn) { - throw new IllegalArgumentException("현재는 %s의 차례입니다.".formatted(nowTurn.name())); - } + checkValidPieceColor(chessBoard, nowTurn, origin); Position destination = originAndDestination.get(1); chessBoard.moveAndCapturePiece(origin, destination); }, OutputView::printErrorMessage); } + + private void checkValidPieceColor(ChessBoard chessBoard, Color nowTurn, Position origin) { + if (chessBoard.getPieceOfPosition(origin).getColor() != nowTurn) { + throw new IllegalArgumentException("현재는 %s의 차례입니다.".formatted(nowTurn.name())); + } + } } From b57268ec9a7c21b273effe6f3550c39627d05d4f Mon Sep 17 00:00:00 2001 From: seaniiio Date: Sat, 22 Mar 2025 17:26:20 +0900 Subject: [PATCH 19/19] =?UTF-8?q?refactor:=20ChessPiece=EC=9D=98=20?= =?UTF-8?q?=EA=B2=BD=EB=A1=9C,=20=EB=B0=A9=ED=96=A5=EC=9D=84=20=EC=83=81?= =?UTF-8?q?=EC=88=98=EB=A1=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/domain/board/ChessBoard.java | 1 - .../limited_moving_chess_piece/BlackPawn.java | 4 +++- .../piece/limited_moving_chess_piece/King.java | 10 ++++++---- .../piece/limited_moving_chess_piece/Knight.java | 14 ++++++++------ .../limited_moving_chess_piece/WhitePawn.java | 4 +++- .../piece/linear_moving_chess_piece/Bishop.java | 6 +++--- .../piece/linear_moving_chess_piece/Queen.java | 10 ++++++---- .../piece/linear_moving_chess_piece/Rook.java | 8 +++++--- 8 files changed, 34 insertions(+), 23 deletions(-) diff --git a/src/main/java/chess/domain/board/ChessBoard.java b/src/main/java/chess/domain/board/ChessBoard.java index a88195ae62a..30acc542a97 100644 --- a/src/main/java/chess/domain/board/ChessBoard.java +++ b/src/main/java/chess/domain/board/ChessBoard.java @@ -29,7 +29,6 @@ public ChessPiece getPieceOfPosition(Position position) { } public void moveAndCapturePiece(Position origin, Position destination) { - ChessPiece movePiece = getPieceOfPosition(origin); List route = movePiece.findRoute(origin, destination); boolean isExistHurdleOnRoute = checkHurdleExistOnRouteWithoutDestination(origin, route); diff --git a/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java index d4dca2ed8d1..56e92d48955 100644 --- a/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/BlackPawn.java @@ -6,7 +6,9 @@ public class BlackPawn extends Pawn { + private static final List ROUTES = List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.RIGHT_DOWN); + public BlackPawn() { - super(List.of(Movement.DOWN_DOWN, Movement.DOWN, Movement.LEFT_DOWN, Movement.RIGHT_DOWN), Color.BLACK); + super(ROUTES, Color.BLACK); } } diff --git a/src/main/java/chess/domain/piece/limited_moving_chess_piece/King.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/King.java index 316df95232a..9063798d901 100644 --- a/src/main/java/chess/domain/piece/limited_moving_chess_piece/King.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/King.java @@ -6,11 +6,13 @@ public class King extends LimitedMovingChessPiece { + private static final List ROUTES = List.of( + Movement.LEFT, Movement.UP, Movement.RIGHT, Movement.DOWN, + Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP + ); + public King(Color side) { - super(List.of( - Movement.LEFT, Movement.LEFT_DOWN, Movement.UP, Movement.RIGHT, - Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP - ), side); + super(ROUTES, side); } @Override diff --git a/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java index ef83e016305..a4d322c6b93 100644 --- a/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/Knight.java @@ -7,13 +7,15 @@ public class Knight extends LimitedMovingChessPiece { + private static final List ROUTES = List.of( + Movement.DOWN_DOWN_LEFT, Movement.DOWN_DOWN_RIGHT, + Movement.RIGHT_RIGHT_DOWN, Movement.RIGHT_RIGHT_UP, + Movement.UP_UP_LEFT, Movement.UP_UP_RIGHT, + Movement.LEFT_LEFT_DOWN, Movement.LEFT_LEFT_UP + ); + public Knight(Color side) { - super(List.of( - Movement.DOWN_DOWN_LEFT, Movement.DOWN_DOWN_RIGHT, - Movement.RIGHT_RIGHT_DOWN, Movement.RIGHT_RIGHT_UP, - Movement.UP_UP_LEFT, Movement.UP_UP_RIGHT, - Movement.LEFT_LEFT_DOWN, Movement.LEFT_LEFT_UP - ), side); + super(ROUTES, side); } @Override diff --git a/src/main/java/chess/domain/piece/limited_moving_chess_piece/WhitePawn.java b/src/main/java/chess/domain/piece/limited_moving_chess_piece/WhitePawn.java index 1822479f145..8e17f2cdf73 100644 --- a/src/main/java/chess/domain/piece/limited_moving_chess_piece/WhitePawn.java +++ b/src/main/java/chess/domain/piece/limited_moving_chess_piece/WhitePawn.java @@ -6,7 +6,9 @@ public class WhitePawn extends Pawn { + private static final List ROUTES = List.of(Movement.UP_UP, Movement.UP, Movement.LEFT_UP, Movement.RIGHT_UP); + public WhitePawn() { - super(List.of(Movement.UP_UP, Movement.UP, Movement.LEFT_UP, Movement.RIGHT_UP), Color.WHITE); + super(ROUTES, Color.WHITE); } } diff --git a/src/main/java/chess/domain/piece/linear_moving_chess_piece/Bishop.java b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Bishop.java index 0dd18d9de11..633803ec63a 100644 --- a/src/main/java/chess/domain/piece/linear_moving_chess_piece/Bishop.java +++ b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Bishop.java @@ -6,10 +6,10 @@ public class Bishop extends LinearMovingChessPiece { + private static final List DIRECTIONS = List.of(Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP); + public Bishop(Color side) { - super(List.of( - Movement.LEFT_DOWN, Movement.LEFT_UP, Movement.RIGHT_DOWN, Movement.RIGHT_UP - ), side); + super(DIRECTIONS, side); } @Override diff --git a/src/main/java/chess/domain/piece/linear_moving_chess_piece/Queen.java b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Queen.java index d88a9fc7f7d..8e2c7dcdec4 100644 --- a/src/main/java/chess/domain/piece/linear_moving_chess_piece/Queen.java +++ b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Queen.java @@ -6,11 +6,13 @@ public class Queen extends LinearMovingChessPiece { + private static final List DIRECTIONS = List.of( + Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT, + Movement.RIGHT_DOWN, Movement.LEFT_DOWN, Movement.RIGHT_UP, Movement.LEFT_UP + ); + public Queen(Color side) { - super(List.of( - Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT, - Movement.RIGHT_DOWN, Movement.LEFT_DOWN, Movement.RIGHT_UP, Movement.LEFT_UP) - , side); + super(DIRECTIONS, side); } @Override diff --git a/src/main/java/chess/domain/piece/linear_moving_chess_piece/Rook.java b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Rook.java index e62392ace39..bd119366641 100644 --- a/src/main/java/chess/domain/piece/linear_moving_chess_piece/Rook.java +++ b/src/main/java/chess/domain/piece/linear_moving_chess_piece/Rook.java @@ -6,10 +6,12 @@ public class Rook extends LinearMovingChessPiece { + private static final List DIRECTIONS = List.of( + Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT + ); + public Rook(Color side) { - super(List.of( - Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT - ), side); + super(DIRECTIONS, side); } @Override