refactor : 리뷰 반영

woowacourse · Apr 3, 2020 · e89e26d · e89e26d
1 parent 3e7ee5a
commit e89e26d
Show file tree

Hide file tree

Showing 10 changed files with 109 additions and 87 deletions.
diff --git a/src/main/java/chess/domain/ChessGame.java b/src/main/java/chess/domain/ChessGame.java
@@ -1,7 +1,7 @@
 package chess.domain;
 
 import chess.domain.board.Board;
-import chess.domain.board.EnumRepositoryBoardInitializer;
+import chess.domain.board.DefaultBoardInitializer;
 import chess.domain.player.Player;
 import chess.domain.result.Status;
 import chess.domain.state.ReadyState;
@@ -12,7 +12,7 @@ public class ChessGame {
     private Turn turn = Turn.from(Player.WHITE);
 
     public ChessGame() {
-        this.state = new ReadyState(new EnumRepositoryBoardInitializer());
+        this.state = new ReadyState(new DefaultBoardInitializer());
     }
 
     public void start() {

diff --git a/...board/EnumRepositoryBoardInitializer.java → ...domain/board/DefaultBoardInitializer.java b/...board/EnumRepositoryBoardInitializer.java → ...domain/board/DefaultBoardInitializer.java
@@ -6,12 +6,12 @@
 import java.util.HashMap;
 import java.util.Map;
 
-public class EnumRepositoryBoardInitializer implements BoardInitializer {
+public class DefaultBoardInitializer implements BoardInitializer {
 
     @Override
     public Map<Position, PieceState> create() {
         Map<Position, PieceState> initialBoard = new HashMap<>();
-        for (InitialPieceRepository pieceRepository : InitialPieceRepository.values()) {
+        for (InitialPiecePosition pieceRepository : InitialPiecePosition.values()) {
             initialBoard.put(pieceRepository.getPosition(), pieceRepository.getInitialPiece());
         }
         return initialBoard;

diff --git a/.../domain/board/InitialPieceRepository.java → ...ss/domain/board/InitialPiecePosition.java b/.../domain/board/InitialPieceRepository.java → ...ss/domain/board/InitialPiecePosition.java
@@ -6,7 +6,7 @@
 
 import java.util.function.BiFunction;
 
-public enum InitialPieceRepository {
+public enum InitialPiecePosition {
     BLACK_PAWN_1(NotMovedPawn::of, Player.BLACK, Position.of("A7")),
     BLACK_PAWN_2(NotMovedPawn::of, Player.BLACK, Position.of("B7")),
     BLACK_PAWN_3(NotMovedPawn::of, Player.BLACK, Position.of("C7")),
@@ -44,7 +44,7 @@ public enum InitialPieceRepository {
     private Player player;
     private Position position;
 
-    InitialPieceRepository(BiFunction<Position, Player, Piece> generator, Player player, Position position) {
+    InitialPiecePosition(BiFunction<Position, Player, Piece> generator, Player player, Position position) {
         this.generator = generator;
         this.player = player;
         this.position = position;

diff --git a/src/main/java/chess/domain/piece/AttackablePawn.java b/src/main/java/chess/domain/piece/AttackablePawn.java
@@ -21,12 +21,20 @@ protected void validateAttack(Position target, Map<Position, PieceDto> boardDto)
 
         PieceDto pieceDto = boardDto.get(target);
         if (ATTACK_DIRECTION_BY_PLAYER.get(player).contains(direction)) {
-            if (Objects.isNull(pieceDto)) {
-                throw new MovingDirectionException();
-            }
-            if (position.getRankDifference(target) != direction.getRankDirection()) {
-                throw new MovingDistanceException();
-            }
+            checkEnemyOnAttackDirection(pieceDto);
+            checkAttackDistance(target, direction);
+        }
+    }
+
+    private void checkAttackDistance(final Position target, final MovingDirection direction) {
+        if (position.getRankDifference(target) != direction.getRankDirection()) {
+            throw new MovingDistanceException();
+        }
+    }
+
+    private void checkEnemyOnAttackDirection(final PieceDto pieceDto) {
+        if (Objects.isNull(pieceDto)) {
+            throw new MovingDirectionException();
         }
     }
 }
diff --git a/src/main/java/chess/domain/piece/MovedPawn.java b/src/main/java/chess/domain/piece/MovedPawn.java
@@ -24,13 +24,21 @@ protected void validateMove(Position target, Map<Position, PieceDto> boardDto) {
         MovingDirection movingDirection = MovingDirection.getDirection(position, target);
 
         if (MOVING_DIRECTION_BY_PLAYER.get(player).equals(movingDirection)) {
-            if (position.getRankDifference(target) != movingDirection.getRankDirection()) {
-                throw new MovingDistanceException();
-            }
-            PieceDto piece = boardDto.get(target);
-            if (!Objects.isNull(piece)) {
-                throw new ObstacleOnPathException();
-            }
+            checkMovingDistance(target, movingDirection);
+            checkObstacleOnPath(target, boardDto);
+        }
+    }
+
+    private void checkObstacleOnPath(final Position target, final Map<Position, PieceDto> boardDto) {
+        PieceDto piece = boardDto.get(target);
+        if (!Objects.isNull(piece)) {
+            throw new ObstacleOnPathException();
+        }
+    }
+
+    private void checkMovingDistance(final Position target, final MovingDirection movingDirection) {
+        if (position.getRankDifference(target) != movingDirection.getRankDirection()) {
+            throw new MovingDistanceException();
         }
     }
 

diff --git a/src/main/java/chess/domain/state/EndState.java b/src/main/java/chess/domain/state/EndState.java
@@ -3,19 +3,27 @@
 import chess.domain.MoveParameter;
 import chess.domain.Turn;
 import chess.domain.board.Board;
+import chess.domain.piece.Pawn;
 import chess.domain.piece.PieceState;
 import chess.domain.player.Player;
+import chess.domain.position.File;
 import chess.domain.position.Position;
 import chess.domain.result.Status;
 
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 
 public class EndState implements State {
 
+    public static final double DEFAULT_PAWN_POINT = 1d;
+    public static final double DUPLICATED_PAWN_POINT = 0.5d;
+    private static final int PAWN_DUPLICATION_COUNT = 1;
+
     private final Status status;
 
-    public EndState(Status status) {
-        this.status = status;
+    public EndState(Board board) {
+        this.status = createStatus(board);
     }
 
     @Override
@@ -58,5 +66,58 @@ public boolean isEnd() {
         return true;
     }
 
+    private Status createStatus(Board board) {
+        Map<Player, Double> status = new HashMap<>();
+        double blackSum = 0;
+        double whiteSum = 0;
+
+        for (File file : File.values()) {
+            blackSum += getPawnPointsByFile(file, Player.BLACK);
+            whiteSum += getPawnPointsByFile(file, Player.WHITE);
+        }
+
+        blackSum = getPlayerSum(blackSum, Player.BLACK);
+        whiteSum = getPlayerSum(whiteSum, Player.WHITE);
+
+        status.put(Player.BLACK, blackSum);
+        status.put(Player.WHITE, whiteSum);
+        return new Status(Collections.unmodifiableMap(status));
+    }
+
+    private double getPlayerSum(double blackSum, Player player) {
+        blackSum += getRemainPiece(player)
+                .values()
+                .stream()
+                .filter(piece -> !(piece instanceof Pawn))
+                .mapToDouble(PieceState::getPoint)
+                .sum();
+        return blackSum;
+    }
 
+    @Override
+    public Map<Position, PieceState> getRemainPiece(Player player, Board board) {
+        return board.getRemainPieces(player);
+    }
+
+    private double getPawnPointsByFile(File file, Player player) {
+
+        /* 해당 file의 PAWN 점수합을 계산한다 */
+        double duplicatedPawnCount = getDuplicatedPawnCount(file, player);
+        if (duplicatedPawnCount > PAWN_DUPLICATION_COUNT) {
+            return duplicatedPawnCount * DUPLICATED_PAWN_POINT;
+        }
+        return duplicatedPawnCount * DEFAULT_PAWN_POINT;
+
+    }
+
+    private double getDuplicatedPawnCount(File file, Player player) {
+        /* 해당 file의 PAWN 개수합을 계산한다 */
+        return getRemainPiece(player)
+                .entrySet()
+                .stream()
+                .filter(entry -> entry.getValue() instanceof Pawn)
+                .filter(entry -> entry.getKey().isSameFile(file))
+                .mapToDouble(entry -> entry.getValue().getPoint())
+                .sum();
+    }
 }
diff --git a/src/main/java/chess/domain/state/RunningState.java b/src/main/java/chess/domain/state/RunningState.java
@@ -3,23 +3,18 @@
 import chess.domain.MoveParameter;
 import chess.domain.Turn;
 import chess.domain.board.Board;
-import chess.domain.piece.Pawn;
 import chess.domain.piece.PieceState;
 import chess.domain.player.Player;
-import chess.domain.position.File;
 import chess.domain.position.Position;
 import chess.domain.result.Status;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
 public class RunningState implements State {
 
-    public static final double DEFAULT_PAWN_POINT = 1d;
-    public static final double DUPLICATED_PAWN_POINT = 0.5d;
     public static final double DEFAULT = 0d;
-    private static final int PAWN_DUPLICATION_COUNT = 1;
+
     private Board board;
 
     public RunningState(Board board) {
@@ -37,52 +32,24 @@ public State move(MoveParameter moveParameter, Turn turn) {
         board.move(moveParameter.getSource(), moveParameter.getTarget(), turn);
         if (board.isLost(Player.WHITE)) {
             status.put(Player.BLACK, DEFAULT);
-            return new EndState(new Status(status));
+            return new EndState(board);
         }
         if (board.isLost(Player.BLACK)) {
 
             status.put(Player.WHITE, DEFAULT);
-            return new EndState(new Status(status));
+            return new EndState(board);
         }
         return this;
     }
 
     @Override
     public State end() {
-        return new EndState(createStatus());
+        return new EndState(board);
     }
 
     @Override
     public State status() {
-        return new EndState(createStatus());
-    }
-
-    public Status createStatus() {
-        Map<Player, Double> status = new HashMap<>();
-        double blackSum = 0;
-        double whiteSum = 0;
-
-        for (File file : File.values()) {
-            blackSum += getPawnPointsByFile(file, Player.BLACK);
-            whiteSum += getPawnPointsByFile(file, Player.WHITE);
-        }
-
-        blackSum = getPlayerSum(blackSum, Player.BLACK);
-        whiteSum = getPlayerSum(whiteSum, Player.WHITE);
-
-        status.put(Player.BLACK, blackSum);
-        status.put(Player.WHITE, whiteSum);
-        return new Status(Collections.unmodifiableMap(status));
-    }
-
-    private double getPlayerSum(double blackSum, Player player) {
-        blackSum += getRemainPiece(player)
-                .values()
-                .stream()
-                .filter(piece -> !(piece instanceof Pawn))
-                .mapToDouble(PieceState::getPoint)
-                .sum();
-        return blackSum;
+        throw new UnsupportedOperationException("게임이 아직 종료되지 않았습니다.");
     }
 
     @Override
@@ -95,28 +62,6 @@ public Status getStatus() {
         throw new UnsupportedOperationException("게임이 아직 종료되지 않았습니다.");
     }
 
-    private double getPawnPointsByFile(File file, Player player) {
-
-        /* 해당 file의 PAWN 점수합을 계산한다 */
-        double duplicatedPawnCount = getDuplicatedPawnCount(file, player);
-        if (duplicatedPawnCount > PAWN_DUPLICATION_COUNT) {
-            return duplicatedPawnCount * DUPLICATED_PAWN_POINT;
-        }
-        return duplicatedPawnCount * DEFAULT_PAWN_POINT;
-
-    }
-
-    private double getDuplicatedPawnCount(File file, Player player) {
-        /* 해당 file의 PAWN 개수합을 계산한다 */
-        return getRemainPiece(player)
-                .entrySet()
-                .stream()
-                .filter(entry -> entry.getValue() instanceof Pawn)
-                .filter(entry -> entry.getKey().isSameFile(file))
-                .mapToDouble(entry -> entry.getValue().getPoint())
-                .sum();
-    }
-
     @Override
     public Board getBoard() {
         return board;

diff --git a/src/test/java/chess/domain/board/BoardTest.java b/src/test/java/chess/domain/board/BoardTest.java
@@ -17,12 +17,12 @@ class BoardTest {
     @Test
     @DisplayName("board는 boardInitializer 타입의 객체를 받아서 생성")
     void initialize() {
-        Board board = Board.of(new EnumRepositoryBoardInitializer());
+        Board board = Board.of(new DefaultBoardInitializer());
     }
 
     @Test
     void move() {
-        Board board = Board.of(new EnumRepositoryBoardInitializer());
+        Board board = Board.of(new DefaultBoardInitializer());
         board.move(Position.of("B8"), Position.of("A6"), Turn.from(Player.BLACK));
         Map<Position, PieceState> piecePosition = board.getBoard();
 

diff --git a/src/test/java/chess/domain/state/ReadyStateTest.java b/src/test/java/chess/domain/state/ReadyStateTest.java
@@ -2,7 +2,7 @@
 
 import chess.domain.MoveParameter;
 import chess.domain.Turn;
-import chess.domain.board.EnumRepositoryBoardInitializer;
+import chess.domain.board.DefaultBoardInitializer;
 import chess.domain.player.Player;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -19,7 +19,7 @@ class ReadyStateTest {
 
     @BeforeEach
     void setUp() {
-        readyState = new ReadyState(new EnumRepositoryBoardInitializer());
+        readyState = new ReadyState(new DefaultBoardInitializer());
     }
 
     @Test

diff --git a/src/test/java/chess/domain/state/RunningStateTest.java b/src/test/java/chess/domain/state/RunningStateTest.java
@@ -3,7 +3,7 @@
 import chess.domain.MoveParameter;
 import chess.domain.Turn;
 import chess.domain.board.Board;
-import chess.domain.board.EnumRepositoryBoardInitializer;
+import chess.domain.board.DefaultBoardInitializer;
 import chess.domain.player.Player;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -19,7 +19,7 @@ class RunningStateTest {
 
     @BeforeEach
     void setUp() {
-        runningState = new RunningState(Board.of(new EnumRepositoryBoardInitializer()));
+        runningState = new RunningState(Board.of(new DefaultBoardInitializer()));
     }
 
     @Test