2주차 미션 / 서버 3조 김윤서

src/main/java/ladder/Direction.java

@@ -0,0 +1,16 @@
+package ladder;
+
+public enum Direction {
+
+    LEFT(-1), RIGHT(1), NONE(0);
+
+    private final int value;
+
+    Direction(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/ladder/ExceptionMessage.java

@@ -0,0 +1,19 @@
+package ladder;
+
+public enum ExceptionMessage {
+
+    INVALID_LADDER_POSITION("사다리 위치는 1이상 자연수입니다."),
+    INVALID_LADDER_NUMBER("사다리의 행과 열은 2 이상이어야 합니다."),
+    INVALID_POSITION("유효하지 않은 위치입니다."),
+    INVALID_DRAW_POSITION("사다리를 그릴 수 없는 위치입니다.");
+
+    private final String message;
+
+    ExceptionMessage(String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}

src/main/java/ladder/GreaterThanOne.java

@@ -0,0 +1,25 @@
+package ladder;
+
+public class GreaterThanOne {
+
+    private final int number;
+
+    public GreaterThanOne(int number) {
+        this.number = number;
+    }
+
+    public static GreaterThanOne from(int number) {
+        if (!isGreaterThanOne(number)) {
+            throw new IllegalArgumentException(ExceptionMessage.INVALID_LADDER_NUMBER.getMessage());
+        }
+        return new GreaterThanOne(number);
+    }
+
+    private static boolean isGreaterThanOne(int number) {
+        return number > 1;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+}

src/main/java/ladder/LadderCreatorInterface.java

@@ -0,0 +1,6 @@
+package ladder;
+
+public interface LadderCreatorInterface {
+    Row[] getRows();
+    void drawLine(Position row, Position col);
+}

src/main/java/ladder/LadderGame.java

@@ -0,0 +1,16 @@
+package ladder;
+
+public class LadderGame {
+
+    private final LadderCreatorInterface ladderCreator;
+
+    public LadderGame(LadderCreatorInterface ladderCreator) {
+        this.ladderCreator = ladderCreator;
+    }
+
+    public int run(Position position) {
+        LadderRunner ladderRunner = new LadderRunner(ladderCreator.getRows());
+        ladderRunner.run(position);
+        return position.getPosition();
+    }
+}

src/main/java/ladder/LadderGameFactory.java

@@ -0,0 +1,11 @@
+package ladder;
+
+import ladder.creator.LadderAutoCreator;
+
+public class LadderGameFactory {
+
+    public static LadderGame createRandomLadderGame(GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson) {
+        LadderCreatorInterface ladderCreator = new LadderAutoCreator(numberOfRow, numberOfPerson);
+        return new LadderGame(ladderCreator);
+    }
+}

src/main/java/ladder/LadderRunner.java

@@ -0,0 +1,36 @@
+package ladder;
+
+public class LadderRunner {
+
+    private final Row[] rows;
+
+    public LadderRunner(Row[] rows) {
+        this.rows = rows;
+    }
+
+    public int run(Position position) {
+        for (int i = 0; i < rows.length; i++) {
+            System.out.println("Before");
+            printLadder(position, i);
+            System.out.println();
+
+            rows[i].nextPosition(position);
+
+            System.out.println("After");
+            printLadder(position, i);
+            System.out.println();
+        }
+        return position.getPosition();
+    }
+
+    private void printLadder(Position position, int currentRow) {
+        StringBuilder ladderBuilder = new StringBuilder();
+
+        for (int i = 0; i < rows.length; i++) {
+            ladderBuilder.append(rows[i].printRow(position, i == currentRow));
+            ladderBuilder.append("\n");
+        }
+
+        System.out.print(ladderBuilder.toString());
+    }
+}

src/main/java/ladder/Node.java

@@ -0,0 +1,55 @@
+package ladder;
+
+import static ladder.Direction.*;
+
+public class Node {
+
+    private Direction direction;
+
+    private Node(Direction direction) {
+        this.direction = direction;
+    }
+
+    public Direction getDirection() {
+        return direction;
+    }
+
+    public static Node from(Direction direction) {
+        return new Node(direction);
+    }
+
+    public void setRightNode(Position position) {
+        direction = RIGHT;
+    }
+
+    public void setLeftNode(Position position) {
+        direction = LEFT;
+    }
+
+    public void move(Position position) {
+        if (isRight()) {
+            position.next();
+            return;
+        }
+        if (isLeft()) {
+            position.prev();
+            return;
+        }
+    }
+
+    public boolean isAlreadySetDirection() {
+        return isNone();
+    }
+
+    public boolean isRight() {
+        return direction == RIGHT;
+    }
+
+    public boolean isLeft() {
+        return direction == LEFT;
+    }
+
+    public boolean isNone() {
+        return direction == NONE;
+    }
+}

src/main/java/ladder/Position.java

@@ -0,0 +1,45 @@
+package ladder;
+
+public class Position {
+
+    private int position;
+
+    private Position(int position) {
+        this.position = position;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    public static Position from(int position) {
+        validatePosition(position);
+        return new Position(position);
+    }
+
+    public boolean isBiggerThan(int position) {
+        return this.position > position;
+    }
+
+    public boolean isSmallerThan(int position) {
+        return this.position < position;
+    }
+
+    public void next() {
+        position++;
+    }
+
+    public void prev() {
+        position--;
+    }
+
+    private static void validatePosition(int position) {
+        if (!isPosition(position)) {
+            throw new IllegalArgumentException(ExceptionMessage.INVALID_LADDER_POSITION.getMessage());
+        }
+    }
+
+    private static boolean isPosition(int position) {
+        return position >= 0;
+    }
+}

src/main/java/ladder/Row.java

@@ -0,0 +1,90 @@
+package ladder;
+
+import static ladder.Direction.*;
+
+public class Row {
+
+    Node[] nodes;
+
+    public Row(GreaterThanOne numberOfPerson) {
+        nodes = new Node[numberOfPerson.getNumber()];
+        for (int i = 0; i < numberOfPerson.getNumber(); i++) {
+            nodes[i] = Node.from(NONE);
+        }
+    }
+
+    public boolean canDrawLineAt(int col) {
+        if (col < 0 || col >= nodes.length - 1) {
+            return false;
+        }
+        return nodes[col].isNone() && nodes[col + 1].isNone();
+    }
+
+    public void drawLine(Position startPosition) {
+        validateDrawLinePosition(startPosition);
+
+        setDirectionBetweenNextPosition(startPosition);
+    }
+
+    private void setDirectionBetweenNextPosition(Position position) {
+        nodes[position.getPosition()].setRightNode(position);
+        position.next();
+        nodes[position.getPosition()].setLeftNode(position);
+    }
+
+    public void nextPosition(Position position) {
+        validatePosition(position);
+
+        nodes[position.getPosition()].move(position);
+    }
+
+    public String printRow(Position position, boolean isCurrentRow) {
+        StringBuilder rowBuilder = new StringBuilder();
+
+        for (int i = 0; i < nodes.length; i++) {
+            rowBuilder.append(getNodeIndex(i))
+                    .append((isCurrentRow && i == position.getPosition()) ? "*" : "")
+                    .append(i < nodes.length - 1 ? " " : "");
+        }
+        return rowBuilder.toString();
+    }
+
+    private void validatePosition(Position position) {
+        if (position.isBiggerThan(nodes.length - 1)) {
+            throw new IllegalArgumentException(ExceptionMessage.INVALID_POSITION.getMessage());
+        }
+    }
+
+    private void validateDrawLinePosition(Position startPosition) {
+        if (isInvalidPosition(startPosition) || isLineAtPosition(startPosition) || isLineAtNextPosition(startPosition)) {
+            throw new IllegalArgumentException(ExceptionMessage.INVALID_DRAW_POSITION.getMessage());
+        }
+    }
+
+    private boolean isInvalidPosition(Position startPosition) {
+        return startPosition.isBiggerThan(nodes.length - 1);
+    }
+
+    private boolean isLineAtPosition(Position startPosition) {
+        return !nodes[startPosition.getPosition()].isAlreadySetDirection();
+    }
+
+    private boolean isLineAtNextPosition(Position startPosition) {
+        startPosition.next();
+        boolean IsLineAtPosition = !nodes[startPosition.getPosition()].isAlreadySetDirection();
+        startPosition.prev();
+        return IsLineAtPosition;
+    }
+
+    private String getNodeIndex(int index) {
+        switch (nodes[index].getDirection()) {
+            case RIGHT:
+                return "1";
+            case LEFT:
+                return "-1";
+            case NONE:
+            default:
+                return "0";
+        }
+    }
+}

src/main/java/ladder/creator/LadderAutoCreator.java

@@ -0,0 +1,50 @@
+package ladder.creator;
+
+import ladder.GreaterThanOne;
+import ladder.LadderCreatorInterface;
+import ladder.Position;
+import ladder.Row;
+
+import java.util.Random;
+
+public class LadderAutoCreator implements LadderCreatorInterface {
+
+    private final Row[] rows;
+    private final int numberOfLines;
+    private final Random random = new Random();
+
+    public LadderAutoCreator(GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson) {
+        rows = new Row[numberOfRow.getNumber()];
+
+        numberOfLines = (int) (numberOfRow.getNumber() * numberOfPerson.getNumber() * 0.3);
+
+        for (int i = 0; i < numberOfRow.getNumber(); i++) {
+            rows[i] = new Row(numberOfPerson);
+        }
+
+        createRandomLines(numberOfPerson);
+    }
+
+    private void createRandomLines(GreaterThanOne numberOfPerson) {
+        int linesDrawn = 0;
+        while (linesDrawn < numberOfLines) {
+            int randomRow = random.nextInt(rows.length);
+            int randomCol = random.nextInt(numberOfPerson.getNumber() - 1);
+
+            Position position = Position.from(randomCol);
+
+            if (rows[randomRow].canDrawLineAt(position.getPosition())) {
+                rows[randomRow].drawLine(position);
+                linesDrawn++;
+            }
+        }
+    }
+
+    public void drawLine(Position row, Position col) {
+        rows[row.getPosition()].drawLine(col);
+    }
+
+    public Row[] getRows() {
+        return rows;
+    }
+}