[그리디] 김민욱 사다리 미션 1~5 단계 제출합니다

src/main/java/Application.java

@@ -0,0 +1,12 @@
+import controller.LadderController;
+import view.InputView;
+import view.OutputView;
+
+public class Application {
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        LadderController controller = new LadderController(inputView, outputView);
+        controller.run();
+    }
+}

src/main/java/controller/LadderController.java

@@ -0,0 +1,56 @@
+package controller;
+
+import domain.*;
+import view.InputView;
+import view.OutputView;
+
+public class LadderController {
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public LadderController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        Players players = inputView.readPlayers();
+        Rewards rewards = inputRewards(players);
+        LadderHeight height = new LadderHeight(inputView.readHeight());
+
+        Ladder ladder = Ladder.generate(new LadderWidth(players.size()), height, new RandomBooleanGenerator());
+        outputView.printLadderBoard(players, ladder, rewards);
+
+        GameResult gameResult = createGameResult(players, rewards, ladder);
+        printTargetResults(gameResult);
+    }
+
+    private Rewards inputRewards(Players players) {
+        Rewards rewards = inputView.readRewards();
+        players.validateMatch(rewards);
+        return rewards;
+    }
+
+    private GameResult createGameResult(Players players, Rewards rewards, Ladder ladder) {
+        LadderResult ladderResult = ladder.play(new LadderWidth(players.size()));
+        return GameResult.of(players, rewards, ladderResult);
+    }
+
+    private void printTargetResults(GameResult gameResult) {
+        while (true) {
+            String target = inputView.readTargetPerson();
+            if (processTarget(target, gameResult)) {
+                break;
+            }
+        }
+    }
+
+    private boolean processTarget(String target, GameResult gameResult) {
+        if ("all".equals(target)) {
+            outputView.printAllResults(gameResult);
+            return true;
+        }
+        outputView.printSingleResult(gameResult.findByName(target));
+        return false;
+    }
+}

src/main/java/domain/BooleanGenerator.java

@@ -0,0 +1,6 @@
+package domain;
+
+
+public interface BooleanGenerator {
+    boolean generate();
+}

src/main/java/domain/GameResult.java

@@ -0,0 +1,38 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class GameResult {
+    private final List<Player> players;
+
+    public GameResult(List<Player> players) {
+        this.players = players;
+    }
+
+    public static GameResult of(Players players, Rewards rewards, LadderResult ladderResult) {
+        List<Player> playerList = new ArrayList<>();
+        for (int i = 0; i < players.size(); i++) {
+            playerList.add(createPlayer(i, players, rewards, ladderResult));
+        }
+        return new GameResult(playerList);
+    }
+
+    private static Player createPlayer(int index, Players players, Rewards rewards, LadderResult result) {
+        Position start = new Position(index);
+        Position end = result.getEndPosition(start);
+        return new Player(players.getName(index), rewards.getReward(end.getValue()));
+    }
+
+    public Player findByName(String targetName) {
+        return players.stream()
+                .filter(player -> player.hasName(targetName))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 사람입니다."));
+    }
+
+    public List<Player> getAll() {
+        return Collections.unmodifiableList(players);
+    }
+}

src/main/java/domain/Ladder.java

@@ -0,0 +1,70 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.IntStream;
+
+public class Ladder {
+    private final List<Line> lines;
+
+    public Ladder(List<Line> lines) {
+        this.lines = lines;
+    }
+
+    public static Ladder generate(LadderWidth width, LadderHeight height, BooleanGenerator generator) {
+        Ladder ladder = createLadder(width, height, generator);
+        while (ladder.hasEmptyInterval(width)) {
+            ladder = createLadder(width, height, generator);
+        }
+        return ladder;
+    }
+
+    private static Ladder createLadder(LadderWidth width, LadderHeight height, BooleanGenerator generator) {
+        List<Line> lines = new ArrayList<>();
+        Line currentLine = Line.generateFirst(width, generator);
+        lines.add(currentLine);
+        return new Ladder(addRemainingLines(lines, width, height, generator, currentLine));
+    }
+
+    private static List<Line> addRemainingLines(List<Line> lines, LadderWidth width, LadderHeight height, BooleanGenerator generator, Line firstLine) {
+        Line currentLine = firstLine;
+        for (int i = 1; i < height.getValue(); i++) {
+            currentLine = Line.generateNext(width, generator, currentLine);
+            lines.add(currentLine);
+        }
+        return lines;
+    }
+
+    private boolean hasEmptyInterval(LadderWidth width) {
+        return IntStream.range(0, width.getIntervalCount())
+                .anyMatch(this::isEmptyInterval);
+    }
+
+    private boolean isEmptyInterval(int index) {
+        return lines.stream().noneMatch(line -> line.isConnectedAt(index));
+    }
+
+    public LadderResult play(LadderWidth width) {
+        Map<Position, Position> results = new LinkedHashMap<>();
+        for (int i = 0; i < width.getValue(); i++) {
+            Position startPosition = new Position(i);
+            results.put(startPosition, playOne(startPosition));
+        }
+        return new LadderResult(results);
+    }
+
+    private Position playOne(Position startPosition) {
+        Position current = startPosition;
+        for (Line line : lines) {
+            current = line.move(current);
+        }
+        return current;
+    }
+
+    public List<Line> getLines() {
+        return Collections.unmodifiableList(lines);
+    }
+}

src/main/java/domain/LadderHeight.java

@@ -0,0 +1,24 @@
+package domain;
+
+public class LadderHeight {
+    private static final int MINIMUM_HEIGHT = 1;
+    private static final String ERROR_MESSAGE = "사다리 높이는 1 이상이어야 합니다.";
+
+    private final int value;
+
+    public LadderHeight(int value) {
+        validate(value);
+        this.value = value;
+    }
+
+    private void validate(int value) {
+        if (value < MINIMUM_HEIGHT) {
+            throw new IllegalArgumentException(ERROR_MESSAGE);
+        }
+    }
+
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/domain/LadderResult.java

@@ -0,0 +1,15 @@
+package domain;
+import java.util.Map;
+
+
+public class LadderResult {
+    private final Map<Position, Position> results;
+
+    public LadderResult(Map<Position, Position> results) {
+        this.results = results;
+    }
+
+    public Position getEndPosition(Position start) {
+        return results.get(start);
+    }
+}

src/main/java/domain/LadderWidth.java

@@ -0,0 +1,28 @@
+package domain;
+
+public class LadderWidth {
+    private static final int MINIMUM_WIDTH = 2;
+    private static final String ERROR_MESSAGE = "사다리 폭은 2 이상이어야 합니다.";
+
+    private final int value;
+
+    public LadderWidth(int value) {
+        validate(value);
+        this.value = value;
+    }
+
+    private void validate(int value) {
+        if (value < MINIMUM_WIDTH) {
+            throw new IllegalArgumentException(ERROR_MESSAGE);
+        }
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public int getIntervalCount() {
+        return value - 1;
+    }
+
+}

src/main/java/domain/Line.java

@@ -0,0 +1,78 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Line {
+    private final List<Boolean> points;
+
+    public Line(List<Boolean> points) {
+        this.points = points;
+    }
+
+    public static Line generateFirst(LadderWidth width, BooleanGenerator generator) {
+        List<Boolean> points = new ArrayList<>();
+        boolean previous = false;
+        for (int i = 0; i < width.getIntervalCount(); i++) {
+            previous = addPoint(points, previous, false, generator);
+        }
+        return new Line(points);
+    }
+
+    public static Line generateNext(LadderWidth width, BooleanGenerator generator, Line previousLine) {
+        List<Boolean> points = new ArrayList<>();
+        boolean previous = false;
+        for (int i = 0; i < width.getIntervalCount(); i++) {
+            boolean above = previousLine.isConnectedAt(i);
+            previous = addPoint(points, previous, above, generator);
+        }
+        return new Line(points);
+    }
+
+    private static boolean addPoint(List<Boolean> points, boolean previous, boolean above, BooleanGenerator gen) {
+        boolean nextPoint = determineNext(previous, above, gen);
+        points.add(nextPoint);
+        return nextPoint;
+    }
+
+    private static boolean determineNext(boolean previous, boolean above, BooleanGenerator gen) {
+        if (previous || above) {
+            return false;
+        }
+        return gen.generate();
+    }
+
+    public boolean isConnectedAt(int index) {
+        return points.get(index);
+    }
+
+    public Position move(Position position) {
+        int currentIndex = position.getValue();
+        if (canMoveLeft(currentIndex)) {
+            return position.moveLeft();
+        }
+        if (canMoveRight(currentIndex)) {
+            return position.moveRight();
+        }
+        return position;
+    }
+
+    private boolean canMoveLeft(int currentIndex) {
+        if (currentIndex <= 0) {
+            return false;
+        }
+        return points.get(currentIndex - 1);
+    }
+
+    private boolean canMoveRight(int currentIndex) {
+        if (currentIndex >= points.size()) {
+            return false;
+        }
+        return points.get(currentIndex);
+    }
+
+    public List<Boolean> getPoints() {
+        return Collections.unmodifiableList(points);
+    }
+}

src/main/java/domain/Player.java

@@ -0,0 +1,24 @@
+package domain;
+
+
+public class Player {
+    private final PlayerName name;
+    private final Reward reward;
+
+    public Player(PlayerName name, Reward reward) {
+        this.name = name;
+        this.reward = reward;
+    }
+
+    public boolean hasName(String targetName) {
+        return this.name.getValue().equals(targetName);
+    }
+
+    public PlayerName getName() {
+        return name;
+    }
+
+    public Reward getReward() {
+        return reward;
+    }
+}

src/main/java/domain/PlayerName.java

@@ -0,0 +1,17 @@
+package domain;
+
+public class PlayerName {
+    private static final int MAX_LENGTH = 5;
+    private final String value;
+
+    public PlayerName(String value) {
+        if (value.length() > MAX_LENGTH) {
+            throw new IllegalArgumentException("이름은 5자를 초과할 수 없습니다.");
+        }
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}