[이예진] 사다리 게임 구현 (1-5단계)

README.md

@@ -0,0 +1,37 @@
+# java-ladder : 사다리 - 함수형 프로그래밍
+
+## Level1. 사다리 출력
+
+### - 요구사항
+
+- [x] 네이버 사다리 게임을 참고하여 도메인을 분석하여 구현한다.
+- [x] 사다리는 4x4 크기로 고정되고, 연결 여부는 랜덤으로 결정한다.
+- [x] 사다리 타기가 정상적으로 동작하려면 라인이 겹치지 않도록 해야 한다.
+- [x] 모든 엔티티를 작게 유지한다.
+- [x] 3개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않는다.
+
+## Level2. 사다리 생성
+
+### - 요구사항
+
+- [x] 사다리는 크기를 입력 받아 생성할 수 있다. (넓이 & 높이)
+
+## Level3. 사다리 타기
+
+### - 요구사항
+
+- [x] 사다리의 시작 지점과 도착 지점을 출력한다.
+
+## Level4. 게임 실행
+
+### - 요구사항
+
+- [x] 사다리 게임에 참여하는 사람에 이름을 최대 5글자까지 부여할 수 있다. 사다리를 출력할 때 사람 이름도 같이 출력한다.
+- [x] 사람 이름은 쉼표(,)를 기준으로 구분한다.
+- [x] 개인별 이름을 입력하면 개인별 결과를 출력하고, "all"을 입력하면 전체 참여자의 실행 결과를 출력한다.
+
+## Level5. 리팩토링
+
+### - 요구사항
+
+- [x] 학습 테스트를 통해 학습한 내용을 반영한다. 자바에서 제공하는 함수형 문법을 적용해보고, 어떠한 차이가 있는지 경험한다.

src/main/java/ladder/controller/Application.java

@@ -0,0 +1,13 @@
+package ladder.controller;
+
+import ladder.view.InputView;
+import ladder.view.OutputView;
+
+public class Application {
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        LadderGame game = new LadderGame(inputView, outputView);
+        game.play();
+    }
+}

src/main/java/ladder/controller/LadderGame.java

@@ -0,0 +1,67 @@
+package ladder.controller;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import ladder.model.GameSetup;
+import ladder.model.Ladder;
+import ladder.model.Participants;
+import ladder.model.ResultType;
+import ladder.model.Results;
+import ladder.view.InputView;
+import ladder.view.OutputView;
+
+public class LadderGame {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public LadderGame(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void play() {
+        GameSetup setup = createGameSetup();
+        displayLadder(setup);
+        processResult(setup);
+    }
+
+    private GameSetup createGameSetup() {
+        Participants participants = inputView.inputParticipants();
+        List<String> results = inputView.inputResults();
+        int height = inputView.inputHeight();
+        Ladder ladder = Ladder.create(participants.size(), height);
+        return new GameSetup(participants, results, ladder);
+    }
+
+    private void displayLadder(GameSetup setup) {
+        outputView.printLadder(setup.getLadder(), setup.getParticipants(), setup.getResults());
+    }
+
+    private void processResult(GameSetup setup) {
+        String result = inputView.inputGameResult();
+        Results gameResults = createGameResults(setup);
+        printGameResults(result, gameResults);
+    }
+
+    private Results createGameResults(GameSetup setup) {
+        List<Integer> ladderResults = setup.getLadder().result();
+        return new Results(setup.getParticipants(),
+            mapResults(setup.getResults(), ladderResults));
+    }
+
+    private void printGameResults(String result, Results gameResults) {
+        if (ResultType.ALL.equals(ResultType.from(result))) {
+            outputView.printAllResults(gameResults);
+            return;
+        }
+        outputView.printSingleResult(gameResults.getResult(result));
+    }
+
+    private List<String> mapResults(List<String> inputResults, List<Integer> ladderResults) {
+        return IntStream.range(0, inputResults.size())
+            .mapToObj(i -> inputResults.get(ladderResults.get(i)))
+            .collect(Collectors.toList());
+    }
+}

src/main/java/ladder/model/GameSetup.java

@@ -0,0 +1,29 @@
+package ladder.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GameSetup {
+
+    private final Participants participants;
+    private final List<String> results;
+    private final Ladder ladder;
+
+    public GameSetup(Participants participants, List<String> results, Ladder ladder) {
+        this.participants = participants;
+        this.results = new ArrayList<>(results);
+        this.ladder = ladder;
+    }
+
+    public Participants getParticipants() {
+        return participants;
+    }
+
+    public List<String> getResults() {
+        return new ArrayList<>(results);
+    }
+
+    public Ladder getLadder() {
+        return ladder;
+    }
+}

src/main/java/ladder/model/Ladder.java

@@ -0,0 +1,66 @@
+package ladder.model;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Ladder {
+
+    private final List<Line> lines;
+
+    private Ladder(List<Line> lines) {
+        this.lines = lines;
+    }
+
+    public static Ladder create(int width, int height) {
+        return new Ladder(
+            IntStream.range(0, height)
+                .mapToObj(i -> Line.create(width))
+                .collect(Collectors.toList())
+        );
+    }
+
+    public void draw() {
+        for (Line line : lines) {
+            line.draw();
+        }
+    }
+
+    public List<Integer> result() {
+        int width = lines.get(0).getPoints().size() + 1;
+        return IntStream.range(0, width)
+            .map(this::getEndPoint)
+            .boxed()
+            .collect(Collectors.toList());
+    }
+
+    private int getEndPoint(int start) {
+        int position = start;
+
+        for (Line line : lines) {
+            position = move(position, line.getPoints());
+        }
+
+        return position;
+    }
+
+    private int move(int position, List<Boolean> points) {
+        if (canMoveLeft(position, points)) {
+            return position - 1;
+        }
+
+        if (canMoveRight(position, points)) {
+            return position + 1;
+        }
+
+        return position;
+    }
+
+    private boolean canMoveLeft(int position, List<Boolean> points) {
+        return position > 0 && points.get(position - 1);
+    }
+
+    private boolean canMoveRight(int position, List<Boolean> points) {
+        return position < points.size() && points.get(position);
+    }
+}

src/main/java/ladder/model/Line.java

@@ -0,0 +1,50 @@
+package ladder.model;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Line {
+
+    private final List<Boolean> points;
+
+    private Line(List<Boolean> points) {
+        this.points = points;
+    }
+
+    public List<Boolean> getPoints() {
+        return new ArrayList<>(points);
+    }
+
+    public static Line create(int width) {
+        Random random = new Random();
+        List<Boolean> points = new ArrayList<>();
+        return new Line(IntStream.range(0, width - 1)
+            .mapToObj(i -> shouldConnect(points, i, random))
+            .collect(Collectors.toList()));
+    }
+
+    private static boolean shouldConnect(List<Boolean> points, int index, Random random) {
+        boolean connection = (index <= 0 || !points.get(index - 1)) && random.nextBoolean();
+        points.add(connection);
+        return connection;
+    }
+
+    public void draw() {
+        for (Boolean point : points) {
+            System.out.print("|");
+            printLine(point);
+        }
+        System.out.println("|");
+    }
+
+    private void printLine(Boolean connected) {
+        if (connected) {
+            System.out.print("-----");
+            return;
+        }
+        System.out.print("     ");
+    }
+}

src/main/java/ladder/model/Name.java

@@ -0,0 +1,18 @@
+package ladder.model;
+
+public class Name {
+
+    private static final int MAX_LENGTH = 5;
+    private final String name;
+
+    public Name(String name) {
+        if (name.length() > MAX_LENGTH) {
+            throw new IllegalArgumentException("이름은 최대 5글자까지 가능합니다.");
+        }
+        this.name = name;
+    }
+
+    public boolean matches(String other) {
+        return name.equals(other);
+    }
+}

src/main/java/ladder/model/Participants.java

@@ -0,0 +1,32 @@
+package ladder.model;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Participants {
+
+    private final List<Name> names;
+
+    private Participants(List<Name> names) {
+        this.names = names;
+    }
+
+    public static Participants from(String input) {
+        return new Participants(
+            Arrays.stream(input.split(","))
+                  .map(String::trim)
+                  .map(Name::new)
+                  .collect(Collectors.toList())
+        );
+    }
+
+    public int size() {
+        return names.size();
+    }
+
+    public List<Name> values() {
+        return new ArrayList<>(names);
+    }
+}

src/main/java/ladder/model/ResultType.java

@@ -0,0 +1,16 @@
+package ladder.model;
+
+public enum ResultType {
+    ALL("all"),
+    SINGLE("");
+
+    private final String value;
+
+    ResultType(String value) {
+        this.value = value;
+    }
+
+    public static ResultType from(String input) {
+        return "all".equals(input) ? ALL : SINGLE;
+    }
+}

src/main/java/ladder/model/Results.java

@@ -0,0 +1,31 @@
+package ladder.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Results {
+
+    private final Participants participants;
+    private final List<String> results;
+
+    public Results(Participants participants, List<String> results) {
+        this.participants = participants;
+        this.results = results;
+    }
+
+    public List<String> getAll() {
+        return new ArrayList<>(results);
+    }
+
+    public List<Name> getParticipants() {
+        return participants.values();
+    }
+
+    public String getResult(String participant) {
+        return participants.values().stream()
+            .filter(name -> name.matches(participant))
+            .findFirst()
+            .map(name -> results.get(participants.values().indexOf(name)))
+            .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 참가자입니다."));
+    }
+}