From 7b69c72f40da8f9e18c9cef6f3f82b1000310b0a Mon Sep 17 00:00:00 2001 From: PraiseBak <60121346+PraiseBak@users.noreply.github.com> Date: Sat, 22 Mar 2025 15:53:18 +0900 Subject: [PATCH 1/4] =?UTF-8?q?feat:=20=EB=B9=84=EC=88=8D,=ED=82=B9,?= =?UTF-8?q?=ED=8F=B0=20=EC=9D=B4=EB=8F=99=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC?= =?UTF-8?q?=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 8 ++ src/main/java/Application.java | 2 + src/main/java/chess/Column.java | 1 - .../chess/exception/InvalidMoveException.java | 7 ++ src/main/java/chess/piece/Bishop.java | 85 ++++++++++++++++- src/main/java/chess/piece/King.java | 67 +++++++++++++- src/main/java/chess/piece/Pawn.java | 92 ++++++++++++++++++- src/main/java/chess/piece/Piece.java | 13 +++ src/test/java/chess/piece/BishopTest.java | 51 ++++++++++ src/test/java/chess/piece/KingTest.java | 57 ++++++++++++ src/test/java/chess/piece/PawnTest.java | 63 +++++++++++++ src/test/java/chess/piece/RemovePiece.java | 21 +++++ .../java/chess/piece/RemovePieceTest.java | 27 ++++++ 13 files changed, 490 insertions(+), 4 deletions(-) create mode 100644 src/main/java/Application.java create mode 100644 src/main/java/chess/exception/InvalidMoveException.java create mode 100644 src/main/java/chess/piece/Piece.java create mode 100644 src/test/java/chess/piece/BishopTest.java create mode 100644 src/test/java/chess/piece/KingTest.java create mode 100644 src/test/java/chess/piece/PawnTest.java create mode 100644 src/test/java/chess/piece/RemovePiece.java create mode 100644 src/test/java/chess/piece/RemovePieceTest.java diff --git a/README.md b/README.md index 8102f91c870..6a19ec58298 100644 --- a/README.md +++ b/README.md @@ -5,3 +5,11 @@ ## 우아한테크코스 코드리뷰 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md) + + +# what is this +기본 위치 구조가 짜여져있을때 체스 구현하기 +- [] 첫번쨰 플레이어는 Black 두번째 플레이어는 White +- [] 플레이어는 기물을 이동시킬 수 있다 +- [] 플레이어는 체크메이트시 상대방을 이긴다 +- [] 기권 기능은 없다 diff --git a/src/main/java/Application.java b/src/main/java/Application.java new file mode 100644 index 00000000000..31b27e6664f --- /dev/null +++ b/src/main/java/Application.java @@ -0,0 +1,2 @@ +public class Application { +} diff --git a/src/main/java/chess/Column.java b/src/main/java/chess/Column.java index b64b4dc77a3..ad51629133b 100644 --- a/src/main/java/chess/Column.java +++ b/src/main/java/chess/Column.java @@ -31,7 +31,6 @@ public Column moveLeft(final int step) { if (canMoveLeft(step)) { return values()[ordinal() - step]; } - throw new IllegalStateException("움직일 수 없는 위치입니다."); } diff --git a/src/main/java/chess/exception/InvalidMoveException.java b/src/main/java/chess/exception/InvalidMoveException.java new file mode 100644 index 00000000000..3a98e930f1e --- /dev/null +++ b/src/main/java/chess/exception/InvalidMoveException.java @@ -0,0 +1,7 @@ +package chess.exception; + +public class InvalidMoveException extends IllegalArgumentException{ + public InvalidMoveException(){ + super("유효하지 않은 기물 움직임입니다"); + } +} diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java index b14ab70f981..ef128f066af 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/src/main/java/chess/piece/Bishop.java @@ -1,5 +1,88 @@ package chess.piece; -public class Bishop { +import chess.Color; +import chess.Movement; +import chess.Position; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Optional; +public class Bishop implements Piece{ + + private Position position; + private final Color color; + private final List movements = List.of(Movement.RIGHT_UP,Movement.LEFT_UP,Movement.RIGHT_DOWN,Movement.LEFT_DOWN); + + public Bishop(Position position, Color color) { + this.position = position; + this.color = color; + } + + public void move(Position wantedPosition, List wantedPositionExistPieces) { + for (Movement movement : movements){ + this.position = movementWhenPossible(movement,wantedPosition,wantedPositionExistPieces); + if(position.equals(wantedPosition)) { + return; + } + } + if(!position.equals(wantedPosition)){ + throw new InvalidMoveException(); + } + } + + private Position movementWhenPossible(Movement movement, Position wantedPosition, + List wantedPositionExistPiece) { + Position temporalPosition = position; + while (temporalPosition.canMove(movement)){ + temporalPosition = temporalPosition.move(movement); + if(temporalPosition.equals(wantedPosition) && isPositionDoesntExistSameColor(wantedPositionExistPiece, temporalPosition)){ + return temporalPosition; + } + if(isSamePositionPieceExist(wantedPositionExistPiece, temporalPosition)){ + throw new InvalidMoveException(); + } + } + return position; + } + + private boolean isPositionDoesntExistSameColor(List wantedPositionExistPiece, Position temporalPosition) { + Optional otherPieceByPosition = findOtherPieceByPosition(temporalPosition, wantedPositionExistPiece); + if(otherPieceByPosition.isEmpty()){ + return true; + } + return isOpposite(otherPieceByPosition.get()); + } + + private Optional findOtherPieceByPosition(Position temporalPosition, List wantedPositionExistPiece) { + for(Piece piece : wantedPositionExistPiece){ + if(piece.getPosition().equals(temporalPosition)){ + return Optional.of(piece); + } + } + return Optional.empty(); + } + + private boolean isSamePositionPieceExist(List wantedPositionExistPiece, Position temporalPosition) { + for(Piece piece : wantedPositionExistPiece){ + if(piece.getPosition().equals(temporalPosition)){ + return true; + } + } + return false; + } + + @Override + public Position getPosition() { + return position; + } + + @Override + public boolean isOpposite(Piece piece) { + return color.opposite() == piece.getColor(); + } + + @Override + public Color getColor() { + return color; + } } diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java index d64210cad13..f4f45d4f32a 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/piece/King.java @@ -1,5 +1,70 @@ package chess.piece; -public class King { +import chess.Color; +import chess.Movement; +import chess.Position; +import chess.exception.InvalidMoveException; +import java.util.List; +public class King implements Piece{ + + private Position position; + private final Color color; + private final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); + + public King(Position position, Color color) { + this.position = position; + this.color = color; + } + + @Override + public void move(Position wantedPosition, List wantedPositionExistPiece) { + boolean isWantedPositionExistSameColor = isWantedPositionIsNotSameColor(wantedPositionExistPiece); + + if(!isWantedPositionExistSameColor){ + throw new InvalidMoveException(); + + } + for(Movement movement : movements){ + var temporalPosition = moveWhenPossible(movement); + if(temporalPosition.equals(wantedPosition)){ + position = temporalPosition; + return; + } + } + throw new InvalidMoveException(); + } + + private boolean isWantedPositionIsNotSameColor(List wantedPositionExistPiece) { + if(wantedPositionExistPiece.isEmpty()){ + return true; + } + + Piece first = wantedPositionExistPiece.getFirst(); + return this.isOpposite(first); + } + + private Position moveWhenPossible(Movement movement) { + var temporalPosition = position; + if(temporalPosition.canMove(movement)){ + return temporalPosition.move(movement); + } + return position; + } + + @Override + public Position getPosition() { + return position; + } + + @Override + public boolean isOpposite(Piece piece) { + Color oppositeColor = this.color.opposite(); + return oppositeColor.equals(piece.getColor()); + } + + @Override + public Color getColor() { + return color; + } } diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index c8b6cafa51e..9cb2cc05eac 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -1,5 +1,95 @@ package chess.piece; -public class Pawn { +import chess.Color; +import chess.Movement; +import chess.Position; +import chess.Row; +import chess.exception.InvalidMoveException; +import java.util.List; +public class Pawn implements Piece{ + + private static final int START_MOVE_WEIGHT = 2; + private static final int NOT_START_MOVE_WEIGHT = 1; + private static final Movement BLACK_MOVEMENT = Movement.DOWN; + private static final List BLACK_ATTACK_MOVEMENTS = List.of(Movement.LEFT_DOWN,Movement.RIGHT_DOWN); + private static final Movement WHITE_MOVEMENT = Movement.UP; + private static final List WHITE_ATTACK_MOVEMENTS = List.of(Movement.LEFT_UP,Movement.RIGHT_UP); + + private final Row startRow; + private final Movement onlyMoveMovement; + private final List attackMovement; + private final Color color; + private Position position; + + + public Pawn(Position position, Color color) { + this.color = color; + this.position = position; + startRow = position.row(); + if(color == Color.BLACK){ + onlyMoveMovement = BLACK_MOVEMENT; + attackMovement = BLACK_ATTACK_MOVEMENTS; + return; + } + onlyMoveMovement = WHITE_MOVEMENT; + attackMovement = WHITE_ATTACK_MOVEMENTS; + } + + private Position attackMove(Piece wantedPositionExistPiece, Position wantedPosition) { + for(Movement movement : attackMovement){ + var temporalPosition = moveWhenPossible(movement); + if(temporalPosition.equals(wantedPositionExistPiece.getPosition()) && wantedPositionExistPiece.isOpposite(this)){ + return wantedPosition; + } + } + throw new InvalidMoveException(); + } + + private Position moveWhenPossible(Movement movement) { + if(position.canMove(movement)){ + return position.move(movement); + } + return position; + } + + private Position onlyMove(int startMoveWeight, Position wantedPosition) { + Position temporalPosition = position; + for (int i = 0; i < startMoveWeight; i++) { + temporalPosition = temporalPosition.move(onlyMoveMovement); + if(temporalPosition.equals(wantedPosition)){ + return temporalPosition; + } + } + throw new InvalidMoveException(); + } + + @Override + public void move(Position wantedPosition, List wantedPositionExistPiece) { + if(!wantedPositionExistPiece.isEmpty()){ + this.position = attackMove(wantedPositionExistPiece.getFirst(),wantedPosition); + return; + } + if(isPawnStartMove()){ + this.position = onlyMove(START_MOVE_WEIGHT,wantedPosition); + return; + } + this.position = onlyMove(NOT_START_MOVE_WEIGHT,wantedPosition); + } + + private boolean isPawnStartMove() { + return startRow.equals(position.row()); + } + + public boolean isOpposite(Piece piece) { + return color.opposite() == piece.getColor(); + } + + public Color getColor() { + return color; + } + + public Position getPosition() { + return position; + } } diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java new file mode 100644 index 00000000000..f85d4d4d6c1 --- /dev/null +++ b/src/main/java/chess/piece/Piece.java @@ -0,0 +1,13 @@ +package chess.piece; + +import chess.Color; +import chess.Position; +import java.util.List; +import java.util.Optional; + +public interface Piece { + void move(Position wantedPosition, List wantedPositionExistPiece); + Position getPosition(); + boolean isOpposite(Piece piece); + Color getColor(); +} diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java new file mode 100644 index 00000000000..21ef43710c0 --- /dev/null +++ b/src/test/java/chess/piece/BishopTest.java @@ -0,0 +1,51 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Optional; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class BishopTest { + + @Test + void 비숍은_대각선으로_이동할수_있다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + bishop.move(Fixtures.D2,List.of()); + Assertions.assertThat(bishop.getPosition()).isEqualTo(Fixtures.D2); + } + + @Test + void 비숍은_직선으로_이동할수_없다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + Assertions.assertThatThrownBy(() -> bishop.move(Fixtures.C2,List.of())) + .isInstanceOf(InvalidMoveException.class); + } + + @Test + void 비숍은_적팀이_있는_대각선으로_이동할수_있다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + bishop.move(Fixtures.D2,List.of()); + Assertions.assertThat(bishop.getPosition()).isEqualTo(Fixtures.D2); + } + + @Test + void 같은팀이_있는곳으로는_이동할수_없다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + Pawn sameColorTeam = new Pawn(Fixtures.D2,Color.WHITE); + Assertions.assertThatThrownBy(() -> bishop.move(Fixtures.D2, List.of(sameColorTeam))).isInstanceOf( + InvalidMoveException.class); + } + + @Test + void 적팀이_있는곳으로는_이동할수_있다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.D2,Color.BLACK); + bishop.move(Fixtures.D2,List.of(enemy)); + Assertions.assertThat(bishop.getPosition()).isEqualTo(Fixtures.D2); + } +} + + diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/piece/KingTest.java new file mode 100644 index 00000000000..297fb7089a6 --- /dev/null +++ b/src/test/java/chess/piece/KingTest.java @@ -0,0 +1,57 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.exception.InvalidMoveException; +import java.util.List; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.junit.jupiter.params.provider.ValueSources; + +public class KingTest { + + @Test + void 킹은_위로_한칸_이동할수_있다(){ + King king = new King(Fixtures.A2,Color.WHITE); + king.move(Fixtures.A3, List.of()); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.A3); + } + + @Test + void 킹은_오른쪽으로_한칸_이동할수_있다(){ + King king = new King(Fixtures.A2,Color.WHITE); + king.move(Fixtures.B2, List.of()); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.B2); + } + + @Test + void 킹은_왼쪽_한칸_이동할수_있다(){ + King king = new King(Fixtures.B2,Color.WHITE); + king.move(Fixtures.A2, List.of()); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.A2); + } + + @Test + void 킹은_아래로_한칸_이동할수_있다(){ + King king = new King(Fixtures.D2,Color.WHITE); + king.move(Fixtures.D1, List.of()); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.D1); + } + + @Test + void 킹은_적팀이_있으면_잡을수_있다(){ + King king = new King(Fixtures.A2,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.A3,Color.BLACK); + king.move(Fixtures.A3, List.of(enemy)); + Assertions.assertThat(king.getPosition()).isEqualTo(Fixtures.A3); + } + + @Test + void 킹은_같은팀이_있는곳으로_이동할_수_없다(){ + King king = new King(Fixtures.A2,Color.WHITE); + Pawn sameTeam = new Pawn(Fixtures.A3,Color.WHITE); + Assertions.assertThatThrownBy(() -> king.move(Fixtures.A3,List.of(sameTeam))).isInstanceOf(InvalidMoveException.class); + } +} diff --git a/src/test/java/chess/piece/PawnTest.java b/src/test/java/chess/piece/PawnTest.java new file mode 100644 index 00000000000..26c88d2d58e --- /dev/null +++ b/src/test/java/chess/piece/PawnTest.java @@ -0,0 +1,63 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.Position; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Optional; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class PawnTest { + + @Test + void 백_폰은_처음_위치에서_두칸_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A2, Color.WHITE); + pawn.move(Fixtures.A4, List.of()); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.A4); + } + + @Test + void 백_폰은_처음_위치에서_한칸_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A2, Color.WHITE); + pawn.move(Fixtures.A3, List.of()); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.A3); + } + + @Test + void 이동할수_없는곳이면_예외가_발생한다(){ + Pawn pawn = new Pawn(Fixtures.A2, Color.WHITE); + Assertions.assertThatThrownBy(() -> pawn.move(Fixtures.A2,List.of())).isInstanceOf(InvalidMoveException.class); + } + + @Test + void 흑_폰은_처음_위치에서_두칸_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A7, Color.BLACK); + pawn.move(Fixtures.A5, List.of()); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.A5); + } + + @Test + void 흑_폰은_처음_위치에서_한칸_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A7, Color.BLACK); + pawn.move(Fixtures.A6, List.of()); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.A6); + } + + @Test + void 백_폰은_대각선의_흑폰으로_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A2, Color.WHITE); + Pawn enemyPawn = new Pawn(Fixtures.B3, Color.BLACK); + pawn.move(Fixtures.B3,List.of(enemyPawn)); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.B3); + } + + @Test + void 흑_폰은_대각선의_백폰으로_이동할수_있다(){ + Pawn pawn = new Pawn(Fixtures.A7, Color.BLACK); + Pawn enemyPawn = new Pawn(Fixtures.B6, Color.WHITE); + pawn.move(Fixtures.B3,List.of(enemyPawn)); + Assertions.assertThat(pawn.getPosition()).isEqualTo(Fixtures.B3); + } +} diff --git a/src/test/java/chess/piece/RemovePiece.java b/src/test/java/chess/piece/RemovePiece.java new file mode 100644 index 00000000000..70e15ea2176 --- /dev/null +++ b/src/test/java/chess/piece/RemovePiece.java @@ -0,0 +1,21 @@ +package chess.piece; + +import java.util.Optional; + +public class RemovePiece { + + private final Pawn movedPiece; + private final Pawn enemy; + + public RemovePiece(Pawn movedPiece, Pawn enemy) { + this.movedPiece = movedPiece; + this.enemy = enemy; + } + + public Optional getDeadPiece() { + if(movedPiece.getPosition().equals(enemy.getPosition()) && movedPiece.isOpposite(enemy)){ + return Optional.of(enemy); + } + return Optional.empty(); + } +} diff --git a/src/test/java/chess/piece/RemovePieceTest.java b/src/test/java/chess/piece/RemovePieceTest.java new file mode 100644 index 00000000000..cc7a249cfb4 --- /dev/null +++ b/src/test/java/chess/piece/RemovePieceTest.java @@ -0,0 +1,27 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.exception.InvalidMoveException; +import java.util.Optional; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class RemovePieceTest { + + @Test + void 죽는_기물을_반환한다(){ + Pawn pawn = new Pawn(Fixtures.A4, Color.WHITE); + Pawn enemy = new Pawn(Fixtures.A4, Color.BLACK); + RemovePiece removePiece = new RemovePiece(pawn, enemy); + Assertions.assertThat(removePiece.getDeadPiece().get()).isEqualTo(enemy); + } + + @Test + void 죽는_기물이_없으면_반환하지_않는다(){ + Pawn pawn = new Pawn(Fixtures.A4, Color.WHITE); + Pawn enemy = new Pawn(Fixtures.A5, Color.BLACK); + RemovePiece removePiece = new RemovePiece(pawn, enemy); + Assertions.assertThat(removePiece.getDeadPiece()).isEqualTo(Optional.empty()); + } +} From 5b5e02b38bca790843991477bb5e8e2d68695770 Mon Sep 17 00:00:00 2001 From: PraiseBak <60121346+PraiseBak@users.noreply.github.com> Date: Sat, 22 Mar 2025 17:12:27 +0900 Subject: [PATCH 2/4] =?UTF-8?q?feat:=20=EC=B2=B4=EC=8A=A4=20=EA=B8=B0?= =?UTF-8?q?=EB=AC=BC=20=EC=9D=B4=EB=8F=99=20=EA=B5=AC=ED=98=84=20=EB=B0=8F?= =?UTF-8?q?=20=EA=B0=99=EC=9D=80=20=EC=9C=84=EC=B9=98=EC=9D=BC=EC=8B=9C=20?= =?UTF-8?q?=EA=B8=B0=EB=AC=BC=20=EC=A3=BD=EC=9D=8C=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/ChessGame.java | 80 +++++++++++++ src/main/java/chess/piece/Bishop.java | 25 +++- src/main/java/chess/piece/King.java | 26 ++++- src/main/java/chess/piece/Knight.java | 92 ++++++++++++++- src/main/java/chess/piece/Pawn.java | 25 ++++ src/main/java/chess/piece/Piece.java | 2 + src/main/java/chess/piece/Queen.java | 109 +++++++++++++++++- src/main/java/chess/piece/Rook.java | 107 ++++++++++++++++- src/test/java/chess/ChessGameTest.java | 46 ++++++++ src/test/java/chess/piece/BishopTest.java | 9 ++ src/test/java/chess/piece/KnightTest.java | 92 +++++++++++++++ src/test/java/chess/piece/QueenTest.java | 95 +++++++++++++++ src/test/java/chess/piece/RemovePiece.java | 21 ---- .../java/chess/piece/RemovePieceTest.java | 27 ----- src/test/java/chess/piece/RookTest.java | 66 +++++++++++ 15 files changed, 768 insertions(+), 54 deletions(-) create mode 100644 src/main/java/chess/ChessGame.java create mode 100644 src/test/java/chess/ChessGameTest.java create mode 100644 src/test/java/chess/piece/KnightTest.java create mode 100644 src/test/java/chess/piece/QueenTest.java delete mode 100644 src/test/java/chess/piece/RemovePiece.java delete mode 100644 src/test/java/chess/piece/RemovePieceTest.java create mode 100644 src/test/java/chess/piece/RookTest.java diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java new file mode 100644 index 00000000000..45180964275 --- /dev/null +++ b/src/main/java/chess/ChessGame.java @@ -0,0 +1,80 @@ +package chess; + +import chess.piece.King; +import chess.piece.Piece; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +public class ChessGame { + + private final List pieces; + + public ChessGame(List pieces) { + this.pieces = new ArrayList<>(pieces); + } + + public boolean isSomeBodyKingDoesntExist(){ + Map colorKingDead = getKingSurviveStatus(); + for(Color color : colorKingDead.keySet()){ + if(colorKingDead.get(color)){ + return true; + } + } + return false; + } + + private Map getKingSurviveStatus() { + Map colorKingDead = new HashMap<>(Map.of(Color.BLACK,true,Color.WHITE,true)); + for(Piece piece : pieces){ + if(piece instanceof King){ + colorKingDead.put(piece.getColor(),false); + } + } + return colorKingDead; + } + + public Color getLoseColor(){ + Map colorKingDead = getKingSurviveStatus(); + for(Color color : colorKingDead.keySet()){ + if(colorKingDead.get(color)){ + return color; + } + } + return Color.EMPTY; + } + + public Optional killPieceWhenExistSamePositionPiece(Piece movePiece) { + Optional samePositionOtherPiece = findSamePositionPiece(movePiece); + if(samePositionOtherPiece.isEmpty()){ + return samePositionOtherPiece; + } + + Piece otherPiece = samePositionOtherPiece.get(); + if(movePiece.isSamePosition(otherPiece) && movePiece.isOpposite(otherPiece)){ + killPiece(otherPiece); + return Optional.of(otherPiece); + } + return Optional.empty(); + } + + private Optional findSamePositionPiece(Piece movePiece) { + for(Piece piece : pieces){ + if(piece.isSamePosition(movePiece) && movePiece.isOpposite(piece)){ + return Optional.of(piece); + } + } + return Optional.empty(); + } + + private void killPiece(Piece deadPiece) { + for (int i = 0; i < pieces.size(); i++) { + Piece piece = pieces.get(i); + if(piece.equals(deadPiece)){ + pieces.remove(piece); + } + } + } +} diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java index ef128f066af..4d4da488ea9 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/src/main/java/chess/piece/Bishop.java @@ -5,13 +5,14 @@ import chess.Position; import chess.exception.InvalidMoveException; import java.util.List; +import java.util.Objects; import java.util.Optional; public class Bishop implements Piece{ private Position position; private final Color color; - private final List movements = List.of(Movement.RIGHT_UP,Movement.LEFT_UP,Movement.RIGHT_DOWN,Movement.LEFT_DOWN); + private static final List movements = List.of(Movement.RIGHT_UP,Movement.LEFT_UP,Movement.RIGHT_DOWN,Movement.LEFT_DOWN); public Bishop(Position position, Color color) { this.position = position; @@ -85,4 +86,26 @@ public boolean isOpposite(Piece piece) { public Color getColor() { return color; } + + @Override + public boolean isSamePosition(Piece otherPiece) { + return otherPiece.getPosition().equals(position); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + Bishop bishop = (Bishop) o; + return Objects.equals(position, bishop.position) && color == bishop.color; + } + + @Override + public int hashCode() { + return Objects.hash(position, color); + } } diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java index f4f45d4f32a..3bdfe45821e 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/piece/King.java @@ -5,12 +5,13 @@ import chess.Position; import chess.exception.InvalidMoveException; import java.util.List; +import java.util.Objects; public class King implements Piece{ private Position position; private final Color color; - private final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); + private static final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); public King(Position position, Color color) { this.position = position; @@ -23,7 +24,6 @@ public void move(Position wantedPosition, List wantedPositionExistPiece) if(!isWantedPositionExistSameColor){ throw new InvalidMoveException(); - } for(Movement movement : movements){ var temporalPosition = moveWhenPossible(movement); @@ -67,4 +67,26 @@ public boolean isOpposite(Piece piece) { public Color getColor() { return color; } + + @Override + public boolean isSamePosition(Piece otherPiece) { + return otherPiece.getPosition().equals(position); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + King king = (King) o; + return Objects.equals(position, king.position) && color == king.color; + } + + @Override + public int hashCode() { + return Objects.hash(position, color); + } } diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java index 2ee7c47a3bc..ac62ae78e02 100644 --- a/src/main/java/chess/piece/Knight.java +++ b/src/main/java/chess/piece/Knight.java @@ -1,5 +1,95 @@ package chess.piece; -public class Knight { +import chess.Color; +import chess.Movement; +import chess.Position; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Objects; +public class Knight implements Piece{ + + private Position position; + private static final List movements = List.of( + Movement.DOWN_DOWN_LEFT, Movement.DOWN_DOWN_RIGHT, + Movement.RIGHT_RIGHT_DOWN, Movement.RIGHT_RIGHT_UP, + Movement.LEFT_LEFT_DOWN, Movement.LEFT_LEFT_UP, + Movement.UP_UP_LEFT, Movement.UP_UP_RIGHT + ); + private final Color color; + + public Knight(Position position, Color color) { + this.position = position; + this.color = color; + } + + @Override + public void move(Position wantedPosition, List wantedPositionExistPiece) { + boolean isWantedPositionExistSameColor = isWantedPositionIsNotSameColor(wantedPositionExistPiece); + if(!isWantedPositionExistSameColor){ + throw new InvalidMoveException(); + } + for(Movement movement : movements){ + var temporalPosition = moveWhenPossible(movement); + if(temporalPosition.equals(wantedPosition)){ + position = temporalPosition; + return; + } + } + throw new InvalidMoveException(); + } + + private Position moveWhenPossible(Movement movement) { + var temporalPosition = position; + if(temporalPosition.canMove(movement)){ + return temporalPosition.move(movement); + } + return position; + } + + private boolean isWantedPositionIsNotSameColor(List wantedPositionExistPiece) { + if(wantedPositionExistPiece.isEmpty()){ + return true; + } + + Piece first = wantedPositionExistPiece.getLast(); + return this.isOpposite(first); + } + + @Override + public Position getPosition() { + return position; + } + + @Override + public boolean isOpposite(Piece piece) { + return color.opposite() == piece.getColor(); + } + + @Override + public Color getColor() { + return color; + } + + @Override + public boolean isSamePosition(Piece otherPiece) { + return otherPiece.getPosition().equals(position); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + Knight knight = (Knight) o; + return Objects.equals(position, knight.position) && color == knight.color; + } + + @Override + public int hashCode() { + return Objects.hash(position, color); + } } diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index 9cb2cc05eac..73c549d7835 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -6,6 +6,7 @@ import chess.Row; import chess.exception.InvalidMoveException; import java.util.List; +import java.util.Objects; public class Pawn implements Piece{ @@ -92,4 +93,28 @@ public Color getColor() { public Position getPosition() { return position; } + + @Override + public boolean isSamePosition(Piece otherPiece) { + return otherPiece.getPosition().equals(position); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + Pawn pawn = (Pawn) o; + return startRow == pawn.startRow && onlyMoveMovement == pawn.onlyMoveMovement && Objects.equals( + attackMovement, pawn.attackMovement) && color == pawn.color && Objects.equals(position, + pawn.position); + } + + @Override + public int hashCode() { + return Objects.hash(startRow, onlyMoveMovement, attackMovement, color, position); + } } diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java index f85d4d4d6c1..e519a1dea1f 100644 --- a/src/main/java/chess/piece/Piece.java +++ b/src/main/java/chess/piece/Piece.java @@ -10,4 +10,6 @@ public interface Piece { Position getPosition(); boolean isOpposite(Piece piece); Color getColor(); + + boolean isSamePosition(Piece otherPiece); } diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java index 9b547261c4b..7f9e944a38c 100644 --- a/src/main/java/chess/piece/Queen.java +++ b/src/main/java/chess/piece/Queen.java @@ -1,5 +1,112 @@ package chess.piece; -public class Queen { +import chess.Color; +import chess.Movement; +import chess.Position; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +public class Queen implements Piece{ + + private Position position; + private final Color color; + private static final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT, + Movement.RIGHT_UP,Movement.RIGHT_DOWN,Movement.LEFT_UP,Movement.LEFT_DOWN); + + public Queen(Position position, Color color) { + this.position = position; + this.color = color; + } + + public void move(Position wantedPosition, List wantedPositionExistPieces) { + for (Movement movement : movements){ + this.position = movementWhenPossible(movement,wantedPosition,wantedPositionExistPieces); + if(position.equals(wantedPosition)) { + return; + } + } + if(!position.equals(wantedPosition)){ + throw new InvalidMoveException(); + } + } + + private Position movementWhenPossible(Movement movement, Position wantedPosition, + List wantedPositionExistPiece) { + Position temporalPosition = position; + while (temporalPosition.canMove(movement)){ + temporalPosition = temporalPosition.move(movement); + if(temporalPosition.equals(wantedPosition) && isPositionDoesntExistSameColor(wantedPositionExistPiece, temporalPosition)){ + return temporalPosition; + } + if(isSamePositionPieceExist(wantedPositionExistPiece, temporalPosition)){ + throw new InvalidMoveException(); + } + } + return position; + } + + private boolean isPositionDoesntExistSameColor(List wantedPositionExistPiece, Position temporalPosition) { + Optional otherPieceByPosition = findOtherPieceByPosition(temporalPosition, wantedPositionExistPiece); + if(otherPieceByPosition.isEmpty()){ + return true; + } + return isOpposite(otherPieceByPosition.get()); + } + + private Optional findOtherPieceByPosition(Position temporalPosition, List wantedPositionExistPiece) { + for(Piece piece : wantedPositionExistPiece){ + if(piece.getPosition().equals(temporalPosition)){ + return Optional.of(piece); + } + } + return Optional.empty(); + } + + private boolean isSamePositionPieceExist(List wantedPositionExistPiece, Position temporalPosition) { + for(Piece piece : wantedPositionExistPiece){ + if(piece.getPosition().equals(temporalPosition)){ + return true; + } + } + return false; + } + + + @Override + public Position getPosition() { + return position; + } + + public boolean isOpposite(Piece piece) { + return color.opposite() == piece.getColor(); + } + + @Override + public Color getColor() { + return color; + } + + @Override + public boolean isSamePosition(Piece otherPiece) { + return otherPiece.getPosition().equals(position); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + Queen queen = (Queen) o; + return Objects.equals(position, queen.position) && color == queen.color; + } + + @Override + public int hashCode() { + return Objects.hash(position, color); + } } diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java index 7ed4d08bf03..f53fff53c1f 100644 --- a/src/main/java/chess/piece/Rook.java +++ b/src/main/java/chess/piece/Rook.java @@ -1,5 +1,110 @@ package chess.piece; -public class Rook { +import chess.Color; +import chess.Movement; +import chess.Position; +import chess.exception.InvalidMoveException; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +public class Rook implements Piece{ + + private Position position; + private final Color color; + private static final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); + + public Rook(Position position, Color color) { + this.position = position; + this.color = color; + } + + public void move(Position wantedPosition, List wantedPositionExistPieces) { + for (Movement movement : movements){ + this.position = movementWhenPossible(movement,wantedPosition,wantedPositionExistPieces); + if(position.equals(wantedPosition)) { + return; + } + } + if(!position.equals(wantedPosition)){ + throw new InvalidMoveException(); + } + } + + private Position movementWhenPossible(Movement movement, Position wantedPosition, + List wantedPositionExistPiece) { + Position temporalPosition = position; + while (temporalPosition.canMove(movement)){ + temporalPosition = temporalPosition.move(movement); + if(temporalPosition.equals(wantedPosition) && isPositionDoesntExistSameColor(wantedPositionExistPiece, temporalPosition)){ + return temporalPosition; + } + if(isSamePositionPieceExist(wantedPositionExistPiece, temporalPosition)){ + throw new InvalidMoveException(); + } + } + return position; + } + + private boolean isPositionDoesntExistSameColor(List wantedPositionExistPiece, Position temporalPosition) { + Optional otherPieceByPosition = findOtherPieceByPosition(temporalPosition, wantedPositionExistPiece); + if(otherPieceByPosition.isEmpty()){ + return true; + } + return isOpposite(otherPieceByPosition.get()); + } + + private Optional findOtherPieceByPosition(Position temporalPosition, List wantedPositionExistPiece) { + for(Piece piece : wantedPositionExistPiece){ + if(piece.getPosition().equals(temporalPosition)){ + return Optional.of(piece); + } + } + return Optional.empty(); + } + + private boolean isSamePositionPieceExist(List wantedPositionExistPiece, Position temporalPosition) { + for(Piece piece : wantedPositionExistPiece){ + if(isSamePosition(piece)){ + return true; + } + } + return false; + } + + @Override + public Position getPosition() { + return position; + } + + public boolean isOpposite(Piece piece) { + return color.opposite() == piece.getColor(); + } + + @Override + public Color getColor() { + return color; + } + + @Override + public boolean isSamePosition(Piece otherPiece) { + return otherPiece.getPosition().equals(position); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + Rook rook = (Rook) o; + return Objects.equals(position, rook.position) && color == rook.color; + } + + @Override + public int hashCode() { + return Objects.hash(position, color); + } } diff --git a/src/test/java/chess/ChessGameTest.java b/src/test/java/chess/ChessGameTest.java new file mode 100644 index 00000000000..91f86f8f1ff --- /dev/null +++ b/src/test/java/chess/ChessGameTest.java @@ -0,0 +1,46 @@ +package chess; + +import chess.piece.King; +import chess.piece.Pawn; +import chess.piece.Piece; +import java.util.List; +import java.util.Optional; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class ChessGameTest { + + @Test + void 왕이_죽었는지_확인할_수_있다(){ + List pieces = List.of(new King(new Position(Row.FOUR, Column.C),Color.WHITE)); + ChessGame chessGame = new ChessGame(pieces); + Assertions.assertThat(chessGame.isSomeBodyKingDoesntExist()).isTrue(); + } + + @Test + void 왕이_없는_팀이_누군지_알수_있다(){ + List pieces = List.of(new King(new Position(Row.FOUR, Column.C), Color.WHITE)); + ChessGame chessGame = new ChessGame(pieces); + Assertions.assertThat(chessGame.getLoseColor()).isEqualTo(Color.BLACK); + } + + @Test + void 기물이_같은_위치에있으면_죽는_기물을_제거한다(){ + Piece movePiece = new Pawn(Fixtures.A1,Color.WHITE); + Piece deadPiece = new Pawn(Fixtures.A1,Color.BLACK); + List pieces = List.of(movePiece,deadPiece); + ChessGame chessGame = new ChessGame(pieces); + Optional resultDeadPiece = chessGame.killPieceWhenExistSamePositionPiece(movePiece); + Assertions.assertThat(resultDeadPiece.get()).isEqualTo(deadPiece); + } + + @Test + void 주근_기물이_없으면_제거하지_않는다(){ + Piece movePiece = new Pawn(Fixtures.A1,Color.WHITE); + Piece deadPiece = new Pawn(Fixtures.A2,Color.BLACK); + List pieces = List.of(movePiece,deadPiece); + ChessGame chessGame = new ChessGame(pieces); + Optional resultDeadPiece = chessGame.killPieceWhenExistSamePositionPiece(movePiece); + Assertions.assertThat(resultDeadPiece.isEmpty()).isTrue(); + } +} diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java index 21ef43710c0..022edf51441 100644 --- a/src/test/java/chess/piece/BishopTest.java +++ b/src/test/java/chess/piece/BishopTest.java @@ -17,6 +17,15 @@ public class BishopTest { Assertions.assertThat(bishop.getPosition()).isEqualTo(Fixtures.D2); } + @Test + void 비숍은_이동할려는위치_이전에_다른_기물이_있으면_이동할수_없다(){ + Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); + Bishop enemy = new Bishop(Fixtures.D2,Color.WHITE); + Bishop enemy2 = new Bishop(Fixtures.E3,Color.BLACK); + + Assertions.assertThatThrownBy(() -> bishop.move(Fixtures.E3,List.of(enemy,enemy2))).isInstanceOf(InvalidMoveException.class); + } + @Test void 비숍은_직선으로_이동할수_없다(){ Bishop bishop = new Bishop(Fixtures.C1,Color.WHITE); diff --git a/src/test/java/chess/piece/KnightTest.java b/src/test/java/chess/piece/KnightTest.java new file mode 100644 index 00000000000..527cb54a9f9 --- /dev/null +++ b/src/test/java/chess/piece/KnightTest.java @@ -0,0 +1,92 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.exception.InvalidMoveException; +import java.util.List; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class KnightTest { + + @Test + void 말은_왼쪽_두칸_위_한칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.B5,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.B5); + } + + @Test + void 말은_왼쪽_한칸_위_두칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.C6,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.C6); + } + + @Test + void 말은_오른쪽_한칸_위_두칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.E6,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.E6); + } + + @Test + void 말은_오른쪽_두칸_위_한칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.F5,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.F5); + } + + @Test + void 말은_오른쪽_두칸_아래_한칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.E2,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.E2); + } + + @Test + void 말은_오른쪽_한칸_아래_두칸_으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.E2,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.E2); + } + + @Test + void 말은_아래_한칸_왼쪽_두칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.B3,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.B3); + } + + @Test + void 말은_아래_두칸_왼쪽_한칸으로_이동할_수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + knight.move (Fixtures.C2,List.of()); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.C2); + } + + @Test + void 말은_직선으로_이동할수_없다(){ + Knight knight = new Knight(Fixtures.C1,Color.WHITE); + Assertions.assertThatThrownBy(() -> knight.move (Fixtures.C2,List.of())) + .isInstanceOf(InvalidMoveException.class); + } + + @Test + void 같은팀이_있는곳으로는_이동할수_없다(){ + Knight knight = new Knight(Fixtures.C1,Color.WHITE); + Pawn sameColorTeam = new Pawn(Fixtures.D2,Color.WHITE); + Assertions.assertThatThrownBy(() -> knight.move (Fixtures.D2, List.of(sameColorTeam))).isInstanceOf( + InvalidMoveException.class); + } + + @Test + void 적팀_있는곳으로는_이동할수_있다(){ + Knight knight = new Knight(Fixtures.D4,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.E6,Color.BLACK); + knight.move(Fixtures.E6,List.of(enemy)); + Assertions.assertThat(knight.getPosition()).isEqualTo(Fixtures.E6); + } +} + + diff --git a/src/test/java/chess/piece/QueenTest.java b/src/test/java/chess/piece/QueenTest.java new file mode 100644 index 00000000000..c167ef3e172 --- /dev/null +++ b/src/test/java/chess/piece/QueenTest.java @@ -0,0 +1,95 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.exception.InvalidMoveException; +import java.util.List; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class QueenTest { + + @Test + void 퀸은_왼쪽으로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.B2,Color.WHITE); + queen.move(Fixtures.A2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.A2); + } + + @Test + void 퀸은_오른쪽으로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.C2,Color.WHITE); + queen.move(Fixtures.D2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.D2); + } + + @Test + void 퀸은_아래로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.C2,Color.WHITE); + queen.move(Fixtures.C1, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.C1); + } + + @Test + void 퀸은_위로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.C1,Color.WHITE); + queen.move(Fixtures.C2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.C2); + } + + @Test + void 퀸은_오른쪽_위로_이동할수_있다(){ + Queen queen = new Queen(Fixtures.C1,Color.WHITE); + queen.move(Fixtures.D2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.D2); + } + + @Test + void 퀸은_왼쪽_위로_이동할수_있다(){ + Queen queen = new Queen(Fixtures.C1,Color.WHITE); + queen.move(Fixtures.B2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.B2); + } + + @Test + void 퀸은_오른쪽_아래로_이동할수_있다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + queen.move(Fixtures.F2, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.F2); + } + + @Test + void 퀸은_왼쪽_아래로_이동할수_있다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + queen.move(Fixtures.A1, List.of()); + Assertions.assertThat(queen.getPosition()).isEqualTo(Fixtures.A1); + } + + @Test + void 퀸은_이동할려는위치_이전에_다른_기물이_있으면_이동할수_없다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + Bishop enemy = new Bishop(Fixtures.C3,Color.WHITE); + Bishop enemy2 = new Bishop(Fixtures.B2,Color.BLACK); + + Assertions.assertThatThrownBy(() -> queen.move(Fixtures.A1, List.of(enemy,enemy2))) + .isInstanceOf(InvalidMoveException.class); + } + + @Test + void 퀸은_같은팀이_있는곳으로_이동할_수_없다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + Pawn sameTeam = new Pawn(Fixtures.D5,Color.WHITE); + Assertions.assertThatThrownBy(() -> queen.move(Fixtures.D5,List.of(sameTeam))).isInstanceOf(InvalidMoveException.class); + } + + @Test + void 퀸은_다른팀이_있는곳으로_이동할_수_있다(){ + Queen queen = new Queen(Fixtures.D4,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.D5,Color.BLACK); + queen.move(Fixtures.D5,List.of(enemy)); + + Assertions.assertThat(enemy.getPosition()).isEqualTo(Fixtures.D5); + } +} + + diff --git a/src/test/java/chess/piece/RemovePiece.java b/src/test/java/chess/piece/RemovePiece.java deleted file mode 100644 index 70e15ea2176..00000000000 --- a/src/test/java/chess/piece/RemovePiece.java +++ /dev/null @@ -1,21 +0,0 @@ -package chess.piece; - -import java.util.Optional; - -public class RemovePiece { - - private final Pawn movedPiece; - private final Pawn enemy; - - public RemovePiece(Pawn movedPiece, Pawn enemy) { - this.movedPiece = movedPiece; - this.enemy = enemy; - } - - public Optional getDeadPiece() { - if(movedPiece.getPosition().equals(enemy.getPosition()) && movedPiece.isOpposite(enemy)){ - return Optional.of(enemy); - } - return Optional.empty(); - } -} diff --git a/src/test/java/chess/piece/RemovePieceTest.java b/src/test/java/chess/piece/RemovePieceTest.java deleted file mode 100644 index cc7a249cfb4..00000000000 --- a/src/test/java/chess/piece/RemovePieceTest.java +++ /dev/null @@ -1,27 +0,0 @@ -package chess.piece; - -import chess.Color; -import chess.Fixtures; -import chess.exception.InvalidMoveException; -import java.util.Optional; -import org.assertj.core.api.Assertions; -import org.junit.jupiter.api.Test; - -public class RemovePieceTest { - - @Test - void 죽는_기물을_반환한다(){ - Pawn pawn = new Pawn(Fixtures.A4, Color.WHITE); - Pawn enemy = new Pawn(Fixtures.A4, Color.BLACK); - RemovePiece removePiece = new RemovePiece(pawn, enemy); - Assertions.assertThat(removePiece.getDeadPiece().get()).isEqualTo(enemy); - } - - @Test - void 죽는_기물이_없으면_반환하지_않는다(){ - Pawn pawn = new Pawn(Fixtures.A4, Color.WHITE); - Pawn enemy = new Pawn(Fixtures.A5, Color.BLACK); - RemovePiece removePiece = new RemovePiece(pawn, enemy); - Assertions.assertThat(removePiece.getDeadPiece()).isEqualTo(Optional.empty()); - } -} diff --git a/src/test/java/chess/piece/RookTest.java b/src/test/java/chess/piece/RookTest.java new file mode 100644 index 00000000000..1bd1df187b7 --- /dev/null +++ b/src/test/java/chess/piece/RookTest.java @@ -0,0 +1,66 @@ +package chess.piece; + +import chess.Color; +import chess.Fixtures; +import chess.Row; +import chess.exception.InvalidMoveException; +import java.util.List; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +public class RookTest { + + @Test + void 룩은_위로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.A2,Color.WHITE); + rook.move(Fixtures.A3, List.of()); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.A3); + } + + @Test + void 룩은_오른쪽으로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.A2,Color.WHITE); + rook.move(Fixtures.B2, List.of()); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.B2); + } + + @Test + void 룩은_아래로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.B2,Color.WHITE); + rook.move(Fixtures.B1, List.of()); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.B1); + } + + @Test + void 룩은_왼쪽으로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.B2,Color.WHITE); + rook.move(Fixtures.A2, List.of()); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.A2); + } + + @Test + void 룩은_이동할려는위치_이전에_다른_기물이_있으면_이동할수_없다(){ + Rook rook = new Rook(Fixtures.A1,Color.WHITE); + Bishop enemy = new Bishop(Fixtures.B1,Color.WHITE); + Bishop enemy2 = new Bishop(Fixtures.C1,Color.BLACK); + + Assertions.assertThatThrownBy(() -> rook.move(Fixtures.E3,List.of(enemy,enemy2))).isInstanceOf(InvalidMoveException.class); + } + + @Test + void 룩은_같은팀이_있는곳으로_이동할_수_없다(){ + Rook rook = new Rook(Fixtures.A2,Color.WHITE); + Pawn sameTeam = new Pawn(Fixtures.A3,Color.WHITE); + Assertions.assertThatThrownBy(() -> rook.move(Fixtures.A3,List.of(sameTeam))).isInstanceOf(InvalidMoveException.class); + } + + @Test + void 룩은_다른팀이_있는곳으로_이동할_수_있다(){ + Rook rook = new Rook(Fixtures.A2,Color.WHITE); + Pawn enemy = new Pawn(Fixtures.A3,Color.BLACK); + rook.move(Fixtures.A3, List.of(enemy)); + Assertions.assertThat(rook.getPosition()).isEqualTo(Fixtures.A3); + } +} + + From 160bad0c018c07c2cf4fd98b6048889e57223faa Mon Sep 17 00:00:00 2001 From: PraiseBak <60121346+PraiseBak@users.noreply.github.com> Date: Sat, 22 Mar 2025 17:30:45 +0900 Subject: [PATCH 3/4] =?UTF-8?q?feat:=20=EC=B2=B4=EC=8A=A4=ED=8C=90=20?= =?UTF-8?q?=EA=B8=B0=EB=AC=BC=20=EC=B4=88=EA=B8=B0=ED=99=94=20=EA=B8=B0?= =?UTF-8?q?=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/Application.java | 8 +++ src/main/java/chess/ChessGame.java | 5 ++ src/main/java/chess/InitiatePieces.java | 65 ++++++++++++++++++++++++ src/main/java/chess/piece/Bishop.java | 8 +++ src/main/java/chess/piece/King.java | 6 +++ src/main/java/chess/piece/Knight.java | 7 +++ src/main/java/chess/piece/Pawn.java | 7 +++ src/main/java/chess/piece/Piece.java | 2 + src/main/java/chess/piece/PieceType.java | 16 ++++++ src/main/java/chess/piece/Queen.java | 7 +++ src/main/java/chess/piece/Rook.java | 7 +++ src/test/java/chess/piece/KingTest.java | 3 -- 12 files changed, 138 insertions(+), 3 deletions(-) create mode 100644 src/main/java/chess/InitiatePieces.java create mode 100644 src/main/java/chess/piece/PieceType.java diff --git a/src/main/java/Application.java b/src/main/java/Application.java index 31b27e6664f..aef07bb79a6 100644 --- a/src/main/java/Application.java +++ b/src/main/java/Application.java @@ -1,2 +1,10 @@ +import chess.ChessGame; +import chess.piece.Piece; +import java.util.List; + public class Application { + + public static void main(String[] args) { + ChessGame chessGame = new ChessGame(); + } } diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java index 45180964275..992e4bfd64a 100644 --- a/src/main/java/chess/ChessGame.java +++ b/src/main/java/chess/ChessGame.java @@ -16,6 +16,11 @@ public ChessGame(List pieces) { this.pieces = new ArrayList<>(pieces); } + public ChessGame() { + + this.pieces = new ArrayList<>(pieces); + } + public boolean isSomeBodyKingDoesntExist(){ Map colorKingDead = getKingSurviveStatus(); for(Color color : colorKingDead.keySet()){ diff --git a/src/main/java/chess/InitiatePieces.java b/src/main/java/chess/InitiatePieces.java new file mode 100644 index 00000000000..973fc4269aa --- /dev/null +++ b/src/main/java/chess/InitiatePieces.java @@ -0,0 +1,65 @@ +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.Rook; +import java.util.Arrays; +import java.util.List; + +public class InitiatePieces { + private final List pawns = List.of( + new Pawn(new Position(Row.TWO,Column.A),Color.WHITE), + new Pawn(new Position(Row.TWO,Column.B),Color.WHITE), + new Pawn(new Position(Row.TWO,Column.C),Color.WHITE), + new Pawn(new Position(Row.TWO,Column.D),Color.WHITE), + new Pawn(new Position(Row.TWO,Column.E),Color.WHITE), + new Pawn(new Position(Row.TWO,Column.F),Color.WHITE), + new Pawn(new Position(Row.TWO,Column.G),Color.WHITE), + new Pawn(new Position(Row.TWO,Column.H),Color.WHITE), + + new Pawn(new Position(Row.SEVEN,Column.A),Color.BLACK), + new Pawn(new Position(Row.SEVEN,Column.B),Color.BLACK), + new Pawn(new Position(Row.SEVEN,Column.C),Color.BLACK), + new Pawn(new Position(Row.SEVEN,Column.D),Color.BLACK), + new Pawn(new Position(Row.SEVEN,Column.E),Color.BLACK), + new Pawn(new Position(Row.SEVEN,Column.F),Color.BLACK), + new Pawn(new Position(Row.SEVEN,Column.G),Color.BLACK), + new Pawn(new Position(Row.SEVEN,Column.H),Color.BLACK) + ); + + private final List kings = List.of( + new King(new Position(Row.EIGHT,Column.E),Color.BLACK), + new King(new Position(Row.ONE,Column.E),Color.BLACK) + ); + + private final List queens = List.of( + new King(new Position(Row.EIGHT,Column.D),Color.BLACK), + new King(new Position(Row.ONE,Column.D),Color.WHITE) + ); + + private final List rooks = List.of( + new Rook(new Position(Row.ONE,Column.A),Color.WHITE), + new Rook(new Position(Row.ONE,Column.H),Color.WHITE), + new Rook(new Position(Row.EIGHT,Column.A),Color.BLACK), + new Rook(new Position(Row.EIGHT,Column.H),Color.BLACK) + ); + + private final List bishops = List.of( + new Bishop(new Position(Row.ONE,Column.C),Color.WHITE), + new Bishop(new Position(Row.ONE,Column.F),Color.WHITE), + new Bishop(new Position(Row.EIGHT,Column.C),Color.BLACK), + new Bishop(new Position(Row.EIGHT,Column.F),Color.BLACK) + ); + + private final List knights = List.of( + new Knight(new Position(Row.ONE,Column.B),Color.WHITE), + new Knight(new Position(Row.ONE,Column.G),Color.WHITE), + new Knight(new Position(Row.EIGHT,Column.B),Color.BLACK), + new Knight(new Position(Row.EIGHT,Column.G),Color.BLACK) + ); +} + + diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java index 4d4da488ea9..3f97b7e2ce4 100644 --- a/src/main/java/chess/piece/Bishop.java +++ b/src/main/java/chess/piece/Bishop.java @@ -12,11 +12,14 @@ public class Bishop implements Piece{ private Position position; private final Color color; + private final PieceType pieceType; private static final List movements = List.of(Movement.RIGHT_UP,Movement.LEFT_UP,Movement.RIGHT_DOWN,Movement.LEFT_DOWN); + public Bishop(Position position, Color color) { this.position = position; this.color = color; + pieceType = PieceType.BISHOP; } public void move(Position wantedPosition, List wantedPositionExistPieces) { @@ -92,6 +95,11 @@ public boolean isSamePosition(Piece otherPiece) { return otherPiece.getPosition().equals(position); } + @Override + public PieceType pieceType() { + return pieceType; + } + @Override public boolean equals(Object o) { if (this == o) { diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java index 3bdfe45821e..4fad2edcee1 100644 --- a/src/main/java/chess/piece/King.java +++ b/src/main/java/chess/piece/King.java @@ -11,11 +11,13 @@ public class King implements Piece{ private Position position; private final Color color; + private final PieceType pieceType; private static final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); public King(Position position, Color color) { this.position = position; this.color = color; + this.pieceType = PieceType.KING; } @Override @@ -73,6 +75,10 @@ public boolean isSamePosition(Piece otherPiece) { return otherPiece.getPosition().equals(position); } + public PieceType pieceType() { + return pieceType; + } + @Override public boolean equals(Object o) { if (this == o) { diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java index ac62ae78e02..5dd14335482 100644 --- a/src/main/java/chess/piece/Knight.java +++ b/src/main/java/chess/piece/Knight.java @@ -17,10 +17,12 @@ public class Knight implements Piece{ Movement.UP_UP_LEFT, Movement.UP_UP_RIGHT ); private final Color color; + private final PieceType pieceType; public Knight(Position position, Color color) { this.position = position; this.color = color; + this.pieceType = PieceType.KNIGHT; } @Override @@ -76,6 +78,11 @@ public boolean isSamePosition(Piece otherPiece) { return otherPiece.getPosition().equals(position); } + @Override + public PieceType pieceType() { + return pieceType; + } + @Override public boolean equals(Object o) { if (this == o) { diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java index 73c549d7835..400aab47b78 100644 --- a/src/main/java/chess/piece/Pawn.java +++ b/src/main/java/chess/piece/Pawn.java @@ -21,6 +21,7 @@ public class Pawn implements Piece{ private final Movement onlyMoveMovement; private final List attackMovement; private final Color color; + private final PieceType pieceType; private Position position; @@ -28,6 +29,7 @@ public Pawn(Position position, Color color) { this.color = color; this.position = position; startRow = position.row(); + pieceType = PieceType.PAWN; if(color == Color.BLACK){ onlyMoveMovement = BLACK_MOVEMENT; attackMovement = BLACK_ATTACK_MOVEMENTS; @@ -99,6 +101,11 @@ public boolean isSamePosition(Piece otherPiece) { return otherPiece.getPosition().equals(position); } + @Override + public PieceType pieceType() { + return pieceType; + } + @Override public boolean equals(Object o) { if (this == o) { diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java index e519a1dea1f..c7bbd774229 100644 --- a/src/main/java/chess/piece/Piece.java +++ b/src/main/java/chess/piece/Piece.java @@ -12,4 +12,6 @@ public interface Piece { Color getColor(); boolean isSamePosition(Piece otherPiece); + + PieceType pieceType(); } diff --git a/src/main/java/chess/piece/PieceType.java b/src/main/java/chess/piece/PieceType.java new file mode 100644 index 00000000000..8f2febd2a4c --- /dev/null +++ b/src/main/java/chess/piece/PieceType.java @@ -0,0 +1,16 @@ +package chess.piece; + +public enum PieceType { + BISHOP("비숍"), + KING("킹"), + KNIGHT("나이트"), + PAWN("폰"), + QUEEN("퀸"), + ROOK("룩"); + + final String type; + + PieceType(String type) { + this.type = type; + } +} diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java index 7f9e944a38c..65da1d27dd7 100644 --- a/src/main/java/chess/piece/Queen.java +++ b/src/main/java/chess/piece/Queen.java @@ -14,10 +14,12 @@ public class Queen implements Piece{ private final Color color; private static final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT, Movement.RIGHT_UP,Movement.RIGHT_DOWN,Movement.LEFT_UP,Movement.LEFT_DOWN); + private final PieceType pieceType; public Queen(Position position, Color color) { this.position = position; this.color = color; + pieceType = PieceType.QUEEN; } public void move(Position wantedPosition, List wantedPositionExistPieces) { @@ -93,6 +95,11 @@ public boolean isSamePosition(Piece otherPiece) { return otherPiece.getPosition().equals(position); } + @Override + public PieceType pieceType() { + return pieceType; + } + @Override public boolean equals(Object o) { if (this == o) { diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java index f53fff53c1f..8354e1caf06 100644 --- a/src/main/java/chess/piece/Rook.java +++ b/src/main/java/chess/piece/Rook.java @@ -13,10 +13,12 @@ public class Rook implements Piece{ private Position position; private final Color color; private static final List movements = List.of(Movement.UP,Movement.DOWN,Movement.LEFT,Movement.RIGHT); + private final PieceType pieceType; public Rook(Position position, Color color) { this.position = position; this.color = color; + pieceType = PieceType.ROOK; } public void move(Position wantedPosition, List wantedPositionExistPieces) { @@ -91,6 +93,11 @@ public boolean isSamePosition(Piece otherPiece) { return otherPiece.getPosition().equals(position); } + @Override + public PieceType pieceType() { + return pieceType; + } + @Override public boolean equals(Object o) { if (this == o) { diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/piece/KingTest.java index 297fb7089a6..648223b35a1 100644 --- a/src/test/java/chess/piece/KingTest.java +++ b/src/test/java/chess/piece/KingTest.java @@ -6,9 +6,6 @@ import java.util.List; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; -import org.junit.jupiter.params.provider.ValueSources; public class KingTest { From 0cbbf4426bf4613941012d2c9adeb7c58b2885f2 Mon Sep 17 00:00:00 2001 From: PraiseBak <60121346+PraiseBak@users.noreply.github.com> Date: Sat, 22 Mar 2025 19:30:12 +0900 Subject: [PATCH 4/4] =?UTF-8?q?feat:=20=EC=B2=B4=EC=8A=A4=ED=8C=90=20?= =?UTF-8?q?=ED=91=9C=EC=8B=9C=20=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Application.java | 25 ++++++++++++++++++++ src/main/java/chess/ChessGame.java | 10 ++++++-- src/main/java/chess/InitiatePieces.java | 18 ++++++++++++++- src/main/java/chess/piece/PieceType.java | 8 +++++-- src/main/java/chess/view/InputView.java | 9 ++++++++ src/main/java/chess/view/OutputView.java | 29 ++++++++++++++++++++++++ 6 files changed, 94 insertions(+), 5 deletions(-) create mode 100644 src/main/java/chess/view/InputView.java create mode 100644 src/main/java/chess/view/OutputView.java diff --git a/src/main/java/Application.java b/src/main/java/Application.java index aef07bb79a6..0f60d93cf63 100644 --- a/src/main/java/Application.java +++ b/src/main/java/Application.java @@ -1,10 +1,35 @@ import chess.ChessGame; +import chess.Color; +import chess.Column; +import chess.Position; +import chess.Row; import chess.piece.Piece; +import chess.view.InputView; +import chess.view.OutputView; +import java.nio.file.LinkPermission; +import java.util.HashMap; import java.util.List; +import java.util.Map; public class Application { + private static final InputView inputView = new InputView(); + private static final OutputView outputView = new OutputView(); + public static void main(String[] args) { ChessGame chessGame = new ChessGame(); + play(chessGame); + } + + private static void play(ChessGame chessGame) { + List pieces = chessGame.getPieces(); + + Map positionPieceMap = new HashMap<>(); + for(Piece piece : pieces){ + Position position = piece.getPosition(); + positionPieceMap.put(position,piece); + } + + outputView.printChessMap(positionPieceMap); } } diff --git a/src/main/java/chess/ChessGame.java b/src/main/java/chess/ChessGame.java index 992e4bfd64a..d97bde233d3 100644 --- a/src/main/java/chess/ChessGame.java +++ b/src/main/java/chess/ChessGame.java @@ -2,6 +2,8 @@ import chess.piece.King; import chess.piece.Piece; +import chess.view.InputView; +import chess.view.OutputView; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -17,8 +19,8 @@ public ChessGame(List pieces) { } public ChessGame() { - - this.pieces = new ArrayList<>(pieces); + InitiatePieces initiatePieces = new InitiatePieces(); + this.pieces = new ArrayList<>(initiatePieces.pieces()); } public boolean isSomeBodyKingDoesntExist(){ @@ -82,4 +84,8 @@ private void killPiece(Piece deadPiece) { } } } + + public List getPieces() { + return pieces; + } } diff --git a/src/main/java/chess/InitiatePieces.java b/src/main/java/chess/InitiatePieces.java index 973fc4269aa..91de43b2758 100644 --- a/src/main/java/chess/InitiatePieces.java +++ b/src/main/java/chess/InitiatePieces.java @@ -6,10 +6,22 @@ import chess.piece.Pawn; import chess.piece.Piece; import chess.piece.Rook; -import java.util.Arrays; +import java.util.ArrayList; import java.util.List; public class InitiatePieces { + + private final List pieces = new ArrayList<>(); + + public InitiatePieces(){ + pieces.addAll(pawns); + pieces.addAll(kings); + pieces.addAll(queens); + pieces.addAll(rooks); + pieces.addAll(bishops); + pieces.addAll(knights); + } + private final List pawns = List.of( new Pawn(new Position(Row.TWO,Column.A),Color.WHITE), new Pawn(new Position(Row.TWO,Column.B),Color.WHITE), @@ -60,6 +72,10 @@ public class InitiatePieces { new Knight(new Position(Row.EIGHT,Column.B),Color.BLACK), new Knight(new Position(Row.EIGHT,Column.G),Color.BLACK) ); + + public List pieces(){ + return pieces; + } } diff --git a/src/main/java/chess/piece/PieceType.java b/src/main/java/chess/piece/PieceType.java index 8f2febd2a4c..e33e234b05d 100644 --- a/src/main/java/chess/piece/PieceType.java +++ b/src/main/java/chess/piece/PieceType.java @@ -1,9 +1,9 @@ package chess.piece; public enum PieceType { - BISHOP("비숍"), + BISHOP("숍"), KING("킹"), - KNIGHT("나이트"), + KNIGHT("말"), PAWN("폰"), QUEEN("퀸"), ROOK("룩"); @@ -13,4 +13,8 @@ public enum PieceType { PieceType(String type) { this.type = type; } + + public String getType() { + return type; + } } diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java new file mode 100644 index 00000000000..b6d3ba7284b --- /dev/null +++ b/src/main/java/chess/view/InputView.java @@ -0,0 +1,9 @@ +package chess.view; + +import chess.piece.Piece; +import java.util.List; + +public class InputView { + public void showPieces(List pieces) { + } +} diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java new file mode 100644 index 00000000000..9d438407e1b --- /dev/null +++ b/src/main/java/chess/view/OutputView.java @@ -0,0 +1,29 @@ +package chess.view; + +import chess.Column; +import chess.Position; +import chess.Row; +import chess.piece.Piece; +import java.util.Map; + +public class OutputView { + public void showPieces(Piece piece) { + if(piece == null){ + System.out.print(" "); + return; + } + System.out.print(piece.pieceType().getType()); + } + + public void printChessMap(Map positionPieceMap) { + for(Row row : Row.values()){ + for(Column column : Column.values()){ + Position position = new Position(row, column); + Piece piece = positionPieceMap.get(position); + showPieces(piece); + } + System.out.println(); + } + + } +}