[2단계 - 사다리 게임] 에버(손채영) 미션 제출합니다.

README.md

@@ -9,17 +9,38 @@
 ### 사다리
 - [x] 사다리 가로줄의 생성 여부는 랜덤으로 결정된다.
 - [x] 사다리 가로줄 라인이 겹치지 않도록 해야 한다.
-    - [x] `|-----|-----|` 와 같은 모양은 허용하지 않는다.
+  - [x] `|-----|-----|` 와 같은 모양은 허용하지 않는다.
 - [x] 사다리 높이는 1부터 20까지 가능하다.
 
+### 게임
+- [x] 참여자와 결과를 사다리를 통해 매칭한다.
+- [x] 높이 횟수만큼 아래의 동작을 반복한다.
+  - [x] 가로줄이 있는 경우 해당 방향으로 한 칸 이동한다.
+  - [x] 가로줄이 없는 경우 밑으로 한 칸 이동한다.
+
+### 결과
+- [x] 결과는 1글자부터 5글자까지 부여할 수 있다.
+- [x] 결과는 쉼표(,)를 기준으로 구분한다.
+- [x] 결과의 수는 참여자의 수와 일치하다.
+
 ### 입력
 - [x] 참여할 사람의 이름을 쉼표(,)로 구분하여 입력받는다.
+- [x] 참여할 사람의 이름은 "all"이 될 수 없다.
 - [x] 최대 사다리 높이를 입력받는다.
-- [x] 잘못된 형태로 입력된 경우 다시 입력받는다.
+- [x] 참여자가 매칭될 결과를 입력받는다.
+- [x] 결과를 보고 싶은 사람을 입력받는다. (개인 이름 또는 all)
+- [x] 모든 입력에 대해 잘못된 형태로 입력된 경우 다시 입력받는다.
 
 ### 출력
 - [x] 사람 이름이 출력되고, 그 다음줄부터 사다리가 출력된다.
   - [x] 사람 이름이 5자 미만인 경우 이름의 마지막 글자가 사다리 세로줄의 바로 왼쪽 열에 위치하게 한다.
   - [x] 사람 이름이 5자인 경우 이름의 마지막 글자가 사다리 세로줄과 같은 열에 위치하게 한다.
   - [x] 사다리 각 행의 가장 왼쪽에는 4칸의 공백이 있다.
   - [x] 사다리 세로줄 간의 간격은 5칸으로 한다.
+- [x] 개인별 실행 결과를 출력한다.
+- [x] 전체 참여자의 실행 결과를 출력한다.
+  - [x] 입력받은 참여자 순서대로 출력한다.
+
+### 컨트롤러
+- [x] "all"을 통해 전체 참여자가 출력되면 게임을 종료한다.
+- [x] 실행 결과 출력은 최대 50번까지만 허용한다.

src/main/java/controller/GameController.java

@@ -1,16 +1,24 @@
 package controller;
 
 import domain.Game;
-import domain.Lines;
+import domain.GameResult;
+import domain.Ladder;
 import domain.Members;
+import domain.Result;
+import domain.Results;
 import domain.StringParser;
+import domain.ResultTarget;
 import error.ErrorHandler;
+import java.util.List;
+import java.util.Map;
 import strategy.RandomConnectionStrategy;
 import view.InputView;
 import view.OutputView;
 
 public class GameController {
 
+    public static final int MAX_GAME_COUNT = 50;
+
     private final InputView inputView;
     private final OutputView outputView;
     private final ErrorHandler errorHandler;
@@ -23,26 +31,55 @@ public GameController(InputView inputView, OutputView outputView, ErrorHandler e
 
     public void run() {
 
-        Members members = makeMembers();
+        Members members = errorHandler.readUntilNoError(this::makeMembers);
+
+        Results results = errorHandler.readUntilNoError(() -> makeResults(members));
+
+        Ladder ladder = errorHandler.readUntilNoError(() -> makeLadder(members));
+
+        Game game = new Game(members, ladder, results);
+        outputView.printLadder(game);
 
-        Lines lines = makeLines(members);
+        GameResult gameResult = game.matchResult();
 
-        Game game = new Game(members, lines);
-        outputView.printResult(game);
+        manageResult(members, gameResult);
     }
 
     private Members makeMembers() {
-        return errorHandler.readUntilNoError(() -> {
-            String rawNames = inputView.readNames();
-            return Members.from(rawNames);
-        });
-    }
-
-    private Lines makeLines(Members members) {
-        return errorHandler.readUntilNoError(() -> {
-            String rawHeight = inputView.readHeight();
-            int height = StringParser.stringToInt(rawHeight);
-            return Lines.of(members.getCount(), height, new RandomConnectionStrategy());
-        });
+        String rawNames = inputView.readNames();
+        List<String> names = StringParser.splitByDelimiter(rawNames, ",");
+        return Members.from(names);
+    }
+
+    private Results makeResults(Members members) {
+        String rawResults = inputView.readResults();
+        List<String> results = StringParser.splitByDelimiter(rawResults, ",");
+        return Results.of(results, members.getCount());
+    }
+
+    private Ladder makeLadder(Members members) {
+        String rawHeight = inputView.readHeight();
+        int height = StringParser.stringToInt(rawHeight);
+        return Ladder.of(height, members.getCount(), new RandomConnectionStrategy());
+    }
+
+    private ResultTarget makeResultTarget(Members members) {
+        String rawTargetName = inputView.readTarget();
+        return ResultTarget.of(rawTargetName, members.getMembers());
+    }
+
+    private void manageResult(Members members, GameResult gameResult) {
+        ResultTarget resultTarget = showResult(members, gameResult);
+        int count = MAX_GAME_COUNT;
+        while (count-- > 0 && !resultTarget.isAllMembers()) {
+            resultTarget = showResult(members, gameResult);
+        }
+    }
+
+    private ResultTarget showResult(Members members, GameResult gameResult) {
+        ResultTarget resultTarget = errorHandler.readUntilNoError(() -> makeResultTarget(members));
+        Map<String, Result> result = gameResult.getResultByTarget(resultTarget);
+        outputView.printResult(result);
+        return resultTarget;
     }
 }

src/main/java/domain/Game.java

@@ -1,20 +1,74 @@
 package domain;
 
+import java.util.List;
+
 public class Game {
 
     private final Members members;
-    private final Lines lines;
+    private final Ladder ladder;
+    private final Results results;
+    private final GameResult gameResult;
 
-    public Game(Members members, Lines lines) {
+    public Game(Members members, Ladder ladder, Results results) {
         this.members = members;
-        this.lines = lines;
+        this.ladder = ladder;
+        this.results = results;
+        this.gameResult = new GameResult();
+    }
+
+    public GameResult matchResult() {
+        for (Member member : members.getMembers()) {
+            int index = members.findPositionOfMember(member);
+            index = tryMoveAll(index);
+            Result result = results.findResultByPosition(index);
+            gameResult.addGameResult(member, result);
+        }
+        return gameResult;
+    }
+
+    private int tryMoveAll(int index) {
+        for (Line line : ladder.getLines()) {
+            List<Connection> connections = line.getConnections();
+            index = tryMove(connections, index);
+        }
+        return index;
+    }
+
+    private int tryMove(List<Connection> connections, int index) {
+        if (canMoveLeft(connections, index)) {
+            return index - 1;
+        }
+        if (canMoveRight(connections, index)) {
+            return index + 1;
+        }
+        return index;
+    }
+
+    private boolean canMoveLeft(List<Connection> connections, int index) {
+        if (index <= 0) {
+            return false;
+        }
+        Connection left = connections.get(index - 1);
+        return left.equals(Connection.CONNECTED);
+    }
+
+    private boolean canMoveRight(List<Connection> connections, int index) {
+        if (index > connections.size() - 1) {
+            return false;
+        }
+        Connection right = connections.get(index);
+        return right.equals(Connection.CONNECTED);
     }
 
     public Members getMembers() {
         return members;
     }
 
-    public Lines getLines() {
-        return lines;
+    public Ladder getLines() {
+        return ladder;
+    }
+
+    public Results getResults() {
+        return results;
     }
 }

src/main/java/domain/GameResult.java

@@ -0,0 +1,48 @@
+package domain;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class GameResult {
+
+    private final HashMap<Member, Result> gameResult;
+
+    public GameResult() {
+        this.gameResult = new LinkedHashMap<>();
+    }
+
+    public void addGameResult(Member member, Result result) {
+        gameResult.put(member, result);
+    }
+
+    public Map<String, Result> getResultByTarget(ResultTarget target) {
+        if (target.isAllMembers()) {
+            return getResultOfAllMember();
+        }
+        String memberName = target.getValue();
+        Result result = getResultByMemberName(target.getValue());
+        return new LinkedHashMap<>() {{
+            put(memberName, result);
+        }};
+    }
+
+    private Result getResultByMemberName(String name) {
+        return gameResult.entrySet().stream()
+                .filter(memberResult -> memberResult.getKey().getName().equals(name))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("해당 이름을 가진 참여자가 없습니다."))
+                .getValue();
+    }
+
+    private Map<String, Result> getResultOfAllMember() {
+        Map<String, Result> resolvedResult = new LinkedHashMap<>();
+        for (Entry<Member, Result> memberResult : gameResult.entrySet()) {
+            String memberName = memberResult.getKey().getName();
+            Result result = memberResult.getValue();
+            resolvedResult.put(memberName, result);
+        }
+        return resolvedResult;
+    }
+}

src/main/java/domain/Ladder.java

@@ -0,0 +1,37 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import strategy.ConnectionStrategy;
+
+public class Ladder {
+
+    public static final int MIN_HEIGHT = 1;
+    public static final int MAX_HEIGHT = 20;
+
+    private final List<Line> lines;
+
+    private Ladder(List<Line> lines) {
+        validateHeight(lines.size());
+        this.lines = lines;
+    }
+
+    private void validateHeight(int height) {
+        if (height < MIN_HEIGHT || height > MAX_HEIGHT) {
+            throw new IllegalArgumentException(MIN_HEIGHT + " 이상 " + MAX_HEIGHT + " 이하의 숫자를 입력해 주세요.");
+        }
+    }
+
+    public static Ladder of(int height, int memberCount, ConnectionStrategy connectionStrategy) {
+        List<Line> lines = new ArrayList<>();
+        for (int i = 0; i < height; i++) {
+            lines.add(Line.of(memberCount, connectionStrategy));
+        }
+        return new Ladder(lines);
+    }
+
+    public List<Line> getLines() {
+        return Collections.unmodifiableList(lines);
+    }
+}

src/main/java/domain/Line.java

@@ -12,7 +12,7 @@ private Line(List<Connection> connections) {
         this.connections = connections;
     }
 
-    public static Line from(int memberCount, ConnectionStrategy connectionStrategy) {
+    public static Line of(int memberCount, ConnectionStrategy connectionStrategy) {
         List<Connection> connections = new ArrayList<>();
         connections.add(connectionStrategy.generateConnection());
 

src/main/java/domain/Member.java

@@ -2,10 +2,10 @@
 
 public class Member {
 
-    private final Name name;
+    private final MemberName name;
 
     public Member(String rawName) {
-        this.name = new Name(rawName);
+        this.name = new MemberName(rawName);
     }
 
     public String getName() {