[사다리타기 - FP, OOP] 3단계 - 사다리(게임 실행) (#1441)

* feat($compile): step2 피드백 반영

step2 피드백 반영
- 매직 넘버, 매직 리터럴 상수로 분리
- Ladder -> Lines 일급 컬렉션으로 변경
- 사다리 게임 발판 전략 패턴 적용
- 출력 View StringBuilder 정적으로 선언해 재활용 하도록 구현
- 사다리 높인 경계값 테스트 및 파라미터 테스트 적용
- 플레이어명 비어있는 이름 예외 처리

* feat($compile): 사디리 포인트 이동(왼쪽, 오른쪽, 멈춤) 기능 구현.

사디리 포인트 이동(왼쪽, 오른쪽, 멈춤) 기능 구현.
- 현재 포인트를 가지는 Point객체 추가
- 현재 이동 방향을 알 수 있는 Direction Enum 객체 추가.

* feat($compile): 사다리 특정 위치에서 시작해서 포인트 이동하는 기능 구현.

사다리 특정 위치에서 시작해서 포인트 이동하는 기능 구현.
- 현재 위치 값과 포인트를 가지는 Position 객체 추가

* feat($compile): 사다리 가로 라인 위치 이동 기능 구현.

사다리 가로 라인 위치 이동 기능 구현.
- Line 객체 추가 및 move 메서드 구현

* feat($compile): 실행결과는 쉼표(,)로 구분한다

실행결과는 쉼표(,)로 구분한다
- 실행결과를 가지는 Result 객체생성
- 실행결과들을 가지는 Results 일급컬렉션 객체 생성

* feat($compile): 포인트 값으로 실행결과 찾기

포인트 값으로 실행결과 찾기
- 플레이어 이름으로 플레이어 시작 포인트 찾기 메서드 추가
- 실행결과 포인트로 실행결과 찾기 메서드 추가

* feat($compile): 사다리 실행 결과를 출력

사다리 실행 결과를 출력
- 사다리 실행 결과를 출력
- 개인별 이름을 입력하면 개인별 결과를 출력.

* feat($compile): "all"을 입력하면 전체 참여자의 실행 결과를 출력.

"all"을 입력하면 전체 참여자의 실행 결과를 출력.
- all 입력 구분하여 결과 출력 분기

Co-authored-by: jeongjaeeom <wsKgatkfrLEFg1RIwaoehyymPa4MBMvjCGyJ8ywPGN8=>

Author: logantect

README.md

@@ -2,9 +2,16 @@
 
 ## 사다리 게임 구현 기능 목록
 * 플레이어 이름은 최대 5글자만 가능하다.
-* 입력된 플레이어 이름들을 ,(콤마) 구분한다.
+* 입력된 플레이어 이름들을 쉼표(,)로 구분한다.
 * 사다리 가로 라인은 겹치지 않도록 한다.
 * 사다리 높이는 1보다 작지 않도록 한다.
+* 사다리 포인트 이동(왼쪽, 오른쪽, 멈춤) 기능 구현.
+* 사다리 특정 위치에서 시작해서 포인트 이동하는 기능 구현.
+* 사다리 가로 라인 위치 이동 기능 구현.
+* 실행결과는 쉼표(,)로 구분한다.
+* 사다리 실행 결과를 출력.
+* 개인별 이름을 입력하면 개인별 결과를 출력.
+* "all"을 입력하면 전체 참여자의 실행 결과를 출력.
 
 ## 진행 방법
 
@@ -15,4 +22,4 @@
 
 ## 온라인 코드 리뷰 과정
 
-* [텍스트와 이미지로 살펴보는 온라인 코드 리뷰 과정](https://github.com/nextstep-step/nextstep-docs/tree/master/codereview)
+* [텍스트와 이미지로 살펴보는 온라인 코드 리뷰 과정](https://github.com/nextstep-step/nextstep-docs/tree/master/codereview)

src/main/java/nextstep/ladder/LadderGameApplication.java

@@ -1,18 +1,32 @@
 package nextstep.ladder;
 
+import java.util.List;
+import java.util.stream.IntStream;
 import nextstep.ladder.domain.Height;
-import nextstep.ladder.domain.Ladder;
+import nextstep.ladder.domain.Lines;
+import nextstep.ladder.domain.Player;
 import nextstep.ladder.domain.Players;
+import nextstep.ladder.domain.Result;
+import nextstep.ladder.domain.Results;
 import nextstep.ladder.view.InputView;
 import nextstep.ladder.view.ResultView;
 
 public class LadderGameApplication {
 
+  public static final String RESULT_ALL_COMMAND = "all";
+
   public static void main(String[] args) {
     Players players = new Players(Players.create(InputView.playerNames()));
+    Results results = new Results(Results.create(InputView.results()));
     Height height = new Height(InputView.ladderHeight());
-    Ladder ladder = new Ladder(height.height(), players.count());
-    ResultView.print(players);
-    ResultView.print(ladder);
+    Lines lines = Lines.of(height.height(), players.count());
+    ResultView.print(players, lines, results);
+
+    String playerName = InputView.resultPlayer();
+    if (RESULT_ALL_COMMAND.equals(playerName)) {
+      ResultView.result(players.players(), lines, results);
+      return;
+    }
+    ResultView.print(results.result(lines.move(players.point(playerName))));
   }
 }

src/main/java/nextstep/ladder/domain/Direction.java

@@ -0,0 +1,17 @@
+package nextstep.ladder.domain;
+
+public enum Direction {
+  LEFT, RIGHT, STOP;
+
+  public boolean left() {
+    return this == LEFT;
+  }
+
+  public boolean right() {
+    return this == RIGHT;
+  }
+
+  public boolean stop() {
+    return this == STOP;
+  }
+}

src/main/java/nextstep/ladder/domain/Height.java

@@ -6,14 +6,15 @@
 
 public class Height {
 
+  public static final int MIN_HEIGHT = 1;
   private final int height;
 
   public Height(String height) {
     this(parseInt(height));
   }
 
   public Height(int height) {
-    if (height < 1) {
+    if (height < MIN_HEIGHT) {
       throw new IllegalArgumentException("사다리 높이는 1보다 작을 수 없습니다.");
     }
     this.height = height;

src/main/java/nextstep/ladder/domain/Ladder.java

@@ -3,61 +3,54 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.Objects;
-import java.util.Random;
 
 public class Line {
 
-  private static final Random RANDOM = new Random();
+  private final List<Position> positions;
 
-  private final List<Boolean> points;
-
-  public Line(int countOfPerson) {
-    this(points(countOfPerson));
+  public Line(List<Position> positions) {
+    this.positions = positions;
   }
 
-  public Line(List<Boolean> points) {
-    this.points = points;
+  public static Line from(int numberOfPlayers, PointStrategy strategy) {
+    List<Position> positions = new ArrayList<>();
+    positions.add(firstPosition(strategy));
+    for (int i = 1; i < numberOfPlayers - 1; i++) {
+      positions.add(bodyPosition(i, positions.get(i - 1), strategy));
+    }
+    positions.add(lastPosition(numberOfPlayers - 1, positions.get(positions.size() - 1)));
+    return from(positions);
   }
 
-  private static List<Boolean> points(int countOfPerson) {
-    List<Boolean> points = new ArrayList<>();
-    points.add(randomPoint());
-    for (int i = 1; i < countOfPerson - 1; i++) {
-      points.add(point(points.get(i - 1), randomPoint()));
-    }
-    return points;
+  public static Line from(List<Position> points) {
+    return new Line(points);
   }
 
-  private static Boolean point(boolean prev, boolean current) {
-    if (prev == current) {
-      return false;
-    }
-    return current;
+  private static Position firstPosition(PointStrategy strategy) {
+    return Position.of(0, Point.of(false, strategy.linkable()));
   }
 
-  private static Boolean randomPoint() {
-    return RANDOM.nextBoolean();
+  private static Position bodyPosition(int position, Position prev, PointStrategy strategy) {
+    return Position.of(position, point(prev, strategy.linkable()));
   }
 
-  public List<Boolean> points() {
-    return Collections.unmodifiableList(points);
+  private static Position lastPosition(int position, Position prev) {
+    return Position.of(position, Point.of(prev.current(), false));
   }
 
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
+  private static Point point(Position prev, boolean current) {
+    if (prev.current() == current) {
+      return Point.of(prev.current(), false);
     }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    Line line = (Line) o;
-    return Objects.equals(points, line.points);
+    return Point.of(prev.current(), current);
+  }
+
+  public int move(int startPoint) {
+    return positions.get(startPoint).move();
   }
 
-  @Override
-  public int hashCode() {
-    return Objects.hash(points);
+  public List<Position> positions() {
+    return Collections.unmodifiableList(positions);
   }
+
 }

src/main/java/nextstep/ladder/domain/Line.java

@@ -0,0 +1,33 @@
+package nextstep.ladder.domain;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Lines {
+
+  private final List<Line> lines;
+
+  public Lines(List<Line> lines) {
+    this.lines = lines;
+  }
+
+  public static Lines of(int height, int numberOfPlayers) {
+    return new Lines(IntStream.range(0, height)
+        .mapToObj(number -> Line.from(numberOfPlayers, new RandomPointStrategy()))
+        .collect(Collectors.toList()));
+  }
+
+  public int move(int startPoint) {
+    int result = startPoint;
+    for (Line line : lines) {
+      result = line.move(result);
+    }
+    return result;
+  }
+
+  public List<Line> lines() {
+    return Collections.unmodifiableList(lines);
+  }
+}

src/main/java/nextstep/ladder/domain/Lines.java

@@ -4,13 +4,29 @@
 
 public class Player {
 
+  public static final int MAX_NAME_LENGTH = 5;
   private final String name;
 
   public Player(String name) {
-    if (name == null || name.length() > 5) {
+    validateEmpty(name);
+    validateLength(name.trim());
+    this.name = name.trim();
+  }
+
+  private void validateEmpty(String name) {
+    if (isBlank(name)) {
+      throw new IllegalArgumentException("플레이어 이름은 비어 있을 수 없습니다.");
+    }
+  }
+
+  private void validateLength(String name) {
+    if (name.length() > MAX_NAME_LENGTH) {
       throw new IllegalArgumentException("플레이어 이름은 최대 5글자만 가능합니다.");
     }
-    this.name = name;
+  }
+
+  private static boolean isBlank(String name) {
+    return name == null || name.isBlank();
   }
 
   @Override

src/main/java/nextstep/ladder/domain/Player.java

@@ -1,13 +1,15 @@
 package nextstep.ladder.domain;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 import java.util.stream.Collectors;
 
 public class Players {
 
   public static final String DELIMITER = ",";
+  public static final String JOINING_DELIMITER = " ";
   private final List<Player> players;
 
   public Players(List<Player> players) {
@@ -23,6 +25,13 @@ public int count() {
     return players.size();
   }
 
+  public int point(String playerName) {
+    return point(new Player(playerName));
+  }
+  public int point(Player player) {
+    return players.indexOf(player);
+  }
+
   private static void validateEmpty(String playerNames) {
     if (playerNames == null || playerNames.isBlank()) {
       throw new IllegalArgumentException("플레이어명은 필수입니다.");
@@ -35,6 +44,10 @@ private static List<Player> players(String playerNames) {
         .collect(Collectors.toList());
   }
 
+  public List<Player> players() {
+    return Collections.unmodifiableList(players);
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
@@ -56,6 +69,6 @@ public int hashCode() {
   public String toString() {
     return players.stream()
         .map(String::valueOf)
-        .collect(Collectors.joining(" "));
+        .collect(Collectors.joining(JOINING_DELIMITER));
   }
 }

src/main/java/nextstep/ladder/domain/Players.java

@@ -0,0 +1,37 @@
+package nextstep.ladder.domain;
+
+public class Point {
+
+  private final boolean left;
+  private final boolean current;
+
+  public static Point of(boolean left, boolean current) {
+    return new Point(left, current);
+  }
+
+  private Point(boolean left, boolean current) {
+    if (left && current) {
+      throw new IllegalArgumentException("사다리 포지션은 양쪽에 동시에 존재할 수 없습니다.");
+    }
+    this.left = left;
+    this.current = current;
+  }
+
+  public boolean current() {
+    return this.current;
+  }
+
+  public Direction move() {
+    if (current) {
+      return Direction.RIGHT;
+    } else if (left) {
+      return Direction.LEFT;
+    }
+    return Direction.STOP;
+  }
+
+  @Override
+  public String toString() {
+    return "{" + "left:" + left + ", current:" + current + '}';
+  }
+}