From c2593cf0b4fd594e43e04b363370bede852e59eb Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 15:02:02 +0900 Subject: [PATCH 01/10] =?UTF-8?q?feat:=20Pawn=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/Column.java | 1 + src/main/java/chess/Position.java | 6 ++ src/main/java/chess/piece/Pawn.java | 73 ++++++++++++++- src/main/java/chess/piece/Piece.java | 26 ++++++ src/test/java/chess/piece/PawnTest.java | 112 ++++++++++++++++++++++++ 5 files changed, 217 insertions(+), 1 deletion(-) create mode 100644 src/main/java/chess/piece/Piece.java create mode 100644 src/test/java/chess/piece/PawnTest.java diff --git a/src/main/java/chess/Column.java b/src/main/java/chess/Column.java index b64b4dc77a3..2684415a5ce 100644 --- a/src/main/java/chess/Column.java +++ b/src/main/java/chess/Column.java @@ -50,4 +50,5 @@ public Column moveRight(final int step) { throw new IllegalStateException("움직일 수 없는 위치입니다."); } + } diff --git a/src/main/java/chess/Position.java b/src/main/java/chess/Position.java index 3ebeb0ea185..e3134c24e34 100644 --- a/src/main/java/chess/Position.java +++ b/src/main/java/chess/Position.java @@ -167,4 +167,10 @@ public Position moveHorizontal(final int step) { } return this; } + + public boolean isSamePosition(Position position){ + return row.equals(position.row) && column.equals(position.column); + } + + } diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index c8b6cafa51e..64de28aa51d 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -1,5 +1,76 @@ package chess.piece; -public class Pawn { +import chess.Color; +import chess.Movement; +import chess.Position; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +public class Pawn extends Piece { + + private static final Map> movementForColor; + + static { + movementForColor = Map.of( + Color.WHITE, + List.of(Movement.UP, Movement.UP_UP,Movement.RIGHT_UP,Movement.LEFT_UP), + Color.BLACK, + List.of(Movement.DOWN, Movement.DOWN_DOWN,Movement.RIGHT_DOWN,Movement.LEFT_DOWN) + ); + } + + private boolean hasMoved; + + protected Pawn(Color color, Position position) { + super(color, position); + hasMoved = false; + } + + public boolean canMove(Position position, List pieces) { + List movements = movementForColor.get(this.color); + + Optional findMovement = getFindMovement(position, movements); + + if (findMovement.isEmpty()) { + return false; + } + + Movement movement = findMovement.get(); + boolean hasFriendlyPiece = pieces.stream().anyMatch(piece -> piece.isSamePosition(position)); + if (movement.equals(Movement.UP_UP) || movement.equals(Movement.DOWN_DOWN)) { + return !hasMoved && !hasFriendlyPiece; + } + + if(!(movement.equals(Movement.UP) || movement.equals(Movement.DOWN))){ + return pieces.stream().anyMatch(piece -> piece.isSamePosition(position) && piece.isAnotherTeam(this)); + } + return hasFriendlyPiece; + } + + private Optional getFindMovement(Position position, List movements) { + return movements.stream().filter(movement -> { + boolean canMove = this.position.canMove(movement); + if(!canMove){ + return false; + } + Position newPosition = this.position.move(movement); + return newPosition.isSamePosition(position); + }).findAny(); + } + + public void moveTo(Position position, List pieces) { + if (!canMove(position,pieces)) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + List movements = movementForColor.get(this.color); + Optional findMovement = getFindMovement(position, movements); + if (findMovement.isEmpty()) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + this.position = this.position.move(findMovement.get()); + hasMoved = true; + } + } diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java new file mode 100644 index 00000000000..802061eeffe --- /dev/null +++ b/src/main/java/chess/piece/Piece.java @@ -0,0 +1,26 @@ +package chess.piece; + +import chess.Color; +import chess.Position; + +public abstract class Piece { + protected Position position; + protected final Color color; + + protected Piece(Color color,Position position) { + this.color = color; + this.position = position; + } + + public Position getPosition() { + return position; + } + + public boolean isAnotherTeam(Piece piece){ + return !this.color.equals(piece.color); + } + + public boolean isSamePosition(Position position){ + return this.position.equals(position); + } +} diff --git a/src/test/java/chess/piece/PawnTest.java b/src/test/java/chess/piece/PawnTest.java new file mode 100644 index 00000000000..38f3deb92eb --- /dev/null +++ b/src/test/java/chess/piece/PawnTest.java @@ -0,0 +1,112 @@ +package chess.piece; + +import static org.assertj.core.api.Assertions.*; + +import chess.Color; +import chess.Column; +import chess.Position; +import chess.Row; +import java.util.List; +import java.util.stream.Stream; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +class PawnTest { + + @ParameterizedTest + @MethodSource + @DisplayName("이동 가능한지 판별") + void canMoveTest(Color color ,Position movePosition, boolean expected){ + Position position = new Position(Row.THREE, Column.A); + Pawn pawn = new Pawn(color,position); + + boolean canMove = pawn.canMove(movePosition, List.of()); + + assertThat(canMove).isEqualTo(expected); + } + + public static Stream canMoveTest(){ + return Stream.of( + Arguments.of( + Color.WHITE,new Position(Row.FIVE,Column.A),true + ), + Arguments.of( + Color.WHITE,new Position(Row.FOUR,Column.A),true + ), + Arguments.of( + Color.WHITE,new Position(Row.SIX,Column.A),false + ), + Arguments.of( + Color.WHITE,new Position(Row.TWO,Column.B),false + ), + Arguments.of( + Color.BLACK,new Position(Row.TWO,Column.A),true + ), + Arguments.of( + Color.BLACK,new Position(Row.ONE,Column.A),true + ), + Arguments.of( + Color.BLACK,new Position(Row.FOUR,Column.A),false + ), + Arguments.of( + Color.BLACK,new Position(Row.FIVE,Column.B),false + ) + ); + } + + @Test + @DisplayName("이동 테스트") + void moveToTest(){ + Position position = new Position(Row.THREE, Column.A); + Pawn pawn = new Pawn(Color.WHITE,position); + Position toPosition = new Position(Row.FIVE, Column.A); + + pawn.moveTo(toPosition,List.of()); + + Position nowPosition = pawn.getPosition(); + assertThat(nowPosition).isEqualTo(toPosition); + } + + @Test + @DisplayName("이동 경로에 아군이 있으면 예외 발생") + void moveToTestException(){ + Position position = new Position(Row.THREE, Column.A); + Pawn pawn = new Pawn(Color.WHITE,position); + Position toPosition = new Position(Row.FIVE, Column.A); + Pawn pawn1 = new Pawn(Color.WHITE,toPosition); + + assertThatThrownBy(()->pawn.moveTo(toPosition,List.of(pawn1))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + @DisplayName("이동 경로에 적이 있으면 대각선은 가능하다.") + void moveToTest2(){ + Position position = new Position(Row.THREE, Column.A); + Pawn pawn = new Pawn(Color.WHITE,position); + Position toPosition = new Position(Row.FOUR, Column.B); + Pawn pawn1 = new Pawn(Color.BLACK,toPosition); + + boolean canMove = pawn.canMove(toPosition, List.of(pawn1)); + + assertThat(canMove).isTrue(); + } + + @Test + @DisplayName("이동 경로에 적이 없는데 대각선으로 못감") + void moveToTestException2(){ + Position position = new Position(Row.THREE, Column.A); + Pawn pawn = new Pawn(Color.WHITE,position); + Position toPosition = new Position(Row.FOUR, Column.B); + Pawn pawn1 = new Pawn(Color.WHITE,toPosition); + + + boolean canMove = pawn.canMove(toPosition, List.of(pawn1)); + + assertThat(canMove).isFalse(); + } +} \ No newline at end of file From 7ac84891792a28ecc52b1940b5395ea803873cf9 Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 15:20:04 +0900 Subject: [PATCH 02/10] =?UTF-8?q?feat:=20King=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/piece/King.java | 55 ++++++++++++++- src/main/java/chess/piece/Pawn.java | 2 +- src/test/java/chess/piece/KingTest.java | 89 +++++++++++++++++++++++++ 3 files changed, 144 insertions(+), 2 deletions(-) create mode 100644 src/test/java/chess/piece/KingTest.java diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java index d64210cad13..8b63f2cbc20 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/piece/King.java @@ -1,5 +1,58 @@ package chess.piece; -public class King { +import chess.Color; +import chess.Movement; +import chess.Position; +import java.util.List; +import java.util.Optional; +public class King extends Piece { + + private static final List movements; + + static { + movements = List.of(Movement.DOWN,Movement.UP,Movement.LEFT,Movement.RIGHT, + Movement.RIGHT_UP,Movement.LEFT_UP,Movement.RIGHT_DOWN,Movement.LEFT_DOWN); + } + + protected King(Color color, Position position) { + super(color, position); + } + + public boolean canMove(Position position, List pieces) { + Optional findMovement = getFindMovement(position, movements); + + if (findMovement.isEmpty()) { + return false; + } + + boolean hasPiece = pieces.stream().anyMatch(piece -> piece.isSamePosition(position)); + + if(hasPiece){ + return pieces.stream().anyMatch(piece -> piece.isSamePosition(position) && piece.isAnotherTeam(this)); + } + return true; + } + + private Optional getFindMovement(Position position, List movements) { + return movements.stream().filter(movement -> { + boolean canMove = this.position.canMove(movement); + if(!canMove){ + return false; + } + Position newPosition = this.position.move(movement); + return newPosition.isSamePosition(position); + }).findAny(); + } + + public void moveTo(Position position, List pieces) { + if (!canMove(position,pieces)) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + Optional findMovement = getFindMovement(position, movements); + if (findMovement.isEmpty()) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + this.position = this.position.move(findMovement.get()); + } } diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index 64de28aa51d..67c876b63ee 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -45,7 +45,7 @@ public boolean canMove(Position position, List pieces) { if(!(movement.equals(Movement.UP) || movement.equals(Movement.DOWN))){ return pieces.stream().anyMatch(piece -> piece.isSamePosition(position) && piece.isAnotherTeam(this)); } - return hasFriendlyPiece; + return !hasFriendlyPiece; } private Optional getFindMovement(Position position, List movements) { diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/piece/KingTest.java new file mode 100644 index 00000000000..da72edead77 --- /dev/null +++ b/src/test/java/chess/piece/KingTest.java @@ -0,0 +1,89 @@ +package chess.piece; + +import static org.assertj.core.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.*; + +import chess.Color; +import chess.Column; +import chess.Position; +import chess.Row; +import java.util.List; +import java.util.stream.Stream; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +class KingTest { + + @ParameterizedTest + @MethodSource + @DisplayName("주위에 비어있는 경우") + void moveCheckTest(Position movePosition, boolean expected){ + Position position = new Position(Row.THREE, Column.B); + King king = new King(Color.BLACK,position); + + boolean canMove = king.canMove(movePosition, List.of()); + + assertThat(canMove).isEqualTo(expected); + } + + public static Stream moveCheckTest() { + return Stream.of( + Arguments.of( + new Position(Row.TWO, Column.B), true + ), + Arguments.of( + new Position(Row.FOUR, Column.B), true + ), + Arguments.of( + new Position(Row.THREE, Column.A), true + ), + Arguments.of( + new Position(Row.THREE, Column.C), true + ), + Arguments.of( + new Position(Row.FOUR, Column.A), true + ), + Arguments.of( + new Position(Row.FOUR, Column.C), true + ), + Arguments.of( + new Position(Row.TWO, Column.A), true + ), + Arguments.of( + new Position(Row.TWO, Column.C), true + ), + Arguments.of( + new Position(Row.FIVE, Column.C), false + ), + Arguments.of( + new Position(Row.THREE, Column.D), false + ) + ); + } + + @Test + @DisplayName("주위에 아군이 있으면 못 움직인다.") + void canMoveTest2(){ + Position position = new Position(Row.THREE, Column.B); + King king = new King(Color.BLACK,position); + Position toPosition = new Position(Row.TWO, Column.C); + Pawn pawn = new Pawn(Color.BLACK,toPosition); + boolean canMove = king.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isFalse(); + } + + @Test + @DisplayName("주위에 적이면 이동가능") + void canMoveTest3(){ + Position position = new Position(Row.THREE, Column.B); + King king = new King(Color.BLACK,position); + Position toPosition = new Position(Row.TWO, Column.C); + Pawn pawn = new Pawn(Color.WHITE,toPosition); + boolean canMove = king.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isTrue(); + } +} \ No newline at end of file From f7f8806e17252d950359f699889cbdf7e01e3818 Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 15:28:35 +0900 Subject: [PATCH 03/10] =?UTF-8?q?feat:=20Knight=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/piece/Knight.java | 57 ++++++++++++- src/test/java/chess/piece/KnightTest.java | 99 +++++++++++++++++++++++ 2 files changed, 155 insertions(+), 1 deletion(-) create mode 100644 src/test/java/chess/piece/KnightTest.java diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java index 2ee7c47a3bc..939505aa9b4 100644 --- a/src/main/java/chess/piece/Knight.java +++ b/src/main/java/chess/piece/Knight.java @@ -1,5 +1,60 @@ package chess.piece; -public class Knight { +import chess.Color; +import chess.Movement; +import chess.Position; +import java.util.List; +import java.util.Optional; + +public class Knight extends Piece { + + private static final List movements; + + static { + movements = List.of(Movement.UP_UP_LEFT,Movement.UP_UP_RIGHT,Movement.DOWN_DOWN_LEFT,Movement.DOWN_DOWN_RIGHT, + Movement.RIGHT_RIGHT_DOWN,Movement.RIGHT_RIGHT_UP,Movement.LEFT_LEFT_DOWN,Movement.LEFT_LEFT_UP); + } + + protected Knight(Color color, Position position) { + super(color, position); + } + + public boolean canMove(Position position, List pieces) { + Optional findMovement = getFindMovement(position, movements); + + if (findMovement.isEmpty()) { + return false; + } + + boolean hasPiece = pieces.stream().anyMatch(piece -> piece.isSamePosition(position)); + + if(hasPiece){ + return pieces.stream().anyMatch(piece -> piece.isSamePosition(position) && piece.isAnotherTeam(this)); + } + return true; + } + + private Optional getFindMovement(Position position, List movements) { + return movements.stream().filter(movement -> { + boolean canMove = this.position.canMove(movement); + if(!canMove){ + return false; + } + Position newPosition = this.position.move(movement); + return newPosition.isSamePosition(position); + }).findAny(); + } + + public void moveTo(Position position, List pieces) { + if (!canMove(position,pieces)) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + Optional findMovement = getFindMovement(position, movements); + if (findMovement.isEmpty()) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + this.position = this.position.move(findMovement.get()); + } + } diff --git a/src/test/java/chess/piece/KnightTest.java b/src/test/java/chess/piece/KnightTest.java new file mode 100644 index 00000000000..f22c9eaa185 --- /dev/null +++ b/src/test/java/chess/piece/KnightTest.java @@ -0,0 +1,99 @@ +package chess.piece; + +import static org.assertj.core.api.Assertions.assertThat; + +import chess.Color; +import chess.Column; +import chess.Position; +import chess.Row; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +class KnightTest { + + @ParameterizedTest + @MethodSource + @DisplayName("주위에 비어있는 경우") + void moveCheckTest(Position movePosition, boolean expected){ + Position position = new Position(Row.THREE, Column.C); + Knight knight = new Knight(Color.BLACK, position); + + boolean canMove = knight.canMove(movePosition, List.of()); + + assertThat(canMove).isEqualTo(expected); + } + + public static Stream moveCheckTest() { + return Stream.of( + Arguments.of( + new Position(Row.FIVE, Column.D), true + ), + Arguments.of( + new Position(Row.FIVE, Column.B), true + ), + Arguments.of( + new Position(Row.FOUR, Column.E), true + ), + Arguments.of( + new Position(Row.TWO, Column.E), true + ), + Arguments.of( + new Position(Row.FOUR, Column.A), true + ), + Arguments.of( + new Position(Row.TWO, Column.A), true + ), + Arguments.of( + new Position(Row.ONE, Column.B), true + ), + Arguments.of( + new Position(Row.ONE, Column.D), true + ), + Arguments.of( + new Position(Row.SIX, Column.B), false + ), + Arguments.of( + new Position(Row.SEVEN, Column.D), false + ) + ); + } + + @Test + @DisplayName("주위에 아군이 있으면 못 움직인다.") + void canMoveTest2(){ + Position position = new Position(Row.THREE, Column.C); + Knight knight = new Knight(Color.BLACK, position); + Position toPosition = new Position(Row.TWO, Column.A); + Pawn pawn = new Pawn(Color.BLACK,toPosition); + boolean canMove = knight.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isFalse(); + } + + @Test + @DisplayName("주위에 적이면 이동가능") + void canMoveTest3(){ + Position position = new Position(Row.THREE, Column.C); + Knight knight = new Knight(Color.BLACK, position); + Position toPosition = new Position(Row.TWO, Column.A); + Pawn pawn = new Pawn(Color.WHITE,toPosition); + boolean canMove = knight.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isTrue(); + } + + @Test + @DisplayName("중간에 누가 있어도 지나갈 수 있다.") + void canMoveTest4(){ + Position position = new Position(Row.THREE, Column.C); + Knight knight = new Knight(Color.BLACK, position); + Position pawnPosition = new Position(Row.THREE, Column.B); + Position toPosition = new Position(Row.TWO, Column.A); + Pawn pawn = new Pawn(Color.WHITE,pawnPosition); + boolean canMove = knight.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isTrue(); + } +} \ No newline at end of file From a58d317588e03da8dab7981647696c795b9e27e4 Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 15:50:14 +0900 Subject: [PATCH 04/10] =?UTF-8?q?feat:=20Rock=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/piece/Rook.java | 88 +++++++++++++++++- src/test/java/chess/piece/RockTest.java | 117 ++++++++++++++++++++++++ 2 files changed, 204 insertions(+), 1 deletion(-) create mode 100644 src/test/java/chess/piece/RockTest.java diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java index 7ed4d08bf03..dc5c63f32b8 100644 --- a/src/main/java/chess/piece/Rook.java +++ b/src/main/java/chess/piece/Rook.java @@ -1,5 +1,91 @@ package chess.piece; -public class Rook { +import chess.Color; +import chess.Movement; +import chess.Position; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public class Rook extends Piece { + + private static final List movements; + + static { + movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); + } + + protected Rook(Color color, Position position) { + super(color, position); + } + + public boolean canMove(Position position, List pieces) { + Optional findMovement = getFindMovement(position, movements); + + if (findMovement.isEmpty()) { + return false; + } + + Movement movement = findMovement.get(); + List paths = getPath(position, movement); + + boolean hasIntermediatePieces = hasIntermediatePieces(pieces, paths); + + if(hasIntermediatePieces){ + return false; + } + + boolean hasPiece = pieces.stream().anyMatch(piece -> piece.isSamePosition(position)); + + if(hasPiece){ + return pieces.stream().anyMatch(piece -> piece.isSamePosition(position) && piece.isAnotherTeam(this)); + } + return true; + } + + private boolean hasIntermediatePieces(List pieces, List paths) { + for (Piece piece : pieces) { + for (Position path : paths) { + if(piece.isSamePosition(path)){ + return true; + } + } + } + return false; + } + + private Optional getFindMovement(Position position, List movements) { + for (Movement movement : movements) { + Position nowPosition = this.position; + while(nowPosition.canMove(movement)){ + nowPosition = nowPosition.move(movement); + if(nowPosition.equals(position)){ + return Optional.of(movement); + } + } + } + return Optional.empty(); + } + + private List getPath(Position endPosition,Movement movement){ + List path = new ArrayList<>(); + Position nowPosition = this.position.move(movement); + while(!nowPosition.equals(endPosition)){ + path.add(nowPosition); + nowPosition = nowPosition.move(movement); + } + return path; + } + + public void moveTo(Position position, List pieces) { + if (!canMove(position,pieces)) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + Optional findMovement = getFindMovement(position, movements); + if (findMovement.isEmpty()) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + this.position = this.position.move(findMovement.get()); + } } diff --git a/src/test/java/chess/piece/RockTest.java b/src/test/java/chess/piece/RockTest.java new file mode 100644 index 00000000000..179191dbcef --- /dev/null +++ b/src/test/java/chess/piece/RockTest.java @@ -0,0 +1,117 @@ +package chess.piece; + +import static org.assertj.core.api.Assertions.assertThat; + +import chess.Color; +import chess.Column; +import chess.Position; +import chess.Row; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +class RockTest { + + @ParameterizedTest + @MethodSource + @DisplayName("주위에 비어있는 경우") + void moveCheckTest(Position movePosition, boolean expected) { + Position position = new Position(Row.THREE, Column.B); + Rook rook = new Rook(Color.BLACK, position); + + boolean canMove = rook.canMove(movePosition, List.of()); + + assertThat(canMove).isEqualTo(expected); + } + + public static Stream moveCheckTest() { + return Stream.of( + Arguments.of( + new Position(Row.THREE, Column.A), true + ), + Arguments.of( + new Position(Row.THREE, Column.C), true + ), + Arguments.of( + new Position(Row.THREE, Column.D), true + ), + Arguments.of( + new Position(Row.THREE, Column.E), true + ), + Arguments.of( + new Position(Row.THREE, Column.F), true + ), + Arguments.of( + new Position(Row.THREE, Column.G), true + ), + Arguments.of( + new Position(Row.THREE, Column.H), true + ), + Arguments.of( + new Position(Row.ONE, Column.B), true + ), + Arguments.of( + new Position(Row.TWO, Column.B), true + ), + Arguments.of( + new Position(Row.FOUR, Column.B), true + ), + Arguments.of( + new Position(Row.FIVE, Column.B), true + ), + Arguments.of( + new Position(Row.SIX, Column.B), true + ), + Arguments.of( + new Position(Row.SEVEN, Column.B), true + ), + Arguments.of( + new Position(Row.EIGHT, Column.B), true + ), + Arguments.of( + new Position(Row.EIGHT, Column.E), false + ), + Arguments.of( + new Position(Row.EIGHT, Column.F), false + ) + ); + } + + @Test + @DisplayName("주위에 아군이 있으면 못 움직인다.") + void canMoveTest2(){ + Position position = new Position(Row.THREE, Column.C); + Rook rook = new Rook(Color.BLACK, position); + Position toPosition = new Position(Row.THREE, Column.D); + Pawn pawn = new Pawn(Color.BLACK,toPosition); + boolean canMove = rook.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isFalse(); + } + + @Test + @DisplayName("주위에 적이면 이동가능") + void canMoveTest3(){ + Position position = new Position(Row.THREE, Column.C); + Rook rook = new Rook(Color.BLACK, position); + Position toPosition = new Position(Row.THREE, Column.D); + Pawn pawn = new Pawn(Color.WHITE,toPosition); + boolean canMove = rook.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isTrue(); + } + + @Test + @DisplayName("중간에 누가 있으면 갈 수 없다.") + void canMoveTest4(){ + Position position = new Position(Row.THREE, Column.C); + Knight knight = new Knight(Color.BLACK, position); + Position pawnPosition = new Position(Row.THREE, Column.B); + Position toPosition = new Position(Row.THREE, Column.D); + Pawn pawn = new Pawn(Color.WHITE,pawnPosition); + boolean canMove = knight.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isFalse(); + } +} From 16e8c53eb5068e2ca0edc1de237634e95929b21e Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 15:59:37 +0900 Subject: [PATCH 05/10] =?UTF-8?q?feat:=20Bishop=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/piece/Bishop.java | 89 +++++++++++++++- src/test/java/chess/piece/BishopTest.java | 117 ++++++++++++++++++++++ 2 files changed, 205 insertions(+), 1 deletion(-) create mode 100644 src/test/java/chess/piece/BishopTest.java diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java index b14ab70f981..c6e5dd4e48c 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/src/main/java/chess/piece/Bishop.java @@ -1,5 +1,92 @@ package chess.piece; -public class Bishop { +import chess.Color; +import chess.Movement; +import chess.Position; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public class Bishop extends Piece { + + private static final List movements; + + static { + movements = List.of(Movement.LEFT_UP,Movement.RIGHT_UP,Movement.LEFT_DOWN,Movement.RIGHT_DOWN); + } + + protected Bishop(Color color, Position position) { + super(color, position); + } + + public boolean canMove(Position position, List pieces) { + Optional findMovement = getFindMovement(position, movements); + + if (findMovement.isEmpty()) { + return false; + } + + Movement movement = findMovement.get(); + List paths = getPath(position, movement); + + boolean hasIntermediatePieces = hasIntermediatePieces(pieces, paths); + + if(hasIntermediatePieces){ + return false; + } + + boolean hasPiece = pieces.stream().anyMatch(piece -> piece.isSamePosition(position)); + + if(hasPiece){ + return pieces.stream().anyMatch(piece -> piece.isSamePosition(position) && piece.isAnotherTeam(this)); + } + return true; + } + + private boolean hasIntermediatePieces(List pieces, List paths) { + for (Piece piece : pieces) { + for (Position path : paths) { + if(piece.isSamePosition(path)){ + return true; + } + } + } + return false; + } + + private Optional getFindMovement(Position position, List movements) { + for (Movement movement : movements) { + Position nowPosition = this.position; + while(nowPosition.canMove(movement)){ + nowPosition = nowPosition.move(movement); + if(nowPosition.equals(position)){ + return Optional.of(movement); + } + } + } + return Optional.empty(); + } + + private List getPath(Position endPosition,Movement movement){ + List path = new ArrayList<>(); + Position nowPosition = this.position.move(movement); + while(!nowPosition.equals(endPosition)){ + path.add(nowPosition); + nowPosition = nowPosition.move(movement); + } + return path; + } + + public void moveTo(Position position, List pieces) { + if (!canMove(position,pieces)) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + Optional findMovement = getFindMovement(position, movements); + if (findMovement.isEmpty()) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + this.position = this.position.move(findMovement.get()); + } + } diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java new file mode 100644 index 00000000000..cbf7c18ad11 --- /dev/null +++ b/src/test/java/chess/piece/BishopTest.java @@ -0,0 +1,117 @@ +package chess.piece; + +import static org.assertj.core.api.Assertions.assertThat; + +import chess.Color; +import chess.Column; +import chess.Position; +import chess.Row; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +class BishopTest { + + @ParameterizedTest + @MethodSource + @DisplayName("주위에 비어있는 경우") + void moveCheckTest(Position movePosition, boolean expected) { + Position position = new Position(Row.THREE, Column.B); + Bishop bishop = new Bishop(Color.BLACK, position); + + boolean canMove = bishop.canMove(movePosition, List.of()); + + assertThat(canMove).isEqualTo(expected); + } + + public static Stream moveCheckTest() { + return Stream.of( + Arguments.of( + new Position(Row.FOUR, Column.C), true + ), + Arguments.of( + new Position(Row.FIVE, Column.D), true + ), + Arguments.of( + new Position(Row.SIX, Column.E), true + ), + Arguments.of( + new Position(Row.SEVEN, Column.F), true + ), + Arguments.of( + new Position(Row.EIGHT, Column.G), true + ), + Arguments.of( + new Position(Row.TWO, Column.A), true + ), + Arguments.of( + new Position(Row.FOUR, Column.A), true + ), + Arguments.of( + new Position(Row.TWO, Column.C), true + ), + Arguments.of( + new Position(Row.ONE, Column.D), true + ), + Arguments.of( + new Position(Row.FOUR, Column.B), false + ), + Arguments.of( + new Position(Row.FIVE, Column.B), false + ), + Arguments.of( + new Position(Row.SIX, Column.B), false + ), + Arguments.of( + new Position(Row.SEVEN, Column.B), false + ), + Arguments.of( + new Position(Row.EIGHT, Column.B), false + ), + Arguments.of( + new Position(Row.EIGHT, Column.E), false + ), + Arguments.of( + new Position(Row.EIGHT, Column.F), false + ) + ); + } + + @Test + @DisplayName("주위에 아군이 있으면 못 움직인다.") + void canMoveTest2(){ + Position position = new Position(Row.THREE, Column.B); + Bishop bishop = new Bishop(Color.BLACK, position); + Position toPosition = new Position(Row.TWO, Column.C); + Pawn pawn = new Pawn(Color.BLACK,toPosition); + boolean canMove = bishop.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isFalse(); + } + + @Test + @DisplayName("주위에 적이면 이동가능") + void canMoveTest3(){ + Position position = new Position(Row.THREE, Column.B); + Bishop bishop = new Bishop(Color.BLACK, position); + Position toPosition = new Position(Row.TWO, Column.C); + Pawn pawn = new Pawn(Color.WHITE,toPosition); + boolean canMove = bishop.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isTrue(); + } + + @Test + @DisplayName("중간에 누가 있으면 갈 수 없다.") + void canMoveTest4(){ + Position position = new Position(Row.THREE, Column.B); + Bishop bishop = new Bishop(Color.BLACK, position); + Position pawnPosition = new Position(Row.TWO, Column.C); + Position toPosition = new Position(Row.ONE, Column.D); + Pawn pawn = new Pawn(Color.WHITE,pawnPosition); + boolean canMove = bishop.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isFalse(); + } +} From 9c421f26f30cd32133790452e344c81a6b2bb2ff Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 16:06:31 +0900 Subject: [PATCH 06/10] =?UTF-8?q?feat:=20Queen=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/piece/Queen.java | 91 ++++++++++++++- src/test/java/chess/piece/QeenTest.java | 144 ++++++++++++++++++++++++ 2 files changed, 234 insertions(+), 1 deletion(-) create mode 100644 src/test/java/chess/piece/QeenTest.java diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java index 9b547261c4b..b65de6de234 100644 --- a/src/main/java/chess/piece/Queen.java +++ b/src/main/java/chess/piece/Queen.java @@ -1,5 +1,94 @@ package chess.piece; -public class Queen { +import chess.Color; +import chess.Movement; +import chess.Position; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public class Queen extends Piece { + + private static final List movements; + + static { + movements = List.of(Movement.LEFT_UP,Movement.RIGHT_UP,Movement.LEFT_DOWN,Movement.RIGHT_DOWN, + Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); + } + + protected Queen(Color color, Position position) { + super(color, position); + } + + public boolean canMove(Position position, List pieces) { + Optional findMovement = getFindMovement(position, movements); + + if (findMovement.isEmpty()) { + return false; + } + + Movement movement = findMovement.get(); + List paths = getPath(position, movement); + + boolean hasIntermediatePieces = hasIntermediatePieces(pieces, paths); + + if(hasIntermediatePieces){ + return false; + } + + boolean hasPiece = pieces.stream().anyMatch(piece -> piece.isSamePosition(position)); + + if(hasPiece){ + return pieces.stream().anyMatch(piece -> piece.isSamePosition(position) && piece.isAnotherTeam(this)); + } + return true; + } + + private boolean hasIntermediatePieces(List pieces, List paths) { + for (Piece piece : pieces) { + for (Position path : paths) { + if(piece.isSamePosition(path)){ + return true; + } + } + } + return false; + } + + private Optional getFindMovement(Position position, List movements) { + for (Movement movement : movements) { + Position nowPosition = this.position; + while(nowPosition.canMove(movement)){ + nowPosition = nowPosition.move(movement); + if(nowPosition.equals(position)){ + return Optional.of(movement); + } + } + } + return Optional.empty(); + } + + private List getPath(Position endPosition,Movement movement){ + List path = new ArrayList<>(); + Position nowPosition = this.position.move(movement); + while(!nowPosition.equals(endPosition)){ + path.add(nowPosition); + nowPosition = nowPosition.move(movement); + } + return path; + } + + public void moveTo(Position position, List pieces) { + if (!canMove(position,pieces)) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + Optional findMovement = getFindMovement(position, movements); + if (findMovement.isEmpty()) { + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + this.position = this.position.move(findMovement.get()); + } + + } diff --git a/src/test/java/chess/piece/QeenTest.java b/src/test/java/chess/piece/QeenTest.java new file mode 100644 index 00000000000..22c139ae06b --- /dev/null +++ b/src/test/java/chess/piece/QeenTest.java @@ -0,0 +1,144 @@ +package chess.piece; + +import static org.assertj.core.api.Assertions.assertThat; + +import chess.Color; +import chess.Column; +import chess.Position; +import chess.Row; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +class QeenTest { + + @ParameterizedTest + @MethodSource + @DisplayName("주위에 비어있는 경우") + void moveCheckTest(Position movePosition, boolean expected) { + Position position = new Position(Row.THREE, Column.B); + Queen queen = new Queen(Color.BLACK, position); + + boolean canMove = queen.canMove(movePosition, List.of()); + + assertThat(canMove).isEqualTo(expected); + } + + public static Stream moveCheckTest() { + return Stream.of( + Arguments.of( + new Position(Row.FOUR, Column.C), true + ), + Arguments.of( + new Position(Row.FIVE, Column.D), true + ), + Arguments.of( + new Position(Row.SIX, Column.E), true + ), + Arguments.of( + new Position(Row.SEVEN, Column.F), true + ), + Arguments.of( + new Position(Row.EIGHT, Column.G), true + ), + Arguments.of( + new Position(Row.TWO, Column.A), true + ), + Arguments.of( + new Position(Row.FOUR, Column.A), true + ), + Arguments.of( + new Position(Row.TWO, Column.C), true + ), + Arguments.of( + new Position(Row.ONE, Column.D), true + ), + Arguments.of( + new Position(Row.THREE, Column.A), true + ), + Arguments.of( + new Position(Row.THREE, Column.C), true + ), + Arguments.of( + new Position(Row.THREE, Column.D), true + ), + Arguments.of( + new Position(Row.THREE, Column.E), true + ), + Arguments.of( + new Position(Row.THREE, Column.F), true + ), + Arguments.of( + new Position(Row.THREE, Column.G), true + ), + Arguments.of( + new Position(Row.THREE, Column.H), true + ), + Arguments.of( + new Position(Row.ONE, Column.B), true + ), + Arguments.of( + new Position(Row.TWO, Column.B), true + ), + Arguments.of( + new Position(Row.FOUR, Column.B), true + ), + Arguments.of( + new Position(Row.FIVE, Column.B), true + ), + Arguments.of( + new Position(Row.SIX, Column.B), true + ), + Arguments.of( + new Position(Row.SEVEN, Column.B), true + ), + Arguments.of( + new Position(Row.EIGHT, Column.B), true + ), + Arguments.of( + new Position(Row.EIGHT, Column.E), false + ), + Arguments.of( + new Position(Row.EIGHT, Column.F), false + ) + ); + } + + @Test + @DisplayName("주위에 아군이 있으면 못 움직인다.") + void canMoveTest2(){ + Position position = new Position(Row.THREE, Column.B); + Queen queen = new Queen(Color.BLACK, position); + Position toPosition = new Position(Row.TWO, Column.C); + Pawn pawn = new Pawn(Color.BLACK,toPosition); + boolean canMove = queen.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isFalse(); + } + + @Test + @DisplayName("주위에 적이면 이동가능") + void canMoveTest3(){ + Position position = new Position(Row.THREE, Column.B); + Queen queen = new Queen(Color.BLACK, position); + Position toPosition = new Position(Row.TWO, Column.C); + Pawn pawn = new Pawn(Color.WHITE,toPosition); + boolean canMove = queen.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isTrue(); + } + + @Test + @DisplayName("중간에 누가 있으면 갈 수 없다.") + void canMoveTest4(){ + Position position = new Position(Row.THREE, Column.B); + Queen queen = new Queen(Color.BLACK, position); + Position pawnPosition = new Position(Row.TWO, Column.C); + Position toPosition = new Position(Row.ONE, Column.D); + Pawn pawn = new Pawn(Color.WHITE,pawnPosition); + boolean canMove = queen.canMove(toPosition, List.of(pawn)); + assertThat(canMove).isFalse(); + } +} From 40034bd9870d7158fe86409aa78e9d1f15d51890 Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 16:09:14 +0900 Subject: [PATCH 07/10] =?UTF-8?q?feat:=20Pieces=20=EC=B6=94=EC=83=81=20?= =?UTF-8?q?=EB=A9=94=EC=84=9C=EB=93=9C=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 25 +++++++++++++++++++++++++ src/main/java/chess/piece/Bishop.java | 2 ++ src/main/java/chess/piece/King.java | 4 ++-- src/main/java/chess/piece/Knight.java | 4 ++-- src/main/java/chess/piece/Pawn.java | 4 ++-- src/main/java/chess/piece/Piece.java | 6 ++++++ src/main/java/chess/piece/Queen.java | 4 ++-- src/main/java/chess/piece/Rook.java | 4 ++-- 8 files changed, 43 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 8102f91c870..9bbc0e52013 100644 --- a/README.md +++ b/README.md @@ -5,3 +5,28 @@ ## 우아한테크코스 코드리뷰 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md) + 폰 + +- 처음에는 두 칸 혹은 한 칸 +- 대각선에 적이 있으면 먹을 수 있음 + +룩 + +- 장기에서 차와 같음 + +나이트 + +- 장기에서 마와 같음 +- 말을 넘을 수 있음 + +킹 + +- 장기에서 왕과 같음 + +비숍 + +- 대각선 + +퀸 + +- 비숏과 룩 기능 합체 \ No newline at end of file diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java index c6e5dd4e48c..1ab15127585 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/src/main/java/chess/piece/Bishop.java @@ -19,6 +19,7 @@ protected Bishop(Color color, Position position) { super(color, position); } + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); @@ -77,6 +78,7 @@ private List getPath(Position endPosition,Movement movement){ return path; } + @Override public void moveTo(Position position, List pieces) { if (!canMove(position,pieces)) { throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java index 8b63f2cbc20..2daf9ce769a 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/piece/King.java @@ -18,7 +18,7 @@ public class King extends Piece { protected King(Color color, Position position) { super(color, position); } - + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); @@ -44,7 +44,7 @@ private Optional getFindMovement(Position position, List mov return newPosition.isSamePosition(position); }).findAny(); } - + @Override public void moveTo(Position position, List pieces) { if (!canMove(position,pieces)) { throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java index 939505aa9b4..6a7a2eedf09 100644 --- a/src/main/java/chess/piece/Knight.java +++ b/src/main/java/chess/piece/Knight.java @@ -18,7 +18,7 @@ public class Knight extends Piece { protected Knight(Color color, Position position) { super(color, position); } - + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); @@ -44,7 +44,7 @@ private Optional getFindMovement(Position position, List mov return newPosition.isSamePosition(position); }).findAny(); } - + @Override public void moveTo(Position position, List pieces) { if (!canMove(position,pieces)) { throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index 67c876b63ee..9ba9bdc1e69 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -26,7 +26,7 @@ protected Pawn(Color color, Position position) { super(color, position); hasMoved = false; } - + @Override public boolean canMove(Position position, List pieces) { List movements = movementForColor.get(this.color); @@ -58,7 +58,7 @@ private Optional getFindMovement(Position position, List mov return newPosition.isSamePosition(position); }).findAny(); } - + @Override public void moveTo(Position position, List pieces) { if (!canMove(position,pieces)) { throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java index 802061eeffe..5ef2b6694fb 100644 --- a/src/main/java/chess/piece/Piece.java +++ b/src/main/java/chess/piece/Piece.java @@ -1,7 +1,10 @@ package chess.piece; import chess.Color; +import chess.Movement; import chess.Position; +import java.util.List; +import java.util.Optional; public abstract class Piece { protected Position position; @@ -23,4 +26,7 @@ public boolean isAnotherTeam(Piece piece){ public boolean isSamePosition(Position position){ return this.position.equals(position); } + + public abstract void moveTo(Position position, List pieces); + public abstract boolean canMove(Position position, List pieces); } diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java index b65de6de234..58ce8275f29 100644 --- a/src/main/java/chess/piece/Queen.java +++ b/src/main/java/chess/piece/Queen.java @@ -19,7 +19,7 @@ public class Queen extends Piece { protected Queen(Color color, Position position) { super(color, position); } - + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); @@ -77,7 +77,7 @@ private List getPath(Position endPosition,Movement movement){ } return path; } - + @Override public void moveTo(Position position, List pieces) { if (!canMove(position,pieces)) { throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java index dc5c63f32b8..284fb3d0bb8 100644 --- a/src/main/java/chess/piece/Rook.java +++ b/src/main/java/chess/piece/Rook.java @@ -18,7 +18,7 @@ public class Rook extends Piece { protected Rook(Color color, Position position) { super(color, position); } - + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); @@ -76,7 +76,7 @@ private List getPath(Position endPosition,Movement movement){ } return path; } - + @Override public void moveTo(Position position, List pieces) { if (!canMove(position,pieces)) { throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); From 39c48f2936dfe0f4a5e7d12b4068e24487ff5360 Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 16:27:40 +0900 Subject: [PATCH 08/10] =?UTF-8?q?feat:=20ChessBoard=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/ChessBoard.java | 53 ++++++++++++++++++++++++ src/main/java/chess/piece/Bishop.java | 5 +++ src/main/java/chess/piece/King.java | 6 +++ src/main/java/chess/piece/Knight.java | 6 +++ src/main/java/chess/piece/Pawn.java | 6 +++ src/main/java/chess/piece/Piece.java | 27 ++++++++++-- src/main/java/chess/piece/PieceType.java | 10 +++++ src/main/java/chess/piece/Queen.java | 6 +++ src/main/java/chess/piece/Rook.java | 6 +++ 9 files changed, 122 insertions(+), 3 deletions(-) create mode 100644 src/main/java/chess/ChessBoard.java create mode 100644 src/main/java/chess/piece/PieceType.java diff --git a/src/main/java/chess/ChessBoard.java b/src/main/java/chess/ChessBoard.java new file mode 100644 index 00000000000..3909f147140 --- /dev/null +++ b/src/main/java/chess/ChessBoard.java @@ -0,0 +1,53 @@ +package chess; + +import chess.piece.King; +import chess.piece.Piece; +import chess.piece.PieceType; +import java.util.List; +import java.util.Optional; + +public class ChessBoard { + + private final List pieces; + + public ChessBoard(List pieces) { + this.pieces = pieces; + } + + public void movePiece(Position startPosition, Position endPosition, Color turn){ + Piece startPiece = pieces.stream().filter(piece -> piece.isSamePosition(startPosition) && piece.isSameColor(turn)) + .findAny() + .orElseThrow(() -> new IllegalArgumentException("해당 자리에는 말이 없거나 상대 말입니다.")); + boolean canMove = startPiece.canMove(startPosition, findAlivePiece()); + + if(!canMove){ + throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); + } + Optional endPiece = pieces.stream() + .filter(piece -> piece.isSamePosition(endPosition) && piece.isAnotherTeam(startPiece)) + .findAny(); + endPiece.ifPresent(Piece::changePieceToDead); + startPiece.moveTo(endPosition,findAlivePiece()); + } + + public boolean isKingDead(){ + return pieces.stream() + .anyMatch(piece -> piece.isSamePieceType(PieceType.KING) && !piece.isAlive()); + } + + public Color findWinColor(){ + Optional deadKing = pieces.stream() + .filter(piece -> piece.isSamePieceType(PieceType.KING) && !piece.isAlive()) + .findAny(); + if(deadKing.isEmpty()){ + throw new IllegalArgumentException("게임이 아직 안끝났습니다."); + } + return deadKing.get().getColor().opposite(); + } + + private List findAlivePiece(){ + return pieces.stream() + .filter(Piece::isAlive) + .toList(); + } +} diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java index 1ab15127585..1f022d912f5 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/src/main/java/chess/piece/Bishop.java @@ -19,6 +19,11 @@ protected Bishop(Color color, Position position) { super(color, position); } + @Override + public PieceType getPieceType() { + return PieceType.BISHOP; + } + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java index 2daf9ce769a..58ae29a059d 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/piece/King.java @@ -18,6 +18,12 @@ public class King extends Piece { protected King(Color color, Position position) { super(color, position); } + + @Override + public PieceType getPieceType() { + return PieceType.KING; + } + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java index 6a7a2eedf09..9c841ed42fa 100644 --- a/src/main/java/chess/piece/Knight.java +++ b/src/main/java/chess/piece/Knight.java @@ -18,6 +18,12 @@ public class Knight extends Piece { protected Knight(Color color, Position position) { super(color, position); } + + @Override + public PieceType getPieceType() { + return PieceType.KNIGHT; + } + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index 9ba9bdc1e69..4606d8258c7 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -26,6 +26,12 @@ protected Pawn(Color color, Position position) { super(color, position); hasMoved = false; } + + @Override + public PieceType getPieceType() { + return PieceType.PAWN; + } + @Override public boolean canMove(Position position, List pieces) { List movements = movementForColor.get(this.color); diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java index 5ef2b6694fb..ec04687b568 100644 --- a/src/main/java/chess/piece/Piece.java +++ b/src/main/java/chess/piece/Piece.java @@ -1,18 +1,18 @@ package chess.piece; import chess.Color; -import chess.Movement; import chess.Position; import java.util.List; -import java.util.Optional; public abstract class Piece { protected Position position; protected final Color color; + protected boolean isAlive; protected Piece(Color color,Position position) { this.color = color; this.position = position; + isAlive = true; } public Position getPosition() { @@ -20,13 +20,34 @@ public Position getPosition() { } public boolean isAnotherTeam(Piece piece){ - return !this.color.equals(piece.color); + return !isSameColor(piece.color); + } + + public boolean isSameColor(Color color){ + return this.color.equals(color); } public boolean isSamePosition(Position position){ return this.position.equals(position); } + public boolean isAlive(){ + return isAlive; + } + + public void changePieceToDead(){ + isAlive = false; + } + + public boolean isSamePieceType(PieceType pieceType){ + return getPieceType().equals(pieceType); + } + + public Color getColor() { + return color; + } + + public abstract PieceType getPieceType(); public abstract void moveTo(Position position, List pieces); public abstract boolean canMove(Position position, List pieces); } diff --git a/src/main/java/chess/piece/PieceType.java b/src/main/java/chess/piece/PieceType.java new file mode 100644 index 00000000000..65fd3aebe21 --- /dev/null +++ b/src/main/java/chess/piece/PieceType.java @@ -0,0 +1,10 @@ +package chess.piece; + +public enum PieceType { + BISHOP, + KING, + KNIGHT, + PAWN, + QUEEN, + ROCK +} diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java index 58ce8275f29..b9964888d13 100644 --- a/src/main/java/chess/piece/Queen.java +++ b/src/main/java/chess/piece/Queen.java @@ -19,6 +19,12 @@ public class Queen extends Piece { protected Queen(Color color, Position position) { super(color, position); } + + @Override + public PieceType getPieceType() { + return PieceType.QUEEN; + } + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java index 284fb3d0bb8..f9a662c0d9c 100644 --- a/src/main/java/chess/piece/Rook.java +++ b/src/main/java/chess/piece/Rook.java @@ -18,6 +18,12 @@ public class Rook extends Piece { protected Rook(Color color, Position position) { super(color, position); } + + @Override + public PieceType getPieceType() { + return PieceType.ROCK; + } + @Override public boolean canMove(Position position, List pieces) { Optional findMovement = getFindMovement(position, movements); From cc04b44949152b67dbf8fa87c635429a8169a02b Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 19:31:35 +0900 Subject: [PATCH 09/10] =?UTF-8?q?feat:=20=EC=B2=B4=EC=8A=A4=20=EA=B5=AC?= =?UTF-8?q?=ED=98=84=20=EC=99=84=EB=A3=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Application.java | 10 ++++ src/main/java/chess/ChessBoard.java | 7 ++- src/main/java/chess/ChessRunner.java | 57 ++++++++++++++++++ src/main/java/chess/Color.java | 16 +++++- src/main/java/chess/Column.java | 35 +++++++++--- src/main/java/chess/PiecesFactory.java | 57 ++++++++++++++++++ src/main/java/chess/Position.java | 4 ++ src/main/java/chess/Row.java | 35 +++++++++--- src/main/java/chess/piece/Bishop.java | 10 +--- src/main/java/chess/piece/King.java | 2 +- src/main/java/chess/piece/Knight.java | 2 +- src/main/java/chess/piece/Pawn.java | 2 +- src/main/java/chess/piece/PieceType.java | 22 +++++-- src/main/java/chess/piece/Queen.java | 2 +- src/main/java/chess/piece/Rook.java | 2 +- src/main/java/util/PositionConvertor.java | 29 ++++++++++ src/main/java/view/InputView.java | 21 +++++++ src/main/java/view/OutputView.java | 70 +++++++++++++++++++++++ src/test/java/chess/piece/PawnTest.java | 1 - 19 files changed, 342 insertions(+), 42 deletions(-) create mode 100644 src/main/java/Application.java create mode 100644 src/main/java/chess/ChessRunner.java create mode 100644 src/main/java/chess/PiecesFactory.java create mode 100644 src/main/java/util/PositionConvertor.java create mode 100644 src/main/java/view/InputView.java create mode 100644 src/main/java/view/OutputView.java diff --git a/src/main/java/Application.java b/src/main/java/Application.java new file mode 100644 index 00000000000..0fb979a4687 --- /dev/null +++ b/src/main/java/Application.java @@ -0,0 +1,10 @@ +import chess.ChessRunner; +import view.InputView; +import view.OutputView; + +public class Application { + public static void main(String[] args) { + ChessRunner chessRunner = new ChessRunner(new InputView(),new OutputView()); + chessRunner.run(); + } +} diff --git a/src/main/java/chess/ChessBoard.java b/src/main/java/chess/ChessBoard.java index 3909f147140..4f7bc6c45cc 100644 --- a/src/main/java/chess/ChessBoard.java +++ b/src/main/java/chess/ChessBoard.java @@ -18,16 +18,17 @@ public void movePiece(Position startPosition, Position endPosition, Color turn){ Piece startPiece = pieces.stream().filter(piece -> piece.isSamePosition(startPosition) && piece.isSameColor(turn)) .findAny() .orElseThrow(() -> new IllegalArgumentException("해당 자리에는 말이 없거나 상대 말입니다.")); - boolean canMove = startPiece.canMove(startPosition, findAlivePiece()); + boolean canMove = startPiece.canMove(endPosition, findAlivePiece()); if(!canMove){ throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); } + Optional endPiece = pieces.stream() .filter(piece -> piece.isSamePosition(endPosition) && piece.isAnotherTeam(startPiece)) .findAny(); - endPiece.ifPresent(Piece::changePieceToDead); startPiece.moveTo(endPosition,findAlivePiece()); + endPiece.ifPresent(Piece::changePieceToDead); } public boolean isKingDead(){ @@ -45,7 +46,7 @@ public Color findWinColor(){ return deadKing.get().getColor().opposite(); } - private List findAlivePiece(){ + public List findAlivePiece(){ return pieces.stream() .filter(Piece::isAlive) .toList(); diff --git a/src/main/java/chess/ChessRunner.java b/src/main/java/chess/ChessRunner.java new file mode 100644 index 00000000000..cd2cc4e98e3 --- /dev/null +++ b/src/main/java/chess/ChessRunner.java @@ -0,0 +1,57 @@ +package chess; + +import chess.piece.Piece; +import java.util.List; +import view.InputView; +import view.OutputView; + +public class ChessRunner { + + private final InputView inputView; + private final OutputView outputView; + + public ChessRunner(InputView inputView, OutputView outputView) { + this.inputView = inputView; + this.outputView = outputView; + } + + public void run(){ + ChessBoard chessBoard = initializeBoard(); + showBoard(chessBoard); + startGame(chessBoard); + } + + private void showBoard(ChessBoard chessBoard){ + List alivePiece = chessBoard.findAlivePiece(); + outputView.printBoard(alivePiece); + } + + + private void startGame(ChessBoard chessBoard){ + Color turn = Color.WHITE; + while (!chessBoard.isKingDead()) { + move(chessBoard,turn); + showBoard(chessBoard); + turn = turn.opposite(); + } + Color winColor = chessBoard.findWinColor(); + outputView.printWinner(winColor); + } + + public void move(ChessBoard chessBoard,Color turn){ + while(true){ + try{ + Position startPosition = inputView.getStartPosition(turn); + Position endPosition = inputView.getEndPosition(); + chessBoard.movePiece(startPosition,endPosition,turn); + return; + }catch(IllegalArgumentException e){ + outputView.printExceptionMessage(e.getMessage()); + } + } + } + + private ChessBoard initializeBoard(){ + return new ChessBoard(PiecesFactory.getInitializedPieces()); + } +} diff --git a/src/main/java/chess/Color.java b/src/main/java/chess/Color.java index 55cd020b681..8e25bf4d987 100644 --- a/src/main/java/chess/Color.java +++ b/src/main/java/chess/Color.java @@ -2,9 +2,13 @@ public enum Color { - BLACK, - WHITE, - EMPTY; + BLACK("흑"), + WHITE("백"), + EMPTY("없음"); + + Color(String name) { + this.name = name; + } public boolean isWhite() { return this == WHITE; @@ -25,4 +29,10 @@ public Color opposite() { default -> EMPTY; }; } + + private final String name; + + public String getName() { + return name; + } } diff --git a/src/main/java/chess/Column.java b/src/main/java/chess/Column.java index 2684415a5ce..8cfd4b35f92 100644 --- a/src/main/java/chess/Column.java +++ b/src/main/java/chess/Column.java @@ -1,15 +1,34 @@ package chess; +import java.util.Arrays; + public enum Column { - A, - B, - C, - D, - E, - F, - G, - H; + A('A'), + B('B'), + C('C'), + D('D'), + E('E'), + F('F'), + G('G'), + H('H'); + + private final char name; + + Column(char name) { + this.name = name; + } + + public char getName() { + return name; + } + + public static Column findColumn(char input){ + return Arrays.stream(Column.values()) + .filter(row -> row.name==input) + .findAny() + .orElseThrow(()->new IllegalArgumentException("A부터 H까지 열을 선택해주세요(대문자만 가능합니다)")); + } public boolean isFarLeft() { return ordinal() == 0; diff --git a/src/main/java/chess/PiecesFactory.java b/src/main/java/chess/PiecesFactory.java new file mode 100644 index 00000000000..2617c274474 --- /dev/null +++ b/src/main/java/chess/PiecesFactory.java @@ -0,0 +1,57 @@ +package chess; + +import chess.piece.Bishop; +import chess.piece.King; +import chess.piece.Knight; +import chess.piece.Pawn; +import chess.piece.Piece; +import chess.piece.Queen; +import chess.piece.Rook; +import java.util.List; +import java.util.Map; + +public class PiecesFactory { + + private static final List pieces; + + static { + pieces=List.of( + new Pawn(Color.WHITE,new Position(Row.TWO,Column.A)), + new Pawn(Color.WHITE,new Position(Row.TWO,Column.B)), + new Pawn(Color.WHITE,new Position(Row.TWO,Column.C)), + new Pawn(Color.WHITE,new Position(Row.TWO,Column.D)), + new Pawn(Color.WHITE,new Position(Row.TWO,Column.E)), + new Pawn(Color.WHITE,new Position(Row.TWO,Column.F)), + new Pawn(Color.WHITE,new Position(Row.TWO,Column.G)), + new Pawn(Color.WHITE,new Position(Row.TWO,Column.H)), + new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.A)), + new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.B)), + new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.C)), + new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.D)), + new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.E)), + new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.F)), + new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.G)), + new Pawn(Color.BLACK,new Position(Row.SEVEN,Column.H)), + new King(Color.WHITE,new Position(Row.ONE,Column.E)), + new King(Color.BLACK,new Position(Row.EIGHT,Column.E)), + new Queen(Color.WHITE,new Position(Row.ONE,Column.D)), + new Queen(Color.BLACK,new Position(Row.EIGHT,Column.D)), + new Rook(Color.WHITE,new Position(Row.ONE,Column.A)), + new Rook(Color.WHITE,new Position(Row.ONE,Column.H)), + new Rook(Color.BLACK,new Position(Row.EIGHT,Column.A)), + new Rook(Color.BLACK,new Position(Row.EIGHT,Column.H)), + new Knight(Color.WHITE,new Position(Row.ONE,Column.B)), + new Knight(Color.WHITE,new Position(Row.ONE,Column.G)), + new Knight(Color.BLACK,new Position(Row.EIGHT,Column.B)), + new Knight(Color.BLACK,new Position(Row.EIGHT,Column.G)), + new Bishop(Color.WHITE,new Position(Row.ONE,Column.C)), + new Bishop(Color.WHITE,new Position(Row.ONE,Column.F)), + new Bishop(Color.BLACK,new Position(Row.EIGHT,Column.C)), + new Bishop(Color.BLACK,new Position(Row.EIGHT,Column.F)) + ); + } + + public static List getInitializedPieces(){ + return pieces; + } +} diff --git a/src/main/java/chess/Position.java b/src/main/java/chess/Position.java index e3134c24e34..1fd9fda8abd 100644 --- a/src/main/java/chess/Position.java +++ b/src/main/java/chess/Position.java @@ -8,6 +8,10 @@ public Position(final Row row, final Column column) { this(column, row); } + public static Position copyOf(final Position position){ + return new Position(position.row,position.column); + } + public boolean canMoveUp() { return row.canMoveUp(1); } diff --git a/src/main/java/chess/Row.java b/src/main/java/chess/Row.java index 126ed048daa..8cc6b7a1322 100644 --- a/src/main/java/chess/Row.java +++ b/src/main/java/chess/Row.java @@ -1,15 +1,34 @@ package chess; +import java.util.Arrays; + public enum Row { - EIGHT, - SEVEN, - SIX, - FIVE, - FOUR, - THREE, - TWO, - ONE; + EIGHT('8'), + SEVEN('7'), + SIX('6'), + FIVE('5'), + FOUR('4'), + THREE('3'), + TWO('2'), + ONE('1'); + + private final char name; + + Row(char name) { + this.name = name; + } + + public char getName() { + return name; + } + + public static Row findRow(char input){ + return Arrays.stream(Row.values()) + .filter(row -> row.name==input) + .findAny() + .orElseThrow(()->new IllegalArgumentException("1부터 8까지 행을 선택해주세요")); + } public boolean isTop() { return ordinal() == 0; diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java index 1f022d912f5..2f3b3798702 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/src/main/java/chess/piece/Bishop.java @@ -15,7 +15,7 @@ public class Bishop extends Piece { movements = List.of(Movement.LEFT_UP,Movement.RIGHT_UP,Movement.LEFT_DOWN,Movement.RIGHT_DOWN); } - protected Bishop(Color color, Position position) { + public Bishop(Color color, Position position) { super(color, position); } @@ -88,12 +88,6 @@ public void moveTo(Position position, List pieces) { if (!canMove(position,pieces)) { throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); } - Optional findMovement = getFindMovement(position, movements); - if (findMovement.isEmpty()) { - throw new IllegalArgumentException("해당 자리에 이동할 수 없습니다."); - } - this.position = this.position.move(findMovement.get()); + this.position = Position.copyOf(position); } - - } diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java index 58ae29a059d..196eb8f487a 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/piece/King.java @@ -15,7 +15,7 @@ public class King extends Piece { Movement.RIGHT_UP,Movement.LEFT_UP,Movement.RIGHT_DOWN,Movement.LEFT_DOWN); } - protected King(Color color, Position position) { + public King(Color color, Position position) { super(color, position); } diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java index 9c841ed42fa..c7423055c24 100644 --- a/src/main/java/chess/piece/Knight.java +++ b/src/main/java/chess/piece/Knight.java @@ -15,7 +15,7 @@ public class Knight extends Piece { Movement.RIGHT_RIGHT_DOWN,Movement.RIGHT_RIGHT_UP,Movement.LEFT_LEFT_DOWN,Movement.LEFT_LEFT_UP); } - protected Knight(Color color, Position position) { + public Knight(Color color, Position position) { super(color, position); } diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index 4606d8258c7..ac86cf0629c 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -22,7 +22,7 @@ public class Pawn extends Piece { private boolean hasMoved; - protected Pawn(Color color, Position position) { + public Pawn(Color color, Position position) { super(color, position); hasMoved = false; } diff --git a/src/main/java/chess/piece/PieceType.java b/src/main/java/chess/piece/PieceType.java index 65fd3aebe21..7c0c87647aa 100644 --- a/src/main/java/chess/piece/PieceType.java +++ b/src/main/java/chess/piece/PieceType.java @@ -1,10 +1,20 @@ package chess.piece; public enum PieceType { - BISHOP, - KING, - KNIGHT, - PAWN, - QUEEN, - ROCK + BISHOP("B"), + KING("K"), + KNIGHT("N"), + PAWN("P"), + QUEEN("Q"), + ROCK("R"); + + private final String name; + + PieceType(String name) { + this.name = name; + } + + public String getName() { + return name; + } } diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java index b9964888d13..acd72ba3324 100644 --- a/src/main/java/chess/piece/Queen.java +++ b/src/main/java/chess/piece/Queen.java @@ -16,7 +16,7 @@ public class Queen extends Piece { Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); } - protected Queen(Color color, Position position) { + public Queen(Color color, Position position) { super(color, position); } diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java index f9a662c0d9c..9e1b76f2bb8 100644 --- a/src/main/java/chess/piece/Rook.java +++ b/src/main/java/chess/piece/Rook.java @@ -15,7 +15,7 @@ public class Rook extends Piece { movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); } - protected Rook(Color color, Position position) { + public Rook(Color color, Position position) { super(color, position); } diff --git a/src/main/java/util/PositionConvertor.java b/src/main/java/util/PositionConvertor.java new file mode 100644 index 00000000000..0ed59132e81 --- /dev/null +++ b/src/main/java/util/PositionConvertor.java @@ -0,0 +1,29 @@ +package util; + +import chess.Column; +import chess.Position; +import chess.Row; + +public class PositionConvertor { + + public static Position convertInputToPosition(String input) { + validateLength(input); + char colInput = getColInput(input); + char rowInput = getRowInput(input); + return new Position(Row.findRow(rowInput), Column.findColumn(colInput)); + } + + private static char getColInput(String input) { + return input.charAt(0); + } + + private static char getRowInput(String input) { + return input.charAt(1); + } + + private static void validateLength(String input) { + if (input.length() != 2) { + throw new IllegalArgumentException("열과 행 정보를 정확히 입력해주세요"); + } + } +} diff --git a/src/main/java/view/InputView.java b/src/main/java/view/InputView.java new file mode 100644 index 00000000000..a2e42d4d4d4 --- /dev/null +++ b/src/main/java/view/InputView.java @@ -0,0 +1,21 @@ +package view; + +import chess.Color; +import chess.Position; +import java.util.Scanner; +import util.PositionConvertor; + +public class InputView { + + private final Scanner scanner = new Scanner(System.in); + + public Position getStartPosition(Color turn){ + System.out.printf("%s의 차례입니다. 이동하고 싶은 말의 위치를 선택해주세요. 예) A4\n",turn.getName()); + return PositionConvertor.convertInputToPosition(scanner.nextLine().trim()); + } + + public Position getEndPosition(){ + System.out.println("이동하려는 위치를 입력해주세요."); + return PositionConvertor.convertInputToPosition(scanner.nextLine().trim()); + } +} diff --git a/src/main/java/view/OutputView.java b/src/main/java/view/OutputView.java new file mode 100644 index 00000000000..271824e8b9e --- /dev/null +++ b/src/main/java/view/OutputView.java @@ -0,0 +1,70 @@ +package view; + +import chess.Color; +import chess.Column; +import chess.Position; +import chess.Row; +import chess.piece.Piece; +import chess.piece.PieceType; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +public class OutputView { + + public void printWinner(Color color){ + System.out.printf("축하합니다! %s의 승리입니다!\n",color.getName()); + } + + public void printBoard(List pieces){ + String columnInfo = Arrays.stream(Column.values()) + .map(Column::getName) + .map(String::valueOf) + .collect(Collectors.joining(" ")); + System.out.println(" "+columnInfo); + Row[] rows = Row.values(); + Column[] columns = Column.values(); + for (int row = 0; row < rows.length; row++) { + printRowInfo(rows[row]); + for (int col = 0; col < columns.length; col++) { + Position position = new Position(rows[row],columns[col]); + Optional findPiece = getFindPiece(pieces, position); + printPositionState(findPiece.orElse(null)); + } + System.out.println(); + } + System.out.println(); + System.out.println(); + } + + public void printExceptionMessage(String message){ + System.out.println(message); + } + + private void printRowInfo(Row row) { + System.out.printf("%2s ", row.getName()); + } + + private void printPositionState(Piece findPiece) { + if (findPiece == null) { + System.out.print("- "); + return; + } + System.out.print(getDescription(findPiece) + " "); + } + + private Optional getFindPiece(List pieces, Position position) { + return pieces.stream().filter(piece -> piece.isSamePosition(position)) + .findAny(); + } + + private String getDescription(Piece piece){ + Color color = piece.getColor(); + PieceType pieceType = piece.getPieceType(); + if (color.isWhite()){ + return pieceType.getName(); + } + return pieceType.getName().toLowerCase(); + } +} diff --git a/src/test/java/chess/piece/PawnTest.java b/src/test/java/chess/piece/PawnTest.java index 38f3deb92eb..3817ddc0083 100644 --- a/src/test/java/chess/piece/PawnTest.java +++ b/src/test/java/chess/piece/PawnTest.java @@ -104,7 +104,6 @@ void moveToTestException2(){ Position toPosition = new Position(Row.FOUR, Column.B); Pawn pawn1 = new Pawn(Color.WHITE,toPosition); - boolean canMove = pawn.canMove(toPosition, List.of(pawn1)); assertThat(canMove).isFalse(); From b09f94d915d6d765f9d3960eac4477b0cb5391e0 Mon Sep 17 00:00:00 2001 From: wogus Date: Sat, 22 Mar 2025 19:40:01 +0900 Subject: [PATCH 10/10] =?UTF-8?q?docs:=20readme=20=EC=82=AD=EC=A0=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 25 ------------------------- 1 file changed, 25 deletions(-) diff --git a/README.md b/README.md index 9bbc0e52013..8102f91c870 100644 --- a/README.md +++ b/README.md @@ -5,28 +5,3 @@ ## 우아한테크코스 코드리뷰 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md) - 폰 - -- 처음에는 두 칸 혹은 한 칸 -- 대각선에 적이 있으면 먹을 수 있음 - -룩 - -- 장기에서 차와 같음 - -나이트 - -- 장기에서 마와 같음 -- 말을 넘을 수 있음 - -킹 - -- 장기에서 왕과 같음 - -비숍 - -- 대각선 - -퀸 - -- 비숏과 룩 기능 합체 \ No newline at end of file