🚀 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);
+        Lines lines = Lines.of(players.count(), height);
+
+        return new LadderGame(players, lines);
+    }
+
+    public Players getPlayers() {
+        return players;
+    }
+
+    public Lines getLines() {
+        return lines;
+    }
+}

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

@@ -0,0 +1,59 @@
+package nextstep.ladder.domain;
+
+import java.util.List;
+
+public class Line {
+    private final List<Point> points;
+
+    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() < 2) {
+            throw new IllegalArgumentException("점이 두 개 이상 있어야 합니다.");
+        }
+    }
+
+    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.get(index);
+    }
+}

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

@@ -0,0 +1,40 @@
+package nextstep.ladder.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class LineBuilder {
+
+    private static final Random RANDOM = new Random();
+
+    private final List<Point> points = new ArrayList<>();
+
+    public static Line buildWithRandomPoints(int count) {
+        return new LineBuilder().initRandomMoveablePoint()
+                .addRandomMoveablePoints(count - 2)
+                .build();
+    }
+
+    private Line build() {
+        points.add(lastPoint().createRightmost());
+        return new Line(points);
+    }
+
+    private LineBuilder addRandomMoveablePoints(int numberOfMiddlePoints) {
+        for (int i = 0; i < numberOfMiddlePoints; i++) {
+            Point point = lastPoint().createNext(RANDOM.nextBoolean());
+            points.add(point);
+        }
+        return this;
+    }
+
+    private LineBuilder initRandomMoveablePoint() {
+        points.add(Point.createLeftmost(RANDOM.nextBoolean()));
+        return this;
+    }
+
+    private Point lastPoint() {
+        return points.get(points.size() - 1);
+    }
+}

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

@@ -0,0 +1,36 @@
+package nextstep.ladder.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Lines {
+
+    private final List<Line> lines;
+
+    private 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 static Lines of(int numberOfPlayers, int height) {
+        List<Line> lines = IntStream.range(0, height)
+                .mapToObj(i -> LineBuilder.buildWithRandomPoints(numberOfPlayers))
+                .collect(Collectors.toList());
+        return new Lines(lines);
+    }
+
+    public int getHeight() {
+        return lines.size();
+    }
+
+    public Line getLine(int targetHeight) {
+        return lines.get(targetHeight);
+    }
+}

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

@@ -0,0 +1,24 @@
+package nextstep.ladder.domain;
+
+public class Player {
+    private final String name;
+
+    public Player(String name) {
+        validate(name);
+        this.name = name;
+    }
+
+    private void validate(String name) {
+        if (name == null || name.isEmpty()) {
+            throw new IllegalArgumentException("이름은 비어있을 수 없습니다.");
+        }
+
+        if (name.length() > 5) {
+            throw new IllegalArgumentException("이름은 5자 이하여야 합니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+}

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

@@ -0,0 +1,35 @@
+package nextstep.ladder.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+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) {
+        List<Player> players = playerNames.stream()
+                .map(Player::new)
+                .collect(Collectors.toList());
+
+        return new Players(players);
+    }
+
+    public int count() {
+        return players.size();
+    }
+
+    public Player getPlayer(int index) {
+        return players.get(index);
+    }
+}

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

@@ -0,0 +1,38 @@
+package nextstep.ladder.domain;
+
+public class Point {
+    private final boolean left;
+    private final boolean right;
+
+    public Point(boolean left, boolean right) {
+        validate(left, right);
+        this.left = left;
+        this.right = right;
+    }
+
+    private void validate(boolean left, boolean right) {
+        if (left && right) {
+            throw new IllegalArgumentException("좌 우 모두 이동 가능한 Point 생성 불가");
+        }
+    }
+
+    public static Point createLeftmost(boolean canMoveRight) {
+        return new Point(false, canMoveRight);
+    }
+
+    public Point createRightmost() {
+        return new Point(this.right, false);
+    }
+
+    public Point createNext(boolean canMoveRight) {
+        return new Point(this.right, !this.right && canMoveRight);
+    }
+
+    public boolean canMoveLeft() {
+        return left;
+    }
+
+    public boolean canMoveRight() {
+        return right;
+    }
+}