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

src/main/java/nextstep/Main.java

@@ -1,7 +1,11 @@
 package nextstep;
 
+import nextstep.domain.Bonuses;
+import nextstep.domain.Command;
 import nextstep.domain.Ladder;
-import nextstep.domain.Names;
+import nextstep.domain.LadderGame;
+import nextstep.domain.LadderResult;
+import nextstep.domain.Participants;
 import nextstep.view.InputView;
 import nextstep.view.OutputView;
 
@@ -11,11 +15,22 @@ public static void main(String[] args) {
         InputView in = new InputView();
         OutputView out = new OutputView();
 
-        Names names = in.getName();
+        Participants participants = in.getName();
+        Bonuses bonus = in.getBonus(participants.size());
         int height = in.getHeight();
 
-        Ladder ladder = Ladder.of(names.size(), height);
-        out.printResult(names, ladder);
+        Ladder ladder = Ladder.of(participants.size(), height);
+        LadderGame game = new LadderGame(bonus, participants, ladder);
+        LadderResult result = game.play();
 
+        out.printLadder(participants, ladder, bonus);
+        while (true) {
+            Command command = Command.of(in.readTarget());
+            if (command.isAll()) {
+                out.printAllResults(result);
+                break;
+            }
+            out.printPersonalResult(result, command.getValue());
+        }
     }
 }

src/main/java/nextstep/domain/Bonus.java

@@ -0,0 +1,42 @@
+package nextstep.domain;
+
+public class Bonus {
+    private static final Integer MAX_NAME_LENGTH = 5;
+    private final String bonusName;
+    private final Integer position;
+
+    public Bonus(String bonusName, Integer position) {
+        validate(bonusName);
+        this.bonusName = bonusName;
+        this.position = position;
+    }
+
+    public static Bonus of(String bonusName) {
+        return new Bonus(bonusName, 0);
+    }
+
+    public static Bonus of(String bonusName, int position) {
+        return new Bonus(bonusName, position);
+    }
+
+    private void validate(String input) {
+        if (input == null || input.trim().isEmpty()) {
+            throw new IllegalArgumentException("이름은 빈 문자열이 될 수 없습니다.");
+        }
+        if (input.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException("이름은 최대 " + MAX_NAME_LENGTH + "자까지 허용됩니다.");
+        }
+    }
+
+    public int position() {
+        return position;
+    }
+
+    public boolean isMatch(int index){
+        return position.equals(index);
+    }
+
+    public String getName() {
+        return bonusName;
+    }
+}

src/main/java/nextstep/domain/Bonuses.java

@@ -0,0 +1,49 @@
+package nextstep.domain;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+/**
+ * Bonus의 일급컬렉션
+ */
+public class Bonuses {
+    private List<Bonus> bonuses;
+
+    public Bonuses(String input, int count) {
+        List<Bonus> bonuses = splitAndTrim(input);
+        if (count != bonuses.size()) {
+            throw new IllegalArgumentException("보너스 개수와 사람 수가 일치하지 않습니다.");
+        }
+        this.bonuses = bonuses;
+    }
+
+    private List<Bonus> splitAndTrim(String input) {
+        String[] names = input.split(",");
+        return IntStream.range(0, names.length)
+            .mapToObj(i -> Bonus.of(names[i].trim(), i))
+            .collect(Collectors.toList());
+    }
+
+    public Optional<Bonus> getBonusByPosition(int index) {
+        if (index < 0 || index >= bonuses.size()) {
+            throw new IndexOutOfBoundsException("올바르지 않은 숫자입니다.");
+        }
+        return bonuses.stream()
+            .filter(bonus -> bonus.isMatch(index))
+            .findFirst();
+    }
+
+    public String getNameByPosition(int index) {
+        return getBonusByPosition(index)
+            .map(Bonus::getName)
+            .orElseThrow(NoSuchElementException::new);
+    }
+
+    public List<Bonus> unmodifiableNames() {
+        return Collections.unmodifiableList(bonuses);
+    }
+}

src/main/java/nextstep/domain/Command.java

@@ -0,0 +1,48 @@
+package nextstep.domain;
+
+import static nextstep.domain.CommandEnum.*;
+
+import java.util.Objects;
+
+/**
+ * 사다리게임 결과를 보고싶은 커맨드
+ */
+public class Command {
+    private final String command;
+
+    private Command(String command) {
+        this.command = validate(command.trim());
+    }
+
+    public static Command of(String command) {
+        return new Command(command);
+    }
+
+    public boolean isAll() {
+        return ALL.equals(command);
+    }
+
+    public String validate(String input) {
+        if (input == null || input.isEmpty()) {
+            throw new IllegalArgumentException("빈 문자열은 허용되지 않습니다.");
+        }
+        return input;
+    }
+
+    public String getValue() {
+        return command;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass())
+            return false;
+        Command command1 = (Command)o;
+        return Objects.equals(command, command1.command);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(command);
+    }
+}

src/main/java/nextstep/domain/CommandEnum.java

@@ -0,0 +1,15 @@
+package nextstep.domain;
+
+public enum CommandEnum {
+    ALL("all");
+
+    private final String command;
+
+    CommandEnum(String command) {
+        this.command = command;
+    }
+
+    public boolean equals(String command) {
+        return this.command.equals(command);
+    }
+}

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

@@ -1,7 +1,9 @@
 package nextstep.domain;
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -39,4 +41,11 @@ public int height() {
     public List<Line> lines() {
         return Collections.unmodifiableList(lines);
     }
+
+    public Map<Integer, Integer> result() {
+        Map<Integer, Integer> result = new HashMap<>();
+        IntStream.range(0, lines.size())
+            .forEach(i -> result.put(i, play(i)));
+        return result;
+    }
 }

src/main/java/nextstep/domain/LadderGame.java

@@ -0,0 +1,33 @@
+package nextstep.domain;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class LadderGame {
+    private final Bonuses bonuses;
+    private final Participants participants;
+    private final Ladder ladder;
+
+    public LadderGame(Bonuses bonuses, Participants participants, Ladder ladder) {
+        this.bonuses = bonuses;
+        this.participants = participants;
+        this.ladder = ladder;
+    }
+
+    /**
+     * 모든 참가자의 게임 결과를 계산하여 LadderResult로 반환
+     */
+    public LadderResult play() {
+        // insertion order를 유지하기 위해 LinkedHashMap 사용
+        Map<Participant, Bonus> resultMap = participants.unmodifiableNames().stream()
+            .collect(Collectors.toMap(
+                p -> p,
+                p -> bonuses.getBonusByPosition(ladder.play(p.getPosition())).orElseThrow(IllegalArgumentException::new),
+                (existing, replacement) -> existing,
+                LinkedHashMap::new
+            ));
+        return new LadderResult(resultMap);
+    }
+
+}

src/main/java/nextstep/domain/LadderResult.java

@@ -0,0 +1,38 @@
+package nextstep.domain;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class LadderResult {
+    private final Map<Participant, Bonus> result;
+
+    public LadderResult(Map<Participant, Bonus> result) {
+        this.result = result;
+    }
+
+    public String getBonusName(Participant participant) {
+        return Optional.ofNullable(result.get(participant))
+            .map(Bonus::getName)
+            .orElseThrow(IllegalArgumentException::new);
+    }
+
+    public String findBonusByParticipantName(String name) {
+        return Optional.ofNullable(getAllResult().get(name))
+            .orElseThrow(IllegalArgumentException::new);
+    }
+
+    /* 헬퍼 메서드 */
+    public Map<String, String> getAllResult() {
+        return Collections.unmodifiableMap(
+            result.entrySet().stream()
+                .collect(Collectors.toMap(
+                    e -> e.getKey().getName(),
+                    e -> e.getValue().getName(),
+                    (a, b) -> a, LinkedHashMap::new
+                ))
+        );
+    }
+}

src/main/java/nextstep/domain/Name.java → src/main/java/nextstep/domain/Participant.java

@@ -5,21 +5,15 @@
 /**
  * 이름 클래스
  */
-public class Name {
+public class Participant {
     private static final Integer MAX_NAME_LENGTH = 5;
     private final String name;
+    private final Integer position;
 
-    private Name(String name) {
+    public Participant(String name, int Position) {
         validate(name);
         this.name = name;
-    }
-
-    public static Name of(String name) {
-        return new Name(name);
-    }
-
-    public String getName() {
-        return name;
+        this.position = Position;
     }
 
     private void validate(String input) {
@@ -31,17 +25,24 @@ private void validate(String input) {
         }
     }
 
-    @Override
-    public String toString() {
+    public int getPosition() {
+        return position;
+    }
+
+    public boolean isSameName(String name) {
+        return this.name.equals(name);
+    }
+
+    public String getName() {
         return name;
     }
 
     @Override
     public boolean equals(Object o) {
         if (o == null || getClass() != o.getClass())
             return false;
-        Name name1 = (Name)o;
-        return Objects.equals(name, name1.name);
+        Participant participant1 = (Participant)o;
+        return Objects.equals(name, participant1.name);
     }
 
     @Override