2주차 미션/ 서버 2조 임제형

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

src/main/java/ladder/GreaterThanOne.java

@@ -0,0 +1,24 @@
+package ladder;
+
+public class GreaterThanOne {
+    private final int number;
+
+    private 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/LadderGame.java

@@ -0,0 +1,26 @@
+package ladder;
+
+import ladder.creator.LadderCreator;
+
+public class LadderGame {
+
+    private final LadderCreator ladderCreator;
+
+    private LadderGame(LadderCreator ladderCreator) {
+        this.ladderCreator = ladderCreator;
+    }
+
+    public static LadderGame from(LadderCreator ladderCreator){
+        return new LadderGame(ladderCreator);
+    }
+
+    public int run(Position position) {
+        LadderRunner ladderRunner = LadderRunner.from(ladderCreator.getLadderWrapper());
+        ladderRunner.run(position);
+        return position.getValue();
+    }
+
+    public LadderCreator getLadderCreator() {
+        return ladderCreator;
+    }
+}

src/main/java/ladder/LadderGameFactory.java

@@ -0,0 +1,17 @@
+package ladder;
+
+import ladder.creator.CustomLadderCreator;
+import ladder.creator.LadderCreator;
+import ladder.creator.RandomLadderCreator;
+
+public class LadderGameFactory {
+    public static LadderGame createRandomLadderGame(LadderSize ladderSize){
+        LadderCreator randomLadderCreator = RandomLadderCreator.from(ladderSize);
+        return LadderGame.from(randomLadderCreator);
+    }
+
+    public static LadderGame createCustomLadderGame(LadderSize ladderSize){
+        LadderCreator customLadderCreator = CustomLadderCreator.from(ladderSize);
+        return LadderGame.from(customLadderCreator);
+    }
+}

src/main/java/ladder/LadderPosition.java

@@ -0,0 +1,23 @@
+package ladder;
+
+public class LadderPosition {
+    private Position rowPos;
+    private Position colPos;
+
+    private LadderPosition(Position rowPos, Position colPos) {
+        this.rowPos = rowPos;
+        this.colPos = colPos;
+    }
+
+    public static LadderPosition of(Position rowPos, Position colPos){
+        return new LadderPosition(rowPos, colPos);
+    }
+
+    public Position getRowPos() {
+        return rowPos;
+    }
+
+    public Position getColPos() {
+        return colPos;
+    }
+}

src/main/java/ladder/LadderRunner.java

@@ -0,0 +1,30 @@
+package ladder;
+
+public class LadderRunner {
+    LadderWrapper ladderWrapper;
+
+    private LadderRunner(LadderWrapper ladderWrapper) {
+        this.ladderWrapper = ladderWrapper;
+    }
+
+    public static LadderRunner from(LadderWrapper ladderWrapper) {
+        return new LadderRunner(ladderWrapper);
+    }
+
+    public int run(Position position) {
+        LadderPosition ladderPosition = LadderPosition.of(Position.from(0), position);
+        while(!ladderWrapper.isLadderPositionAtLastRow(ladderPosition)){
+            moveTurnPrinting(ladderPosition);
+        }
+        Position lastColPosition = ladderPosition.getColPos();
+        return lastColPosition.getValue();
+    }
+
+    private void moveTurnPrinting(LadderPosition ladderPosition){
+        ladderWrapper.printRowsWithLabel(ladderPosition, "Before");
+        ladderWrapper.changeLadderPositionHorizontally(ladderPosition);
+        ladderWrapper.printRowsWithLabel(ladderPosition, "After");
+        ladderWrapper.changeLadderPositionVertically(ladderPosition);
+        System.out.println();
+    }
+}

src/main/java/ladder/LadderSize.java

@@ -0,0 +1,23 @@
+package ladder;
+
+public class LadderSize {
+    private GreaterThanOne numberOfRow;
+    private GreaterThanOne numberOfPerson;
+
+    private LadderSize(GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson){
+        this.numberOfRow = numberOfRow;
+        this.numberOfPerson = numberOfPerson;
+    }
+
+    public static LadderSize of(GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson){
+        return new LadderSize(numberOfRow, numberOfPerson);
+    }
+
+    public GreaterThanOne getNumberOfRow() {
+        return numberOfRow;
+    }
+
+    public GreaterThanOne getNumberOfPerson() {
+        return numberOfPerson;
+    }
+}

src/main/java/ladder/LadderWrapper.java

@@ -0,0 +1,62 @@
+package ladder;
+
+public class LadderWrapper {
+    private final Row[] rows;
+
+    private LadderWrapper(Row[] rows) {
+        this.rows = rows;
+    }
+
+    public static LadderWrapper from(Row[] rows){
+        return new LadderWrapper(rows);
+    }
+
+    public void changeLadderPositionHorizontally(LadderPosition ladderPosition){
+        Position rowPosition = ladderPosition.getRowPos();
+        rows[rowPosition.getValue()].nextPosition(ladderPosition.getColPos());
+    }
+
+    public void changeLadderPositionVertically(LadderPosition ladderPosition){
+        Position rowPosition = ladderPosition.getRowPos();
+        rowPosition.next();
+    }
+
+    public boolean isLadderPositionAtLastRow(LadderPosition ladderPosition){
+        Position rowPosition = ladderPosition.getRowPos();
+        return rowPosition.getValue() == rows.length;
+    }
+
+    public void printRowsWithLabel(LadderPosition ladderPosition, String label){
+        System.out.println(label);
+        printRows(ladderPosition);
+    }
+
+    private void printRows(LadderPosition ladderPosition){
+        Position nowRowPosition = ladderPosition.getRowPos();
+        for(int rowIndex=0; rowIndex<rows.length; rowIndex++){
+            if(rowIndex != nowRowPosition.getValue()) { System.out.println(rows[rowIndex].buildRowString()); continue; }
+            System.out.println(rows[rowIndex].buildStarRowString(ladderPosition.getColPos()));
+        }
+    }
+
+    public void drawLine(LadderPosition ladderPosition){
+        Position rowPos = ladderPosition.getRowPos();
+        Position colPos = ladderPosition.getColPos();
+        rows[rowPos.getValue()].drawLine(colPos);
+    }
+
+    public int getRowsSize(){
+        return rows.length;
+    }
+
+    public int getColsSize(){
+        return rows[0].getNodesSize();
+    }
+
+    public int getLadderValue(LadderPosition ladderPosition){
+        Position rowPos = ladderPosition.getRowPos();
+        Position colPos = ladderPosition.getColPos();
+
+        return rows[rowPos.getValue()].getRowValue(colPos);
+    }
+}

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 static Node from(Direction direction) {
+        return new Node(direction);
+    }
+
+    public int getDirectionValue(){
+        return direction.getValue();
+    }
+
+    public void move(Position position) {
+        if (isRight()) {
+            position.next();
+            return;
+        }
+        if (isLeft()) {
+            position.prev();
+            return;
+        }
+    }
+
+    public void setRightNode() {
+        direction = RIGHT;
+    }
+
+    public void setLeftNode() {
+        direction = LEFT;
+    }
+
+    public boolean isAlreadySetDirection() {
+        return !isNone();
+    }
+
+    private boolean isRight() {
+        return direction == RIGHT;
+    }
+
+    private boolean isLeft() {
+        return direction == LEFT;
+    }
+
+    private boolean isNone() {
+        return direction == NONE;
+    }
+}

src/main/java/ladder/Position.java

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