3단계 - 사다리(게임 실행) (#2421)

* feat:🚀 2단계 - 사다리(생성)

* refactor:스트림활용, 안쓰는 코드 정리

* feat:PR반영, README에 TODO 갱신

* refactor:리팩토링 및 테스트 케이스 보강

* feat:3단계 사다리(게임 실행)

* refactor:PR 반영

* chore:게임 화면 개선. 안쓰는 import제거

Author: Victor-shin

README.md

@@ -1,7 +1,33 @@
 # 사다리 게임
 
+
+## 3단계 - 사다리(게임 실행)
+### TODO
+- [x] PR 반영
+  - [x] Line 객체에 가변 인자를 받은 생성자를 추가
+  - [x] LineGenerator가 generateLine에서 Line 객체를 리턴
+  - [x] LineGeneratorTest의 너무 많은 가변인자 테스트 정리->보다 적은수로 경우의 수를 커버 
+  - [x] Ladder.java에 game Play에 대한 책임 부여 검토
+  - [x] Line.java에 LEFT, RIGHT, PASS와 같은 상태값을 enum으로 구현
+  - [x] Line의 index 원시값 포장 
+  - [x] LineGenerator에 현재값,이전값을 가지는 Point 객체 도입 검토
+
+- [x] 사다리 실행 결과를 출력해야 한다.
+- [x] 개인별 이름을 입력하면 개인별 결과를 출력하고, "all"을 입력하면 전체 참여자의 실행 결과를 출력한다.
+
+### 프로그래밍 요구사항
+- 자바 8의 스트림과 람다를 적용해 프로그래밍한다.
+- 규칙 6: 모든 엔티티를 작게 유지한다.
+- **규칙 7: 3개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않는다.**
+
+
+
 ## 2단계 - 사다리 생성
 ### TODO
+- [x] 사다리 실행 결과를 출력해야 한다.
+- [x] 개인별 이름을 입력하면 개인별 결과를 출력하고, "all"을 입력하면 전체 참여자의 실행 결과를 출력한다.
+
+- [x] PR 반영
 - [x] 사다리 게임에 참여하는 사람에 이름을 최대5글자까지 부여할 수 있다. 사다리를 출력할 때 사람 이름도 같이 출력한다.
 - [x] 사람 이름은 쉼표(,)를 기준으로 구분한다.
 - [x] 사람 이름을 5자 기준으로 출력하기 때문에 사다리 폭도 넓어져야 한다.
@@ -11,6 +37,7 @@
 ### 프로그래밍 요구사항
 - 자바 8의 스트림과 람다를 적용해 프로그래밍한다.
 - 규칙 6: 모든 엔티티를 작게 유지한다.
+- **규칙 7: 3개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않는다.**
 
 
 ## 진행 방법

src/main/java/nextstep/ladder/LadderGame.java

@@ -1,20 +1,53 @@
 package nextstep.ladder;
 
 import nextstep.ladder.domain.ladder.Height;
+import nextstep.ladder.domain.ladder.Index;
 import nextstep.ladder.domain.ladder.Ladder;
 import nextstep.ladder.domain.generator.LadderGenerator;
+import nextstep.ladder.domain.name.Name;
 import nextstep.ladder.domain.name.Names;
+import nextstep.ladder.domain.reward.Reward;
+import nextstep.ladder.domain.reward.Rewards;
 import nextstep.ladder.view.InputView;
 import nextstep.ladder.view.ResultView;
 
+import java.util.List;
+import java.util.stream.Collectors;
+
 public class LadderGame {
 
     public static void main(String[] args) {
         Names names = new Names(InputView.getNames());
         Height height = new Height(InputView.getHeight());
+        Rewards rewards = new Rewards(InputView.getRewards());
 
         Ladder ladder = LadderGenerator.generateLadder(names.count(), height);
 
-        ResultView.result(names, ladder);
+        ResultView.ladderResult(names, ladder, rewards);
+
+        while(true) {
+            String playerName = InputView.getPlayerName();
+
+            if (playerName.equalsIgnoreCase("quit")) {
+                break;
+            }
+
+            if (playerName.equalsIgnoreCase("all")) {
+                List<Integer> rewardList = ladder.all().stream()
+                    .map(Index::value)
+                    .collect(Collectors.toList());
+                ResultView.rewardResult(names, rewards, rewardList);
+                continue;
+            }
+
+            Name name = new Name(playerName);
+            Index rewardIdx = ladder.resultOf(names.positionOf(name));
+            try {
+                Reward reward = rewards.get(rewardIdx.value());
+                System.out.println(reward);
+            } catch(IndexOutOfBoundsException e) {
+                System.out.println("이름이 명단에 없습니다.");
+            }
+        }
     }
 }

src/main/java/nextstep/ladder/domain/common/AbstractValueList.java

@@ -0,0 +1,34 @@
+package nextstep.ladder.domain.common;
+
+import java.util.List;
+
+public abstract class AbstractValueList<T> {
+    protected final List<T> values;
+
+    protected AbstractValueList(List<T> values) {
+        if (values == null || values.isEmpty()) {
+            throw new IllegalArgumentException("리스트는 비어 있을 수 없습니다.");
+        }
+        this.values = List.copyOf(values);
+    }
+
+    public List<T> values() {
+        return values;
+    }
+
+    public int count() {
+        return values.size();
+    }
+
+    public T get(int index) {
+        return values.get(index);
+    }
+
+    public int positionOf(Object value) {
+        if (value == null) {
+            throw new IllegalArgumentException("찾는 값은 null일 수 없습니다.");
+        }
+
+        return values.indexOf(value);
+    }
+}

src/main/java/nextstep/ladder/domain/generator/CombinationGenerator.java

@@ -5,10 +5,10 @@
 import nextstep.ladder.domain.ladder.Line;
 
 public class LadderGenerator {
-    public static Ladder generateLadder(int countOfPerson, Height height) {
-        Ladder ladder = new Ladder();
+    public static Ladder generateLadder(int countOfPeople, Height height) {
+        Ladder ladder = new Ladder(countOfPeople);
         for (int i = 0; i < height.value(); i++) {
-            Line line = new Line(countOfPerson);
+            Line line = new Line(countOfPeople);
             ladder.add(line);
         }
 

src/main/java/nextstep/ladder/domain/generator/LadderGenerator.java

@@ -0,0 +1,44 @@
+package nextstep.ladder.domain.generator;
+
+import nextstep.ladder.domain.ladder.Line;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class LineGenerator {
+    public static Line generateLine(int countOfPerson) {
+        List<Boolean> line = new ArrayList<>();
+        Point point = new Point(false, false);
+
+        for (int i = 0; i < countOfPerson - 1; i++) {
+            boolean nextBoolean = randomBoolean();
+            point = new Point(point.next(), nextBoolean);
+            
+            if (point.isConsecutive()) {
+                nextBoolean = false;
+                point = new Point(point.current(), false);
+            }
+            
+            line.add(nextBoolean);
+        }
+        return new Line(line);
+    }
+
+    public static void assertValidLine(List<Boolean> values) {
+        if (values == null || values.isEmpty()) {
+            throw new IllegalArgumentException("사다리에는 빈값이 올 수 없습니다. values=" + values);
+        }
+
+        for(int i = 0; i < values.size() -1; i++) {
+            Point point = new Point(values.get(i), values.get(i + 1));
+            if(point.isConsecutive()) {
+                throw new IllegalArgumentException("연속된 사다리 계단은 나올 수 없습니다.");
+            }
+        }
+    }
+
+    private static boolean randomBoolean() {
+        return ThreadLocalRandom.current().nextBoolean();
+    }
+}

src/main/java/nextstep/ladder/domain/generator/LineGenerator.java

@@ -0,0 +1,23 @@
+package nextstep.ladder.domain.generator;
+
+public class Point {
+    private final boolean current;
+    private final boolean next;
+
+    public Point(boolean current, boolean next) {
+        this.current = current;
+        this.next = next;
+    }
+
+    public boolean isConsecutive() {
+        return current && next;
+    }
+
+    public boolean current() {
+        return current;
+    }
+
+    public boolean next() {
+        return next;
+    }
+}

src/main/java/nextstep/ladder/domain/generator/Point.java

@@ -0,0 +1,24 @@
+package nextstep.ladder.domain.ladder;
+
+public enum Direction {
+    LEFT {
+        @Override
+        public Index move(Index index) {
+            return index.decrement();
+        }
+    },
+    RIGHT {
+        @Override
+        public Index move(Index index) {
+            return index.increment();
+        }
+    },
+    PASS {
+        @Override
+        public Index move(Index index) {
+            return index;
+        }
+    };
+
+    public abstract Index move(Index index);
+} 

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

@@ -0,0 +1,43 @@
+package nextstep.ladder.domain.ladder;
+
+public class Index {
+    private final int value;
+    private final int max;
+
+    public Index(int value, int max) {
+        validate(value, max);
+        this.value = value;
+        this.max = max;
+    }
+
+    private void validate(int value, int max) {
+        if (value < 0 || value >= max) {
+            throw new IllegalArgumentException("인덱스는 0 이상 " + (max - 1) + " 이하여야 합니다.");
+        }
+    }
+
+    public int value() {
+        return value;
+    }
+
+    public Index increment() {
+        return new Index(value + 1, max);
+    }
+
+    public Index decrement() {
+        return new Index(value - 1, max);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Index index = (Index) o;
+        return value == index.value && max == index.max;
+    }
+
+    @Override
+    public int hashCode() {
+        return value;
+    }
+} 

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

@@ -4,17 +4,35 @@
 import java.util.List;
 
 public class Ladder {
-     List<Line> lineList;
+    private final List<Line> lineList;
+    private final int countOfPeople;
 
-    public Ladder() {
+    public Ladder(int countOfPeople) {
+        this.countOfPeople = countOfPeople;
         this.lineList = new ArrayList<>();
     }
 
-     public List<Line> values() {
-         return lineList;
-     }
+    public List<Line> values() {
+        return lineList;
+    }
+
+    public void add(Line line) {
+        lineList.add(line);
+    }
 
-     public void add(Line line) {
-         lineList.add(line);
-     }
+    public Index resultOf(int position) {
+        Index index = new Index(position, countOfPeople);
+        for(Line line: values()) {
+            index = line.movePerson(index);
+        }
+        return index;
+    }
+
+    public List<Index> all() {
+        List<Index> results = new ArrayList<>();
+        for(int i = 0; i < countOfPeople; i++) {
+            results.add(resultOf(i));
+        }
+        return results;
+    }
 }