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

README.md

@@ -1,13 +1,13 @@
 # 사디리
 ## 기능 요구사항
-* 사다리 게임에 참여하는 사람에 이름을 부여할 수 있다.
- * 이름은 최대 5글자로 제한된다.
- * 사람의 이름은 띄어쓰기가 존재하지 않는 쉼표로 구분한다.
-* 사다리의 모양은 |-----|으로 출력된다.
- * 사다리를 출력할 때 사람 이름도 같이 출력한다.
- * 참여하는 사람의 숫자에 따라 사다리의 폭과 사다리의 개수가 달라진다.
- * |-----|-----| 같이 연속적인 사다리는 가능하지 않다.
- * 하나의 라인에는 최소 하나 이상이 사다리가 존재하며 사다리의 개수는 랜덤하다.
+[] 사다리 게임에 참여하는 사람에 이름을 부여할 수 있다.
+ [] 이름은 최대 5글자로 제한된다.
+ [] 사람의 이름은 띄어쓰기가 존재하지 않는 쉼표로 구분한다.
+[] 사다리의 모양은 |-----|으로 출력된다.
+ [] 사다리를 출력할 때 사람 이름도 같이 출력한다.
+ [] 참여하는 사람의 숫자에 따라 사다리의 폭과 사다리의 개수가 달라진다.
+ [] |-----|-----| 같이 연속적인 사다리는 가능하지 않다.
+ [] 하나의 라인에는 최소 하나 이상이 사다리가 존재하며 사다리의 개수는 랜덤하다.
 
 ## 프로그래밍 요구사항
 * 최대한 자바 8의 스트림과 람다를 이용한다.

src/main/java/nextstep/ladder/application/LadderController.java

@@ -11,19 +11,24 @@ public class LadderController {
 
     public static void main(String[] args) {
         InputView inputView = new InputView();
-        String[] participants = splitParticipants(inputView);
+        String[] participants = inputView.inputParticipant();
+        String[] results = inputView.inputResults();
         int highCount = inputView.inputHighCount();
 
         LadderService ladderService = new LadderService();
-        LadderResponse response = ladderService.createLadder(new LadderRequest(participants, highCount));
+        LadderResponse createResponse = ladderService.findWinner(new LadderRequest(
+                participants,
+                results,
+                highCount));
 
         LinePrinter printer = new LinePrinter(highCount);
-        ResultView resultView = new ResultView(printer, participants, response.getLines());
-        resultView.showResult();
-    }
-
-    private static String[] splitParticipants(InputView inputView) {
-        return inputView.inputParticipant()
-                .split(",");
+        ResultView resultView = new ResultView(
+                printer,
+                createResponse.getLines(),
+                createResponse.getParticipants(),
+                results);
+        resultView.showLadder();
+        resultView.showParticipant(inputView.inputWantShow());
+        resultView.showParticipant(inputView.inputWantShow());
     }
 }

src/main/java/nextstep/ladder/application/dto/LadderRequest.java

@@ -3,17 +3,23 @@
 
 public class LadderRequest {
     private String[] participants;
+    private String[] results;
     private int highCount;
 
-    public LadderRequest(String[] participants, int highCount) {
+    public LadderRequest(String[] participants, String[] results, int highCount) {
         this.participants = participants;
+        this.results = results;
         this.highCount = highCount;
     }
 
     public String[] getParticipants() {
         return participants;
     }
 
+    public String[] getResults() {
+        return results;
+    }
+
     public int getHighCount() {
         return highCount;
     }

src/main/java/nextstep/ladder/application/dto/LadderResponse.java

@@ -1,16 +1,23 @@
 package nextstep.ladder.application.dto;
 
 import nextstep.ladder.domain.line.Lines;
+import nextstep.ladder.domain.participant.Participants;
 
 
 public class LadderResponse {
-    private final Lines lines;
+    private Lines lines;
+    private Participants participants;
 
-    public LadderResponse(Lines lines) {
+    public LadderResponse(Lines lines, Participants participants) {
         this.lines = lines;
+        this.participants = participants;
     }
 
-    public Lines getLines() {
+    public final Lines getLines() {
         return lines;
     }
+
+    public final Participants getParticipants() {
+        return participants;
+    }
 }

src/main/java/nextstep/ladder/application/service/LadderService.java

@@ -4,16 +4,25 @@
 import nextstep.ladder.application.dto.LadderResponse;
 import nextstep.ladder.domain.line.Line;
 import nextstep.ladder.domain.line.Lines;
+import nextstep.ladder.domain.participant.Participants;
 
 import java.util.stream.IntStream;
 
 public class LadderService {
 
-    public LadderResponse createLadder(LadderRequest request) {
-        Lines lines = new Lines(request.getHighCount());
-        IntStream.range(0, request.getHighCount())
-                .forEach(index -> lines.addLine(new Line(request.getParticipants())));
+    public LadderResponse findWinner(LadderRequest request) {
+        Lines lines = createLines(request);
+        Participants participants = Participants.of(request.getParticipants());
+        lines.moveParticipants(participants);
+        participants.insertMyResult(request.getResults());
+        return new LadderResponse(lines, participants);
+    }
 
-        return new LadderResponse(lines);
+    private Lines createLines(LadderRequest request) {
+        Lines lines = new Lines();
+        int rowLineNumber = request.getParticipants().length - 1;
+        IntStream.range(0, request.getHighCount())
+                .forEach(index -> lines.addLine(new Line(rowLineNumber)));
+        return lines;
     }
 }

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

@@ -1,15 +1,60 @@
 package nextstep.ladder.domain.line;
 
+import nextstep.ladder.domain.participant.Participant;
+import nextstep.ladder.domain.participant.Participants;
+
 public class Line {
+    private final int rowLineNumber;
     private RowLinePositions rowLinePosition;
 
     public Line(String[] participants) {
         int participantNumber = participants.length;
-        int rowLineNumber = participantNumber - 1;
-        rowLinePosition = new RowLinePositions(rowLineNumber);
+        rowLineNumber = participantNumber - 1;
+        rowLinePosition = RowLinePositions.create(rowLineNumber);
+    }
+
+    public Line(int rowLineNumber) {
+        this.rowLineNumber = rowLineNumber;
+        rowLinePosition = RowLinePositions.create(rowLineNumber);
+    }
+
+    public Line(int rowLineNumber, RowLinePositions rowLinePositions) {
+        this.rowLineNumber = rowLineNumber;
+        this.rowLinePosition = rowLinePositions;
     }
 
     public boolean isTruePosition(int index) {
         return rowLinePosition.isTrue(index);
     }
+
+    public void movableParticipants(Participants participants) {
+        participants.getParticipantList()
+                .stream()
+                .forEachOrdered(participant -> movableParticipant(participant));
+    }
+
+    public void movableParticipant(Participant participant) {
+        if (movableLeft(participant)) {
+            return;
+        }
+        movableRight(participant);
+    }
+
+    private boolean movableLeft(Participant participant) {
+        int index = participant.getCurrentIndex();
+        if (index != 0 && isTruePosition(index -1)) {
+            participant.moveLeft();
+            return true;
+        }
+        return false;
+    }
+
+    private boolean movableRight(Participant participant) {
+        int index = participant.getCurrentIndex();
+        if (index != rowLineNumber && isTruePosition(index)) {
+            participant.moveRight();
+            return true;
+        }
+        return false;
+    }
 }

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

@@ -1,24 +1,25 @@
 package nextstep.ladder.domain.line;
 
+import nextstep.ladder.domain.participant.Participants;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.stream.IntStream;
 
 public class Lines {
     private List<Line> lineList = new ArrayList<>();
-    private int highCount;
 
     public Lines() {}
 
-    public Lines(int highCount) {
-        this.highCount = highCount;
-    }
-
     public void addLine(Line line) {
         lineList.add(line);
     }
 
+    public void moveParticipants(Participants participants) {
+        lineList.stream()
+                .forEachOrdered(line -> line.movableParticipants(participants));
+    }
+
     public final List<Line> getLineList() {
         return Collections.unmodifiableList(lineList);
     }

src/main/java/nextstep/ladder/domain/line/RowLinePositions.java

@@ -7,35 +7,41 @@
 import java.util.stream.IntStream;
 
 public class RowLinePositions {
-    private List<Boolean> positionList = new ArrayList<>();
-    private int rowLineCount;
-    private Random random = new Random();
+    private List<Boolean> positionList;
+    private int rowLineNumber;
+    private static final Random random = new Random();
 
-    public RowLinePositions(int rowLineCount) {
-        this.rowLineCount = rowLineCount;
-        initializePositionList();
+    public RowLinePositions(List<Boolean> positionList, int rowLineNumber) {
+        this.positionList = positionList;
+        this.rowLineNumber = rowLineNumber;
     }
 
-    private void initializePositionList() {
+    public static RowLinePositions create(int rowLineNumber) {
+        List<Boolean> positionList = new ArrayList<>();
+        initializePositionList(positionList, rowLineNumber);
+        return new RowLinePositions(positionList, rowLineNumber);
+    }
+
+    private static void initializePositionList(List<Boolean> positionList, int rowLineNumber) {
         positionList.add(random.nextBoolean());
-        IntStream.range(1, rowLineCount)
-                .forEach(index -> addRandomBoolean(index));
-        addTrueIfAllFalse();
+        IntStream.range(1, rowLineNumber)
+                .forEach(index -> addRandomBoolean(positionList, index));
+        addTrueIfAllFalse(positionList, rowLineNumber);
     }
 
-    private void addRandomBoolean(int index) {
+    private static void addRandomBoolean(List<Boolean> positionList, int index) {
         if (positionList.get(index - 1)) {
             positionList.add(false);
             return;
         }
         positionList.add(random.nextBoolean());
     }
 
-    private void addTrueIfAllFalse() {
+    private static void addTrueIfAllFalse(List<Boolean> positionList, int rowLineNumber) {
         boolean isAllFalse = positionList.stream()
                 .allMatch(e -> e.equals(Boolean.FALSE));
         if (isAllFalse) {
-            positionList.set(random.nextInt(rowLineCount), Boolean.TRUE);
+            positionList.set(random.nextInt(rowLineNumber), Boolean.TRUE);
         }
     }
 

src/main/java/nextstep/ladder/domain/participant/Participant.java

@@ -0,0 +1,42 @@
+package nextstep.ladder.domain.participant;
+
+
+public class Participant {
+    private String name;
+    private int currentIndex;
+    private String result;
+
+    public Participant(String name, int currentIndex) {
+        this.name = name;
+        this.currentIndex = currentIndex;
+    }
+
+    public void moveLeft() {
+        currentIndex -= 1;
+    }
+
+    public void moveRight() {
+        currentIndex += 1;
+    }
+
+    public void insertResult(String[] results) {
+        result = results[currentIndex];
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public final int getCurrentIndex() {
+        return currentIndex;
+    }
+
+    public String getResult() {
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "{name:" + name + "}" + "{currentPosition:" + currentIndex + "}" + "|";
+    }
+}

src/main/java/nextstep/ladder/domain/participant/Participants.java

@@ -0,0 +1,41 @@
+package nextstep.ladder.domain.participant;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class Participants {
+    private final List<Participant> participantList;
+
+    public Participants(List<Participant> participantList) {
+        this.participantList = participantList;
+    }
+
+    public static Participants of(String[] participants) {
+        List<Participant> participantList = new ArrayList<>();
+        Arrays.stream(participants)
+                .forEach(participant -> participantList.add(new Participant(participant, participantList.size())));
+        return new Participants(participantList);
+    }
+
+    public void insertMyResult(String[] results) {
+        participantList.stream()
+                .forEach(participant -> participant.insertResult(results));
+    }
+
+    public Participant findByName(String name) {
+        return participantList.stream()
+                .filter(participant -> participant.getName().equals(name))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("Can not find name"));
+    }
+
+    public int getParticipantsNumber() {
+        return participantList.size();
+    }
+
+    public final List<Participant> getParticipantList() {
+        return Collections.unmodifiableList(participantList);
+    }
+}