유태식 - 사다리 게임

.gitignore

@@ -1,3 +1,4 @@
 .idea/**
 .gradle/**
-build/
+build/**
+out/**

README.md

@@ -1 +1,34 @@
-# java-ladder 게임
+# 사다리 게임
+## 기능 구현 목록
+### 참여자 이름 입력
+- [x] 여러 사람의 이름은 쉼표(,)를 기준으로 구분
+- [x] 참여자의 이름은 최대 5글자
+- [x] 앞 뒤 공백을 제거
+- [x] 중복된 이름이 있는 경우 예외 처리
+- [ ] 이름이 공백일 수 없음 
+
+### 실행결과 입력
+- [x] 여러 결과는 쉼표(,)를 기준으로 구분
+- [x] 결과는 최대 5글자
+- [x] 앞 뒤 공백을 제거
+- [ ] 결과가 공백일 수 없음
+- [ ] 참여자 수와 결과의 수가 같아야 함 
+
+### 사다리 높이 입력
+- [x] 사다리 높이는 1 이상이여야함  
+
+### 사다리 생성
+- [x] 사다리의 라인이 겹치지 않도록 사다리를 생성
+e.g. |-----|-----|  모양과 같이 가로 라인이 겹치는 경우 어느 방향으로 이동할
+지 결정할 수 없다.
+
+### 사다리 출력
+- [x] 사다리 위에 사람 이름을 출력
+- [x] 사람 이름을 5자 기준으로 출력
+- [x] 사다리 폭 또한 사람 이름을 기준으로 함
+- [ ] 사다리 아래에 결과를 출력
+- [ ] 결과를 5자 기준으로 출력
+
+### 사다리게임 결과 출력
+- [ ] 'all'을 입력시 전체참여자의 실행결과를 출력
+- [ ] 개인의 이름을 입력시 해당하는 참여자의 실행결과를 출력

build.gradle

@@ -15,4 +15,5 @@ dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.1'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.1'
     testCompile "org.assertj:assertj-core:3.14.0"
+    compile 'org.apache.commons:commons-lang3:3.9'
 }

gradlew.bat

@@ -46,12 +46,12 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windows variants
+@rem Get command-ladderLine arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
 
 :win9xME_args
-@rem Slurp the command line arguments.
+@rem Slurp the command ladderLine arguments.
 set CMD_LINE_ARGS=
 set _SKIP=2
 
@@ -61,7 +61,7 @@ if "x%~1" == "x" goto execute
 set CMD_LINE_ARGS=%*
 
 :execute
-@rem Setup the command line
+@rem Setup the command ladderLine
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 

settings.gradle

@@ -1,2 +1,2 @@
-rootProject.name = 'java-racingcar'
+rootProject.name = 'java-ladder'
 

src/main/java/laddergame/LadderGame.java

@@ -0,0 +1,13 @@
+package laddergame;
+
+import laddergame.controller.LadderGameController;
+import laddergame.view.InputView;
+import laddergame.view.OutputView;
+
+public class LadderGame {
+
+    public static void main(String[] args) {
+        LadderGameController ladderGameController = new LadderGameController(new InputView(), new OutputView());
+        ladderGameController.run();
+    }
+}

src/main/java/laddergame/controller/LadderGameController.java

@@ -0,0 +1,39 @@
+package laddergame.controller;
+
+import laddergame.domain.ladder.Ladder;
+import laddergame.domain.ladder.strategy.RandomLadderCreationStrategy;
+import laddergame.domain.ladderheight.LadderHeight;
+import laddergame.domain.player.Players;
+import laddergame.domain.result.Results;
+import laddergame.service.LadderGameService;
+import laddergame.view.InputView;
+import laddergame.view.OutputView;
+
+public class LadderGameController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final LadderGameService ladderGameService = new LadderGameService();
+
+    public LadderGameController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        String playerNames = inputView.getPlayerNamesFromConsole();
+        Players players = ladderGameService.createPlayers(playerNames);
+
+        String gameResults = inputView.getGameResultFromConsole();
+        Results results = ladderGameService.createResults(gameResults, players.size());
+
+        int ladderHeightInput = inputView.getLadderHeightFromConsole();
+        LadderHeight ladderHeight = ladderGameService.createLadderHeight(ladderHeightInput);
+
+        Ladder ladder = ladderGameService.createLadder(players, ladderHeight, new RandomLadderCreationStrategy());
+
+        //LadderGame ladderGame = ladderGameService.createLadderGame(players, results, ladder);
+
+        outputView.printResult(players, ladder);
+    }
+}

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

@@ -0,0 +1,34 @@
+package laddergame.domain.ladder;
+
+import laddergame.domain.ladder.strategy.LadderCreationStrategy;
+import laddergame.domain.ladderheight.LadderHeight;
+import laddergame.domain.player.Players;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Ladder {
+
+    private final List<LadderLine> lines;
+
+    private Ladder(final List<LadderLine> lines) {
+        this.lines = lines;
+    }
+
+    public static Ladder with(final Players players, final LadderHeight ladderHeight, LadderCreationStrategy strategy) {
+        List<LadderLine> lines = new ArrayList<>();
+        int width = players.size();
+        int height = ladderHeight.getHeight();
+
+        for (int i = 0; i < height; i++) {
+            LadderLine line = LadderLine.with(width, strategy);
+            lines.add(line);
+        }
+
+        return new Ladder(lines);
+    }
+
+    public List<LadderLine> getLines() {
+        return lines;
+    }
+}

src/main/java/laddergame/domain/ladder/LadderLine.java

@@ -0,0 +1,93 @@
+package laddergame.domain.ladder;
+
+import laddergame.domain.ladder.strategy.LadderCreationStrategy;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class LadderLine {
+
+    public static final String POINT= "|";
+    public static final String CONNECTION= "-----";
+    public static final String NON_CONNECTION= "     ";
+
+    private final List<Point> points;
+
+    public LadderLine(final List<Point> points) {
+        this.points = points;
+    }
+
+    public static LadderLine with(final int width, LadderCreationStrategy strategy) {
+        List<Point> points = new ArrayList<>();
+        Point previousPoint = null;
+
+        for (int i = 0; i < width; i++) {
+            int remain = width - i;
+            Point point = generatePoint(previousPoint, remain, strategy);
+            points.add(point);
+            previousPoint = point;
+        }
+
+        return new LadderLine(points);
+    }
+
+    private static Point generatePoint(Point point, int remain, LadderCreationStrategy strategy) {
+        if (isFirstPoint(point)) {
+            return Point.generateFirstPoint(strategy);
+        }
+
+        if (isLastPoint(remain)) {
+            return Point.generateLastPoint(point);
+        }
+
+        return point.decideNextPoint(strategy);
+    }
+
+    private static boolean isFirstPoint(Point point) {
+        return point == null;
+    }
+
+    private static boolean isLastPoint(int remain) {
+        return remain == 1;
+    }
+
+    public int size() {
+        return points.size();
+    }
+
+    public String lineToString() {
+        List<Point> points = getPoints();
+
+        String result = "     ";
+        for (Point point : points) {
+            String connectionString = point.connectionToString();
+            result += (POINT + connectionString);
+        }
+        return result;
+    }
+
+    public List<Point> getPoints() {
+        return points;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LadderLine that = (LadderLine) o;
+        return Objects.equals(points, that.points);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(points);
+    }
+
+    @Override
+    public String toString() {
+        return "LadderLine{" +
+                "points=" + points +
+                '}';
+    }
+}

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

@@ -0,0 +1,63 @@
+package laddergame.domain.ladder;
+
+import laddergame.domain.ladder.strategy.LadderCreationStrategy;
+
+public enum Point {
+
+    LEFT(true, false),
+    RIGHT(false, true),
+    NONE(false, false);
+
+    private boolean leftConnection;
+    private boolean rightConnection;
+
+    Point(boolean leftConnection, boolean rightConnection) {
+        this.leftConnection = leftConnection;
+        this.rightConnection = rightConnection;
+    }
+
+    public static Point generateFirstPoint(LadderCreationStrategy strategy) {
+        return generatePoint(false, strategy.isConnectable());
+    }
+
+    public static Point generateLastPoint(Point point) {
+        if (point.hasRightConnection()) {
+            return generatePoint(true, false);
+        }
+        return generatePoint(false, false);
+    }
+
+    public Point decideNextPoint(LadderCreationStrategy strategy) {
+        if (rightConnection) {
+            return generatePoint(true, false );
+        }
+        return generatePoint(false, strategy.isConnectable());
+    }
+
+    private static Point generatePoint(boolean leftConnection, boolean rightConnection) {
+        if (leftConnection && rightConnection) {
+            throw new IllegalArgumentException();
+        }
+
+        if (leftConnection) {
+            return LEFT;
+        }
+
+        if (rightConnection) {
+            return RIGHT;
+        }
+
+        return NONE;
+    }
+
+    public boolean hasRightConnection() {
+        return rightConnection;
+    }
+
+    public String connectionToString() {
+        if (hasRightConnection()) {
+            return LadderLine.CONNECTION;
+        }
+        return LadderLine.NON_CONNECTION;
+    }
+}

src/main/java/laddergame/domain/ladder/strategy/LadderCreationStrategy.java

@@ -0,0 +1,6 @@
+package laddergame.domain.ladder.strategy;
+
+public interface LadderCreationStrategy {
+
+    boolean isConnectable();
+}

src/main/java/laddergame/domain/ladder/strategy/ManualLadderCreationStrategy.java

@@ -0,0 +1,9 @@
+package laddergame.domain.ladder.strategy;
+
+public class ManualLadderCreationStrategy implements LadderCreationStrategy {
+
+    @Override
+    public boolean isConnectable() {
+        return true;
+    }
+}

src/main/java/laddergame/domain/ladder/strategy/RandomLadderCreationStrategy.java

@@ -0,0 +1,11 @@
+package laddergame.domain.ladder.strategy;
+
+import java.util.Random;
+
+public class RandomLadderCreationStrategy implements LadderCreationStrategy{
+
+    @Override
+    public boolean isConnectable() {
+        return new Random().nextBoolean();
+    }
+}

src/main/java/laddergame/domain/ladderheight/LadderHeight.java

@@ -0,0 +1,24 @@
+package laddergame.domain.ladderheight;
+
+public class LadderHeight {
+
+    private static final int LADDER_HEIGHT_MIN_LENGTH = 1;
+
+    private final int height;
+
+    public LadderHeight(int height) {
+        if (!isLongerThanMinLength(height)) {
+            throw new IllegalArgumentException();
+        }
+
+        this.height = height;
+    }
+
+    private boolean isLongerThanMinLength(int height) {
+        return height >= LADDER_HEIGHT_MIN_LENGTH;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+}