[Step2] 🚀 2단계 - 사다리(생성)

src/main/java/ladder/Main.java

@@ -0,0 +1,24 @@
+package ladder;
+
+import ladder.domain.Ladder;
+import ladder.domain.LadderGenerator;
+import ladder.domain.player.Players;
+import ladder.domain.player.PlayersGenerator;
+import ladder.view.InputView;
+import ladder.view.ResultView;
+
+public class Main {
+    public static void main(String[] args) {
+        Players players = PlayersGenerator.create(InputView.getPlayerNames());
+        int width = players.getPlayerNumber();
+        System.out.println();
+
+        int height = InputView.getLadderHeight();
+        System.out.println();
+
+        Ladder ladder = new LadderGenerator().generate(height, width);
+        ResultView.showResultMessage();
+        ResultView.showPlayers(players);
+        ResultView.showLadder(ladder);
+    }
+}

src/main/java/ladder/README.md

@@ -0,0 +1,14 @@
+# 🚀2단계 - 사다리(생성)
+
+## 기능 요구사항
+
+- 사다리 게임에 참여하는 사람에 이름을 최대5글자까지 부여할 수 있다. 사다리를 출력할 때 사람 이름도 같이 출력한다.
+- 사람 이름은 쉼표(,)를 기준으로 구분한다.
+- 사람 이름을 5자 기준으로 출력하기 때문에 사다리 폭도 넓어져야 한다.
+- 사다리 타기가 정상적으로 동작하려면 라인이 겹치지 않도록 해야 한다.
+- |-----|-----| 모양과 같이 가로 라인이 겹치는 경우 어느 방향으로 이동할지 결정할 수 없다.
+
+## 프로그래밍 요구사항
+
+- 자바 8의 스트림과 람다를 적용해 프로그래밍한다.
+- 규칙 6: 모든 엔티티를 작게 유지한다.

src/main/java/ladder/domain/AdjacentVerticalLines.java

@@ -0,0 +1,43 @@
+package ladder.domain;
+
+import ladder.exception.IllegalAdjacentVerticalLinesException;
+
+public class AdjacentVerticalLines {
+    private final VerticalLine leftVerticalLine;
+    private final VerticalLine rightVerticalLine;
+
+    public AdjacentVerticalLines(VerticalLine firstVerticalLine, VerticalLine secondVerticalLine) {
+        checkAdjacentVerticalLines(firstVerticalLine, secondVerticalLine);
+
+        this.leftVerticalLine = min(firstVerticalLine, secondVerticalLine);
+        this.rightVerticalLine = max(firstVerticalLine, secondVerticalLine);
+    }
+
+    public VerticalLine getLeftVerticalLine() {
+        return leftVerticalLine;
+    }
+
+    public VerticalLine getRightVerticalLine() {
+        return rightVerticalLine;
+    }
+
+    private void checkAdjacentVerticalLines(VerticalLine firstVerticalLine, VerticalLine secondVerticalLine) {
+        if (Math.abs(firstVerticalLine.getIndex() - secondVerticalLine.getIndex()) > 1) {
+            throw new IllegalAdjacentVerticalLinesException(
+                    String.format("입력된 인덱스 : %d, %d", firstVerticalLine.getIndex(), secondVerticalLine.getIndex())
+            );
+        }
+    }
+
+    private VerticalLine max(VerticalLine firstVerticalLine, VerticalLine secondVerticalLine) {
+        return firstVerticalLine.getIndex() > secondVerticalLine.getIndex()
+                ? firstVerticalLine
+                : secondVerticalLine;
+    }
+
+    private VerticalLine min(VerticalLine firstVerticalLine, VerticalLine secondVerticalLine) {
+        return firstVerticalLine.getIndex() > secondVerticalLine.getIndex()
+                ? secondVerticalLine
+                : firstVerticalLine;
+    }
+}

src/main/java/ladder/domain/HorizontalLine.java

@@ -0,0 +1,44 @@
+package ladder.domain;
+
+import ladder.exception.IllegalHorizontalLineHeightException;
+
+public class HorizontalLine {
+    static final int MINIMUM_HEIGHT = 0;
+
+    private final AdjacentVerticalLines adjacentVerticalLines;
+    private final int height;
+
+    public HorizontalLine(AdjacentVerticalLines adjacentVerticalLines, int height) {
+        checkHeight(height);
+
+        this.adjacentVerticalLines = adjacentVerticalLines;
+        this.height = height;
+    }
+
+    private void checkHeight(int height) {
+        if (height < MINIMUM_HEIGHT) {
+            throw new IllegalHorizontalLineHeightException(String.format("최소 높이 : %d", MINIMUM_HEIGHT));
+        }
+    }
+
+    public AdjacentVerticalLines getAdjacentVerticalLines() {
+        return adjacentVerticalLines;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public VerticalLine getLeftVerticalLine() {
+        return adjacentVerticalLines.getLeftVerticalLine();
+    }
+
+    public VerticalLine getRightVerticalLine() {
+        return adjacentVerticalLines.getRightVerticalLine();
+    }
+
+    public boolean isConnected(VerticalLine verticalLine) {
+        return verticalLine == adjacentVerticalLines.getLeftVerticalLine()
+                || verticalLine == adjacentVerticalLines.getRightVerticalLine();
+    }
+}

src/main/java/ladder/domain/HorizontalLines.java

@@ -0,0 +1,44 @@
+package ladder.domain;
+
+import ladder.exception.IllegalHorizontalLineHeightException;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class HorizontalLines {
+    private final Set<HorizontalLine> horizontalLineSet;
+    private final int maxHeight;
+
+    public HorizontalLines(Set<HorizontalLine> horizontalLineSet, int maxHeight) {
+        checkValidHorizontalLineHeight(horizontalLineSet, maxHeight);
+
+        this.horizontalLineSet = horizontalLineSet;
+        this.maxHeight = maxHeight;
+    }
+
+    private void checkValidHorizontalLineHeight(Set<HorizontalLine> horizontalLineSet, int maxHeight) {
+        if (horizontalLineSet.stream()
+                .anyMatch(it -> it.getHeight() >= maxHeight)
+        ) {
+            throw new IllegalHorizontalLineHeightException(String.format("최대 높이 : %d", maxHeight));
+        }
+    }
+
+    public Set<HorizontalLine> getHorizontalLineSet() {
+        return Set.copyOf(horizontalLineSet);
+    }
+
+    public Set<HorizontalLine> getHorizontalLineSetByHeight(int height) {
+        return horizontalLineSet.stream()
+                .filter(it -> it.getHeight() == height)
+                .collect(Collectors.toSet());
+    }
+
+    public int getMaxHeight() {
+        return maxHeight;
+    }
+
+    public int getSize() {
+        return horizontalLineSet.size();
+    }
+}

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

@@ -0,0 +1,66 @@
+package ladder.domain;
+
+import ladder.exception.ContinuousHorizontalLineException;
+import ladder.exception.NotEnoughVerticalLinesException;
+
+import java.util.Set;
+
+public class Ladder {
+    static final int MINIMUM_VERTICAL_LINES_QUANTITY = 2;
+
+    private final VerticalLines verticalLines;
+    private final HorizontalLines horizontalLines;
+
+    public Ladder(VerticalLines verticalLines, HorizontalLines horizontalLines) {
+        checkVerticalLines(verticalLines);
+        checkValidLines(verticalLines, horizontalLines);
+
+        this.verticalLines = verticalLines;
+        this.horizontalLines = horizontalLines;
+    }
+
+    private void checkVerticalLines(VerticalLines verticalLines) {
+        if (verticalLines.getSize() < MINIMUM_VERTICAL_LINES_QUANTITY) {
+            throw new NotEnoughVerticalLinesException(String.format("세로선 갯수 : %d", verticalLines.getSize()));
+        }
+    }
+
+    private void checkValidLines(VerticalLines verticalLines, HorizontalLines horizontalLines) {
+        for (int i = 0; i < horizontalLines.getMaxHeight(); i++) {
+            Set<HorizontalLine> horizontalLineSet = horizontalLines.getHorizontalLineSetByHeight(i);
+            checkExistContinuousHorizontalLinesOnSameHeight(verticalLines, horizontalLineSet);
+        }
+    }
+
+    private void checkExistContinuousHorizontalLinesOnSameHeight(VerticalLines verticalLines, Set<HorizontalLine> horizontalLineSet) {
+        verticalLines.getVerticalLineSet()
+                .forEach(verticalLine ->
+                        checkConnectingWithManyHorizontalLines(verticalLine, horizontalLineSet)
+                );
+    }
+
+    private void checkConnectingWithManyHorizontalLines(VerticalLine verticalLine, Set<HorizontalLine> horizontalLineSet) {
+        if (horizontalLineSet.stream()
+                .filter(it -> it.isConnected(verticalLine))
+                .count() > 1
+        ) {
+            throw new ContinuousHorizontalLineException(String.format("중복되는 세로선 위치 : %d", verticalLine.getIndex()));
+        }
+    }
+
+    public int getHeight() {
+        return horizontalLines.getMaxHeight();
+    }
+
+    public int getWidth() {
+        return verticalLines.getMaxWidth();
+    }
+
+    public VerticalLines getVerticalLines() {
+        return verticalLines;
+    }
+
+    public HorizontalLines getHorizontalLines() {
+        return horizontalLines;
+    }
+}

src/main/java/ladder/domain/LadderGenerateStrategy.java

@@ -0,0 +1,5 @@
+package ladder.domain;
+
+public interface LadderGenerateStrategy {
+    boolean canGenerate();
+}

src/main/java/ladder/domain/LadderGenerator.java

@@ -0,0 +1,71 @@
+package ladder.domain;
+
+import ladder.exception.IllegalLadderParameterException;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class LadderGenerator {
+    private static final double DEFAULT_CHANCE = 0.5;
+
+    private final LadderGenerateStrategy ladderGenerateStrategy;
+
+    public LadderGenerator() {
+        this.ladderGenerateStrategy = () -> Math.random() < DEFAULT_CHANCE;
+    }
+
+    public LadderGenerator(LadderGenerateStrategy ladderGenerateStrategy) {
+        this.ladderGenerateStrategy = ladderGenerateStrategy;
+    }
+
+    public Ladder generate(int height, int width) {
+        checkHeightAndWidth(height, width);
+
+        VerticalLines verticalLines = VerticalLines.create(width);
+        HorizontalLines horizontalLines = createHorizontalLines(verticalLines, height);
+
+        return new Ladder(verticalLines, horizontalLines);
+    }
+
+    private HorizontalLines createHorizontalLines(VerticalLines verticalLines, int height) {
+        HashSet<HorizontalLine> horizontalLineHashSet = new HashSet<>();
+
+        for (int i = 0; i < height; i++) {
+            Set<HorizontalLine> sameHeightHorizontalLineSet = createSameHeightHorizontalLineSet(verticalLines, i);
+            horizontalLineHashSet.addAll(sameHeightHorizontalLineSet);
+        }
+
+        return new HorizontalLines(horizontalLineHashSet, height);
+    }
+
+    private Set<HorizontalLine> createSameHeightHorizontalLineSet(VerticalLines verticalLines, int height) {
+        HashSet<HorizontalLine> sameHeightHorizontalLineHashSet = new HashSet<>();
+
+        for (int i = 0; i < verticalLines.getMaxWidth() - 1; i++) {
+            VerticalLine nowVerticalLine = verticalLines.getVerticalLineByIndex(i);
+            VerticalLine nextVerticalLine = verticalLines.getVerticalLineByIndex(i + 1);
+
+            boolean notExistPreviousHorizontalLine = sameHeightHorizontalLineHashSet.stream()
+                    .noneMatch(horizontalLine ->
+                            horizontalLine.getRightVerticalLine() == nowVerticalLine
+                    );
+
+            if (notExistPreviousHorizontalLine && ladderGenerateStrategy.canGenerate()) {
+                sameHeightHorizontalLineHashSet.add(
+                        new HorizontalLine(
+                                new AdjacentVerticalLines(nowVerticalLine, nextVerticalLine),
+                                height
+                        )
+                );
+            }
+        }
+        return sameHeightHorizontalLineHashSet;
+    }
+
+    private void checkHeightAndWidth(int height, int width) {
+        if (height < HorizontalLine.MINIMUM_HEIGHT
+                || width < Ladder.MINIMUM_VERTICAL_LINES_QUANTITY) {
+            throw new IllegalLadderParameterException(String.format("입력된 높이 : %d, 입력된 너비 : %d", height, width));
+        }
+    }
+}

src/main/java/ladder/domain/VerticalLine.java

@@ -0,0 +1,13 @@
+package ladder.domain;
+
+public class VerticalLine {
+    private final int index;
+
+    public VerticalLine(int index) {
+        this.index = index;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+}

src/main/java/ladder/domain/VerticalLines.java

@@ -0,0 +1,53 @@
+package ladder.domain;
+
+import ladder.exception.IllegalVerticalLineWidthException;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class VerticalLines {
+    private final Set<VerticalLine> verticalLineSet;
+    private final int maxWidth;
+
+    public VerticalLines(Set<VerticalLine> verticalLineSet, int maxWidth) {
+        checkValidVerticalLineWidth(verticalLineSet, maxWidth);
+
+        this.verticalLineSet = verticalLineSet;
+        this.maxWidth = maxWidth;
+    }
+
+    private void checkValidVerticalLineWidth(Set<VerticalLine> verticalLineSet, int maxWidth) {
+        if (verticalLineSet.stream()
+                .anyMatch(it -> it.getIndex() >= maxWidth)
+        ) {
+            throw new IllegalVerticalLineWidthException(String.format("최대 너비 : %d", maxWidth));
+        }
+    }
+
+    public Set<VerticalLine> getVerticalLineSet() {
+        return Set.copyOf(verticalLineSet);
+    }
+
+    public int getMaxWidth() {
+        return maxWidth;
+    }
+
+    public VerticalLine getVerticalLineByIndex(int index) {
+        return verticalLineSet.stream()
+                .filter(it -> it.getIndex() == index)
+                .findFirst()
+                .orElse(null);
+    }
+
+    public int getSize() {
+        return verticalLineSet.size();
+    }
+
+    public static VerticalLines create(int count) {
+        HashSet<VerticalLine> verticalLineHashSet = new HashSet<>();
+        for (int i = 0; i < count; i++) {
+            verticalLineHashSet.add(new VerticalLine(i));
+        }
+        return new VerticalLines(verticalLineHashSet, count);
+    }
+}