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

README.md

@@ -1,9 +1,48 @@
 # 사다리 게임
+
 ## 진행 방법
+
 * 사다리 게임 게임 요구사항을 파악한다.
 * 요구사항에 대한 구현을 완료한 후 자신의 github 아이디에 해당하는 브랜치에 Pull Request(이하 PR)를 통해 코드 리뷰 요청을 한다.
 * 코드 리뷰 피드백에 대한 개선 작업을 하고 다시 PUSH한다.
 * 모든 피드백을 완료하면 다음 단계를 도전하고 앞의 과정을 반복한다.
 
 ## 온라인 코드 리뷰 과정
-* [텍스트와 이미지로 살펴보는 온라인 코드 리뷰 과정](https://github.com/nextstep-step/nextstep-docs/tree/master/codereview)
+
+* [텍스트와 이미지로 살펴보는 온라인 코드 리뷰 과정](https://github.com/nextstep-step/nextstep-docs/tree/master/codereview)
+
+---
+
+## Step 2. 사다리(생성)
+
+### 기능 요구사항
+
+- 사다리 게임에 참여하는 사람에 이름을 최대5글자까지 부여할 수 있다. 사다리를 출력할 때 사람 이름도 같이 출력한다.
+- 사람 이름은 쉼표(,)를 기준으로 구분한다.
+- 사람 이름을 5자 기준으로 출력하기 때문에 사다리 폭도 넓어져야 한다.
+- 사다리 타기가 정상적으로 동작하려면 라인이 겹치지 않도록 해야 한다.
+- |-----|-----| 모양과 같이 가로 라인이 겹치는 경우 어느 방향으로 이동할지 결정할 수 없다.
+
+### 프로그래밍 요구사항
+
+- 자바 8의 스트림과 람다를 적용해 프로그래밍한다.
+- 규칙 6: 모든 엔티티를 작게 유지한다.
+
+### 요구사항 분석
+
+- [X] 참가자는 이름을 갖는다.
+    - [X] 이름은 최대 5자이다.
+    - [X] 이름이 비어있거나 6자 이상이면 예외가 발생한다.
+- [ ] 사다리
+    - [X] 사다리의 가로 라인을 수를 설정할 수 있다. (높이)
+    - [X] 사다리의 세로 라인은 사람 수 만큼 생성된다. (너비)
+    - [X] 사다리의 각 가로 라인에는 사람 수 만큼 포인트(점)가 생성된다.
+        - [X] 좌, 우에 포인트가 존재하는 경우 이동할 수 있다.
+            - [X] 가장 왼쪽 포인트에서는 좌로 이동 불가하다.
+            - [X] 가장 오른쪽 포인트에서는 우로 이동 불가하다.
+        - [X] 연속으로 이동 가능한 포인트는 존재할 수 없다. -> 좌 우 모두 이동 가능한 포인트는 존재할 수 없다
+- [ ] 포인트
+    - [X] 좌, 우 모두 이동 가능한 포인트는 존재할 수 없다. 세 가지 경우만 존재한다.
+        - [X] 좌 이동 불가, 우 이동 불가
+        - [X] 좌 이동 가능, 우 이동 불가
+        - [X] 좌 이동 불가, 우 이동 가능 

build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'java'
 apply plugin: 'eclipse'
 
 version = '1.0.0'
-sourceCompatibility = 1.8
+sourceCompatibility = 11
 
 repositories {
     mavenCentral()

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Sat Apr 06 16:04:18 KST 2024
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.0-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/nextstep/ladder/LadderGameApplication.java

@@ -0,0 +1,18 @@
+package nextstep.ladder;
+
+import nextstep.ladder.domain.LadderGame;
+import nextstep.ladder.util.ConsoleUtil;
+
+import java.util.List;
+
+public class LadderGameApplication {
+
+    public static void main(String[] args) {
+        List<String> playerNames = ConsoleUtil.inputPlayerNames();
+        int height = ConsoleUtil.inputHeight();
+
+        LadderGame ladderGame = LadderGame.start(playerNames, height);
+
+        ConsoleUtil.printGameResults(ladderGame);
+    }
+}

src/main/java/nextstep/ladder/domain/LadderGame.java

@@ -0,0 +1,29 @@
+package nextstep.ladder.domain;
+
+import java.util.List;
+
+public class LadderGame {
+
+    private final Players players;
+    private final Lines lines;
+
+    private LadderGame(final Players players, final Lines lines) {
+        this.players = players;
+        this.lines = lines;
+    }
+
+    public static LadderGame start(List<String> playerNames, int height) {
+        Players players = Players.of(playerNames);
+        LinesGenerator linesGenerator = new RandomLinesGenerator(players.count(), height);
+
+        return new LadderGame(players, linesGenerator.generate());
+    }
+
+    public Players getPlayers() {
+        return players;
+    }
+
+    public Lines getLines() {
+        return lines;
+    }
+}

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

@@ -0,0 +1,96 @@
+package nextstep.ladder.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Line {
+    private static final int MIN_POINT_SIZE = 2;
+
+    private final List<Point> points;
+
+    private Line(List<Point> points) {
+        validate(points);
+        this.points = points;
+    }
+
+    private void validate(List<Point> points) {
+        validatePointsListSize(points);
+        validatePointMovements(points);
+    }
+
+    private void validatePointsListSize(List<Point> points) {
+        if (points == null || points.isEmpty()) {
+            throw new IllegalArgumentException("점이 없습니다.");
+        }
+
+        if (points.size() < MIN_POINT_SIZE) {
+            throw new IllegalArgumentException("점이 " + MIN_POINT_SIZE + "개 이상 있어야 합니다.");
+        }
+    }
+
+    private void validatePointMovements(List<Point> points) {
+        if (firstPoint(points).canMoveLeft() || lastPoint(points).canMoveRight()) {
+            throw new IllegalArgumentException("첫 점에서는 왼쪽으로 이동할 수 없고, 마지막 점에서는 오른쪽으로 이동할 수 없습니다.");
+        }
+
+        for (int i = 0; i < points.size() - 1; i++) {
+            assertConsecutivePointsAreMovable(points, i);
+        }
+    }
+
+    private void assertConsecutivePointsAreMovable(List<Point> points, int i) {
+        if (points.get(i).canMoveRight() && !points.get(i + 1).canMoveLeft()) {
+            throw new IllegalArgumentException("연속된 점에서는 서로 이동 가능해야 합니다.");
+        }
+    }
+
+    private Point firstPoint(List<Point> points) {
+        return points.get(0);
+    }
+
+    private Point lastPoint(List<Point> points) {
+        return points.get(points.size() - 1);
+    }
+
+    public int width() {
+        return points.size();
+    }
+
+    public Point getPoint(int index) {
+        return points.stream()
+                .filter(point -> point.sameIndex(index))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("포인트가 없습니다. index: " + index));
+    }
+
+    static class LineBuilder {
+        private final List<Point> points;
+
+        public LineBuilder() {
+            this.points = new ArrayList<>();
+        }
+
+        public LineBuilder point(boolean canMoveRight) {
+            if (points.isEmpty()) {
+                points.add(Point.createLeftmost(canMoveRight));
+                return this;
+            }
+            points.add(lastPoint().createNext(canMoveRight));
+            return this;
+        }
+
+        public Line build() {
+            if (points.isEmpty()) {
+                throw new IllegalStateException("점이 없습니다.");
+            }
+
+            points.add(lastPoint().createRightmost());
+
+            return new Line(points);
+        }
+
+        private Point lastPoint() {
+            return points.get(points.size() - 1);
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+package nextstep.ladder.domain;
+
+import java.util.List;
+
+public class Lines {
+    private final List<Line> lines;
+
+    public Lines(List<Line> lines) {
+        validate(lines);
+        this.lines = lines;
+    }
+
+    private void validate(List<Line> lines) {
+        if (lines == null || lines.isEmpty()) {
+            throw new IllegalArgumentException("사다리 높이는 1 이상이어야 합니다.");
+        }
+    }
+
+    public int getHeight() {
+        return lines.size();
+    }
+
+    public Line getLine(int targetHeight) {
+        return lines.get(targetHeight);
+    }
+}

src/main/java/nextstep/ladder/domain/LinesGenerator.java

@@ -0,0 +1,5 @@
+package nextstep.ladder.domain;
+
+public interface LinesGenerator {
+    Lines generate();
+}

src/main/java/nextstep/ladder/domain/Player.java

@@ -0,0 +1,40 @@
+package nextstep.ladder.domain;
+
+public class Player {
+    private static final int MAX_NAME_LENGTH = 5;
+    private static final int MIN_INDEX = 0;
+
+    private final int index;
+    private final String name;
+
+    public Player(int index, String name) {
+        validate(index);
+        validate(name);
+        this.index = index;
+        this.name = name;
+    }
+
+    private static void validate(int index) {
+        if (index < MIN_INDEX) {
+            throw new IllegalArgumentException("인덱스는 " + MIN_INDEX + "보다 작을 수 없습니다.");
+        }
+    }
+
+    private void validate(String name) {
+        if (name == null || name.isEmpty()) {
+            throw new IllegalArgumentException("이름은 비어있을 수 없습니다.");
+        }
+
+        if (name.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException("이름은 " + MAX_NAME_LENGTH + "자 이하여야 합니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean sameIndex(int index) {
+        return this.index == index;
+    }
+}

src/main/java/nextstep/ladder/domain/Players.java

@@ -0,0 +1,39 @@
+package nextstep.ladder.domain;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.toList;
+
+public class Players {
+    private final List<Player> players;
+
+    private Players(List<Player> players) {
+        validate(players);
+        this.players = players;
+    }
+
+    private void validate(List<Player> players) {
+        if (players == null || players.isEmpty()) {
+            throw new IllegalArgumentException("참가자가 없습니다.");
+        }
+    }
+
+    public static Players of(List<String> playerNames) {
+        return IntStream.range(0, playerNames.size())
+                .mapToObj(index -> new Player(index, playerNames.get(index)))
+                .collect(collectingAndThen(toList(), Players::new));
+    }
+
+    public int count() {
+        return players.size();
+    }
+
+    public Player getPlayer(int index) {
+        return players.stream()
+                .filter(player -> player.sameIndex(index))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("참가자가 없습니다. index: " + index));
+    }
+}

src/main/java/nextstep/ladder/domain/Point.java

@@ -0,0 +1,68 @@
+package nextstep.ladder.domain;
+
+import java.util.Objects;
+
+public class Point {
+    private static final int MIN_INDEX = 0;
+
+    private final int index;
+    private final boolean left;
+    private final boolean right;
+
+    public Point(int index, boolean left, boolean right) {
+        validate(index);
+        validate(left, right);
+        this.index = index;
+        this.left = left;
+        this.right = right;
+    }
+
+    private void validate(int index) {
+        if (index < MIN_INDEX) {
+            throw new IllegalArgumentException("인덱스는 " + MIN_INDEX + "보다 작을 수 없습니다.");
+        }
+    }
+
+    private void validate(boolean left, boolean right) {
+        if (left && right) {
+            throw new IllegalArgumentException("좌 우 모두 이동 가능한 Point 생성 불가");
+        }
+    }
+
+    public static Point createLeftmost(boolean canMoveRight) {
+        return new Point(MIN_INDEX, false, canMoveRight);
+    }
+
+    public Point createRightmost() {
+        return new Point(this.index + 1, this.right, false);
+    }
+
+    public Point createNext(boolean canMoveRight) {
+        return new Point(this.index + 1, this.right, !this.right && canMoveRight);
+    }
+
+    public boolean canMoveLeft() {
+        return left;
+    }
+
+    public boolean canMoveRight() {
+        return right;
+    }
+
+    public boolean sameIndex(int index) {
+        return this.index == index;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Point point = (Point) o;
+        return index == point.index && left == point.left && right == point.right;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(index, left, right);
+    }
+}