From 0856ae2fc8f687820d76b44382aa832630f939cd Mon Sep 17 00:00:00 2001 From: eunii Date: Sun, 15 Aug 2021 16:18:59 +0900 Subject: [PATCH 01/42] test: Generate King test commit content --- README.md | 34 +++++++++++++++++++ build.gradle | 5 +++ src/main/java/chess/domain/piece/King.java | 27 +++++++++++++++ src/main/java/chess/domain/piece/Team.java | 19 +++++++++++ .../java/chess/domain/piece/KingTest.java | 26 ++++++++++++++ src/test/java/empty.txt | 0 6 files changed, 111 insertions(+) create mode 100644 src/main/java/chess/domain/piece/King.java create mode 100644 src/main/java/chess/domain/piece/Team.java create mode 100644 src/test/java/chess/domain/piece/KingTest.java delete mode 100644 src/test/java/empty.txt diff --git a/README.md b/README.md index 4a9cf0f..0e00665 100644 --- a/README.md +++ b/README.md @@ -1 +1,35 @@ # java-chess 게임 + +- [] 체스판 + - []rank(세로) : 8 :1~8 + - []file(가로) : 8 :a~h + - [] 말이 없는 칸은 . + - []초기화 + +- [] 아웃풋 뷰 + - [] 체스판 출력 기능 + - + +- [] 기물 + - [] king + - [] 상하좌우 중 1칸 이동 + - [] queen + - [] 상하좌우 대각선 n칸 이동 + - [] bishop + - [] 대각선으로 n칸 이동 + - [] knight + - [] 사방중 한방향으로 한칸 & 양 대각선 중 한 방향으로 한칸 으로 이동 + - [] 상대 말 넘어감 + - [] rook + - [] 상하좌우 n칸 이동 + - [] pawn + - [] 첫회 한정: 2칸 상 이동 || 1칸 상 이동 + - [] 1칸 이동 + - [] 공격은 대각선으로만 + +- [] 진영 + - [] 기물 2 세트 생성 (1개는 대문자, 소문자) + +- [] 체스 게임 룰 + - [] start : 체스판 초기화 및 진영 세팅 + - [] end: 게임 종료 \ No newline at end of file diff --git a/build.gradle b/build.gradle index d41dd5b..a4fc147 100644 --- a/build.gradle +++ b/build.gradle @@ -18,4 +18,9 @@ dependencies { testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.1' testCompile "org.assertj:assertj-core:3.14.0" + //lombok + compileOnly 'org.projectlombok:lombok:1.18.20' + annotationProcessor 'org.projectlombok:lombok:1.18.20' + testCompileOnly 'org.projectlombok:lombok:1.18.20' + testAnnotationProcessor 'org.projectlombok:lombok:1.18.20' } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java new file mode 100644 index 0000000..c2a385d --- /dev/null +++ b/src/main/java/chess/domain/piece/King.java @@ -0,0 +1,27 @@ +package chess.domain.piece; + +public class King { + private Team team; + private String position; + private String displayName; + public King(Team team) { + this.team = team; + if(team.equals(Team.BLACK)) { + this.position = "E1"; + this.displayName = "k"; + } + + if(team.equals(Team.WHITE)) { + this.position = "E8"; + this.displayName = "K"; + } + + + } + + public String getPosition() { + } + + public String getDisplayName() { + } +} diff --git a/src/main/java/chess/domain/piece/Team.java b/src/main/java/chess/domain/piece/Team.java new file mode 100644 index 0000000..f6401d2 --- /dev/null +++ b/src/main/java/chess/domain/piece/Team.java @@ -0,0 +1,19 @@ +package chess.domain.piece; + +import lombok.Getter; + +@Getter +public enum Team { + BLACK(1), + WHITE(2); + + private int marker; + + Team(int marker) { + this.marker = marker; + } + + public int getMarker() { + return marker; + } +} diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java new file mode 100644 index 0000000..2fd1640 --- /dev/null +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -0,0 +1,26 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.DisplayName; + +import static org.assertj.core.api.Assertions.as; +import static org.assertj.core.api.Assertions.assertThat; + +public class KingTest { + + @Test + @DisplayName("킹을 팀을 넣어서 생성하면 1팀 위치는 e8, 2팀은 e1에 , 표시명은 1팀K, 2팀k로 리턴한다") + void create() { + + //given + King king1 = new King("1"); + King king2 = new King("2"); + + //when // given + assertThat(king1.getPosition()).isEqual("E8"); + assertThat(king1.getDisplayName()).isEqual("K"); + assertThat(king2.getPosition()).isEqual("E1"); + assertThat(king2.getDisplayName()).isEqual("k"); + } + +} diff --git a/src/test/java/empty.txt b/src/test/java/empty.txt deleted file mode 100644 index e69de29..0000000 From cb0898720ce218a17af49864377b8e2047f4f967 Mon Sep 17 00:00:00 2001 From: eunii Date: Sun, 15 Aug 2021 16:35:46 +0900 Subject: [PATCH 02/42] test: King creation test Done --- src/main/java/chess/domain/piece/King.java | 11 +++-------- src/test/java/chess/domain/piece/KingTest.java | 15 +++++++-------- 2 files changed, 10 insertions(+), 16 deletions(-) diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index c2a385d..c085c9e 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -1,5 +1,8 @@ package chess.domain.piece; +import lombok.Getter; + +@Getter public class King { private Team team; private String position; @@ -15,13 +18,5 @@ public King(Team team) { this.position = "E8"; this.displayName = "K"; } - - - } - - public String getPosition() { - } - - public String getDisplayName() { } } diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java index 2fd1640..ffb1afe 100644 --- a/src/test/java/chess/domain/piece/KingTest.java +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -3,24 +3,23 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.DisplayName; -import static org.assertj.core.api.Assertions.as; import static org.assertj.core.api.Assertions.assertThat; public class KingTest { @Test @DisplayName("킹을 팀을 넣어서 생성하면 1팀 위치는 e8, 2팀은 e1에 , 표시명은 1팀K, 2팀k로 리턴한다") - void create() { + void testKingCreation() { //given - King king1 = new King("1"); - King king2 = new King("2"); + King king1 = new King(Team.BLACK); + King king2 = new King(Team.WHITE); //when // given - assertThat(king1.getPosition()).isEqual("E8"); - assertThat(king1.getDisplayName()).isEqual("K"); - assertThat(king2.getPosition()).isEqual("E1"); - assertThat(king2.getDisplayName()).isEqual("k"); + assertThat(king1.getPosition()).isEqualTo("E1"); + assertThat(king1.getDisplayName()).isEqualTo("k"); + assertThat(king2.getPosition()).isEqualTo("E8"); + assertThat(king2.getDisplayName()).isEqualTo("K"); } } From 5a3143d7e92da7f85a07c240514dc9203a99e9f9 Mon Sep 17 00:00:00 2001 From: eunii Date: Sun, 15 Aug 2021 17:12:04 +0900 Subject: [PATCH 03/42] =?UTF-8?q?refactor:=20File,=20Rank=20enum=20?= =?UTF-8?q?=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/chess/domain/piece/File.java | 18 +++++++++++++++++ src/main/java/chess/domain/piece/King.java | 11 +++++----- .../chess/domain/piece/PiecePosition.java | 20 +++++++++++++++++++ src/main/java/chess/domain/piece/Rank.java | 18 +++++++++++++++++ src/main/java/chess/domain/piece/Team.java | 12 +++++++++++ .../java/chess/domain/piece/KingTest.java | 4 ++-- 6 files changed, 75 insertions(+), 8 deletions(-) create mode 100644 src/main/java/chess/domain/piece/File.java create mode 100644 src/main/java/chess/domain/piece/PiecePosition.java create mode 100644 src/main/java/chess/domain/piece/Rank.java diff --git a/src/main/java/chess/domain/piece/File.java b/src/main/java/chess/domain/piece/File.java new file mode 100644 index 0000000..7e605c0 --- /dev/null +++ b/src/main/java/chess/domain/piece/File.java @@ -0,0 +1,18 @@ +package chess.domain.piece; + +public enum File { + A("a"), + B("b"), + C("c"), + D("d"), + E("e"), + F("f"), + G("g"), + H("h"); + + private String filePosition; + + File(String filePosition) { + this.filePosition = filePosition; + } +} diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index c085c9e..ca6e45f 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -4,19 +4,18 @@ @Getter public class King { + private String name = "K"; private Team team; - private String position; + private PiecePosition piecePosition; private String displayName; public King(Team team) { this.team = team; + this.displayName = team.displayName(name); if(team.equals(Team.BLACK)) { - this.position = "E1"; - this.displayName = "k"; + this.piecePosition = new PiecePosition(File.E, Rank.ONE); } - if(team.equals(Team.WHITE)) { - this.position = "E8"; - this.displayName = "K"; + this.piecePosition = new PiecePosition(File.E, Rank.EIGHT); } } } diff --git a/src/main/java/chess/domain/piece/PiecePosition.java b/src/main/java/chess/domain/piece/PiecePosition.java new file mode 100644 index 0000000..be93ab5 --- /dev/null +++ b/src/main/java/chess/domain/piece/PiecePosition.java @@ -0,0 +1,20 @@ +package chess.domain.piece; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +@Getter +@RequiredArgsConstructor +public class PiecePosition { + private final File file; + private final Rank rank; + + @Override + public boolean equals(Object object) { + if (object instanceof PiecePosition) { + PiecePosition position = (PiecePosition) object; + return this.getFile().equals(position.getFile()) && this.getRank().equals(position.getRank()); + } + return false; + } +} diff --git a/src/main/java/chess/domain/piece/Rank.java b/src/main/java/chess/domain/piece/Rank.java new file mode 100644 index 0000000..e9f137f --- /dev/null +++ b/src/main/java/chess/domain/piece/Rank.java @@ -0,0 +1,18 @@ +package chess.domain.piece; + +public enum Rank { + ONE(1), + TWO(2), + THREE(3), + FOUR(4), + FIVE(5), + SIX(6), + SEVEN(7), + EIGHT(8); + + private int rankPosition; + + Rank(int rankPosition) { + this.rankPosition = rankPosition; + } +} diff --git a/src/main/java/chess/domain/piece/Team.java b/src/main/java/chess/domain/piece/Team.java index f6401d2..9efe965 100644 --- a/src/main/java/chess/domain/piece/Team.java +++ b/src/main/java/chess/domain/piece/Team.java @@ -2,6 +2,8 @@ import lombok.Getter; +import java.util.Locale; + @Getter public enum Team { BLACK(1), @@ -16,4 +18,14 @@ public enum Team { public int getMarker() { return marker; } + + public String displayName(String name) { + if (this.equals(BLACK)) { + return name.toLowerCase(); + } + if (this.equals(WHITE)) { + return name.toUpperCase(); + } + return name; + } } diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java index ffb1afe..4fd91ff 100644 --- a/src/test/java/chess/domain/piece/KingTest.java +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -16,9 +16,9 @@ void testKingCreation() { King king2 = new King(Team.WHITE); //when // given - assertThat(king1.getPosition()).isEqualTo("E1"); + assertThat(king1.getPiecePosition()).isEqualTo(new PiecePosition(File.E, Rank.ONE)); assertThat(king1.getDisplayName()).isEqualTo("k"); - assertThat(king2.getPosition()).isEqualTo("E8"); + assertThat(king2.getPiecePosition()).isEqualTo(new PiecePosition(File.E, Rank.EIGHT)); assertThat(king2.getDisplayName()).isEqualTo("K"); } From 8cbba8c538d70f88001b2eeaabe718c8fb6771cd Mon Sep 17 00:00:00 2001 From: eunii Date: Sun, 15 Aug 2021 17:25:12 +0900 Subject: [PATCH 04/42] feat: Create Piece class(ancestor class) --- src/main/java/chess/domain/piece/King.java | 12 ++++-------- src/main/java/chess/domain/piece/Piece.java | 17 +++++++++++++++++ 2 files changed, 21 insertions(+), 8 deletions(-) create mode 100644 src/main/java/chess/domain/piece/Piece.java diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index ca6e45f..748c9ef 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -3,16 +3,12 @@ import lombok.Getter; @Getter -public class King { - private String name = "K"; - private Team team; - private PiecePosition piecePosition; - private String displayName; +public class King extends Piece { + public King(Team team) { - this.team = team; - this.displayName = team.displayName(name); + super("K", team); if(team.equals(Team.BLACK)) { - this.piecePosition = new PiecePosition(File.E, Rank.ONE); + super.piecePosition = new PiecePosition(File.E, Rank.ONE); } if(team.equals(Team.WHITE)) { this.piecePosition = new PiecePosition(File.E, Rank.EIGHT); diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java new file mode 100644 index 0000000..09fe473 --- /dev/null +++ b/src/main/java/chess/domain/piece/Piece.java @@ -0,0 +1,17 @@ +package chess.domain.piece; + +import lombok.Getter; + +@Getter +public abstract class Piece { + protected String name; + protected Team team; + protected PiecePosition piecePosition; + protected String displayName; + + protected Piece(String name, Team team) { + this.name = name; + this.team = team; + this.displayName = team.displayName(name); + } +} From 467fe4ec268bc5bda99dfcd7e4b4c5cd0421324d Mon Sep 17 00:00:00 2001 From: eunii Date: Sun, 15 Aug 2021 17:43:17 +0900 Subject: [PATCH 05/42] feat: Generate All Piece classes --- src/main/java/chess/domain/piece/Bishop.java | 8 ++++++++ src/main/java/chess/domain/piece/King.java | 13 ++----------- src/main/java/chess/domain/piece/Knight.java | 8 ++++++++ src/main/java/chess/domain/piece/Pawn.java | 7 +++++++ src/main/java/chess/domain/piece/Piece.java | 3 ++- src/main/java/chess/domain/piece/Queen.java | 8 ++++++++ src/main/java/chess/domain/piece/Rook.java | 8 ++++++++ src/test/java/chess/domain/piece/KingTest.java | 4 ++-- 8 files changed, 45 insertions(+), 14 deletions(-) create mode 100644 src/main/java/chess/domain/piece/Bishop.java create mode 100644 src/main/java/chess/domain/piece/Knight.java create mode 100644 src/main/java/chess/domain/piece/Pawn.java create mode 100644 src/main/java/chess/domain/piece/Queen.java create mode 100644 src/main/java/chess/domain/piece/Rook.java diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java new file mode 100644 index 0000000..fa4d0b9 --- /dev/null +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -0,0 +1,8 @@ +package chess.domain.piece; + +public class Bishop extends Piece { + + public Bishop(Team team, PiecePosition piecePosition) { + super("B", team, piecePosition); + } +} diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index 748c9ef..b143c57 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -1,17 +1,8 @@ package chess.domain.piece; -import lombok.Getter; - -@Getter public class King extends Piece { - public King(Team team) { - super("K", team); - if(team.equals(Team.BLACK)) { - super.piecePosition = new PiecePosition(File.E, Rank.ONE); - } - if(team.equals(Team.WHITE)) { - this.piecePosition = new PiecePosition(File.E, Rank.EIGHT); - } + public King(Team team, PiecePosition piecePosition) { + super("K", team, piecePosition); } } diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java new file mode 100644 index 0000000..e275bf1 --- /dev/null +++ b/src/main/java/chess/domain/piece/Knight.java @@ -0,0 +1,8 @@ +package chess.domain.piece; + +public class Knight extends Piece { + + public Knight(Team team, PiecePosition piecePosition) { + super("N", team, piecePosition); + } +} diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java new file mode 100644 index 0000000..36f73ea --- /dev/null +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -0,0 +1,7 @@ +package chess.domain.piece; + +public class Pawn extends Piece { + public Pawn(Team team, PiecePosition piecePosition) { + super("P", team, piecePosition); + } +} diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index 09fe473..b98049a 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -9,9 +9,10 @@ public abstract class Piece { protected PiecePosition piecePosition; protected String displayName; - protected Piece(String name, Team team) { + protected Piece(String name, Team team, PiecePosition piecePosition) { this.name = name; this.team = team; this.displayName = team.displayName(name); + this.piecePosition = piecePosition; } } diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java new file mode 100644 index 0000000..eaf747a --- /dev/null +++ b/src/main/java/chess/domain/piece/Queen.java @@ -0,0 +1,8 @@ +package chess.domain.piece; + +public class Queen extends Piece { + + public Queen(Team team, PiecePosition pieceposition) { + super("Q", team, pieceposition); + } +} diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java new file mode 100644 index 0000000..cd6ec92 --- /dev/null +++ b/src/main/java/chess/domain/piece/Rook.java @@ -0,0 +1,8 @@ +package chess.domain.piece; + +public class Rook extends Piece { + + public Rook(Team team, PiecePosition piecePosition) { + super("R", team, piecePosition); + } +} diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java index 4fd91ff..0d10d95 100644 --- a/src/test/java/chess/domain/piece/KingTest.java +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -12,8 +12,8 @@ public class KingTest { void testKingCreation() { //given - King king1 = new King(Team.BLACK); - King king2 = new King(Team.WHITE); + King king1 = new King(Team.BLACK, new PiecePosition(File.E, Rank.ONE)); + King king2 = new King(Team.WHITE, new PiecePosition(File.E, Rank.EIGHT)); //when // given assertThat(king1.getPiecePosition()).isEqualTo(new PiecePosition(File.E, Rank.ONE)); From b4d5d32829f713faef5cc7cefd104805b6aafca9 Mon Sep 17 00:00:00 2001 From: eunii Date: Sun, 15 Aug 2021 18:32:47 +0900 Subject: [PATCH 06/42] refactor: Extract rank by team --- src/main/java/chess/domain/piece/Team.java | 16 +++--- src/main/java/chess/domain/team/Camp.java | 53 +++++++++++++++++++ src/test/java/chess/domain/team/CampTest.java | 27 ++++++++++ 3 files changed, 87 insertions(+), 9 deletions(-) create mode 100644 src/main/java/chess/domain/team/Camp.java create mode 100644 src/test/java/chess/domain/team/CampTest.java diff --git a/src/main/java/chess/domain/piece/Team.java b/src/main/java/chess/domain/piece/Team.java index 9efe965..dbc0e2f 100644 --- a/src/main/java/chess/domain/piece/Team.java +++ b/src/main/java/chess/domain/piece/Team.java @@ -2,21 +2,19 @@ import lombok.Getter; -import java.util.Locale; - @Getter public enum Team { - BLACK(1), - WHITE(2); +BLACK(1, Rank.EIGHT, Rank.SEVEN), + WHITE(2, Rank.ONE, Rank.TWO); private int marker; + private Rank piecesRank; + private Rank pawnRank; - Team(int marker) { + Team(int marker, Rank piecesRank, Rank pawnRank) { this.marker = marker; - } - - public int getMarker() { - return marker; + this.piecesRank = piecesRank; + this.pawnRank = pawnRank; } public String displayName(String name) { diff --git a/src/main/java/chess/domain/team/Camp.java b/src/main/java/chess/domain/team/Camp.java new file mode 100644 index 0000000..c7b9e1f --- /dev/null +++ b/src/main/java/chess/domain/team/Camp.java @@ -0,0 +1,53 @@ +package chess.domain.team; + +import chess.domain.piece.*; +import lombok.Getter; + +import java.util.LinkedList; +import java.util.List; + +@Getter +public class Camp { + private List pieces = new LinkedList<>(); + private Team team; + + public Camp(Team team) { + this.team = team; + //킹1/퀸1/비숍2/나이트2/룩2/폰8; + createKing(); + createQueen(); + createBishop(); + creatKnight(); + createRook(); + createPawn(); + } + + private void createKing() { + pieces.add(new King(team, new PiecePosition(File.E, team.getPiecesRank()))); + } + + private void createQueen() { + pieces.add(new Queen(team, new PiecePosition(File.D, team.getPiecesRank()))); + } + + private void createBishop() { + pieces.add(new Bishop(team, new PiecePosition(File.C, team.getPiecesRank()))); + pieces.add(new Bishop(team, new PiecePosition(File.F, team.getPiecesRank()))); + } + + private void creatKnight() { + pieces.add(new Knight(team, new PiecePosition(File.B, team.getPiecesRank()))); + pieces.add(new Knight(team, new PiecePosition(File.G, team.getPiecesRank()))); + } + + private void createRook() { + pieces.add(new Rook(team, new PiecePosition(File.A, team.getPiecesRank()))); + pieces.add(new Rook(team, new PiecePosition(File.H, team.getPiecesRank()))); + } + + private void createPawn() { + for(File file : File.values()) { + pieces.add(new Pawn(team, new PiecePosition(file, team.getPawnRank()))); + } + } +} diff --git a/src/test/java/chess/domain/team/CampTest.java b/src/test/java/chess/domain/team/CampTest.java new file mode 100644 index 0000000..25434b1 --- /dev/null +++ b/src/test/java/chess/domain/team/CampTest.java @@ -0,0 +1,27 @@ +package chess.domain.team; + +import chess.domain.piece.King; +import chess.domain.piece.Team; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +class CampTest { + @Test + @DisplayName("team 별 기물 세트를 만든다") + void createPieceSetTest() { + //given + Camp blackTeam = new Camp(Team.BLACK); + Camp whiteTeam = new Camp(Team.WHITE); + + //when + + //then + assertThat(blackTeam.getPieces()) + .hasSize(16); + // .contains(new King()); + assertThat(whiteTeam.getPieces()).hasSize(16); + } + +} \ No newline at end of file From 75e36a4665bbd3cad452ad05ea82750e38e01520 Mon Sep 17 00:00:00 2001 From: eunii Date: Sun, 15 Aug 2021 18:51:05 +0900 Subject: [PATCH 07/42] test: Generate ChessPlateTest --- .../java/chess/domain/plate/ChessPlate.java | 21 +++++++++++++++++++ .../chess/domain/plate/ChessPlateTest.java | 19 +++++++++++++++++ src/test/java/chess/domain/team/CampTest.java | 3 +-- 3 files changed, 41 insertions(+), 2 deletions(-) create mode 100644 src/main/java/chess/domain/plate/ChessPlate.java create mode 100644 src/test/java/chess/domain/plate/ChessPlateTest.java diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java new file mode 100644 index 0000000..5d052f0 --- /dev/null +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -0,0 +1,21 @@ +package chess.domain.plate; + +import chess.domain.piece.Piece; +import chess.domain.piece.Team; +import chess.domain.team.Camp; +import lombok.Getter; + +import java.util.LinkedList; +import java.util.List; + +@Getter +public class ChessPlate { + List allPieces = new LinkedList<>(); + + public ChessPlate() { + Camp black = new Camp(Team.BLACK); + Camp white = new Camp(Team.WHITE); + allPieces.addAll(black.getPieces()); + allPieces.addAll(white.getPieces()); + } +} diff --git a/src/test/java/chess/domain/plate/ChessPlateTest.java b/src/test/java/chess/domain/plate/ChessPlateTest.java new file mode 100644 index 0000000..64248b3 --- /dev/null +++ b/src/test/java/chess/domain/plate/ChessPlateTest.java @@ -0,0 +1,19 @@ +package chess.domain.plate; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ChessPlateTest { + + @Test + @DisplayName("체스판 생성하고 포함된 객체 개수 확인") + void testCreateChessPlate() { + //given + ChessPlate chessPlate = new ChessPlate(); + + //when,then + assertThat(chessPlate.getAllPieces()).hasSize(32); + } +} diff --git a/src/test/java/chess/domain/team/CampTest.java b/src/test/java/chess/domain/team/CampTest.java index 25434b1..5de9ab9 100644 --- a/src/test/java/chess/domain/team/CampTest.java +++ b/src/test/java/chess/domain/team/CampTest.java @@ -1,11 +1,10 @@ package chess.domain.team; -import chess.domain.piece.King; import chess.domain.piece.Team; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; + import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; class CampTest { @Test From 74509aa5edc38a0ddc1ffab3229dc68bc23004eb Mon Sep 17 00:00:00 2001 From: eunii Date: Sun, 15 Aug 2021 19:16:27 +0900 Subject: [PATCH 08/42] feat: Generate printPlate --- .../chess/controller/chessController.java | 12 +++++++++ src/main/java/chess/domain/piece/File.java | 25 +++++++++++-------- src/main/java/chess/domain/piece/Rank.java | 3 +++ .../java/chess/domain/plate/ChessPlate.java | 20 +++++++++++++++ src/main/java/chess/view/OutputView.java | 10 ++++++++ 5 files changed, 60 insertions(+), 10 deletions(-) create mode 100644 src/main/java/chess/controller/chessController.java create mode 100644 src/main/java/chess/view/OutputView.java diff --git a/src/main/java/chess/controller/chessController.java b/src/main/java/chess/controller/chessController.java new file mode 100644 index 0000000..552d57c --- /dev/null +++ b/src/main/java/chess/controller/chessController.java @@ -0,0 +1,12 @@ +package chess.controller; + +import chess.domain.plate.ChessPlate; +import chess.view.OutputView; + +public class chessController { + public static void main(String[] args) { + OutputView outputView = new OutputView(); + ChessPlate chessPlate = new ChessPlate(); + outputView.printChessPlate(chessPlate.getPlate()); + } +} diff --git a/src/main/java/chess/domain/piece/File.java b/src/main/java/chess/domain/piece/File.java index 7e605c0..8913535 100644 --- a/src/main/java/chess/domain/piece/File.java +++ b/src/main/java/chess/domain/piece/File.java @@ -1,18 +1,23 @@ package chess.domain.piece; +import lombok.Getter; + +@Getter public enum File { - A("a"), - B("b"), - C("c"), - D("d"), - E("e"), - F("f"), - G("g"), - H("h"); + A("a",1), + B("b",2), + C("c",3), + D("d",4), + E("e",5), + F("f",6), + G("g",7), + H("h",8); - private String filePosition; + private String fileMarker; + private int filePosition; - File(String filePosition) { + File(String fileMarker, int filePosition) { + this.fileMarker = fileMarker; this.filePosition = filePosition; } } diff --git a/src/main/java/chess/domain/piece/Rank.java b/src/main/java/chess/domain/piece/Rank.java index e9f137f..7c62bb1 100644 --- a/src/main/java/chess/domain/piece/Rank.java +++ b/src/main/java/chess/domain/piece/Rank.java @@ -1,5 +1,8 @@ package chess.domain.piece; +import lombok.Getter; + +@Getter public enum Rank { ONE(1), TWO(2), diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 5d052f0..9b0a777 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -10,6 +10,9 @@ @Getter public class ChessPlate { + private static final String BLANK ="."; + private String[][] plate = new String[8][8]; + List allPieces = new LinkedList<>(); public ChessPlate() { @@ -18,4 +21,21 @@ public ChessPlate() { allPieces.addAll(black.getPieces()); allPieces.addAll(white.getPieces()); } + + public String[][] getPlate() { + + for (int i = 0; i < plate.length; i++) { + for (int j = 0; j < plate.length; j++) { + plate[i][j] = "."; + } + } + + allPieces.forEach(piece -> { + int x = piece.getPiecePosition().getRank().getRankPosition()-1; + int y = piece.getPiecePosition().getFile().getFilePosition()-1; + plate[x][y] = piece.getDisplayName(); + }); + return plate; + } + } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java new file mode 100644 index 0000000..6035782 --- /dev/null +++ b/src/main/java/chess/view/OutputView.java @@ -0,0 +1,10 @@ +package chess.view; + +import java.util.Arrays; + +public class OutputView { + + public void printChessPlate(String[][] plate) { + System.out.println(Arrays.deepToString(plate)); + } +} From 61afd40a2a235bd8a643181180f7ec35a63fef2b Mon Sep 17 00:00:00 2001 From: eunii Date: Sun, 15 Aug 2021 21:30:44 +0900 Subject: [PATCH 09/42] feat: Generate comparator --- .../chess/domain/PicesPositionComparator.java | 26 +++++++++++++++++ .../java/chess/domain/RankComparator.java | 19 +++++++++++++ src/main/java/chess/domain/piece/Piece.java | 4 +-- .../java/chess/domain/plate/ChessPlate.java | 28 ++++++++----------- src/main/java/chess/view/OutputView.java | 15 ++++++++-- .../chess/domain/team/RankComparatorTest.java | 17 +++++++++++ 6 files changed, 89 insertions(+), 20 deletions(-) create mode 100644 src/main/java/chess/domain/PicesPositionComparator.java create mode 100644 src/main/java/chess/domain/RankComparator.java create mode 100644 src/test/java/chess/domain/team/RankComparatorTest.java diff --git a/src/main/java/chess/domain/PicesPositionComparator.java b/src/main/java/chess/domain/PicesPositionComparator.java new file mode 100644 index 0000000..94abe97 --- /dev/null +++ b/src/main/java/chess/domain/PicesPositionComparator.java @@ -0,0 +1,26 @@ +package chess.domain; + +import chess.domain.piece.PiecePosition; +import chess.domain.piece.Rank; + +import java.util.Comparator; + +public class PicesPositionComparator implements Comparator { + + @Override + public int compare(Object o1, Object o2) { + if(o1 instanceof PiecePosition && o2 instanceof PiecePosition) { + PiecePosition p1 = (PiecePosition) o1; + PiecePosition p2 = (PiecePosition) o2; + + int pvalue1 = p1.getRank().getRankPosition(); + int pvalue2 = p2.getRank().getRankPosition(); + + if(pvalue1 == pvalue2) { + return p1.getFile().getFilePosition() - p2.getFile().getFilePosition(); + } + return pvalue1 - pvalue2; + } + return 0; + } +} diff --git a/src/main/java/chess/domain/RankComparator.java b/src/main/java/chess/domain/RankComparator.java new file mode 100644 index 0000000..e31c993 --- /dev/null +++ b/src/main/java/chess/domain/RankComparator.java @@ -0,0 +1,19 @@ +package chess.domain; + +import chess.domain.piece.Rank; + +import java.util.Comparator; + +public class RankComparator implements Comparator { + + @Override + public int compare(Object o1, Object o2) { + if(o1 instanceof Rank && o2 instanceof Rank) { + Rank r1 = (Rank) o1; + Rank r2 = (Rank) o2; + + return r2.getRankPosition() - r1.getRankPosition(); + } + return 0; + } +} diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index b98049a..ba28ddd 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -3,13 +3,13 @@ import lombok.Getter; @Getter -public abstract class Piece { +public class Piece { protected String name; protected Team team; protected PiecePosition piecePosition; protected String displayName; - protected Piece(String name, Team team, PiecePosition piecePosition) { + public Piece(String name, Team team, PiecePosition piecePosition) { this.name = name; this.team = team; this.displayName = team.displayName(name); diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 9b0a777..04031a4 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -1,19 +1,17 @@ package chess.domain.plate; -import chess.domain.piece.Piece; -import chess.domain.piece.Team; +import chess.domain.RankComparator; +import chess.domain.piece.*; import chess.domain.team.Camp; import lombok.Getter; -import java.util.LinkedList; -import java.util.List; +import java.util.*; @Getter public class ChessPlate { private static final String BLANK ="."; - private String[][] plate = new String[8][8]; - - List allPieces = new LinkedList<>(); + private Map plate = new HashMap<>(); + private List allPieces = new LinkedList<>(); public ChessPlate() { Camp black = new Camp(Team.BLACK); @@ -22,20 +20,18 @@ public ChessPlate() { allPieces.addAll(white.getPieces()); } - public String[][] getPlate() { + public Map getPlate() { + RankComparator rankComparator = new RankComparator(); - for (int i = 0; i < plate.length; i++) { - for (int j = 0; j < plate.length; j++) { - plate[i][j] = "."; + for (Rank rank: Rank.values()) { + for (File file : File.values()) { + plate.put(new PiecePosition(file, rank), new Piece(".",Team.BLACK, new PiecePosition(file,rank))); } } - allPieces.forEach(piece -> { - int x = piece.getPiecePosition().getRank().getRankPosition()-1; - int y = piece.getPiecePosition().getFile().getFilePosition()-1; - plate[x][y] = piece.getDisplayName(); + plate.put(piece.getPiecePosition(), piece); }); + return plate; } - } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 6035782..abbf38a 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -1,10 +1,21 @@ package chess.view; +import chess.domain.piece.File; +import chess.domain.piece.Piece; +import chess.domain.piece.PiecePosition; +import chess.domain.piece.Rank; + import java.util.Arrays; +import java.util.Map; public class OutputView { - public void printChessPlate(String[][] plate) { - System.out.println(Arrays.deepToString(plate)); + public void printChessPlate(Map plate) { + for (Map.Entry entry: plate.entrySet()) { + if(entry.getKey().getFile().equals(File.H)){ + System.out.println(entry.getValue().getDisplayName()); + } + System.out.print(entry.getValue().getDisplayName()+", "); + } } } diff --git a/src/test/java/chess/domain/team/RankComparatorTest.java b/src/test/java/chess/domain/team/RankComparatorTest.java new file mode 100644 index 0000000..9ed2198 --- /dev/null +++ b/src/test/java/chess/domain/team/RankComparatorTest.java @@ -0,0 +1,17 @@ +package chess.domain.team; + +import chess.domain.RankComparator; +import chess.domain.piece.Rank; + +import java.util.Arrays; + +public class RankComparatorTest { + public static void main(String[] args) { + RankComparator rankComparator = new RankComparator(); + Arrays.stream(Rank.values()) + .sorted(rankComparator::compare) + .forEach(rank -> { + System.out.println(rank.getRankPosition()); + }); + } +} From 74a6f6f46e9efc157144fe40431b18aa14d2a8dd Mon Sep 17 00:00:00 2001 From: chunghyeon-kim Date: Tue, 17 Aug 2021 06:18:17 +0900 Subject: [PATCH 10/42] feat: Print initial chess plate --- build.gradle | 4 ++++ .../chess/controller/chessController.java | 2 +- .../chess/domain/piece/PiecePosition.java | 21 ++++++++++++++----- .../java/chess/domain/plate/ChessPlate.java | 3 ++- src/main/java/chess/view/OutputView.java | 13 ++++++------ 5 files changed, 30 insertions(+), 13 deletions(-) diff --git a/build.gradle b/build.gradle index a4fc147..3cb6e48 100644 --- a/build.gradle +++ b/build.gradle @@ -24,3 +24,7 @@ dependencies { testCompileOnly 'org.projectlombok:lombok:1.18.20' testAnnotationProcessor 'org.projectlombok:lombok:1.18.20' } + +test { + useJUnitPlatform() +} diff --git a/src/main/java/chess/controller/chessController.java b/src/main/java/chess/controller/chessController.java index 552d57c..0eb05a7 100644 --- a/src/main/java/chess/controller/chessController.java +++ b/src/main/java/chess/controller/chessController.java @@ -7,6 +7,6 @@ public class chessController { public static void main(String[] args) { OutputView outputView = new OutputView(); ChessPlate chessPlate = new ChessPlate(); - outputView.printChessPlate(chessPlate.getPlate()); + outputView.printChessPlate(chessPlate); } } diff --git a/src/main/java/chess/domain/piece/PiecePosition.java b/src/main/java/chess/domain/piece/PiecePosition.java index be93ab5..c509f91 100644 --- a/src/main/java/chess/domain/piece/PiecePosition.java +++ b/src/main/java/chess/domain/piece/PiecePosition.java @@ -3,6 +3,8 @@ import lombok.Getter; import lombok.RequiredArgsConstructor; +import java.util.Objects; + @Getter @RequiredArgsConstructor public class PiecePosition { @@ -10,11 +12,20 @@ public class PiecePosition { private final Rank rank; @Override - public boolean equals(Object object) { - if (object instanceof PiecePosition) { - PiecePosition position = (PiecePosition) object; - return this.getFile().equals(position.getFile()) && this.getRank().equals(position.getRank()); + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof PiecePosition)) { + return false; } - return false; + PiecePosition that = (PiecePosition) o; + return getFile() == that.getFile() && + getRank() == that.getRank(); + } + + @Override + public int hashCode() { + return Objects.hash(getFile(), getRank()); } } diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 04031a4..4daf25c 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -18,9 +18,10 @@ public ChessPlate() { Camp white = new Camp(Team.WHITE); allPieces.addAll(black.getPieces()); allPieces.addAll(white.getPieces()); + arrangePieces(); } - public Map getPlate() { + public Map arrangePieces() { RankComparator rankComparator = new RankComparator(); for (Rank rank: Rank.values()) { diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index abbf38a..06524cf 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -4,18 +4,19 @@ import chess.domain.piece.Piece; import chess.domain.piece.PiecePosition; import chess.domain.piece.Rank; +import chess.domain.plate.ChessPlate; -import java.util.Arrays; import java.util.Map; public class OutputView { - public void printChessPlate(Map plate) { - for (Map.Entry entry: plate.entrySet()) { - if(entry.getKey().getFile().equals(File.H)){ - System.out.println(entry.getValue().getDisplayName()); + public void printChessPlate(ChessPlate chessPlate) { + for (Rank rank : Rank.values()) { + for(File file : File.values()) { + System.out.print(chessPlate.getPlate().get(new PiecePosition(file, rank)).getDisplayName()); } - System.out.print(entry.getValue().getDisplayName()+", "); + + System.out.println(); } } } From 824c514fafe2a9536d2f554a477514e6548555db Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 19:25:56 +0900 Subject: [PATCH 11/42] feat: Arrange rank when print chess plate --- README.md | 18 +++++++------ .../chess/controller/chessController.java | 2 +- src/main/java/chess/domain/piece/Team.java | 16 ++++++------ src/main/java/chess/domain/team/Camp.java | 18 ++++++------- src/main/java/chess/view/OutputView.java | 25 ++++++++++++++----- 5 files changed, 47 insertions(+), 32 deletions(-) diff --git a/README.md b/README.md index 0e00665..63e3081 100644 --- a/README.md +++ b/README.md @@ -1,14 +1,16 @@ # java-chess 게임 -- [] 체스판 - - []rank(세로) : 8 :1~8 - - []file(가로) : 8 :a~h - - [] 말이 없는 칸은 . - - []초기화 +- [x] 체스판 + - [x]rank(세로) : 8 :1~8 + - [x]file(가로) : 8 :a~h + - [x] 말이 없는 칸은 . + - [x]초기화 - [] 아웃풋 뷰 - [] 체스판 출력 기능 - - + - [] 게임 진행시 마다 체스판을 출력해준다 + - [x] 게임 시작 설명 출력 + - [] 기물 - [] king @@ -27,8 +29,8 @@ - [] 1칸 이동 - [] 공격은 대각선으로만 -- [] 진영 - - [] 기물 2 세트 생성 (1개는 대문자, 소문자) +- [x] 진영 + - [x] 기물 2 세트 생성 (1개는 대문자, 소문자) - [] 체스 게임 룰 - [] start : 체스판 초기화 및 진영 세팅 diff --git a/src/main/java/chess/controller/chessController.java b/src/main/java/chess/controller/chessController.java index 0eb05a7..34bcf66 100644 --- a/src/main/java/chess/controller/chessController.java +++ b/src/main/java/chess/controller/chessController.java @@ -7,6 +7,6 @@ public class chessController { public static void main(String[] args) { OutputView outputView = new OutputView(); ChessPlate chessPlate = new ChessPlate(); - outputView.printChessPlate(chessPlate); + outputView.initPrint(); } } diff --git a/src/main/java/chess/domain/piece/Team.java b/src/main/java/chess/domain/piece/Team.java index dbc0e2f..e6392f6 100644 --- a/src/main/java/chess/domain/piece/Team.java +++ b/src/main/java/chess/domain/piece/Team.java @@ -4,25 +4,25 @@ @Getter public enum Team { -BLACK(1, Rank.EIGHT, Rank.SEVEN), + BLACK(1, Rank.EIGHT, Rank.SEVEN), WHITE(2, Rank.ONE, Rank.TWO); private int marker; - private Rank piecesRank; - private Rank pawnRank; + private Rank piecesInitRank; + private Rank pawnInitRank; - Team(int marker, Rank piecesRank, Rank pawnRank) { + Team(int marker, Rank piecesRank, Rank pawnInitRank) { this.marker = marker; - this.piecesRank = piecesRank; - this.pawnRank = pawnRank; + this.piecesInitRank = piecesRank; + this.pawnInitRank = pawnInitRank; } public String displayName(String name) { if (this.equals(BLACK)) { - return name.toLowerCase(); + return name.toUpperCase(); } if (this.equals(WHITE)) { - return name.toUpperCase(); + return name.toLowerCase(); } return name; } diff --git a/src/main/java/chess/domain/team/Camp.java b/src/main/java/chess/domain/team/Camp.java index c7b9e1f..3937eb6 100644 --- a/src/main/java/chess/domain/team/Camp.java +++ b/src/main/java/chess/domain/team/Camp.java @@ -23,31 +23,31 @@ public Camp(Team team) { } private void createKing() { - pieces.add(new King(team, new PiecePosition(File.E, team.getPiecesRank()))); + pieces.add(new King(team, new PiecePosition(File.E, team.getPiecesInitRank()))); } private void createQueen() { - pieces.add(new Queen(team, new PiecePosition(File.D, team.getPiecesRank()))); + pieces.add(new Queen(team, new PiecePosition(File.D, team.getPiecesInitRank()))); } private void createBishop() { - pieces.add(new Bishop(team, new PiecePosition(File.C, team.getPiecesRank()))); - pieces.add(new Bishop(team, new PiecePosition(File.F, team.getPiecesRank()))); + pieces.add(new Bishop(team, new PiecePosition(File.C, team.getPiecesInitRank()))); + pieces.add(new Bishop(team, new PiecePosition(File.F, team.getPiecesInitRank()))); } private void creatKnight() { - pieces.add(new Knight(team, new PiecePosition(File.B, team.getPiecesRank()))); - pieces.add(new Knight(team, new PiecePosition(File.G, team.getPiecesRank()))); + pieces.add(new Knight(team, new PiecePosition(File.B, team.getPiecesInitRank()))); + pieces.add(new Knight(team, new PiecePosition(File.G, team.getPiecesInitRank()))); } private void createRook() { - pieces.add(new Rook(team, new PiecePosition(File.A, team.getPiecesRank()))); - pieces.add(new Rook(team, new PiecePosition(File.H, team.getPiecesRank()))); + pieces.add(new Rook(team, new PiecePosition(File.A, team.getPiecesInitRank()))); + pieces.add(new Rook(team, new PiecePosition(File.H, team.getPiecesInitRank()))); } private void createPawn() { for(File file : File.values()) { - pieces.add(new Pawn(team, new PiecePosition(file, team.getPawnRank()))); + pieces.add(new Pawn(team, new PiecePosition(file, team.getPawnInitRank()))); } } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 06524cf..91c5cfc 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -1,22 +1,35 @@ package chess.view; +import chess.domain.RankComparator; import chess.domain.piece.File; import chess.domain.piece.Piece; import chess.domain.piece.PiecePosition; import chess.domain.piece.Rank; import chess.domain.plate.ChessPlate; +import java.util.Arrays; import java.util.Map; public class OutputView { public void printChessPlate(ChessPlate chessPlate) { - for (Rank rank : Rank.values()) { - for(File file : File.values()) { - System.out.print(chessPlate.getPlate().get(new PiecePosition(file, rank)).getDisplayName()); - } + RankComparator rankComparator = new RankComparator(); + Arrays.stream(Rank.values()) + .sorted(rankComparator::compare) + .forEach(rank -> { + for (File file : File.values()) { + System.out.print(chessPlate.getPlate().get(new PiecePosition(file, rank)).getDisplayName()); + } + System.out.println(); + }); + } - System.out.println(); - } + public void initPrint() { + System.out.println(">체스 게임을 시작합니다."); + System.out.println(">게임 시작 : start"); + System.out.println(">게임 종료 : end"); + System.out.println(">게임 이동 : move source 위치 target 위치 - 예. move b2 b3"); } + + } From 7a90d5c35806321b4585737fd4644f8cfec014e4 Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 20:17:20 +0900 Subject: [PATCH 12/42] feat: get chess command --- README.md | 4 ++++ src/main/java/chess/view/InputView.java | 11 +++++++++++ 2 files changed, 15 insertions(+) create mode 100644 src/main/java/chess/view/InputView.java diff --git a/README.md b/README.md index 63e3081..38110b0 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,10 @@ - [] 게임 진행시 마다 체스판을 출력해준다 - [x] 게임 시작 설명 출력 +-[] 인풋 뷰 + - [x] 게임 명령어 인풋 받기 + - [x] start/end/move로 시작하지 않으면 계속 묻기 + - [] 기물 - [] king diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java new file mode 100644 index 0000000..5ea4a87 --- /dev/null +++ b/src/main/java/chess/view/InputView.java @@ -0,0 +1,11 @@ +package chess.view; + +import java.util.Scanner; + +public class InputView { + private static final Scanner SCANNER = new Scanner(System.in); + public String getUserCommand() { + String input = SCANNER.nextLine(); + return input.trim().toLowerCase(); + } +} From 80c0735c35162929be07298ef78ee920f1c65cc9 Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 20:23:27 +0900 Subject: [PATCH 13/42] feat: make start/end feature --- README.md | 7 ++++--- src/main/java/chess/ChessApplication.java | 12 ++++++++++++ src/main/java/chess/controller/chessController.java | 12 ------------ src/main/java/chess/service/ChessService.java | 9 +++++++++ src/main/java/chess/view/OutputView.java | 6 ++++-- 5 files changed, 29 insertions(+), 17 deletions(-) create mode 100644 src/main/java/chess/ChessApplication.java delete mode 100644 src/main/java/chess/controller/chessController.java create mode 100644 src/main/java/chess/service/ChessService.java diff --git a/README.md b/README.md index 38110b0..641ddbd 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,7 @@ - [] 아웃풋 뷰 - [] 체스판 출력 기능 + - [x] 'start' 입력 시 체스판 초기화 하고 출력 - [] 게임 진행시 마다 체스판을 출력해준다 - [x] 게임 시작 설명 출력 @@ -36,6 +37,6 @@ - [x] 진영 - [x] 기물 2 세트 생성 (1개는 대문자, 소문자) -- [] 체스 게임 룰 - - [] start : 체스판 초기화 및 진영 세팅 - - [] end: 게임 종료 \ No newline at end of file +- [x] 체스 게임 룰 + - [x] start : 체스판 초기화 및 진영 세팅 + - [x] end: 게임 종료 \ No newline at end of file diff --git a/src/main/java/chess/ChessApplication.java b/src/main/java/chess/ChessApplication.java new file mode 100644 index 0000000..e751aad --- /dev/null +++ b/src/main/java/chess/ChessApplication.java @@ -0,0 +1,12 @@ +package chess; + +import chess.controller.ChessController; + +public class ChessApplication { + + public static void main(String[] args) { + ChessController chessController = new ChessController(); + chessController.play(); + } +} + diff --git a/src/main/java/chess/controller/chessController.java b/src/main/java/chess/controller/chessController.java deleted file mode 100644 index 34bcf66..0000000 --- a/src/main/java/chess/controller/chessController.java +++ /dev/null @@ -1,12 +0,0 @@ -package chess.controller; - -import chess.domain.plate.ChessPlate; -import chess.view.OutputView; - -public class chessController { - public static void main(String[] args) { - OutputView outputView = new OutputView(); - ChessPlate chessPlate = new ChessPlate(); - outputView.initPrint(); - } -} diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java new file mode 100644 index 0000000..4f2d95e --- /dev/null +++ b/src/main/java/chess/service/ChessService.java @@ -0,0 +1,9 @@ +package chess.service; + +import chess.domain.plate.ChessPlate; + +public class ChessService { + public ChessPlate start() { + return new ChessPlate(); + } +} diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 91c5cfc..0f5581f 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -2,13 +2,11 @@ import chess.domain.RankComparator; import chess.domain.piece.File; -import chess.domain.piece.Piece; import chess.domain.piece.PiecePosition; import chess.domain.piece.Rank; import chess.domain.plate.ChessPlate; import java.util.Arrays; -import java.util.Map; public class OutputView { @@ -31,5 +29,9 @@ public void initPrint() { System.out.println(">게임 이동 : move source 위치 target 위치 - 예. move b2 b3"); } + public void printInCorrectCommandMessage(){ + System.out.println("start/end/move 중 하나를 입력해주세요"); + } + } From be7a84d47bc90f0b27a85845f6e9522c837fcfe7 Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 20:51:57 +0900 Subject: [PATCH 14/42] feat: Get move source target position --- .../chess/controller/ChessController.java | 44 +++++++++++++++++++ src/main/java/chess/domain/piece/File.java | 9 ++++ src/main/java/chess/domain/piece/Rank.java | 9 ++++ src/main/java/chess/service/ChessService.java | 10 +++++ src/main/java/chess/view/InputView.java | 2 + .../java/chess/service/ChessServiceTest.java | 23 ++++++++++ 6 files changed, 97 insertions(+) create mode 100644 src/main/java/chess/controller/ChessController.java create mode 100644 src/test/java/chess/service/ChessServiceTest.java diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java new file mode 100644 index 0000000..6d9ca44 --- /dev/null +++ b/src/main/java/chess/controller/ChessController.java @@ -0,0 +1,44 @@ +package chess.controller; + +import chess.service.ChessService; +import chess.view.InputView; +import chess.view.OutputView; + +public class ChessController { + private static final OutputView outputView = new OutputView(); + private static final InputView inputView = new InputView(); + public static final String START = "start"; + public static final String END = "end"; + public static final String MOVE = "move"; + + public void play() { + ChessService chessService = new ChessService(); + outputView.initPrint(); + String command = START; + while (!command.equals(END)){ + command = getCommand(); + checkCommadMessage(chessService, command); + } + } + + private void checkCommadMessage(ChessService chessService, String command) { + if(command.equals(START)){ + chessService.start(); + } + + if(command.startsWith(MOVE)) { + String[] position = command.split(" "); + chessService.move(position[1],position[2]); + } + + } + + private static String getCommand() { + String command = inputView.getUserCommand(); + while(!(command.startsWith(START) || command.equals(END) || command.startsWith(MOVE))){ + outputView.printInCorrectCommandMessage(); + command = inputView.getUserCommand(); + } + return command; + } +} diff --git a/src/main/java/chess/domain/piece/File.java b/src/main/java/chess/domain/piece/File.java index 8913535..35c853e 100644 --- a/src/main/java/chess/domain/piece/File.java +++ b/src/main/java/chess/domain/piece/File.java @@ -2,6 +2,8 @@ import lombok.Getter; +import java.util.Arrays; + @Getter public enum File { A("a",1), @@ -20,4 +22,11 @@ public enum File { this.fileMarker = fileMarker; this.filePosition = filePosition; } + + public static File valueOfString(String fileMarker) { + return Arrays.stream(File.values()) + .filter(v -> v.fileMarker.equals(fileMarker)) + .findFirst() + .orElseThrow(()->new IllegalAccessError("해당되는 위치가 없습니다.")); + } } diff --git a/src/main/java/chess/domain/piece/Rank.java b/src/main/java/chess/domain/piece/Rank.java index 7c62bb1..d48792c 100644 --- a/src/main/java/chess/domain/piece/Rank.java +++ b/src/main/java/chess/domain/piece/Rank.java @@ -2,6 +2,8 @@ import lombok.Getter; +import java.util.Arrays; + @Getter public enum Rank { ONE(1), @@ -18,4 +20,11 @@ public enum Rank { Rank(int rankPosition) { this.rankPosition = rankPosition; } + + public static Rank findBy(String rankPosition) { + return Arrays.stream(Rank.values()) + .filter(r -> r.rankPosition == Integer.parseInt(rankPosition)) + .findFirst() + .orElseThrow(()->new IllegalAccessError("해당되는 위치가 없습니다.")); + } } diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java index 4f2d95e..6f3bb6a 100644 --- a/src/main/java/chess/service/ChessService.java +++ b/src/main/java/chess/service/ChessService.java @@ -1,9 +1,19 @@ package chess.service; +import chess.domain.piece.File; +import chess.domain.piece.Rank; import chess.domain.plate.ChessPlate; public class ChessService { public ChessPlate start() { return new ChessPlate(); } + + public void move(String sourcePosition, String targetPosition) { + String fileString = sourcePosition.substring(0,1); + File f = File.valueOfString(fileString); + String rankString = sourcePosition.substring(1); + Rank r = Rank.findBy(rankString); + + } } diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java index 5ea4a87..b96984b 100644 --- a/src/main/java/chess/view/InputView.java +++ b/src/main/java/chess/view/InputView.java @@ -8,4 +8,6 @@ public String getUserCommand() { String input = SCANNER.nextLine(); return input.trim().toLowerCase(); } + + } diff --git a/src/test/java/chess/service/ChessServiceTest.java b/src/test/java/chess/service/ChessServiceTest.java new file mode 100644 index 0000000..90c08aa --- /dev/null +++ b/src/test/java/chess/service/ChessServiceTest.java @@ -0,0 +1,23 @@ +package chess.service; + +import chess.domain.piece.File; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +class ChessServiceTest { + @Test + @DisplayName("File 생성 테스트") + void generateFileWithString() { + //given + File a = File.valueOfString("b"); + + //when + + //then + assertThat(a.getFileMarker()).isEqualTo("b"); + assertThat(a.getFilePosition()).isEqualTo(2); + } +} \ No newline at end of file From 2d334fc34c9c60d9b3eea33a71aae9ba952ba332 Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 21:11:41 +0900 Subject: [PATCH 15/42] feat: Get target sourcepiece --- .../java/chess/domain/plate/ChessPlate.java | 5 +++++ src/main/java/chess/service/ChessService.java | 18 +++++++++++++++--- 2 files changed, 20 insertions(+), 3 deletions(-) diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 4daf25c..1a5118b 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -35,4 +35,9 @@ public Map arrangePieces() { return plate; } + public void move(PiecePosition sposition, PiecePosition targPiecePosition){ + //TO-DO 기물별 허용 움직임 범위인지 체크 + // 가려는 곳이 상대편 말이거나, 비어있는지 체크 + + } } diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java index 6f3bb6a..9bca402 100644 --- a/src/main/java/chess/service/ChessService.java +++ b/src/main/java/chess/service/ChessService.java @@ -1,19 +1,31 @@ package chess.service; import chess.domain.piece.File; +import chess.domain.piece.Piece; +import chess.domain.piece.PiecePosition; import chess.domain.piece.Rank; import chess.domain.plate.ChessPlate; +import java.util.Optional; + public class ChessService { + private static ChessPlate chessPlate= new ChessPlate(); public ChessPlate start() { - return new ChessPlate(); + this.chessPlate = new ChessPlate(); + return chessPlate; } public void move(String sourcePosition, String targetPosition) { String fileString = sourcePosition.substring(0,1); - File f = File.valueOfString(fileString); + File sourceFile = File.valueOfString(fileString); String rankString = sourcePosition.substring(1); - Rank r = Rank.findBy(rankString); + Rank sourceRank = Rank.findBy(rankString); + PiecePosition sourcePiecePosition = new PiecePosition(sourceFile, sourceRank); + Piece source = chessPlate.getAllPieces().stream() + .filter(piece -> piece.getPiecePosition().equals(sourcePiecePosition)) + .findFirst() + .orElseThrow(() -> new IllegalArgumentException("해당 위치에 기물이 없습니다")); + } } From 78a791eeda211a424cf628559077f1ed5f8f89b8 Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 21:17:24 +0900 Subject: [PATCH 16/42] feat: add move & movable abstract methods --- src/main/java/chess/domain/piece/Bishop.java | 10 ++++++++++ src/main/java/chess/domain/piece/King.java | 10 ++++++++++ src/main/java/chess/domain/piece/Knight.java | 10 ++++++++++ src/main/java/chess/domain/piece/Pawn.java | 10 ++++++++++ src/main/java/chess/domain/piece/Piece.java | 7 ++++++- src/main/java/chess/domain/piece/Queen.java | 10 ++++++++++ src/main/java/chess/domain/piece/Rook.java | 10 ++++++++++ src/main/java/chess/domain/plate/ChessPlate.java | 3 ++- 8 files changed, 68 insertions(+), 2 deletions(-) diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index fa4d0b9..badd184 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -5,4 +5,14 @@ public class Bishop extends Piece { public Bishop(Team team, PiecePosition piecePosition) { super("B", team, piecePosition); } + + @Override + public boolean movable(PiecePosition targetPosition) { + return false; + } + + @Override + public Piece move(PiecePosition tarPiecePosition) { + return null; + } } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index b143c57..f373620 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -5,4 +5,14 @@ public class King extends Piece { public King(Team team, PiecePosition piecePosition) { super("K", team, piecePosition); } + + @Override + public boolean movable(PiecePosition targetPosition) { + return false; + } + + @Override + public Piece move(PiecePosition tarPiecePosition) { + return null; + } } diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index e275bf1..536a545 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -5,4 +5,14 @@ public class Knight extends Piece { public Knight(Team team, PiecePosition piecePosition) { super("N", team, piecePosition); } + + @Override + public boolean movable(PiecePosition targetPosition) { + return false; + } + + @Override + public Piece move(PiecePosition tarPiecePosition) { + return null; + } } diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 36f73ea..e909f38 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -4,4 +4,14 @@ public class Pawn extends Piece { public Pawn(Team team, PiecePosition piecePosition) { super("P", team, piecePosition); } + + @Override + public boolean movable(PiecePosition targetPosition) { + return false; + } + + @Override + public Piece move(PiecePosition tarPiecePosition) { + return null; + } } diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index ba28ddd..6823435 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -3,7 +3,7 @@ import lombok.Getter; @Getter -public class Piece { +public abstract class Piece { protected String name; protected Team team; protected PiecePosition piecePosition; @@ -15,4 +15,9 @@ public Piece(String name, Team team, PiecePosition piecePosition) { this.displayName = team.displayName(name); this.piecePosition = piecePosition; } + + public abstract boolean movable(PiecePosition targetPosition); + + public abstract Piece move(PiecePosition tarPiecePosition); + } diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index eaf747a..f21fd33 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -5,4 +5,14 @@ public class Queen extends Piece { public Queen(Team team, PiecePosition pieceposition) { super("Q", team, pieceposition); } + + @Override + public boolean movable(PiecePosition targetPosition) { + return false; + } + + @Override + public Piece move(PiecePosition tarPiecePosition) { + return null; + } } diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index cd6ec92..34c3e84 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -5,4 +5,14 @@ public class Rook extends Piece { public Rook(Team team, PiecePosition piecePosition) { super("R", team, piecePosition); } + + @Override + public boolean movable(PiecePosition targetPosition) { + return false; + } + + @Override + public Piece move(PiecePosition tarPiecePosition) { + return null; + } } diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 1a5118b..6a13c2e 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -26,7 +26,8 @@ public Map arrangePieces() { for (Rank rank: Rank.values()) { for (File file : File.values()) { - plate.put(new PiecePosition(file, rank), new Piece(".",Team.BLACK, new PiecePosition(file,rank))); +// plate.put(new PiecePosition(file, rank), new Piece(".",Team.BLACK, new PiecePosition(file,rank))); + plate.put(new PiecePosition(file, rank), null); } } allPieces.forEach(piece -> { From e8365640cc683929aa714d2e1a12db7d53158c96 Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 21:41:42 +0900 Subject: [PATCH 17/42] feat: Make king movable method and test --- src/main/java/chess/domain/piece/King.java | 13 +++++++++++-- src/main/java/chess/domain/piece/Team.java | 7 +++++-- src/test/java/chess/domain/piece/KingTest.java | 15 +++++++++++++++ 3 files changed, 31 insertions(+), 4 deletions(-) diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index f373620..0824446 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -1,14 +1,23 @@ package chess.domain.piece; public class King extends Piece { - public King(Team team, PiecePosition piecePosition) { super("K", team, piecePosition); } @Override public boolean movable(PiecePosition targetPosition) { - return false; + int originFile = super.piecePosition.getFile().getFilePosition(); + int originRank = super.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + //상하좌우 한칸씩 + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + if(fileGap == 1 && rankGap == 1) { + return false; + } + return fileGap + rankGap == 1; } @Override diff --git a/src/main/java/chess/domain/piece/Team.java b/src/main/java/chess/domain/piece/Team.java index e6392f6..506e16c 100644 --- a/src/main/java/chess/domain/piece/Team.java +++ b/src/main/java/chess/domain/piece/Team.java @@ -5,7 +5,8 @@ @Getter public enum Team { BLACK(1, Rank.EIGHT, Rank.SEVEN), - WHITE(2, Rank.ONE, Rank.TWO); + WHITE(2, Rank.ONE, Rank.TWO), + NEUTRAL(0); private int marker; private Rank piecesInitRank; @@ -16,7 +17,9 @@ public enum Team { this.piecesInitRank = piecesRank; this.pawnInitRank = pawnInitRank; } - + Team(int marker) { + this.marker = marker; + } public String displayName(String name) { if (this.equals(BLACK)) { return name.toUpperCase(); diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java index 0d10d95..f07ad30 100644 --- a/src/test/java/chess/domain/piece/KingTest.java +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -22,4 +22,19 @@ void testKingCreation() { assertThat(king2.getDisplayName()).isEqualTo("K"); } + @Test + @DisplayName("King의 이동 가능한 좌표를 확인한다") + void checkKingMovable() { + //given + King king = new King(Team.BLACK, new PiecePosition(File.E, Rank.EIGHT)); + + //when + + //then + assertThat(king.movable(new PiecePosition(File.D, Rank.EIGHT))).isTrue(); + assertThat(king.movable(new PiecePosition(File.C, Rank.EIGHT))).isFalse(); + assertThat(king.movable(new PiecePosition(File.E, Rank.SEVEN))).isTrue(); + assertThat(king.movable(new PiecePosition(File.E, Rank.SIX))).isFalse(); + } + } From 18ad96dbc9df1ff905d5bbb8700af68535c23a4c Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 21:47:47 +0900 Subject: [PATCH 18/42] refactor: Delete move method of piece --- src/main/java/chess/domain/piece/Bishop.java | 5 ----- src/main/java/chess/domain/piece/King.java | 5 ----- src/main/java/chess/domain/piece/Knight.java | 5 ----- src/main/java/chess/domain/piece/Pawn.java | 5 ----- src/main/java/chess/domain/piece/Piece.java | 2 -- src/main/java/chess/domain/piece/Queen.java | 5 ----- src/main/java/chess/domain/piece/Rook.java | 5 ----- 7 files changed, 32 deletions(-) diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index badd184..6b99267 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -10,9 +10,4 @@ public Bishop(Team team, PiecePosition piecePosition) { public boolean movable(PiecePosition targetPosition) { return false; } - - @Override - public Piece move(PiecePosition tarPiecePosition) { - return null; - } } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index 0824446..5c7f718 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -19,9 +19,4 @@ public boolean movable(PiecePosition targetPosition) { } return fileGap + rankGap == 1; } - - @Override - public Piece move(PiecePosition tarPiecePosition) { - return null; - } } diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index 536a545..9a62098 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -10,9 +10,4 @@ public Knight(Team team, PiecePosition piecePosition) { public boolean movable(PiecePosition targetPosition) { return false; } - - @Override - public Piece move(PiecePosition tarPiecePosition) { - return null; - } } diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index e909f38..4192341 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -9,9 +9,4 @@ public Pawn(Team team, PiecePosition piecePosition) { public boolean movable(PiecePosition targetPosition) { return false; } - - @Override - public Piece move(PiecePosition tarPiecePosition) { - return null; - } } diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index 6823435..bff7c79 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -18,6 +18,4 @@ public Piece(String name, Team team, PiecePosition piecePosition) { public abstract boolean movable(PiecePosition targetPosition); - public abstract Piece move(PiecePosition tarPiecePosition); - } diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index f21fd33..93116bb 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -10,9 +10,4 @@ public Queen(Team team, PiecePosition pieceposition) { public boolean movable(PiecePosition targetPosition) { return false; } - - @Override - public Piece move(PiecePosition tarPiecePosition) { - return null; - } } diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index 34c3e84..d818e3a 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -10,9 +10,4 @@ public Rook(Team team, PiecePosition piecePosition) { public boolean movable(PiecePosition targetPosition) { return false; } - - @Override - public Piece move(PiecePosition tarPiecePosition) { - return null; - } } From 584394a3d8cdf0a137a2d84fd6de4aa0482a8d36 Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 21:55:19 +0900 Subject: [PATCH 19/42] feat: Make Bishop movable method and test --- src/main/java/chess/domain/piece/Bishop.java | 8 +++++++- src/main/java/chess/domain/piece/King.java | 3 --- .../java/chess/domain/piece/BishopTest.java | 20 +++++++++++++++++++ .../java/chess/domain/piece/KingTest.java | 4 +--- 4 files changed, 28 insertions(+), 7 deletions(-) create mode 100644 src/test/java/chess/domain/piece/BishopTest.java diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 6b99267..51d4da1 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -8,6 +8,12 @@ public Bishop(Team team, PiecePosition piecePosition) { @Override public boolean movable(PiecePosition targetPosition) { - return false; + int originFile = super.piecePosition.getFile().getFilePosition(); + int originRank = super.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + return fileGap == rankGap; } } diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index 5c7f718..bff423d 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -14,9 +14,6 @@ public boolean movable(PiecePosition targetPosition) { //상하좌우 한칸씩 int fileGap = Math.abs(originFile - targetFile); int rankGap = Math.abs(originRank - targetRank); - if(fileGap == 1 && rankGap == 1) { - return false; - } return fileGap + rankGap == 1; } } diff --git a/src/test/java/chess/domain/piece/BishopTest.java b/src/test/java/chess/domain/piece/BishopTest.java new file mode 100644 index 0000000..466a25d --- /dev/null +++ b/src/test/java/chess/domain/piece/BishopTest.java @@ -0,0 +1,20 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class BishopTest { + @Test + @DisplayName("Bishop의 이동 가능한 좌표를 확인한다") + void checkKingMovable() { + //given + Bishop bishop = new Bishop(Team.BLACK, new PiecePosition(File.E, Rank.EIGHT)); + + //when//then + assertThat(bishop.movable(new PiecePosition(File.D, Rank.SEVEN))).isTrue(); + assertThat(bishop.movable(new PiecePosition(File.D, Rank.EIGHT))).isFalse(); + assertThat(bishop.movable(new PiecePosition(File.E, Rank.SEVEN))).isFalse(); + } +} diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java index f07ad30..109774c 100644 --- a/src/test/java/chess/domain/piece/KingTest.java +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -28,9 +28,7 @@ void checkKingMovable() { //given King king = new King(Team.BLACK, new PiecePosition(File.E, Rank.EIGHT)); - //when - - //then + //when//then assertThat(king.movable(new PiecePosition(File.D, Rank.EIGHT))).isTrue(); assertThat(king.movable(new PiecePosition(File.C, Rank.EIGHT))).isFalse(); assertThat(king.movable(new PiecePosition(File.E, Rank.SEVEN))).isTrue(); From f75d8224178a82ed4ac957f243584c7fa655d821 Mon Sep 17 00:00:00 2001 From: eunii Date: Tue, 17 Aug 2021 22:01:49 +0900 Subject: [PATCH 20/42] feat: Make Rook movable method and test --- src/main/java/chess/domain/piece/Rook.java | 8 +++++++- .../java/chess/domain/piece/RookTest.java | 20 +++++++++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) create mode 100644 src/test/java/chess/domain/piece/RookTest.java diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index d818e3a..6d6f67e 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -8,6 +8,12 @@ public Rook(Team team, PiecePosition piecePosition) { @Override public boolean movable(PiecePosition targetPosition) { - return false; + int originFile = super.piecePosition.getFile().getFilePosition(); + int originRank = super.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + return fileGap == 0 || rankGap == 0; } } diff --git a/src/test/java/chess/domain/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java new file mode 100644 index 0000000..82d6376 --- /dev/null +++ b/src/test/java/chess/domain/piece/RookTest.java @@ -0,0 +1,20 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class RookTest { + @Test + @DisplayName("Rook의 이동 가능한 좌표를 확인한다") + void checkRookMovable() { + //given + Rook rook = new Rook(Team.BLACK, new PiecePosition(File.A, Rank.EIGHT)); + + //when//then + assertThat(rook.movable(new PiecePosition(File.A, Rank.THREE))).isTrue(); + assertThat(rook.movable(new PiecePosition(File.B, Rank.EIGHT))).isTrue(); + assertThat(rook.movable(new PiecePosition(File.C, Rank.SEVEN))).isFalse(); + } +} From 7a9a66d3a83c8d144b4ecdec62ac03c6e1b60d39 Mon Sep 17 00:00:00 2001 From: eunii Date: Wed, 18 Aug 2021 19:21:51 +0900 Subject: [PATCH 21/42] feat: Make Queen movable method and test --- README.md | 16 +++++----- src/main/java/chess/domain/piece/Bishop.java | 2 +- src/main/java/chess/domain/piece/Queen.java | 10 +++++- .../java/chess/domain/piece/QueenTest.java | 31 +++++++++++++++++++ 4 files changed, 50 insertions(+), 9 deletions(-) create mode 100644 src/test/java/chess/domain/piece/QueenTest.java diff --git a/README.md b/README.md index 641ddbd..c52ca71 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,11 @@ # java-chess 게임 -- [x] 체스판 +- [] 체스판 - [x]rank(세로) : 8 :1~8 - [x]file(가로) : 8 :a~h - [x] 말이 없는 칸은 . - [x]초기화 + - [] 기물 이동기능 - [] 아웃풋 뷰 - [] 체스판 출력 기능 @@ -17,18 +18,19 @@ - [x] start/end/move로 시작하지 않으면 계속 묻기 -- [] 기물 +- [] 기물 +- [] 말을 넘어갈 수 없음(나이트 제외) - [] king - - [] 상하좌우 중 1칸 이동 + - [x] 상하좌우 중 1칸 이동범위 체크 - [] queen - - [] 상하좌우 대각선 n칸 이동 + - [x] 상하좌우 대각선 n칸 이동범위 체크 - [] bishop - - [] 대각선으로 n칸 이동 + - [x] 대각선으로 n칸 이동범위 체크 - [] knight - - [] 사방중 한방향으로 한칸 & 양 대각선 중 한 방향으로 한칸 으로 이동 + - [] 사방중 한방향으로 한칸 & 양 대각선 중 한 방향으로 한칸 으로 이동범위 체크 - [] 상대 말 넘어감 - [] rook - - [] 상하좌우 n칸 이동 + - [x] 상하좌우 n칸 이동 - [] pawn - [] 첫회 한정: 2칸 상 이동 || 1칸 상 이동 - [] 1칸 이동 diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 51d4da1..fcbeea2 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -14,6 +14,6 @@ public boolean movable(PiecePosition targetPosition) { int targetRank = targetPosition.getRank().getRankPosition(); int fileGap = Math.abs(originFile - targetFile); int rankGap = Math.abs(originRank - targetRank); - return fileGap == rankGap; + return (fileGap == rankGap); } } diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index 93116bb..2393c58 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -8,6 +8,14 @@ public Queen(Team team, PiecePosition pieceposition) { @Override public boolean movable(PiecePosition targetPosition) { - return false; + int originFile = super.piecePosition.getFile().getFilePosition(); + int originRank = super.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + return (fileGap == rankGap) || (fileGap == 0 || rankGap == 0); } + + } diff --git a/src/test/java/chess/domain/piece/QueenTest.java b/src/test/java/chess/domain/piece/QueenTest.java new file mode 100644 index 0000000..8fca186 --- /dev/null +++ b/src/test/java/chess/domain/piece/QueenTest.java @@ -0,0 +1,31 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class QueenTest { + @Test + @DisplayName("Queen의 이동 가능한 좌표를 확인한다") + void checkQueenMovable() { + //given + Queen queen = new Queen(Team.BLACK, new PiecePosition(File.D, Rank.FOUR)); + + //when//then + assertThat(queen.movable(new PiecePosition(File.D, Rank.THREE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.D, Rank.FIVE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.FOUR))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.E, Rank.FOUR))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.FIVE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.THREE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.E, Rank.FIVE))).isTrue(); + assertThat(queen.movable(new PiecePosition(File.E, Rank.THREE))).isTrue(); + + assertThat(queen.movable(new PiecePosition(File.B, Rank.FIVE))).isFalse(); + assertThat(queen.movable(new PiecePosition(File.F, Rank.FIVE))).isFalse(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.TWO))).isFalse(); + assertThat(queen.movable(new PiecePosition(File.C, Rank.SIX))).isFalse(); + + } +} From 4d17108467d0f18c615f7fc9deafc04ab7ed6436 Mon Sep 17 00:00:00 2001 From: eunii Date: Wed, 18 Aug 2021 20:13:27 +0900 Subject: [PATCH 22/42] feat: Make Pawn movable method --- src/main/java/chess/domain/piece/Bishop.java | 4 +- src/main/java/chess/domain/piece/King.java | 4 +- src/main/java/chess/domain/piece/Pawn.java | 35 +++++++++++++ src/main/java/chess/domain/piece/Queen.java | 4 +- src/main/java/chess/domain/piece/Rook.java | 4 +- .../java/chess/domain/piece/PawnTest.java | 49 +++++++++++++++++++ 6 files changed, 92 insertions(+), 8 deletions(-) create mode 100644 src/test/java/chess/domain/piece/PawnTest.java diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index fcbeea2..392438c 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -8,8 +8,8 @@ public Bishop(Team team, PiecePosition piecePosition) { @Override public boolean movable(PiecePosition targetPosition) { - int originFile = super.piecePosition.getFile().getFilePosition(); - int originRank = super.piecePosition.getRank().getRankPosition(); + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); int targetFile = targetPosition.getFile().getFilePosition(); int targetRank = targetPosition.getRank().getRankPosition(); int fileGap = Math.abs(originFile - targetFile); diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index bff423d..98f37f7 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -7,8 +7,8 @@ public King(Team team, PiecePosition piecePosition) { @Override public boolean movable(PiecePosition targetPosition) { - int originFile = super.piecePosition.getFile().getFilePosition(); - int originRank = super.piecePosition.getRank().getRankPosition(); + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); int targetFile = targetPosition.getFile().getFilePosition(); int targetRank = targetPosition.getRank().getRankPosition(); //상하좌우 한칸씩 diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 4192341..716e4c5 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -7,6 +7,41 @@ public Pawn(Team team, PiecePosition piecePosition) { @Override public boolean movable(PiecePosition targetPosition) { + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + //처음 두칸 + if (checkFirstMove()) { + if (this.getTeam().equals(Team.BLACK)) { + return ((originFile == targetFile) && (originRank - targetRank <= 2)) + || (originRank - targetRank == 1) && Math.abs(originFile - targetFile) <= 1; + } + if (this.getTeam().equals(Team.WHITE)) { + return (originFile == targetFile) && (originRank - targetRank >= -2) + || (originRank - targetRank == -1) && Math.abs(originFile - targetFile) <= 1; + } + } + //한칸 + if (this.getTeam().equals(Team.BLACK)) { + return (originRank - targetRank == 1 && Math.abs(originFile - targetFile) <= 1); + } + if (this.getTeam().equals(Team.WHITE)) { + return (originRank - targetRank == -1 && Math.abs(originFile - targetFile) <= 1); + } + + //대각선 + return false; + } + + private boolean checkFirstMove() { + if (this.getTeam().equals(Team.BLACK)) { + return this.getPiecePosition().getRank().equals(Rank.SEVEN); + } + + if (this.getTeam().equals(Team.WHITE)) { + return this.getPiecePosition().getRank().equals(Rank.TWO); + } return false; } } diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index 2393c58..ea8d2d4 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -8,8 +8,8 @@ public Queen(Team team, PiecePosition pieceposition) { @Override public boolean movable(PiecePosition targetPosition) { - int originFile = super.piecePosition.getFile().getFilePosition(); - int originRank = super.piecePosition.getRank().getRankPosition(); + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); int targetFile = targetPosition.getFile().getFilePosition(); int targetRank = targetPosition.getRank().getRankPosition(); int fileGap = Math.abs(originFile - targetFile); diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index 6d6f67e..36d13f3 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -8,8 +8,8 @@ public Rook(Team team, PiecePosition piecePosition) { @Override public boolean movable(PiecePosition targetPosition) { - int originFile = super.piecePosition.getFile().getFilePosition(); - int originRank = super.piecePosition.getRank().getRankPosition(); + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); int targetFile = targetPosition.getFile().getFilePosition(); int targetRank = targetPosition.getRank().getRankPosition(); int fileGap = Math.abs(originFile - targetFile); diff --git a/src/test/java/chess/domain/piece/PawnTest.java b/src/test/java/chess/domain/piece/PawnTest.java new file mode 100644 index 0000000..3e5896a --- /dev/null +++ b/src/test/java/chess/domain/piece/PawnTest.java @@ -0,0 +1,49 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class PawnTest { + @Test + @DisplayName("폰은 처음 위치에서 2칸 움직일 수 있다") + void testPawnCanMoveTwoBlockAtFirstMove() { + //given + Pawn pawn = new Pawn(Team.BLACK, new PiecePosition(File.C, Rank.SEVEN)); + + //when + + //then + assertThat(pawn.movable(new PiecePosition(File.C, Rank.FIVE))).isTrue(); + } + + @Test + @DisplayName("폰은 1칸 전진할 수 있다") + void testPawnCanMoveOneBlock() { + //given + Pawn pawn = new Pawn(Team.BLACK, new PiecePosition(File.C, Rank.FIVE)); + + //when + + //then + assertThat(pawn.movable(new PiecePosition(File.C, Rank.FOUR))).isTrue(); + assertThat(pawn.movable(new PiecePosition(File.C, Rank.SIX))).isFalse(); + } + + @Test + @DisplayName("폰은 공격할 때 전진방향 대각선으로만 공격할 수 있다") + void pawnMovableDiagonal() { + //given + Pawn blackPawn = new Pawn(Team.BLACK, new PiecePosition(File.C, Rank.SEVEN)); + Pawn whitePawn = new Pawn(Team.WHITE, new PiecePosition(File.D, Rank.TWO)); + + //when + + //then + assertThat(blackPawn.movable(new PiecePosition(File.D, Rank.SIX))).isTrue(); + assertThat(blackPawn.movable(new PiecePosition(File.B, Rank.SIX))).isTrue(); + assertThat(whitePawn.movable(new PiecePosition(File.C, Rank.THREE))).isTrue(); + assertThat(whitePawn.movable(new PiecePosition(File.E, Rank.THREE))).isTrue(); + } +} From 5a09eb15acf36d829ff8a43205f94ecfab8aec90 Mon Sep 17 00:00:00 2001 From: eunii Date: Wed, 18 Aug 2021 20:38:51 +0900 Subject: [PATCH 23/42] refactor: pawn remove duplicated function --- src/main/java/chess/domain/piece/Pawn.java | 25 ++++++------------- src/main/java/chess/domain/piece/Team.java | 8 +++--- .../java/chess/domain/piece/KingTest.java | 4 +-- 3 files changed, 14 insertions(+), 23 deletions(-) diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 716e4c5..2d6e664 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -15,33 +15,22 @@ public boolean movable(PiecePosition targetPosition) { if (checkFirstMove()) { if (this.getTeam().equals(Team.BLACK)) { return ((originFile == targetFile) && (originRank - targetRank <= 2)) - || (originRank - targetRank == 1) && Math.abs(originFile - targetFile) <= 1; + || isDiagonal(originFile, originRank, targetFile, targetRank); } if (this.getTeam().equals(Team.WHITE)) { return (originFile == targetFile) && (originRank - targetRank >= -2) - || (originRank - targetRank == -1) && Math.abs(originFile - targetFile) <= 1; + || isDiagonal(originFile, originRank, targetFile, targetRank); } } //한칸 - if (this.getTeam().equals(Team.BLACK)) { - return (originRank - targetRank == 1 && Math.abs(originFile - targetFile) <= 1); - } - if (this.getTeam().equals(Team.WHITE)) { - return (originRank - targetRank == -1 && Math.abs(originFile - targetFile) <= 1); - } + return isDiagonal(originFile, originRank, targetFile, targetRank); + } - //대각선 - return false; + private boolean isDiagonal(int originFile, int originRank, int targetFile, int targetRank) { + return (originRank - targetRank == 1*this.getTeam().getPawnDirection()) && Math.abs(originFile - targetFile) <= 1; } private boolean checkFirstMove() { - if (this.getTeam().equals(Team.BLACK)) { - return this.getPiecePosition().getRank().equals(Rank.SEVEN); - } - - if (this.getTeam().equals(Team.WHITE)) { - return this.getPiecePosition().getRank().equals(Rank.TWO); - } - return false; + return this.getPiecePosition().getRank().equals(this.getTeam().getPawnInitRank()); } } diff --git a/src/main/java/chess/domain/piece/Team.java b/src/main/java/chess/domain/piece/Team.java index 506e16c..93932f1 100644 --- a/src/main/java/chess/domain/piece/Team.java +++ b/src/main/java/chess/domain/piece/Team.java @@ -4,18 +4,20 @@ @Getter public enum Team { - BLACK(1, Rank.EIGHT, Rank.SEVEN), - WHITE(2, Rank.ONE, Rank.TWO), + BLACK(1, Rank.EIGHT, Rank.SEVEN, 1), + WHITE(2, Rank.ONE, Rank.TWO,-1), NEUTRAL(0); private int marker; private Rank piecesInitRank; private Rank pawnInitRank; + private int pawnDirection; - Team(int marker, Rank piecesRank, Rank pawnInitRank) { + Team(int marker, Rank piecesRank, Rank pawnInitRank, int pawnDirection) { this.marker = marker; this.piecesInitRank = piecesRank; this.pawnInitRank = pawnInitRank; + this.pawnDirection = pawnDirection; } Team(int marker) { this.marker = marker; diff --git a/src/test/java/chess/domain/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java index 109774c..c10656c 100644 --- a/src/test/java/chess/domain/piece/KingTest.java +++ b/src/test/java/chess/domain/piece/KingTest.java @@ -17,9 +17,9 @@ void testKingCreation() { //when // given assertThat(king1.getPiecePosition()).isEqualTo(new PiecePosition(File.E, Rank.ONE)); - assertThat(king1.getDisplayName()).isEqualTo("k"); + assertThat(king1.getDisplayName()).isEqualTo("K"); assertThat(king2.getPiecePosition()).isEqualTo(new PiecePosition(File.E, Rank.EIGHT)); - assertThat(king2.getDisplayName()).isEqualTo("K"); + assertThat(king2.getDisplayName()).isEqualTo("k"); } @Test From f3bf8d887041422cdc1fce66e650cd9523b6b7eb Mon Sep 17 00:00:00 2001 From: eunii Date: Wed, 18 Aug 2021 20:56:38 +0900 Subject: [PATCH 24/42] feat: Make Knight movable method --- src/main/java/chess/domain/piece/Knight.java | 9 +++++- src/main/java/chess/domain/piece/Pawn.java | 8 ++--- .../java/chess/domain/piece/KnightTest.java | 31 +++++++++++++++++++ 3 files changed, 43 insertions(+), 5 deletions(-) create mode 100644 src/test/java/chess/domain/piece/KnightTest.java diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index 9a62098..6f8f8f9 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -8,6 +8,13 @@ public Knight(Team team, PiecePosition piecePosition) { @Override public boolean movable(PiecePosition targetPosition) { - return false; + int originFile = this.piecePosition.getFile().getFilePosition(); + int originRank = this.piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + //상하좌우 한칸씩 + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + return (fileGap + rankGap == 3) && (fileGap == 1 || rankGap == 1); } } diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 2d6e664..1e08789 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -15,18 +15,18 @@ public boolean movable(PiecePosition targetPosition) { if (checkFirstMove()) { if (this.getTeam().equals(Team.BLACK)) { return ((originFile == targetFile) && (originRank - targetRank <= 2)) - || isDiagonal(originFile, originRank, targetFile, targetRank); + || canMoveDiagonalAndOneBlock(originFile, originRank, targetFile, targetRank); } if (this.getTeam().equals(Team.WHITE)) { return (originFile == targetFile) && (originRank - targetRank >= -2) - || isDiagonal(originFile, originRank, targetFile, targetRank); + || canMoveDiagonalAndOneBlock(originFile, originRank, targetFile, targetRank); } } //한칸 - return isDiagonal(originFile, originRank, targetFile, targetRank); + return canMoveDiagonalAndOneBlock(originFile, originRank, targetFile, targetRank); } - private boolean isDiagonal(int originFile, int originRank, int targetFile, int targetRank) { + private boolean canMoveDiagonalAndOneBlock(int originFile, int originRank, int targetFile, int targetRank) { return (originRank - targetRank == 1*this.getTeam().getPawnDirection()) && Math.abs(originFile - targetFile) <= 1; } diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java new file mode 100644 index 0000000..f58eeb6 --- /dev/null +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -0,0 +1,31 @@ +package chess.domain.piece; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +class KnightTest { + @Test + @DisplayName("나이트의 이동범위를 확인한다") + void testCanMoveKnight() { + //given + Knight knight = new Knight(Team.BLACK, new PiecePosition(File.D, Rank.FOUR)); + //when + + //then + assertThat(knight.movable(new PiecePosition(File.B, Rank.FIVE))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.C, Rank.SIX))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.E, Rank.SIX))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.F, Rank.FIVE))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.F, Rank.THREE))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.E, Rank.TWO))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.C, Rank.TWO))).isTrue(); + assertThat(knight.movable(new PiecePosition(File.B, Rank.THREE))).isTrue(); + + assertThat(knight.movable(new PiecePosition(File.B, Rank.SIX))).isFalse(); + assertThat(knight.movable(new PiecePosition(File.E, Rank.FOUR))).isFalse(); + } + +} \ No newline at end of file From dc73e31616b6bcd05a413b71482c08e8b82e0cf4 Mon Sep 17 00:00:00 2001 From: eunii Date: Wed, 18 Aug 2021 21:30:05 +0900 Subject: [PATCH 25/42] feat: Make havePieceOnStraightPath method --- README.md | 6 +-- src/main/java/chess/domain/piece/File.java | 2 +- .../java/chess/domain/plate/ChessPlate.java | 47 +++++++++++++++++++ src/main/java/chess/service/ChessService.java | 4 +- .../chess/domain/plate/ChessPlateTest.java | 27 +++++++++++ .../java/chess/service/ChessServiceTest.java | 3 +- 6 files changed, 80 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index c52ca71..eb81879 100644 --- a/README.md +++ b/README.md @@ -27,13 +27,13 @@ - [] bishop - [x] 대각선으로 n칸 이동범위 체크 - [] knight - - [] 사방중 한방향으로 한칸 & 양 대각선 중 한 방향으로 한칸 으로 이동범위 체크 + - [x] 사방중 한방향으로 한칸 & 양 대각선 중 한 방향으로 한칸 으로 이동범위 체크 - [] 상대 말 넘어감 - [] rook - [x] 상하좌우 n칸 이동 - [] pawn - - [] 첫회 한정: 2칸 상 이동 || 1칸 상 이동 - - [] 1칸 이동 + - [x] 첫회 한정: 2칸 상 이동 || 1칸 상 이동 + - [x] 1칸 이동 - [] 공격은 대각선으로만 - [x] 진영 diff --git a/src/main/java/chess/domain/piece/File.java b/src/main/java/chess/domain/piece/File.java index 35c853e..6a3f356 100644 --- a/src/main/java/chess/domain/piece/File.java +++ b/src/main/java/chess/domain/piece/File.java @@ -23,7 +23,7 @@ public enum File { this.filePosition = filePosition; } - public static File valueOfString(String fileMarker) { + public static File findBy(String fileMarker) { return Arrays.stream(File.values()) .filter(v -> v.fileMarker.equals(fileMarker)) .findFirst() diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 6a13c2e..f0b43f5 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -41,4 +41,51 @@ public void move(PiecePosition sposition, PiecePosition targPiecePosition){ // 가려는 곳이 상대편 말이거나, 비어있는지 체크 } + + public boolean havePieceOnStraightPath(PiecePosition piecePosition, PiecePosition targetPosition) { + if(plate.get(piecePosition) instanceof Knight) { + return true; + } + int originFile = piecePosition.getFile().getFilePosition(); + int originRank = piecePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); + + if(fileGap == 0) { + if(originRank < targetRank) { + for (int i = 1; i < rankGap -1; i++) { + Piece piece = plate.get(new PiecePosition(piecePosition.getFile(), Rank.findBy(String.valueOf(piecePosition.getRank().getRankPosition() + i)))); + return piece != null; + } + } + + if(originRank > targetRank) { + for (int i = 1; i < rankGap -1; i--) { + Piece piece = plate.get(new PiecePosition(piecePosition.getFile(), Rank.findBy(String.valueOf(piecePosition.getRank().getRankPosition() + i)))); + return piece != null; + } + } + } + + if(rankGap == 0) { + if(originFile < targetFile) { + for (int i = 1; i < fileGap -1; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(piecePosition.getFile().getFilePosition() + i)), piecePosition.getRank())); + return piece != null; + } + } + + if(originFile > targetFile) { + for (int i = 1; i < fileGap -1; i--) { + Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(piecePosition.getFile().getFilePosition() + i)), piecePosition.getRank())); + return piece != null; + } + } + } + + + return false; + } } diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java index 9bca402..65828db 100644 --- a/src/main/java/chess/service/ChessService.java +++ b/src/main/java/chess/service/ChessService.java @@ -6,8 +6,6 @@ import chess.domain.piece.Rank; import chess.domain.plate.ChessPlate; -import java.util.Optional; - public class ChessService { private static ChessPlate chessPlate= new ChessPlate(); public ChessPlate start() { @@ -17,7 +15,7 @@ public ChessPlate start() { public void move(String sourcePosition, String targetPosition) { String fileString = sourcePosition.substring(0,1); - File sourceFile = File.valueOfString(fileString); + File sourceFile = File.findBy(fileString); String rankString = sourcePosition.substring(1); Rank sourceRank = Rank.findBy(rankString); PiecePosition sourcePiecePosition = new PiecePosition(sourceFile, sourceRank); diff --git a/src/test/java/chess/domain/plate/ChessPlateTest.java b/src/test/java/chess/domain/plate/ChessPlateTest.java index 64248b3..87ab53c 100644 --- a/src/test/java/chess/domain/plate/ChessPlateTest.java +++ b/src/test/java/chess/domain/plate/ChessPlateTest.java @@ -1,5 +1,8 @@ package chess.domain.plate; +import chess.domain.piece.File; +import chess.domain.piece.PiecePosition; +import chess.domain.piece.Rank; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -16,4 +19,28 @@ void testCreateChessPlate() { //when,then assertThat(chessPlate.getAllPieces()).hasSize(32); } + + @Test + @DisplayName("직선 이동 범위 한칸 전의 경로까지 말이 있는지 확인") + void testCheckHavePieceOnStraightPath() { + //given + ChessPlate chessPlate = new ChessPlate(); + + boolean result = chessPlate.havePieceOnStraightPath(new PiecePosition(File.E, Rank.EIGHT), new PiecePosition(File.E, Rank.SIX)); + + //when,then + assertThat(result).isFalse(); + } + + @Test + @DisplayName("대각선 이동 범위 한칸 전의 경로까지 말이 있는지 확인") + void testCheckHavePieceOnDiagonalPath() { + //given + ChessPlate chessPlate = new ChessPlate(); + + boolean result = chessPlate.havePieceOnStraightPath(new PiecePosition(File.E, Rank.EIGHT), new PiecePosition(File.C, Rank.SIX)); + + //when,then + assertThat(result).isFalse(); + } } diff --git a/src/test/java/chess/service/ChessServiceTest.java b/src/test/java/chess/service/ChessServiceTest.java index 90c08aa..3b426b2 100644 --- a/src/test/java/chess/service/ChessServiceTest.java +++ b/src/test/java/chess/service/ChessServiceTest.java @@ -5,14 +5,13 @@ import org.junit.jupiter.api.Test; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; class ChessServiceTest { @Test @DisplayName("File 생성 테스트") void generateFileWithString() { //given - File a = File.valueOfString("b"); + File a = File.findBy("b"); //when From 8e3acb68cd4f0dc41ca329a630d5041651848344 Mon Sep 17 00:00:00 2001 From: eunii Date: Thu, 19 Aug 2021 19:26:09 +0900 Subject: [PATCH 26/42] refactor: remove Neutral Team --- src/main/java/chess/ChessApplication.java | 8 ++++++-- src/main/java/chess/domain/piece/Team.java | 6 +----- src/main/java/chess/domain/plate/ChessPlate.java | 4 ++-- src/main/java/chess/view/OutputView.java | 6 +++++- 4 files changed, 14 insertions(+), 10 deletions(-) diff --git a/src/main/java/chess/ChessApplication.java b/src/main/java/chess/ChessApplication.java index e751aad..7563773 100644 --- a/src/main/java/chess/ChessApplication.java +++ b/src/main/java/chess/ChessApplication.java @@ -1,12 +1,16 @@ package chess; import chess.controller.ChessController; +import chess.domain.plate.ChessPlate; +import chess.view.OutputView; public class ChessApplication { public static void main(String[] args) { - ChessController chessController = new ChessController(); - chessController.play(); +// ChessController chessController = new ChessController(); +// chessController.play(); + OutputView outputView = new OutputView(); + outputView.printChessPlate(new ChessPlate()); } } diff --git a/src/main/java/chess/domain/piece/Team.java b/src/main/java/chess/domain/piece/Team.java index 93932f1..44f646b 100644 --- a/src/main/java/chess/domain/piece/Team.java +++ b/src/main/java/chess/domain/piece/Team.java @@ -5,8 +5,7 @@ @Getter public enum Team { BLACK(1, Rank.EIGHT, Rank.SEVEN, 1), - WHITE(2, Rank.ONE, Rank.TWO,-1), - NEUTRAL(0); + WHITE(2, Rank.ONE, Rank.TWO,-1); private int marker; private Rank piecesInitRank; @@ -19,9 +18,6 @@ public enum Team { this.pawnInitRank = pawnInitRank; this.pawnDirection = pawnDirection; } - Team(int marker) { - this.marker = marker; - } public String displayName(String name) { if (this.equals(BLACK)) { return name.toUpperCase(); diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index f0b43f5..0d18f88 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -57,14 +57,14 @@ public boolean havePieceOnStraightPath(PiecePosition piecePosition, PiecePositio if(originRank < targetRank) { for (int i = 1; i < rankGap -1; i++) { Piece piece = plate.get(new PiecePosition(piecePosition.getFile(), Rank.findBy(String.valueOf(piecePosition.getRank().getRankPosition() + i)))); - return piece != null; + return piece !=null; } } if(originRank > targetRank) { for (int i = 1; i < rankGap -1; i--) { Piece piece = plate.get(new PiecePosition(piecePosition.getFile(), Rank.findBy(String.valueOf(piecePosition.getRank().getRankPosition() + i)))); - return piece != null; + return piece !=null; } } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 0f5581f..a1c0a49 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -16,7 +16,11 @@ public void printChessPlate(ChessPlate chessPlate) { .sorted(rankComparator::compare) .forEach(rank -> { for (File file : File.values()) { - System.out.print(chessPlate.getPlate().get(new PiecePosition(file, rank)).getDisplayName()); + if(chessPlate.getPlate().get(new PiecePosition(file, rank)) == null) { + System.out.print("."); + }else{ + System.out.print(chessPlate.getPlate().get(new PiecePosition(file, rank)).getDisplayName()); + } } System.out.println(); }); From 98d725bb1e80c233ee66bb4bceac701a52d67fa4 Mon Sep 17 00:00:00 2001 From: eunii Date: Thu, 19 Aug 2021 19:59:41 +0900 Subject: [PATCH 27/42] feat: Make havePieceoOnDiagnalPath check method --- src/main/java/chess/domain/piece/File.java | 25 ++++--- src/main/java/chess/domain/piece/Rank.java | 7 ++ .../java/chess/domain/plate/ChessPlate.java | 65 ++++++++++++++++--- .../chess/domain/plate/ChessPlateTest.java | 7 +- 4 files changed, 84 insertions(+), 20 deletions(-) diff --git a/src/main/java/chess/domain/piece/File.java b/src/main/java/chess/domain/piece/File.java index 6a3f356..1fa68bd 100644 --- a/src/main/java/chess/domain/piece/File.java +++ b/src/main/java/chess/domain/piece/File.java @@ -6,14 +6,14 @@ @Getter public enum File { - A("a",1), - B("b",2), - C("c",3), - D("d",4), - E("e",5), - F("f",6), - G("g",7), - H("h",8); + A("a", 1), + B("b", 2), + C("c", 3), + D("d", 4), + E("e", 5), + F("f", 6), + G("g", 7), + H("h", 8); private String fileMarker; private int filePosition; @@ -27,6 +27,13 @@ public static File findBy(String fileMarker) { return Arrays.stream(File.values()) .filter(v -> v.fileMarker.equals(fileMarker)) .findFirst() - .orElseThrow(()->new IllegalAccessError("해당되는 위치가 없습니다.")); + .orElseThrow(() -> new IllegalAccessError("해당되는 위치가 없습니다.")); + } + + public static File findBy(int filePosition) { + return Arrays.stream(File.values()) + .filter(v -> v.filePosition==filePosition) + .findFirst() + .orElseThrow(() -> new IllegalAccessError("해당되는 위치가 없습니다.")); } } diff --git a/src/main/java/chess/domain/piece/Rank.java b/src/main/java/chess/domain/piece/Rank.java index d48792c..cde096a 100644 --- a/src/main/java/chess/domain/piece/Rank.java +++ b/src/main/java/chess/domain/piece/Rank.java @@ -27,4 +27,11 @@ public static Rank findBy(String rankPosition) { .findFirst() .orElseThrow(()->new IllegalAccessError("해당되는 위치가 없습니다.")); } + + public static Rank findBy(int rankPosition) { + return Arrays.stream(Rank.values()) + .filter(r -> r.rankPosition == rankPosition) + .findFirst() + .orElseThrow(()->new IllegalAccessError("해당되는 위치가 없습니다.")); + } } diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 0d18f88..d68cc70 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -42,12 +42,12 @@ public void move(PiecePosition sposition, PiecePosition targPiecePosition){ } - public boolean havePieceOnStraightPath(PiecePosition piecePosition, PiecePosition targetPosition) { - if(plate.get(piecePosition) instanceof Knight) { + public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePosition targetPosition) { + if(plate.get(sourcePosition) instanceof Knight) { return true; } - int originFile = piecePosition.getFile().getFilePosition(); - int originRank = piecePosition.getRank().getRankPosition(); + int originFile = sourcePosition.getFile().getFilePosition(); + int originRank = sourcePosition.getRank().getRankPosition(); int targetFile = targetPosition.getFile().getFilePosition(); int targetRank = targetPosition.getRank().getRankPosition(); int fileGap = Math.abs(originFile - targetFile); @@ -56,14 +56,14 @@ public boolean havePieceOnStraightPath(PiecePosition piecePosition, PiecePositio if(fileGap == 0) { if(originRank < targetRank) { for (int i = 1; i < rankGap -1; i++) { - Piece piece = plate.get(new PiecePosition(piecePosition.getFile(), Rank.findBy(String.valueOf(piecePosition.getRank().getRankPosition() + i)))); + Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); return piece !=null; } } if(originRank > targetRank) { for (int i = 1; i < rankGap -1; i--) { - Piece piece = plate.get(new PiecePosition(piecePosition.getFile(), Rank.findBy(String.valueOf(piecePosition.getRank().getRankPosition() + i)))); + Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); return piece !=null; } } @@ -72,20 +72,67 @@ public boolean havePieceOnStraightPath(PiecePosition piecePosition, PiecePositio if(rankGap == 0) { if(originFile < targetFile) { for (int i = 1; i < fileGap -1; i++) { - Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(piecePosition.getFile().getFilePosition() + i)), piecePosition.getRank())); + Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(sourcePosition.getFile().getFilePosition() + i)), sourcePosition.getRank())); return piece != null; } } if(originFile > targetFile) { for (int i = 1; i < fileGap -1; i--) { - Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(piecePosition.getFile().getFilePosition() + i)), piecePosition.getRank())); + Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(sourcePosition.getFile().getFilePosition() + i)), sourcePosition.getRank())); return piece != null; } } } + return true; + } + + public boolean havePieceOnDiagonalPath(PiecePosition sourcePosition, PiecePosition targetPosition) { + if(plate.get(sourcePosition) instanceof Knight) { + return true; + } + int originFile = sourcePosition.getFile().getFilePosition(); + int originRank = sourcePosition.getRank().getRankPosition(); + int targetFile = targetPosition.getFile().getFilePosition(); + int targetRank = targetPosition.getRank().getRankPosition(); + int fileGap = Math.abs(originFile - targetFile); + int rankGap = Math.abs(originRank - targetRank); - return false; + //좌상 + if(fileGap == rankGap && (targetFile < originFile && targetRank > originRank)) { + for (int i = 1; i < rankGap -1; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); + return piece !=null; + } + } + + //우상 + if(fileGap == rankGap && (targetFile > originFile && targetRank > originRank)) { + System.out.println("check right up"); + for (int i = 1; i < rankGap; i++) { + System.out.println("enter for loop"); + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); + System.out.println(piece == null); + return piece !=null; + } + } + + //우하 + if(fileGap == rankGap && (targetFile > originFile && targetRank < originRank)) { + for (int i = 1; i < rankGap -1; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); + return piece !=null; + } + } + + //좌하 + if(fileGap == rankGap && (targetFile < originFile && targetRank < originRank)) { + for (int i = 1; i < rankGap -1; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); + return piece !=null; + } + } + return true; } } diff --git a/src/test/java/chess/domain/plate/ChessPlateTest.java b/src/test/java/chess/domain/plate/ChessPlateTest.java index 87ab53c..ad3a9e1 100644 --- a/src/test/java/chess/domain/plate/ChessPlateTest.java +++ b/src/test/java/chess/domain/plate/ChessPlateTest.java @@ -38,9 +38,12 @@ void testCheckHavePieceOnDiagonalPath() { //given ChessPlate chessPlate = new ChessPlate(); - boolean result = chessPlate.havePieceOnStraightPath(new PiecePosition(File.E, Rank.EIGHT), new PiecePosition(File.C, Rank.SIX)); + boolean result = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.F, Rank.EIGHT), new PiecePosition(File.D, Rank.SIX)); + boolean result2 = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.A, Rank.TWO), new PiecePosition(File.C, Rank.FOUR)); + //when,then - assertThat(result).isFalse(); + assertThat(result).isTrue(); + assertThat(result2).isFalse(); } } From 5446c4a19ec214da5da58ea178b28c219437bfcb Mon Sep 17 00:00:00 2001 From: eunii Date: Thu, 19 Aug 2021 20:26:08 +0900 Subject: [PATCH 28/42] feat: chessPlate move method ongoing --- src/main/java/chess/domain/piece/Piece.java | 2 ++ .../java/chess/domain/plate/ChessPlate.java | 23 +++++++++++-------- .../chess/domain/plate/ChessPlateTest.java | 4 ++-- 3 files changed, 17 insertions(+), 12 deletions(-) diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index bff7c79..6b335ec 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -18,4 +18,6 @@ public Piece(String name, Team team, PiecePosition piecePosition) { public abstract boolean movable(PiecePosition targetPosition); +// public abstract Piece move(PiecePosition targetPosition); + } diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index d68cc70..fd4fdef 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -36,15 +36,20 @@ public Map arrangePieces() { return plate; } - public void move(PiecePosition sposition, PiecePosition targPiecePosition){ + public void move(PiecePosition sourcePosition, PiecePosition targetPosition){ //TO-DO 기물별 허용 움직임 범위인지 체크 + Piece piece = plate.get(sourcePosition); + if(piece.movable(targetPosition) && !havePieceOnStraightPath(sourcePosition, targetPosition) && havePieceOnDiagonalPath(sourcePosition, targetPosition)){ +// piece.move(targetPosition); + } + // 가려는 곳이 상대편 말이거나, 비어있는지 체크 } public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePosition targetPosition) { if(plate.get(sourcePosition) instanceof Knight) { - return true; + return false; } int originFile = sourcePosition.getFile().getFilePosition(); int originRank = sourcePosition.getRank().getRankPosition(); @@ -85,12 +90,12 @@ public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePositi } } - return true; + return false; } public boolean havePieceOnDiagonalPath(PiecePosition sourcePosition, PiecePosition targetPosition) { if(plate.get(sourcePosition) instanceof Knight) { - return true; + return false; } int originFile = sourcePosition.getFile().getFilePosition(); int originRank = sourcePosition.getRank().getRankPosition(); @@ -101,7 +106,7 @@ public boolean havePieceOnDiagonalPath(PiecePosition sourcePosition, PiecePositi //좌상 if(fileGap == rankGap && (targetFile < originFile && targetRank > originRank)) { - for (int i = 1; i < rankGap -1; i++) { + for (int i = 1; i < rankGap; i++) { Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); return piece !=null; } @@ -111,16 +116,14 @@ public boolean havePieceOnDiagonalPath(PiecePosition sourcePosition, PiecePositi if(fileGap == rankGap && (targetFile > originFile && targetRank > originRank)) { System.out.println("check right up"); for (int i = 1; i < rankGap; i++) { - System.out.println("enter for loop"); Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); - System.out.println(piece == null); return piece !=null; } } //우하 if(fileGap == rankGap && (targetFile > originFile && targetRank < originRank)) { - for (int i = 1; i < rankGap -1; i++) { + for (int i = 1; i < rankGap ; i++) { Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); return piece !=null; } @@ -128,11 +131,11 @@ public boolean havePieceOnDiagonalPath(PiecePosition sourcePosition, PiecePositi //좌하 if(fileGap == rankGap && (targetFile < originFile && targetRank < originRank)) { - for (int i = 1; i < rankGap -1; i++) { + for (int i = 1; i < rankGap; i++) { Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); return piece !=null; } } - return true; + return false; } } diff --git a/src/test/java/chess/domain/plate/ChessPlateTest.java b/src/test/java/chess/domain/plate/ChessPlateTest.java index ad3a9e1..1aecbd7 100644 --- a/src/test/java/chess/domain/plate/ChessPlateTest.java +++ b/src/test/java/chess/domain/plate/ChessPlateTest.java @@ -39,11 +39,11 @@ void testCheckHavePieceOnDiagonalPath() { ChessPlate chessPlate = new ChessPlate(); boolean result = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.F, Rank.EIGHT), new PiecePosition(File.D, Rank.SIX)); - boolean result2 = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.A, Rank.TWO), new PiecePosition(File.C, Rank.FOUR)); +// boolean result2 = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.A, Rank.TWO), new PiecePosition(File.C, Rank.FOUR)); //when,then assertThat(result).isTrue(); - assertThat(result2).isFalse(); +// assertThat(result2).isFalse(); } } From 66d4e374838d8f3c2f34c47e529ac1f113dce5c8 Mon Sep 17 00:00:00 2001 From: eunii Date: Thu, 19 Aug 2021 20:49:40 +0900 Subject: [PATCH 29/42] feat: make move method except pawn --- README.md | 14 +++++++------- src/main/java/chess/domain/piece/Piece.java | 4 +++- .../java/chess/domain/plate/ChessPlate.java | 17 +++++++++++------ .../java/chess/domain/piece/KnightTest.java | 2 ++ .../chess/domain/plate/ChessPlateTest.java | 19 +++++++++++++++++-- 5 files changed, 40 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index eb81879..346ce7e 100644 --- a/README.md +++ b/README.md @@ -19,17 +19,17 @@ - [] 기물 -- [] 말을 넘어갈 수 없음(나이트 제외) - - [] king +- [x] 말을 넘어갈 수 없음(나이트 제외) + - [x] king - [x] 상하좌우 중 1칸 이동범위 체크 - - [] queen + - [x] queen - [x] 상하좌우 대각선 n칸 이동범위 체크 - - [] bishop + - [x] bishop - [x] 대각선으로 n칸 이동범위 체크 - - [] knight + - [x] knight - [x] 사방중 한방향으로 한칸 & 양 대각선 중 한 방향으로 한칸 으로 이동범위 체크 - - [] 상대 말 넘어감 - - [] rook + - [x] 상대 말 넘어감 + - [x] rook - [x] 상하좌우 n칸 이동 - [] pawn - [x] 첫회 한정: 2칸 상 이동 || 1칸 상 이동 diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index 6b335ec..65e19c8 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -18,6 +18,8 @@ public Piece(String name, Team team, PiecePosition piecePosition) { public abstract boolean movable(PiecePosition targetPosition); -// public abstract Piece move(PiecePosition targetPosition); + public void move(PiecePosition targetPosition){ + piecePosition = targetPosition; + } } diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index fd4fdef..2a32d9f 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -36,15 +36,20 @@ public Map arrangePieces() { return plate; } - public void move(PiecePosition sourcePosition, PiecePosition targetPosition){ + public boolean move(PiecePosition sourcePosition, PiecePosition targetPosition){ //TO-DO 기물별 허용 움직임 범위인지 체크 Piece piece = plate.get(sourcePosition); - if(piece.movable(targetPosition) && !havePieceOnStraightPath(sourcePosition, targetPosition) && havePieceOnDiagonalPath(sourcePosition, targetPosition)){ -// piece.move(targetPosition); + if(piece.movable(targetPosition) && !havePieceOnStraightPath(sourcePosition, targetPosition) && !havePieceOnDiagonalPath(sourcePosition, targetPosition)){ + //이동 위치에 상대 말인지 /내말이 아닐 경우에만 이동한다 + Piece targetPiece = plate.get(targetPosition); + if (targetPiece != null && targetPiece.getTeam().equals(piece.getTeam())){ + return false; + } + plate.remove(sourcePosition); + piece.move(targetPosition); + return true; } - - // 가려는 곳이 상대편 말이거나, 비어있는지 체크 - + return false; } public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePosition targetPosition) { diff --git a/src/test/java/chess/domain/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java index f58eeb6..cb32952 100644 --- a/src/test/java/chess/domain/piece/KnightTest.java +++ b/src/test/java/chess/domain/piece/KnightTest.java @@ -12,6 +12,7 @@ class KnightTest { void testCanMoveKnight() { //given Knight knight = new Knight(Team.BLACK, new PiecePosition(File.D, Rank.FOUR)); + Knight knight1 = new Knight(Team.BLACK, new PiecePosition(File.G, Rank.EIGHT)); //when //then @@ -23,6 +24,7 @@ void testCanMoveKnight() { assertThat(knight.movable(new PiecePosition(File.E, Rank.TWO))).isTrue(); assertThat(knight.movable(new PiecePosition(File.C, Rank.TWO))).isTrue(); assertThat(knight.movable(new PiecePosition(File.B, Rank.THREE))).isTrue(); + assertThat(knight1.movable(new PiecePosition(File.F, Rank.SIX))).isTrue(); assertThat(knight.movable(new PiecePosition(File.B, Rank.SIX))).isFalse(); assertThat(knight.movable(new PiecePosition(File.E, Rank.FOUR))).isFalse(); diff --git a/src/test/java/chess/domain/plate/ChessPlateTest.java b/src/test/java/chess/domain/plate/ChessPlateTest.java index 1aecbd7..d9c24ef 100644 --- a/src/test/java/chess/domain/plate/ChessPlateTest.java +++ b/src/test/java/chess/domain/plate/ChessPlateTest.java @@ -39,11 +39,26 @@ void testCheckHavePieceOnDiagonalPath() { ChessPlate chessPlate = new ChessPlate(); boolean result = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.F, Rank.EIGHT), new PiecePosition(File.D, Rank.SIX)); -// boolean result2 = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.A, Rank.TWO), new PiecePosition(File.C, Rank.FOUR)); + boolean result2 = chessPlate.havePieceOnDiagonalPath(new PiecePosition(File.A, Rank.TWO), new PiecePosition(File.C, Rank.FOUR)); //when,then assertThat(result).isTrue(); -// assertThat(result2).isFalse(); + assertThat(result2).isFalse(); + } + + @Test + @DisplayName("체스말이 이동 가능하면 이동 후 true를 리턴한다") + void move() { + //given + ChessPlate chessPlate = new ChessPlate(); + //when + boolean result = chessPlate.move(new PiecePosition(File.A, Rank.EIGHT), new PiecePosition(File.B, Rank.EIGHT)); + boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); + //then + assertThat(result).isFalse(); + assertThat(result2).isTrue(); + + } } From 9b86fd311201ff13f64595e85d58c6f4198cc963 Mon Sep 17 00:00:00 2001 From: eunii Date: Thu, 19 Aug 2021 21:15:32 +0900 Subject: [PATCH 30/42] feat: Make pawn diagonal move rule --- .../java/chess/domain/plate/ChessPlate.java | 20 +++++++++++++++++++ .../chess/domain/plate/ChessPlateTest.java | 13 +++++++++++- 2 files changed, 32 insertions(+), 1 deletion(-) diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 2a32d9f..c5fbf03 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -39,12 +39,32 @@ public Map arrangePieces() { public boolean move(PiecePosition sourcePosition, PiecePosition targetPosition){ //TO-DO 기물별 허용 움직임 범위인지 체크 Piece piece = plate.get(sourcePosition); + Boolean isPawn = plate.get(sourcePosition) instanceof Pawn; if(piece.movable(targetPosition) && !havePieceOnStraightPath(sourcePosition, targetPosition) && !havePieceOnDiagonalPath(sourcePosition, targetPosition)){ //이동 위치에 상대 말인지 /내말이 아닐 경우에만 이동한다 Piece targetPiece = plate.get(targetPosition); if (targetPiece != null && targetPiece.getTeam().equals(piece.getTeam())){ return false; } + + if(isPawn) { + // 직선 이동 + if(sourcePosition.getFile().equals(targetPosition.getFile())) { + plate.remove(sourcePosition); + piece.move(targetPosition); + return plate.get(targetPosition) == null; + } + + // 대각선 이동 + if((Math.abs(sourcePosition.getFile().getFilePosition() - targetPosition.getFile().getFilePosition()) + == Math.abs(sourcePosition.getRank().getRankPosition() - targetPosition.getRank().getRankPosition())) + && (plate.get(targetPosition) != null && (plate.get(sourcePosition).getTeam() != plate.get(targetPosition).getTeam()))) { + plate.remove(sourcePosition); + piece.move(targetPosition); + return true; + } // end of if + return false; + } plate.remove(sourcePosition); piece.move(targetPosition); return true; diff --git a/src/test/java/chess/domain/plate/ChessPlateTest.java b/src/test/java/chess/domain/plate/ChessPlateTest.java index d9c24ef..2bf3f96 100644 --- a/src/test/java/chess/domain/plate/ChessPlateTest.java +++ b/src/test/java/chess/domain/plate/ChessPlateTest.java @@ -58,7 +58,18 @@ void move() { //then assertThat(result).isFalse(); assertThat(result2).isTrue(); + } - + @Test + @DisplayName("폰이 이동 가능하면 이동 후 true를 리턴한다") + void testPawnMove() { + //given + ChessPlate chessPlate = new ChessPlate(); + //when + boolean result = chessPlate.move(new PiecePosition(File.B, Rank.SEVEN), new PiecePosition(File.C, Rank.SIX)); +// boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); + //then + assertThat(result).isFalse(); +// assertThat(result2).isTrue(); } } From ba9d18c9501fec3cf407198f6e16d546a66574b4 Mon Sep 17 00:00:00 2001 From: eunii Date: Thu, 19 Aug 2021 21:40:27 +0900 Subject: [PATCH 31/42] feat: Make controller and service logic --- src/main/java/chess/ChessApplication.java | 6 ++---- .../java/chess/controller/ChessController.java | 11 +++++++++-- src/main/java/chess/domain/plate/ChessPlate.java | 7 +++++-- src/main/java/chess/service/ChessService.java | 15 ++++++++++++--- src/main/java/chess/view/OutputView.java | 4 ++++ 5 files changed, 32 insertions(+), 11 deletions(-) diff --git a/src/main/java/chess/ChessApplication.java b/src/main/java/chess/ChessApplication.java index 7563773..05854ee 100644 --- a/src/main/java/chess/ChessApplication.java +++ b/src/main/java/chess/ChessApplication.java @@ -7,10 +7,8 @@ public class ChessApplication { public static void main(String[] args) { -// ChessController chessController = new ChessController(); -// chessController.play(); - OutputView outputView = new OutputView(); - outputView.printChessPlate(new ChessPlate()); + ChessController chessController = new ChessController(); + chessController.play(); } } diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index 6d9ca44..6e84934 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -1,5 +1,6 @@ package chess.controller; +import chess.domain.plate.ChessPlate; import chess.service.ChessService; import chess.view.InputView; import chess.view.OutputView; @@ -23,12 +24,18 @@ public void play() { private void checkCommadMessage(ChessService chessService, String command) { if(command.equals(START)){ - chessService.start(); + ChessPlate chessplate = chessService.start(); + outputView.printChessPlate(chessplate); } if(command.startsWith(MOVE)) { String[] position = command.split(" "); - chessService.move(position[1],position[2]); + boolean isMoved = chessService.move(position[1],position[2]); + if(isMoved) { + outputView.printChessPlate(chessService.getChessPlate()); + }else { + outputView.printCannotMoveMessage(); + } } } diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index c5fbf03..691a199 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -49,10 +49,11 @@ public boolean move(PiecePosition sourcePosition, PiecePosition targetPosition){ if(isPawn) { // 직선 이동 - if(sourcePosition.getFile().equals(targetPosition.getFile())) { + if((sourcePosition.getFile().equals(targetPosition.getFile())) && plate.get(targetPosition) == null) { plate.remove(sourcePosition); piece.move(targetPosition); - return plate.get(targetPosition) == null; + plate.put(piece.getPiecePosition(), piece); + return true; } // 대각선 이동 @@ -61,12 +62,14 @@ public boolean move(PiecePosition sourcePosition, PiecePosition targetPosition){ && (plate.get(targetPosition) != null && (plate.get(sourcePosition).getTeam() != plate.get(targetPosition).getTeam()))) { plate.remove(sourcePosition); piece.move(targetPosition); + plate.put(piece.getPiecePosition(), piece); return true; } // end of if return false; } plate.remove(sourcePosition); piece.move(targetPosition); + plate.put(piece.getPiecePosition(), piece); return true; } return false; diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java index 65828db..ebcde02 100644 --- a/src/main/java/chess/service/ChessService.java +++ b/src/main/java/chess/service/ChessService.java @@ -5,25 +5,34 @@ import chess.domain.piece.PiecePosition; import chess.domain.piece.Rank; import chess.domain.plate.ChessPlate; +import lombok.Getter; +@Getter public class ChessService { - private static ChessPlate chessPlate= new ChessPlate(); + private ChessPlate chessPlate= new ChessPlate(); public ChessPlate start() { this.chessPlate = new ChessPlate(); return chessPlate; } - public void move(String sourcePosition, String targetPosition) { + public boolean move(String sourcePosition, String targetPosition) { String fileString = sourcePosition.substring(0,1); File sourceFile = File.findBy(fileString); String rankString = sourcePosition.substring(1); Rank sourceRank = Rank.findBy(rankString); + + String targetFileString = targetPosition.substring(0,1); + File targetFile = File.findBy(targetFileString); + String targetRankString = targetPosition.substring(1); + Rank targetRank = Rank.findBy(targetRankString); + PiecePosition sourcePiecePosition = new PiecePosition(sourceFile, sourceRank); + PiecePosition targetPiecePosition = new PiecePosition(targetFile, targetRank); Piece source = chessPlate.getAllPieces().stream() .filter(piece -> piece.getPiecePosition().equals(sourcePiecePosition)) .findFirst() .orElseThrow(() -> new IllegalArgumentException("해당 위치에 기물이 없습니다")); - + return chessPlate.move(sourcePiecePosition, targetPiecePosition); } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index a1c0a49..0607f10 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -37,5 +37,9 @@ public void printInCorrectCommandMessage(){ System.out.println("start/end/move 중 하나를 입력해주세요"); } + public void printCannotMoveMessage() { + System.out.println("기물을 움직일 수 없습니다."); + } + } From a22ce551324ffe6a410ee3ff12cb854fc6cbd0b9 Mon Sep 17 00:00:00 2001 From: eunii Date: Thu, 19 Aug 2021 21:46:50 +0900 Subject: [PATCH 32/42] feat: Add score to pieces --- src/main/java/chess/domain/piece/Bishop.java | 4 ++++ src/main/java/chess/domain/piece/Knight.java | 4 ++++ src/main/java/chess/domain/piece/Pawn.java | 4 ++++ src/main/java/chess/domain/piece/Queen.java | 4 ++++ src/main/java/chess/domain/piece/Rook.java | 4 ++++ 5 files changed, 20 insertions(+) diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 392438c..651fea0 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -1,6 +1,10 @@ package chess.domain.piece; +import lombok.Getter; + +@Getter public class Bishop extends Piece { + private final double score = 3; public Bishop(Team team, PiecePosition piecePosition) { super("B", team, piecePosition); diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index 6f8f8f9..ebb7c51 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -1,6 +1,10 @@ package chess.domain.piece; +import lombok.Getter; + +@Getter public class Knight extends Piece { + private final double score = 2.5; public Knight(Team team, PiecePosition piecePosition) { super("N", team, piecePosition); diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index 1e08789..bc7c119 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -1,6 +1,10 @@ package chess.domain.piece; +import lombok.Getter; + +@Getter public class Pawn extends Piece { + private final double score = 1; public Pawn(Team team, PiecePosition piecePosition) { super("P", team, piecePosition); } diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index ea8d2d4..4ad744a 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -1,6 +1,10 @@ package chess.domain.piece; +import lombok.Getter; + +@Getter public class Queen extends Piece { + private final double score = 9; public Queen(Team team, PiecePosition pieceposition) { super("Q", team, pieceposition); diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index 36d13f3..d497f9f 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -1,6 +1,10 @@ package chess.domain.piece; +import lombok.Getter; + +@Getter public class Rook extends Piece { + private final double score = 5; public Rook(Team team, PiecePosition piecePosition) { super("R", team, piecePosition); From 11d31f71f41fc0632737787841cafc67d7d139a0 Mon Sep 17 00:00:00 2001 From: eunii Date: Thu, 19 Aug 2021 21:59:30 +0900 Subject: [PATCH 33/42] feat: Make print score method --- src/main/java/chess/domain/piece/Bishop.java | 4 +--- src/main/java/chess/domain/piece/King.java | 2 +- src/main/java/chess/domain/piece/Knight.java | 4 +--- src/main/java/chess/domain/piece/Pawn.java | 3 +-- src/main/java/chess/domain/piece/Piece.java | 4 +++- src/main/java/chess/domain/piece/Queen.java | 4 +--- src/main/java/chess/domain/piece/Rook.java | 4 +--- src/main/java/chess/service/ChessService.java | 23 +++++++++++++++---- .../java/chess/service/ChessServiceTest.java | 10 ++++++++ 9 files changed, 38 insertions(+), 20 deletions(-) diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java index 651fea0..2b44830 100644 --- a/src/main/java/chess/domain/piece/Bishop.java +++ b/src/main/java/chess/domain/piece/Bishop.java @@ -4,10 +4,8 @@ @Getter public class Bishop extends Piece { - private final double score = 3; - public Bishop(Team team, PiecePosition piecePosition) { - super("B", team, piecePosition); + super("B", team, piecePosition,3); } @Override diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java index 98f37f7..379d556 100644 --- a/src/main/java/chess/domain/piece/King.java +++ b/src/main/java/chess/domain/piece/King.java @@ -2,7 +2,7 @@ public class King extends Piece { public King(Team team, PiecePosition piecePosition) { - super("K", team, piecePosition); + super("K", team, piecePosition, 0); } @Override diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java index ebb7c51..6e07215 100644 --- a/src/main/java/chess/domain/piece/Knight.java +++ b/src/main/java/chess/domain/piece/Knight.java @@ -4,10 +4,8 @@ @Getter public class Knight extends Piece { - private final double score = 2.5; - public Knight(Team team, PiecePosition piecePosition) { - super("N", team, piecePosition); + super("N", team, piecePosition, 2.5); } @Override diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java index bc7c119..3ff99bc 100644 --- a/src/main/java/chess/domain/piece/Pawn.java +++ b/src/main/java/chess/domain/piece/Pawn.java @@ -4,9 +4,8 @@ @Getter public class Pawn extends Piece { - private final double score = 1; public Pawn(Team team, PiecePosition piecePosition) { - super("P", team, piecePosition); + super("P", team, piecePosition,1); } @Override diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java index 65e19c8..2cbd2b3 100644 --- a/src/main/java/chess/domain/piece/Piece.java +++ b/src/main/java/chess/domain/piece/Piece.java @@ -8,12 +8,14 @@ public abstract class Piece { protected Team team; protected PiecePosition piecePosition; protected String displayName; + protected double score; - public Piece(String name, Team team, PiecePosition piecePosition) { + public Piece(String name, Team team, PiecePosition piecePosition, double score) { this.name = name; this.team = team; this.displayName = team.displayName(name); this.piecePosition = piecePosition; + this.score = score; } public abstract boolean movable(PiecePosition targetPosition); diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java index 4ad744a..4429386 100644 --- a/src/main/java/chess/domain/piece/Queen.java +++ b/src/main/java/chess/domain/piece/Queen.java @@ -4,10 +4,8 @@ @Getter public class Queen extends Piece { - private final double score = 9; - public Queen(Team team, PiecePosition pieceposition) { - super("Q", team, pieceposition); + super("Q", team, pieceposition, 9); } @Override diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java index d497f9f..e7dad21 100644 --- a/src/main/java/chess/domain/piece/Rook.java +++ b/src/main/java/chess/domain/piece/Rook.java @@ -4,10 +4,8 @@ @Getter public class Rook extends Piece { - private final double score = 5; - public Rook(Team team, PiecePosition piecePosition) { - super("R", team, piecePosition); + super("R", team, piecePosition, 5); } @Override diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java index ebcde02..5fbdcdd 100644 --- a/src/main/java/chess/service/ChessService.java +++ b/src/main/java/chess/service/ChessService.java @@ -1,12 +1,11 @@ package chess.service; -import chess.domain.piece.File; -import chess.domain.piece.Piece; -import chess.domain.piece.PiecePosition; -import chess.domain.piece.Rank; +import chess.domain.piece.*; import chess.domain.plate.ChessPlate; import lombok.Getter; +import java.util.ArrayList; + @Getter public class ChessService { private ChessPlate chessPlate= new ChessPlate(); @@ -35,4 +34,20 @@ public boolean move(String sourcePosition, String targetPosition) { return chessPlate.move(sourcePiecePosition, targetPiecePosition); } + + public ArrayList getGameScore() { + ArrayList result = new ArrayList<>(); + result.add(chessPlate.getPlate().values().stream() + .filter(piece -> piece.getTeam().equals(Team.BLACK)) + .mapToDouble(piece -> piece.getScore()) + .sum()); + + result.add(chessPlate.getPlate().values().stream() + .filter(piece -> piece.getTeam().equals(Team.WHITE)) + .mapToDouble(piece -> piece.getScore()) + .sum()); + + return result; + } + } diff --git a/src/test/java/chess/service/ChessServiceTest.java b/src/test/java/chess/service/ChessServiceTest.java index 3b426b2..6012764 100644 --- a/src/test/java/chess/service/ChessServiceTest.java +++ b/src/test/java/chess/service/ChessServiceTest.java @@ -19,4 +19,14 @@ void generateFileWithString() { assertThat(a.getFileMarker()).isEqualTo("b"); assertThat(a.getFilePosition()).isEqualTo(2); } + + @Test + @DisplayName("진영별 점수를 계산한다.") + void () { + //given + + //when + + //then + } } \ No newline at end of file From e693b9c3162e4c6942c68f83a80b5b7e5352c477 Mon Sep 17 00:00:00 2001 From: eunii Date: Fri, 20 Aug 2021 19:38:32 +0900 Subject: [PATCH 34/42] feat: make calculateDuplicatedPawn Method --- src/main/java/chess/service/ChessService.java | 19 ++++++++++++++ .../java/chess/service/ChessServiceTest.java | 26 ++++++++++++++++--- 2 files changed, 42 insertions(+), 3 deletions(-) diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java index 5fbdcdd..3836f13 100644 --- a/src/main/java/chess/service/ChessService.java +++ b/src/main/java/chess/service/ChessService.java @@ -5,6 +5,9 @@ import lombok.Getter; import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; @Getter public class ChessService { @@ -50,4 +53,20 @@ public ArrayList getGameScore() { return result; } + public double calculatePawnScore(Team team){ + Map> pawnAlign = + chessPlate.getPlate().values().stream() + .filter(piece -> piece instanceof Pawn) + .filter(piece -> piece.getTeam().equals(team)) + .collect(Collectors.groupingBy(piece -> piece.getPiecePosition().getFile(), + Collectors.mapping(Piece::getName, Collectors.toList()))); + double score = 0; + for (List a : pawnAlign.values()) { + if(a.size()>=2){ + score=+a.size(); + } + } + return score*0.5; + } + } diff --git a/src/test/java/chess/service/ChessServiceTest.java b/src/test/java/chess/service/ChessServiceTest.java index 6012764..770844d 100644 --- a/src/test/java/chess/service/ChessServiceTest.java +++ b/src/test/java/chess/service/ChessServiceTest.java @@ -1,6 +1,6 @@ package chess.service; -import chess.domain.piece.File; +import chess.domain.piece.*; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -21,12 +21,32 @@ void generateFileWithString() { } @Test - @DisplayName("진영별 점수를 계산한다.") - void () { + @DisplayName("진영별 점수를 계산한다") + void testGetScore() { //given //when //then } + + @Test + @DisplayName("같은 파일에 있는 폰의 갯수를 리턴한다") + void testCalculatePawnScore() { + //given + ChessService service = new ChessService(); + ChessService service2 = new ChessService(); + service2.move("e2","e4"); + service2.move("e4","e5"); + service2.move("e5","e6"); + service2.move("f7","e6"); + + //when + double score = service.calculatePawnScore(Team.BLACK); + double score2 = service2.calculatePawnScore(Team.BLACK); + + //then + assertThat(score).isEqualTo(0); + assertThat(score2).isEqualTo(1); + } } \ No newline at end of file From 83119aafb6048945b7a6d72cc1e58792bc7d0614 Mon Sep 17 00:00:00 2001 From: eunii Date: Fri, 20 Aug 2021 19:52:42 +0900 Subject: [PATCH 35/42] refactor: Modify getScore Method --- src/main/java/chess/service/ChessService.java | 16 +++++----------- .../java/chess/service/ChessServiceTest.java | 8 ++++++++ 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java index 3836f13..510c207 100644 --- a/src/main/java/chess/service/ChessService.java +++ b/src/main/java/chess/service/ChessService.java @@ -38,19 +38,13 @@ public boolean move(String sourcePosition, String targetPosition) { return chessPlate.move(sourcePiecePosition, targetPiecePosition); } - public ArrayList getGameScore() { - ArrayList result = new ArrayList<>(); - result.add(chessPlate.getPlate().values().stream() - .filter(piece -> piece.getTeam().equals(Team.BLACK)) - .mapToDouble(piece -> piece.getScore()) - .sum()); + public double getGameScore(Team team) { - result.add(chessPlate.getPlate().values().stream() - .filter(piece -> piece.getTeam().equals(Team.WHITE)) + return chessPlate.getPlate().values().stream() + .filter(piece -> piece != null) + .filter(piece -> piece.getTeam().equals(team)) .mapToDouble(piece -> piece.getScore()) - .sum()); - - return result; + .sum() - calculatePawnScore(team); } public double calculatePawnScore(Team team){ diff --git a/src/test/java/chess/service/ChessServiceTest.java b/src/test/java/chess/service/ChessServiceTest.java index 770844d..47bfff9 100644 --- a/src/test/java/chess/service/ChessServiceTest.java +++ b/src/test/java/chess/service/ChessServiceTest.java @@ -24,10 +24,18 @@ void generateFileWithString() { @DisplayName("진영별 점수를 계산한다") void testGetScore() { //given + ChessService service = new ChessService(); + service.start(); + service.move("e2","e4"); + service.move("e4","e5"); + service.move("e5","e6"); + service.move("f7","e6"); //when //then + assertThat(service.getGameScore(Team.BLACK)).isEqualTo(37); + assertThat(service.getGameScore(Team.WHITE)).isEqualTo(37); } @Test From a4076d6e61b8078febb5e66057b0bbb708994902 Mon Sep 17 00:00:00 2001 From: eunii Date: Fri, 20 Aug 2021 21:24:22 +0900 Subject: [PATCH 36/42] refactor: Fix havePieceOnStraight bug --- .../java/chess/domain/plate/ChessPlate.java | 155 +++++++++++------- .../chess/domain/plate/ChessPlateTest.java | 17 +- 2 files changed, 105 insertions(+), 67 deletions(-) diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 691a199..0c5b42b 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -9,7 +9,7 @@ @Getter public class ChessPlate { - private static final String BLANK ="."; + private static final String BLANK = "."; private Map plate = new HashMap<>(); private List allPieces = new LinkedList<>(); @@ -24,10 +24,10 @@ public ChessPlate() { public Map arrangePieces() { RankComparator rankComparator = new RankComparator(); - for (Rank rank: Rank.values()) { + for (Rank rank : Rank.values()) { for (File file : File.values()) { // plate.put(new PiecePosition(file, rank), new Piece(".",Team.BLACK, new PiecePosition(file,rank))); - plate.put(new PiecePosition(file, rank), null); + plate.put(new PiecePosition(file, rank), null); } } allPieces.forEach(piece -> { @@ -36,47 +36,62 @@ public Map arrangePieces() { return plate; } - public boolean move(PiecePosition sourcePosition, PiecePosition targetPosition){ + + public boolean move(PiecePosition sourcePosition, PiecePosition targetPosition) { //TO-DO 기물별 허용 움직임 범위인지 체크 - Piece piece = plate.get(sourcePosition); - Boolean isPawn = plate.get(sourcePosition) instanceof Pawn; - if(piece.movable(targetPosition) && !havePieceOnStraightPath(sourcePosition, targetPosition) && !havePieceOnDiagonalPath(sourcePosition, targetPosition)){ - //이동 위치에 상대 말인지 /내말이 아닐 경우에만 이동한다 - Piece targetPiece = plate.get(targetPosition); - if (targetPiece != null && targetPiece.getTeam().equals(piece.getTeam())){ - return false; - } + Piece sourcePiece = plate.get(sourcePosition); + if (!movable(sourcePosition, targetPosition, sourcePiece)) { + return false; + } - if(isPawn) { - // 직선 이동 - if((sourcePosition.getFile().equals(targetPosition.getFile())) && plate.get(targetPosition) == null) { - plate.remove(sourcePosition); - piece.move(targetPosition); - plate.put(piece.getPiecePosition(), piece); - return true; - } + //이동 위치에 상대 말인지 /내말이 아닐 경우에만 이동한다 + Piece targetPiece = plate.get(targetPosition); + if (targetPiece != null && targetPiece.getTeam().equals(sourcePiece.getTeam())) { + return false; + } - // 대각선 이동 - if((Math.abs(sourcePosition.getFile().getFilePosition() - targetPosition.getFile().getFilePosition()) - == Math.abs(sourcePosition.getRank().getRankPosition() - targetPosition.getRank().getRankPosition())) - && (plate.get(targetPosition) != null && (plate.get(sourcePosition).getTeam() != plate.get(targetPosition).getTeam()))) { - plate.remove(sourcePosition); - piece.move(targetPosition); - plate.put(piece.getPiecePosition(), piece); - return true; - } // end of if - return false; + if (sourcePiece instanceof Pawn) { + // 직선 이동 + if (isStraightMoving(sourcePosition, targetPosition) && targetPiece == null) { + executeMove(sourcePosition, targetPosition, sourcePiece); + return true; } - plate.remove(sourcePosition); - piece.move(targetPosition); - plate.put(piece.getPiecePosition(), piece); - return true; + + // 대각선 이동 + if (isDiagonalMoving(sourcePosition, targetPosition, sourcePiece, targetPiece)) { + executeMove(sourcePosition, targetPosition, sourcePiece); + return true; + } // end of if + return false; } - return false; + executeMove(sourcePosition, targetPosition, sourcePiece); + return true; + } + + private void executeMove(PiecePosition sourcePosition, PiecePosition targetPosition, Piece sourcePiece) { + plate.remove(sourcePosition); + sourcePiece.move(targetPosition); + plate.put(sourcePiece.getPiecePosition(), sourcePiece); + } + + private boolean isStraightMoving(PiecePosition sourcePosition, PiecePosition targetPosition) { + return sourcePosition.getFile().equals(targetPosition.getFile()); + } + + private boolean isDiagonalMoving(PiecePosition sourcePosition, PiecePosition targetPosition, Piece sourcePiece, Piece targetPiece) { + int fileGapAbs = Math.abs(sourcePosition.getFile().getFilePosition() - targetPosition.getFile().getFilePosition()); + int rankGapAbs = Math.abs(sourcePosition.getRank().getRankPosition() - targetPosition.getRank().getRankPosition()); + boolean isTargetEnemy = targetPiece != null && (sourcePiece.getTeam() != targetPiece.getTeam()); + return (fileGapAbs == rankGapAbs) && (isTargetEnemy); + } + + private boolean movable(PiecePosition sourcePosition, PiecePosition targetPosition, Piece piece) { + boolean haveNoPieceOnRoad = !havePieceOnStraightPath(sourcePosition, targetPosition) && !havePieceOnDiagonalPath(sourcePosition, targetPosition); + return piece.movable(targetPosition) && haveNoPieceOnRoad; } public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePosition targetPosition) { - if(plate.get(sourcePosition) instanceof Knight) { + if (plate.get(sourcePosition) instanceof Knight) { return false; } int originFile = sourcePosition.getFile().getFilePosition(); @@ -86,34 +101,42 @@ public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePositi int fileGap = Math.abs(originFile - targetFile); int rankGap = Math.abs(originRank - targetRank); - if(fileGap == 0) { - if(originRank < targetRank) { - for (int i = 1; i < rankGap -1; i++) { + if (fileGap == 0) { + if (originRank < targetRank) { + for (int i = 1; i < rankGap; i++) { Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); - return piece !=null; + if (piece != null) { + return true; + } } } - if(originRank > targetRank) { - for (int i = 1; i < rankGap -1; i--) { - Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); - return piece !=null; + if (originRank > targetRank) { + for (int i = 1; i < rankGap; i++) { + Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); + if (piece != null) { + return true; + } } } } - if(rankGap == 0) { - if(originFile < targetFile) { - for (int i = 1; i < fileGap -1; i++) { + if (rankGap == 0) { + if (originFile < targetFile) { + for (int i = 1; i < fileGap; i++) { Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(sourcePosition.getFile().getFilePosition() + i)), sourcePosition.getRank())); - return piece != null; + if (piece != null) { + return true; + } } } - if(originFile > targetFile) { - for (int i = 1; i < fileGap -1; i--) { - Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(sourcePosition.getFile().getFilePosition() + i)), sourcePosition.getRank())); - return piece != null; + if (originFile > targetFile) { + for (int i = 1; i < fileGap; i++) { + Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(sourcePosition.getFile().getFilePosition() - i)), sourcePosition.getRank())); + if (piece != null) { + return true; + } } } } @@ -122,7 +145,7 @@ public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePositi } public boolean havePieceOnDiagonalPath(PiecePosition sourcePosition, PiecePosition targetPosition) { - if(plate.get(sourcePosition) instanceof Knight) { + if (plate.get(sourcePosition) instanceof Knight) { return false; } int originFile = sourcePosition.getFile().getFilePosition(); @@ -133,35 +156,43 @@ public boolean havePieceOnDiagonalPath(PiecePosition sourcePosition, PiecePositi int rankGap = Math.abs(originRank - targetRank); //좌상 - if(fileGap == rankGap && (targetFile < originFile && targetRank > originRank)) { + if (fileGap == rankGap && (targetFile < originFile && targetRank > originRank)) { for (int i = 1; i < rankGap; i++) { Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); - return piece !=null; + if (piece != null) { + return true; + } } } //우상 - if(fileGap == rankGap && (targetFile > originFile && targetRank > originRank)) { + if (fileGap == rankGap && (targetFile > originFile && targetRank > originRank)) { System.out.println("check right up"); for (int i = 1; i < rankGap; i++) { Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); - return piece !=null; + if (piece != null) { + return true; + } } } //우하 - if(fileGap == rankGap && (targetFile > originFile && targetRank < originRank)) { - for (int i = 1; i < rankGap ; i++) { + if (fileGap == rankGap && (targetFile > originFile && targetRank < originRank)) { + for (int i = 1; i < rankGap; i++) { Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); - return piece !=null; + if (piece != null) { + return true; + } } } //좌하 - if(fileGap == rankGap && (targetFile < originFile && targetRank < originRank)) { + if (fileGap == rankGap && (targetFile < originFile && targetRank < originRank)) { for (int i = 1; i < rankGap; i++) { Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); - return piece !=null; + if (piece != null) { + return true; + } } } return false; diff --git a/src/test/java/chess/domain/plate/ChessPlateTest.java b/src/test/java/chess/domain/plate/ChessPlateTest.java index 2bf3f96..01c1280 100644 --- a/src/test/java/chess/domain/plate/ChessPlateTest.java +++ b/src/test/java/chess/domain/plate/ChessPlateTest.java @@ -27,9 +27,13 @@ void testCheckHavePieceOnStraightPath() { ChessPlate chessPlate = new ChessPlate(); boolean result = chessPlate.havePieceOnStraightPath(new PiecePosition(File.E, Rank.EIGHT), new PiecePosition(File.E, Rank.SIX)); + boolean result2 = chessPlate.havePieceOnStraightPath(new PiecePosition(File.A, Rank.ONE), new PiecePosition(File.A, Rank.THREE)); + boolean result3 = chessPlate.havePieceOnStraightPath(new PiecePosition(File.H, Rank.SEVEN), new PiecePosition(File.H, Rank.FIVE)); //when,then - assertThat(result).isFalse(); + assertThat(result).isTrue(); + assertThat(result2).isTrue(); + assertThat(result3).isFalse(); } @Test @@ -53,11 +57,14 @@ void move() { //given ChessPlate chessPlate = new ChessPlate(); //when - boolean result = chessPlate.move(new PiecePosition(File.A, Rank.EIGHT), new PiecePosition(File.B, Rank.EIGHT)); - boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); +// boolean result = chessPlate.move(new PiecePosition(File.A, Rank.EIGHT), new PiecePosition(File.B, Rank.EIGHT)); +// boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); + boolean result3 = chessPlate.move(new PiecePosition(File.A, Rank.ONE), new PiecePosition(File.A, Rank.THREE)); + //then - assertThat(result).isFalse(); - assertThat(result2).isTrue(); +// assertThat(result).isFalse(); +// assertThat(result2).isTrue(); + assertThat(result3).isFalse(); } @Test From 90167da1e12f680a7acae2a45cbead33be66969f Mon Sep 17 00:00:00 2001 From: eunii Date: Fri, 20 Aug 2021 21:37:55 +0900 Subject: [PATCH 37/42] doc: Modify readme --- README.md | 23 ++++++++++--------- .../java/chess/domain/plate/ChessPlate.java | 8 +++---- 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/README.md b/README.md index 346ce7e..baa82f2 100644 --- a/README.md +++ b/README.md @@ -1,24 +1,24 @@ # java-chess 게임 -- [] 체스판 +- [x] 체스판 - [x]rank(세로) : 8 :1~8 - [x]file(가로) : 8 :a~h - [x] 말이 없는 칸은 . - [x]초기화 - - [] 기물 이동기능 + - [x] 기물 이동기능 -- [] 아웃풋 뷰 - - [] 체스판 출력 기능 +- [x] 아웃풋 뷰 + - [x] 체스판 출력 기능 - [x] 'start' 입력 시 체스판 초기화 하고 출력 - - [] 게임 진행시 마다 체스판을 출력해준다 + - [x] 게임 진행시 마다 체스판을 출력해준다 - [x] 게임 시작 설명 출력 --[] 인풋 뷰 +-[x] 인풋 뷰 - [x] 게임 명령어 인풋 받기 - [x] start/end/move로 시작하지 않으면 계속 묻기 -- [] 기물 +- [x] 기물 - [x] 말을 넘어갈 수 없음(나이트 제외) - [x] king - [x] 상하좌우 중 1칸 이동범위 체크 @@ -31,14 +31,15 @@ - [x] 상대 말 넘어감 - [x] rook - [x] 상하좌우 n칸 이동 - - [] pawn + - [x] pawn - [x] 첫회 한정: 2칸 상 이동 || 1칸 상 이동 - [x] 1칸 이동 - - [] 공격은 대각선으로만 + - [x] 공격은 대각선으로만 - [x] 진영 - [x] 기물 2 세트 생성 (1개는 대문자, 소문자) -- [x] 체스 게임 룰 +- [] 체스 게임 룰 - [x] start : 체스판 초기화 및 진영 세팅 - - [x] end: 게임 종료 \ No newline at end of file + - [x] end: 게임 종료 + - [] 킹을 잡으면 게임이 종료된다 \ No newline at end of file diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 0c5b42b..3d54869 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -104,7 +104,7 @@ public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePositi if (fileGap == 0) { if (originRank < targetRank) { for (int i = 1; i < rankGap; i++) { - Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() + i)))); + Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(sourcePosition.getRank().getRankPosition() + i))); if (piece != null) { return true; } @@ -113,7 +113,7 @@ public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePositi if (originRank > targetRank) { for (int i = 1; i < rankGap; i++) { - Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(String.valueOf(sourcePosition.getRank().getRankPosition() - i)))); + Piece piece = plate.get(new PiecePosition(sourcePosition.getFile(), Rank.findBy(sourcePosition.getRank().getRankPosition() - i))); if (piece != null) { return true; } @@ -124,7 +124,7 @@ public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePositi if (rankGap == 0) { if (originFile < targetFile) { for (int i = 1; i < fileGap; i++) { - Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(sourcePosition.getFile().getFilePosition() + i)), sourcePosition.getRank())); + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() + i), sourcePosition.getRank())); if (piece != null) { return true; } @@ -133,7 +133,7 @@ public boolean havePieceOnStraightPath(PiecePosition sourcePosition, PiecePositi if (originFile > targetFile) { for (int i = 1; i < fileGap; i++) { - Piece piece = plate.get(new PiecePosition(File.findBy(String.valueOf(sourcePosition.getFile().getFilePosition() - i)), sourcePosition.getRank())); + Piece piece = plate.get(new PiecePosition(File.findBy(sourcePosition.getFile().getFilePosition() - i), sourcePosition.getRank())); if (piece != null) { return true; } From acd33e471acc26ccfa2f494cd4b892c3e06f90f8 Mon Sep 17 00:00:00 2001 From: chunghyeon-kim Date: Fri, 20 Aug 2021 22:58:16 +0900 Subject: [PATCH 38/42] refactor: Modify variable names --- src/main/java/chess/domain/plate/ChessPlate.java | 10 ++-------- src/main/java/chess/service/ChessService.java | 12 ++++++------ src/test/java/chess/domain/plate/ChessPlateTest.java | 12 ++++++------ 3 files changed, 14 insertions(+), 20 deletions(-) diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index 3d54869..e71c516 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -1,6 +1,5 @@ package chess.domain.plate; -import chess.domain.RankComparator; import chess.domain.piece.*; import chess.domain.team.Camp; import lombok.Getter; @@ -21,24 +20,19 @@ public ChessPlate() { arrangePieces(); } - public Map arrangePieces() { - RankComparator rankComparator = new RankComparator(); - + public void arrangePieces() { for (Rank rank : Rank.values()) { for (File file : File.values()) { -// plate.put(new PiecePosition(file, rank), new Piece(".",Team.BLACK, new PiecePosition(file,rank))); plate.put(new PiecePosition(file, rank), null); } } allPieces.forEach(piece -> { plate.put(piece.getPiecePosition(), piece); }); - - return plate; } public boolean move(PiecePosition sourcePosition, PiecePosition targetPosition) { - //TO-DO 기물별 허용 움직임 범위인지 체크 + //기물별 허용 움직임 범위인지 체크 Piece sourcePiece = plate.get(sourcePosition); if (!movable(sourcePosition, targetPosition, sourcePiece)) { return false; diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java index 510c207..1eccd61 100644 --- a/src/main/java/chess/service/ChessService.java +++ b/src/main/java/chess/service/ChessService.java @@ -48,19 +48,19 @@ public double getGameScore(Team team) { } public double calculatePawnScore(Team team){ - Map> pawnAlign = + Map> pawnAlign = chessPlate.getPlate().values().stream() - .filter(piece -> piece instanceof Pawn) + .filter(Pawn.class::isInstance) .filter(piece -> piece.getTeam().equals(team)) .collect(Collectors.groupingBy(piece -> piece.getPiecePosition().getFile(), Collectors.mapping(Piece::getName, Collectors.toList()))); double score = 0; - for (List a : pawnAlign.values()) { - if(a.size()>=2){ - score=+a.size(); + for (List pawnNumberByFile : pawnAlign.values()) { + if(pawnNumberByFile.size() >= 2){ + score += pawnNumberByFile.size(); } } - return score*0.5; + return score * 0.5; } } diff --git a/src/test/java/chess/domain/plate/ChessPlateTest.java b/src/test/java/chess/domain/plate/ChessPlateTest.java index 01c1280..f1b3a87 100644 --- a/src/test/java/chess/domain/plate/ChessPlateTest.java +++ b/src/test/java/chess/domain/plate/ChessPlateTest.java @@ -57,13 +57,13 @@ void move() { //given ChessPlate chessPlate = new ChessPlate(); //when -// boolean result = chessPlate.move(new PiecePosition(File.A, Rank.EIGHT), new PiecePosition(File.B, Rank.EIGHT)); -// boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); + boolean result = chessPlate.move(new PiecePosition(File.A, Rank.EIGHT), new PiecePosition(File.B, Rank.EIGHT)); + boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); boolean result3 = chessPlate.move(new PiecePosition(File.A, Rank.ONE), new PiecePosition(File.A, Rank.THREE)); //then -// assertThat(result).isFalse(); -// assertThat(result2).isTrue(); + assertThat(result).isFalse(); + assertThat(result2).isTrue(); assertThat(result3).isFalse(); } @@ -74,9 +74,9 @@ void testPawnMove() { ChessPlate chessPlate = new ChessPlate(); //when boolean result = chessPlate.move(new PiecePosition(File.B, Rank.SEVEN), new PiecePosition(File.C, Rank.SIX)); -// boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); + boolean result2 = chessPlate.move(new PiecePosition(File.G, Rank.EIGHT), new PiecePosition(File.F, Rank.SIX)); //then assertThat(result).isFalse(); -// assertThat(result2).isTrue(); + assertThat(result2).isTrue(); } } From bc5ed405f98590a560dc537f798a24bf907f7bb4 Mon Sep 17 00:00:00 2001 From: chunghyeon-kim Date: Fri, 20 Aug 2021 23:26:11 +0900 Subject: [PATCH 39/42] =?UTF-8?q?feat:=20status=20=EC=9E=85=EB=A0=A5=20?= =?UTF-8?q?=EC=8B=9C=20=EC=A0=90=EC=88=98=EC=99=80=20=EC=8A=B9=EC=9E=90=20?= =?UTF-8?q?=EC=B6=9C=EB=A0=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../chess/controller/ChessController.java | 20 +++++++++++++++--- src/main/java/chess/view/OutputView.java | 21 ++++++++++++++++++- 2 files changed, 37 insertions(+), 4 deletions(-) diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index 6e84934..1b21003 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -1,5 +1,6 @@ package chess.controller; +import chess.domain.piece.Team; import chess.domain.plate.ChessPlate; import chess.service.ChessService; import chess.view.InputView; @@ -11,13 +12,14 @@ public class ChessController { public static final String START = "start"; public static final String END = "end"; public static final String MOVE = "move"; + public static final String STATUS = "status"; public void play() { ChessService chessService = new ChessService(); outputView.initPrint(); String command = START; while (!command.equals(END)){ - command = getCommand(); + command = getUserCommand(); checkCommadMessage(chessService, command); } } @@ -38,14 +40,26 @@ private void checkCommadMessage(ChessService chessService, String command) { } } + if(command.equals(STATUS)) { + printResult(chessService); + } + } - private static String getCommand() { + private static String getUserCommand() { String command = inputView.getUserCommand(); - while(!(command.startsWith(START) || command.equals(END) || command.startsWith(MOVE))){ + while(!(command.startsWith(START) || command.equals(END) || command.startsWith(MOVE) || command.equals(STATUS))){ outputView.printInCorrectCommandMessage(); command = inputView.getUserCommand(); } return command; } + + private void printResult(ChessService chessService) { + double blackScore = chessService.getGameScore(Team.BLACK); + double whiteScore = chessService.getGameScore(Team.WHITE); + + outputView.printScoresOfTwoTeams(blackScore, whiteScore); + outputView.printWinner(blackScore, whiteScore); + } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 0607f10..26bcec4 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -4,6 +4,7 @@ import chess.domain.piece.File; import chess.domain.piece.PiecePosition; import chess.domain.piece.Rank; +import chess.domain.piece.Team; import chess.domain.plate.ChessPlate; import java.util.Arrays; @@ -34,12 +35,30 @@ public void initPrint() { } public void printInCorrectCommandMessage(){ - System.out.println("start/end/move 중 하나를 입력해주세요"); + System.out.println("start/end/move/status 중 하나를 입력해주세요"); } public void printCannotMoveMessage() { System.out.println("기물을 움직일 수 없습니다."); } + public void printScoresOfTwoTeams(double blackScore, double whiteScore) { + System.out.println("Black 팀 점수 : " + blackScore + "점"); + System.out.println("White 팀 점수 : " + whiteScore + "점"); + } + + public void printWinner(double blackScore, double whiteScore) { + if(blackScore > whiteScore) { + System.out.println("Black 팀 승리"); + return; + } + + if(whiteScore > blackScore) { + System.out.println("White 팀 승리"); + return; + } + + System.out.println("무승부"); + } } From f1da948dcc0fe6178ec80fde8202fc89ed3ef6bc Mon Sep 17 00:00:00 2001 From: chunghyeon-kim Date: Fri, 20 Aug 2021 23:49:58 +0900 Subject: [PATCH 40/42] =?UTF-8?q?feat:=20King=EC=9D=B4=20=EC=A3=BD?= =?UTF-8?q?=EC=97=88=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 --- src/main/java/chess/service/ChessService.java | 10 +++++- .../java/chess/service/ChessServiceTest.java | 31 +++++++++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/src/main/java/chess/service/ChessService.java b/src/main/java/chess/service/ChessService.java index 1eccd61..65f7de1 100644 --- a/src/main/java/chess/service/ChessService.java +++ b/src/main/java/chess/service/ChessService.java @@ -11,7 +11,7 @@ @Getter public class ChessService { - private ChessPlate chessPlate= new ChessPlate(); + private ChessPlate chessPlate; public ChessPlate start() { this.chessPlate = new ChessPlate(); return chessPlate; @@ -63,4 +63,12 @@ public double calculatePawnScore(Team team){ return score * 0.5; } + public boolean isKingDead(Team team) { + long KingCount = chessPlate.getPlate().values().stream() + .filter(piece -> piece instanceof King) + .filter(piece -> piece.getTeam().equals(team)) + .count(); + return KingCount < 1; + } + } diff --git a/src/test/java/chess/service/ChessServiceTest.java b/src/test/java/chess/service/ChessServiceTest.java index 47bfff9..29fe30d 100644 --- a/src/test/java/chess/service/ChessServiceTest.java +++ b/src/test/java/chess/service/ChessServiceTest.java @@ -57,4 +57,35 @@ void testCalculatePawnScore() { assertThat(score).isEqualTo(0); assertThat(score2).isEqualTo(1); } + + @Test + @DisplayName("Black King이 잡혔는지 확인하는 메서드 테스트") + void testDetectBlackKingIsDead() { + //given + ChessService service = new ChessService(); + service.start(); + service.getChessPlate().getPlate().remove(new PiecePosition(File.E, Rank.EIGHT)); + + //when + + //then + assertThat(service.isKingDead(Team.BLACK)).isTrue(); + assertThat(service.isKingDead(Team.WHITE)).isFalse(); + } + + @Test + @DisplayName("White King이 잡혔는지 확인하는 메서드 테스트") + void testDetectWhiteKingIsDead() { + //given + ChessService service = new ChessService(); + service.start(); + service.getChessPlate().getPlate().remove(new PiecePosition(File.E, Rank.ONE)); + + //when + + //then + assertThat(service.isKingDead(Team.BLACK)).isFalse(); + assertThat(service.isKingDead(Team.WHITE)).isTrue(); + } + } \ No newline at end of file From 907901d59ce0e3c0b8b62a68e0a579ad8631e7b7 Mon Sep 17 00:00:00 2001 From: chunghyeon-kim Date: Sat, 21 Aug 2021 00:02:50 +0900 Subject: [PATCH 41/42] feat: Print message and exit game when king is dead --- src/main/java/chess/controller/ChessController.java | 12 ++++++++++++ src/main/java/chess/view/OutputView.java | 9 +++++++++ src/test/java/chess/service/ChessServiceTest.java | 1 - 3 files changed, 21 insertions(+), 1 deletion(-) diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java index 1b21003..29b4235 100644 --- a/src/main/java/chess/controller/ChessController.java +++ b/src/main/java/chess/controller/ChessController.java @@ -21,6 +21,7 @@ public void play() { while (!command.equals(END)){ command = getUserCommand(); checkCommadMessage(chessService, command); + gameOverIfKingDead(chessService); } } @@ -62,4 +63,15 @@ private void printResult(ChessService chessService) { outputView.printScoresOfTwoTeams(blackScore, whiteScore); outputView.printWinner(blackScore, whiteScore); } + + private void gameOverIfKingDead(ChessService chessService) { + if(chessService.isKingDead(Team.BLACK)) { + outputView.printBlackKingDeadMessage(); + System.exit(0); + } + if(chessService.isKingDead(Team.WHITE)) { + outputView.printWhiteKingDeadMessage(); + System.exit(0); + } + } } diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java index 26bcec4..887c6a1 100644 --- a/src/main/java/chess/view/OutputView.java +++ b/src/main/java/chess/view/OutputView.java @@ -6,6 +6,7 @@ import chess.domain.piece.Rank; import chess.domain.piece.Team; import chess.domain.plate.ChessPlate; +import chess.service.ChessService; import java.util.Arrays; @@ -61,4 +62,12 @@ public void printWinner(double blackScore, double whiteScore) { System.out.println("무승부"); } + public void printBlackKingDeadMessage() { + System.out.println("Black King이 잡혔습니다. White 팀 승리"); + } + + public void printWhiteKingDeadMessage() { + System.out.println("White King이 잡혔습니다. Black 팀 승리"); + } + } diff --git a/src/test/java/chess/service/ChessServiceTest.java b/src/test/java/chess/service/ChessServiceTest.java index 29fe30d..695a517 100644 --- a/src/test/java/chess/service/ChessServiceTest.java +++ b/src/test/java/chess/service/ChessServiceTest.java @@ -87,5 +87,4 @@ void testDetectWhiteKingIsDead() { assertThat(service.isKingDead(Team.BLACK)).isFalse(); assertThat(service.isKingDead(Team.WHITE)).isTrue(); } - } \ No newline at end of file From 58b21613d8c9b8275fa6ef71d57f9e24f10d8232 Mon Sep 17 00:00:00 2001 From: chunghyeon-kim Date: Wed, 1 Sep 2021 22:51:18 +0900 Subject: [PATCH 42/42] refactor: Modify ChessServiceTest, straight condition --- src/main/java/chess/domain/plate/ChessPlate.java | 2 +- src/test/java/chess/service/ChessServiceTest.java | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/main/java/chess/domain/plate/ChessPlate.java b/src/main/java/chess/domain/plate/ChessPlate.java index e71c516..e666062 100644 --- a/src/main/java/chess/domain/plate/ChessPlate.java +++ b/src/main/java/chess/domain/plate/ChessPlate.java @@ -69,7 +69,7 @@ private void executeMove(PiecePosition sourcePosition, PiecePosition targetPosit } private boolean isStraightMoving(PiecePosition sourcePosition, PiecePosition targetPosition) { - return sourcePosition.getFile().equals(targetPosition.getFile()); + return sourcePosition.getFile().equals(targetPosition.getFile()) || sourcePosition.getRank().equals(targetPosition.getRank()); } private boolean isDiagonalMoving(PiecePosition sourcePosition, PiecePosition targetPosition, Piece sourcePiece, Piece targetPiece) { diff --git a/src/test/java/chess/service/ChessServiceTest.java b/src/test/java/chess/service/ChessServiceTest.java index 695a517..f960857 100644 --- a/src/test/java/chess/service/ChessServiceTest.java +++ b/src/test/java/chess/service/ChessServiceTest.java @@ -43,7 +43,9 @@ void testGetScore() { void testCalculatePawnScore() { //given ChessService service = new ChessService(); + service.start(); ChessService service2 = new ChessService(); + service2.start(); service2.move("e2","e4"); service2.move("e4","e5"); service2.move("e5","e6"); @@ -54,7 +56,7 @@ void testCalculatePawnScore() { double score2 = service2.calculatePawnScore(Team.BLACK); //then - assertThat(score).isEqualTo(0); + assertThat(score).isZero(); assertThat(score2).isEqualTo(1); }