ladder game complete

Author: jyami-kim

src/main/java/LadderGame.java

@@ -1,19 +1,26 @@
 import domain.ladder.Ladder;
-import domain.user.ParticipantUsers;
+import domain.ladderCalculator.LadderIO;
 import dto.GameStartOption;
 import view.InputView;
-import view.OutputView;
+import view.OutputLadder;
 
 public class LadderGame {
 
     public static void main(String args[]) {
-        GameStartOption gameStartOption = InputView.of(System.in).initGameStartOption();
+        InputView inputView = InputView.of(System.in);
+        GameStartOption gameStartOption = inputView.initGameStartOption();
         Ladder ladder = Ladder.of(gameStartOption);
-        ParticipantUsers userManage = ParticipantUsers.of(gameStartOption);
-        OutputView print = OutputView.of(userManage, ladder);
+        LadderIO ladderIO = LadderIO.of(gameStartOption);
+        OutputLadder ladderPrint = OutputLadder.of(ladderIO, ladder);
 
-        print.drawUserNames();
-        print.drawOutput();
+        ladderPrint.drawUserNames();
+        ladderPrint.drawOutput();
+        ladderPrint.drawResults();
+
+        while (true) {
+            String ask = inputView.showResultUser();
+            ladderPrint.showLadderResult(ask);
+        }
 
     }
 }

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

@@ -2,7 +2,9 @@
 
 import domain.maker.LadderMaker;
 import dto.GameStartOption;
+
 import java.util.List;
+import java.util.Optional;
 
 public class Ladder {
 
@@ -16,7 +18,7 @@ private Ladder(GameStartOption gameStartOption) {
         this.pillars = LadderMaker.of().createLadder(gameStartOption);
     }
 
-    public static Ladder of(GameStartOption gameStartOption){
+    public static Ladder of(GameStartOption gameStartOption) {
         return new Ladder(gameStartOption);
     }
 
@@ -39,4 +41,13 @@ public Integer getHeight() {
         return height;
     }
 
+    public Pillar getNextPillar(Pillar nowPillar, Integer nowLocation) {
+        Optional<Bridge> linkBridge = nowPillar.getLevelBridges(nowLocation);
+        if (!linkBridge.isPresent())
+            return nowPillar;
+        return linkBridge.get().getLinkPillarDirection() == LinkedType.RIGHT ?
+                getPillarByNum(nowPillar.getPillarNum() + 1) :
+                getPillarByNum(nowPillar.getPillarNum() - 1);
+    }
+
 }

src/main/java/domain/ladderCalculator/LadderIO.java

@@ -0,0 +1,52 @@
+package domain.ladderCalculator;
+
+import domain.ladder.Ladder;
+import domain.ladder.Pillar;
+import dto.GameStartOption;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static util.RandomIntegerMaker.separateByDelimiter;
+
+public class LadderIO {
+
+    private List<String> users;
+    private List<String> results;
+
+    private LadderIO(GameStartOption gameStartOption) {
+        this.users = separateByDelimiter(gameStartOption.getParticipants());
+        this.results = separateByDelimiter(gameStartOption.getResults());
+    }
+
+    public static LadderIO of(GameStartOption gameStartOption) {
+        return new LadderIO(gameStartOption);
+    }
+
+    public List<String> getUsers() {
+        return users;
+    }
+
+    public List<String> getResults() {
+        return results;
+    }
+
+    public String findResult(Ladder ladder, String userName) {
+        int row = 0;
+        Pillar pillar = ladder.getPillarByNum(users.indexOf(userName));
+        while (row < ladder.getHeight()) {
+            pillar = ladder.getNextPillar(pillar, row);
+            row++;
+        }
+        return results.get(pillar.getPillarNum());
+    }
+
+    public int getUserCharMaxNum() {
+        List<Integer> lengths = users.stream()
+                .map(u -> u.length())
+                .collect(Collectors.toList());
+        return Collections.max(lengths);
+    }
+
+}

src/main/java/domain/user/ParticipantUsers.java

@@ -9,15 +9,17 @@ public class GameStartOption {
 
     private int ladderHeight;
     private String participants;
+    private String results;
 
-    public GameStartOption(String participants, int ladderHeight) {
+    public GameStartOption(String participants, int ladderHeight, String results) {
         this.ladderHeight = ladderHeight;
         this.participants = participants;
+        this.results = results;
         validate();
     }
 
-    public static GameStartOption of(String participants, int ladderHeight){
-        return new GameStartOption(participants, ladderHeight);
+    public static GameStartOption of(String participants, int ladderHeight, String results){
+        return new GameStartOption(participants, ladderHeight, results);
     }
 
     private int getLadderWidth(String participants) {
@@ -37,10 +39,16 @@ public int getLadderHeight() {
         return ladderHeight;
     }
 
+    public String getResults() {
+        return results;
+    }
+
     private void validate(){
         if(ladderHeight < MINIMUM_LADDER_HEIGHT)
             throw new IllegalArgumentException("올바른 사다리 높이를 입력해주세요.");
         if(getLadderWidth() < MINIMUM_PARTICIPANTS_COUNT )
             throw new IllegalArgumentException(("참가자 수를 2명이상 입력해주세요."));
+        if(participants.split(DELIMITER).length != results.split(DELIMITER).length)
+            throw new IllegalArgumentException(("결과와 참가자 수를 동일하게 입력해주세요."));
     }
 }

src/main/java/domain/user/User.java

@@ -30,9 +30,9 @@ public static List<Integer> createRandomIntegersWithRestriction(Integer ladderHe
                 .collect(Collectors.toList());
     }
 
-    public static List<String> separateUserName(String participants) {
-        String[] users = participants.split(DELIMITER);
-        return Arrays.asList(users);
+    public static List<String> separateByDelimiter(String inputString) {
+        String[] splitString = inputString.split(DELIMITER);
+        return Arrays.asList(splitString);
     }
 
     public static Integer randInt(int bound) {

src/main/java/dto/GameStartOption.java

@@ -21,16 +21,27 @@ public String participants() {
         return sc.next();
     }
 
+    public String results(){
+        System.out.println("실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)");
+        return sc.next();
+
+    }
     public int ladderHeight() {
         System.out.println("최대 사다리 높이는 몇 개인가요?");
         return sc.nextInt();
     }
 
+    public String showResultUser() {
+        System.out.println("결과를 보고싶은 사람은?");
+        return sc.next();
+    }
+
     public GameStartOption initGameStartOption(){
         String participants = participants();
+        String results = results();
         int ladderHeight = ladderHeight();
 
-        return new GameStartOption(participants, ladderHeight);
+        return new GameStartOption(participants, ladderHeight, results);
     }
 
 }

src/main/java/util/RandomIntegerMaker.java

@@ -5,26 +5,25 @@
 import domain.converter.Row;
 import domain.ladder.Ladder;
 import domain.ladder.LinkedType;
-import domain.user.ParticipantUsers;
-import domain.user.User;
+import domain.ladderCalculator.LadderIO;
 
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.IntStream;
 
 import static view.OutputLine.*;
 
-public class OutputView {
-    private ParticipantUsers participantUsers;
+public class OutputLadder {
+    private LadderIO ladderIO;
     private Ladder ladder;
 
-    private OutputView(ParticipantUsers participantUsers, Ladder ladder) {
+    private OutputLadder(LadderIO ladderIO, Ladder ladder) {
         this.ladder = ladder;
-        this.participantUsers = participantUsers;
+        this.ladderIO = ladderIO;
     }
 
-    public static OutputView of(ParticipantUsers participantUsers, Ladder ladder) {
-        return new OutputView(participantUsers, ladder);
+    public static OutputLadder of(LadderIO ladderIO, Ladder ladder) {
+        return new OutputLadder(ladderIO, ladder);
     }
 
     public void drawOutput() {
@@ -35,6 +34,39 @@ public void drawOutput() {
         }
     }
 
+    public void drawUserNames() {
+        StringBuilder sb = new StringBuilder();
+        for (String user : ladderIO.getUsers()) {
+            sb.append(user);
+            sb.append(calculateBlank(user));
+            sb.append(BLANK);
+        }
+        System.out.println(sb);
+    }
+
+    public void drawResults() {
+        StringBuilder sb = new StringBuilder();
+        for (String result : ladderIO.getResults()) {
+            sb.append(result);
+            sb.append(calculateBlank(result));
+            sb.append(BLANK);
+        }
+        System.out.println(sb);
+    }
+
+    public void showLadderResult(String userName) {
+        String result = userName.equals("all") ? showAllResult() : ladderIO.findResult(ladder, userName);
+        System.out.println(result);
+    }
+
+    private String showAllResult() {
+        StringBuilder sb = new StringBuilder();
+        for (String user : ladderIO.getUsers()) {
+            sb.append(user + ":" + ladderIO.findResult(ladder, user)+"\n");
+        }
+        return sb.toString();
+    }
+
     private void drawRow(Row row) {
         List<Point> points = row.getPoints();
         Collections.sort(points);
@@ -45,30 +77,20 @@ private void drawRow(Row row) {
     }
 
     private String drawPoint(Point point) {
-        int repeat = participantUsers.getUserCharMaxNum();
+        int repeat = ladderIO.getUserCharMaxNum();
         return point.isBlankPoint() ? DOWN + widthBlank(repeat) : Link(point);
     }
 
-    public void drawUserNames() {
-        StringBuilder sb = new StringBuilder();
-        for (User user : participantUsers.getUsers()) {
-            sb.append(user.getName());
-            sb.append(nameBlank(user));
-            sb.append(BLANK);
-        }
-        System.out.println(sb);
-    }
-
-    private String nameBlank(User user) {
-        int width = participantUsers.getUserCharMaxNum() - user.getName().length();
+    private String calculateBlank(String result) {
+        int width = ladderIO.getUserCharMaxNum() - result.length();
         StringBuilder sb = new StringBuilder();
         IntStream.range(0, width)
                 .forEach(each -> sb.append(BLANK));
         return sb.toString();
     }
 
     private String Link(Point point) {
-        int repeat = participantUsers.getUserCharMaxNum();
+        int repeat = ladderIO.getUserCharMaxNum();
         if (point.getBridge().getLinkPillarDirection() == LinkedType.RIGHT)
             return RIGHT + widthLine(repeat);
         return LEFT + widthBlank(repeat);

src/main/java/view/InputView.java

@@ -10,7 +10,7 @@ public class OutputConverterTest {
 
     @Test
     public void Height에_따른_Level_생성() {
-        GameStartOption gameStartOption = new GameStartOption("pobi,honux,crong,jk", 10);
+        GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 10, "꽝,5000,꽝,3000");
         Ladder ladder = Ladder.of(gameStartOption);
 
         assertEquals(OutputConverter.of(ladder).getRows().size(), 10);