박찬인 - 사다리 게임

src/main/java/LadderController.java

@@ -1,5 +1,5 @@
 import domain.ladder.Ladder;
-import domain.ladderFactory.RandomLadderFactory;
+import domain.ladder.ladderFactory.RandomLadderFactory;
 import dto.UserInputDto;
 import view.InputView;
 import view.OutputView;

src/main/java/domain/direction/Direction.java

@@ -1,34 +1,31 @@
 package domain.direction;
 
-import java.util.Arrays;
+import domain.ladder.Point;
 
-public enum Direction {
-    RIGHT(1),
-    DOWN(2),
-    LEFT(3);
+import java.util.Random;
 
-    private int code;
+public enum Direction {
 
-    Direction(int code) {
-        this.code = code;
-    }
-
-    public int getCode() {
-        return code;
-    }
+    RIGHT,
+    DOWN,
+    LEFT;
 
     public boolean isRight() {
         return this == Direction.RIGHT;
     }
 
-    public static Direction findByCode(int code) {
-        return Arrays.stream(Direction.values())
-                .filter(direction -> direction.hasCode(code))
-                .findFirst()
-                .orElse(DOWN);
+    public static Direction getRightOrDown() {
+        return new Random().nextBoolean() ? RIGHT : DOWN;
+    }
+
+    public static Direction createMidDirection(Point point) {
+        if (point.isRight()) {
+            return Direction.LEFT;
+        }
+        return Direction.getRightOrDown();
     }
 
-    private boolean hasCode(int code) {
-        return this.code == code;
+    public static Direction createLastDirection(Point point) {
+        return point.isRight() ? LEFT : DOWN;
     }
 }

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

@@ -8,31 +8,23 @@
 public class Ladder {
 
     private List<Pillar> pillars;
+    private int height;
 
-    public Ladder(List<Pillar> pillars) {
+    public Ladder(List<Pillar> pillars, int height) {
         this.pillars = pillars;
+        this.height = height;
     }
 
     public Direction getDirection(int x, int y) {
-        List<Point> points = findPointByX(x);
-
-        return points.stream()
-                .filter(point -> point.isLocationXY(x, y))
-                .findFirst()
-                .orElseThrow(RuntimeException::new)
-                .getDirection();
-    }
-
-    private List<Point> findPointByX(int x) {
         return pillars.stream()
-                .filter(pillar -> pillar.isEqualToX(x))
+                .filter(pillar -> pillar.hasXY(x, y))
+                .map(pillar -> pillar.getPointDirection(x, y))
                 .findFirst()
-                .orElseThrow(RuntimeException::new)
-                .getPoints();
+                .orElseThrow(RuntimeException::new);
     }
 
     public int getHeight() {
-        return pillars.get(0).getHeight();
+        return this.height;
     }
 
     public List<String> getNames() {

src/main/java/domain/ladder/Pillar.java

@@ -1,6 +1,6 @@
 package domain.ladder;
 
-import domain.direction.DirectionGenerator;
+import domain.direction.Direction;
 
 import java.util.List;
 
@@ -18,31 +18,33 @@ public String getUserName() {
         return user.getName();
     }
 
-    public List<Point> getPoints() {
-        return points;
+    public Direction getPointDirection(int x, int y) {
+        return getPointByXY(x, y)
+                .getDirection();
     }
 
-    public int getHeight() {
-        return points.size();
+    private Point getPointByXY(int x, int y) {
+        return points.stream()
+                .filter(point -> point.isPresentXY(x, y))
+                .findFirst()
+                .orElseThrow(RuntimeException::new);
     }
 
-    public int getX() {
-        return points.get(0).getX();
-    }
-
-    public boolean isEqualToX(int x) {
-        return getX() == x;
+    public boolean hasXY(int x, int y) {
+        return points.stream()
+                .filter(point -> point.isPresentXY(x, y))
+                .count() > 0;
     }
 
     public static Pillar createFirst(String name, int height) {
-        return new Pillar(new User(name), DirectionGenerator.createFirst(height));
+        return new Pillar(new User(name), PointGenerator.createFirst(height));
     }
 
     public static Pillar createMiddle(String name, Pillar before) {
-        return new Pillar(new User(name), DirectionGenerator.createMiddle(before.points));
+        return new Pillar(new User(name), PointGenerator.createMiddle(before.points));
     }
 
     public static Pillar createLast(String name, Pillar before) {
-        return new Pillar(new User(name), DirectionGenerator.createLast(before.points));
+        return new Pillar(new User(name), PointGenerator.createLast(before.points));
     }
 }

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

@@ -6,24 +6,11 @@ public class Point {
     private Location location;
     private Direction direction;
 
-    public static Point createNextPoint(Point before, Direction direction) {
-        Location nextLocation = new Location(before.location);
-        return new Point(nextLocation, direction);
-    }
-
     public Point(Location location, Direction direction) {
         this.location = location;
         this.direction = direction;
     }
 
-    public int getX() {
-        return this.location.getX();
-    }
-
-    public int getY() {
-        return this.location.getY();
-    }
-
     public Direction getDirection() {
         return this.direction;
     }
@@ -32,7 +19,12 @@ public boolean isRight() {
         return this.direction == Direction.RIGHT;
     }
 
-    public boolean isLocationXY(int x, int y) {
+    public boolean isPresentXY(int x, int y) {
         return this.location.isEqual(x, y);
     }
+
+    public static Point createNextPoint(Point before, Direction direction) {
+        Location nextLocation = new Location(before.location);
+        return new Point(nextLocation, direction);
+    }
 }

src/main/java/domain/ladder/PointGenerator.java

@@ -0,0 +1,30 @@
+package domain.ladder;
+
+import domain.direction.Direction;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class PointGenerator {
+
+    public static List<Point> createFirst(int height) {
+        return IntStream.range(0, height)
+                .mapToObj(y -> new Location(0, y))
+                .map(location -> new Point(location, Direction.getRightOrDown()))
+                .collect(Collectors.toList());
+    }
+
+    public static List<Point> createMiddle(List<Point> before) {
+        return before.stream()
+                .map(point -> Point.createNextPoint(point, Direction.createMidDirection(point)))
+                .collect(Collectors.toList());
+    }
+
+    public static List<Point> createLast(List<Point> points) {
+        return points.stream()
+                .map(point -> Point.createNextPoint(point, Direction.createLastDirection(point)))
+                .collect(Collectors.toList());
+    }
+
+}

src/main/java/domain/ladderFactory/FixedLadderFactory.java → src/main/java/domain/ladder/ladderFactory/FixedLadderFactory.java

@@ -1,4 +1,4 @@
-package domain.ladderFactory;
+package domain.ladder.ladderFactory;
 
 import domain.direction.Direction;
 import domain.ladder.*;
@@ -72,6 +72,6 @@ private int getLastIndex() {
     }
 
     public Ladder createLadder() {
-        return new Ladder(createPillars());
+        return new Ladder(createPillars(), height);
     }
 }

src/main/java/domain/ladderFactory/LadderFactory.java → src/main/java/domain/ladder/ladderFactory/LadderFactory.java

@@ -1,4 +1,4 @@
-package domain.ladderFactory;
+package domain.ladder.ladderFactory;
 
 import domain.ladder.Pillar;
 

src/main/java/domain/ladderFactory/RandomLadderFactory.java → src/main/java/domain/ladder/ladderFactory/RandomLadderFactory.java

@@ -1,4 +1,4 @@
-package domain.ladderFactory;
+package domain.ladder.ladderFactory;
 
 import domain.ladder.Ladder;
 import domain.ladder.Pillar;
@@ -20,24 +20,32 @@ public RandomLadderFactory(UserInputDto inputDto) {
     @Override
     public List<Pillar> createPillars() {
         List<Pillar> pillars = new ArrayList<>();
-        pillars.add(Pillar.createFirst(names.get(0), height));
+        addFirst(pillars);
         addMid(pillars);
-        pillars.add(Pillar.createLast(names.get(getLastIndex()), pillars.get(getLastIndex() - 1)));
+        addLast(pillars);
         return pillars;
     }
 
+    private void addFirst(List<Pillar> pillars) {
+        pillars.add(Pillar.createFirst(names.get(0), height));
+    }
+
     private void addMid(List<Pillar> pillars) {
         for (int i = 1; i < names.size() - 1; i++) {
             Pillar pillar = Pillar.createMiddle(names.get(i), pillars.get(i - 1));
             pillars.add(pillar);
         }
     }
 
+    private void addLast(List<Pillar> pillars) {
+        pillars.add(Pillar.createLast(names.get(getLastIndex()), pillars.get(getLastIndex() - 1)));
+    }
+
     private int getLastIndex() {
         return names.size() - 1;
     }
 
     public Ladder createLadder() {
-        return new Ladder(createPillars());
+        return new Ladder(createPillars(), height);
     }
 }

src/main/java/view/OutputView.java

@@ -1,7 +1,7 @@
 package view;
 
-import domain.ladder.Ladder;
 import domain.direction.Direction;
+import domain.ladder.Ladder;
 
 import java.util.List;
 import java.util.stream.IntStream;
@@ -68,7 +68,7 @@ private String getStick(Direction direction) {
         StringBuilder sb = new StringBuilder();
         int width = getMax(ladder.getNames());
         sb.append(findStick(direction));
-        if (direction != Direction.RIGHT) {
+        if (!direction.isRight()) {
             sb.append(addWidth(width, BLANK));
             return sb.toString();
         }
@@ -77,7 +77,7 @@ private String getStick(Direction direction) {
     }
 
     private String findStick(Direction direction) {
-        if (direction == Direction.RIGHT) {
+        if (direction.isRight()) {
             return RIGHT;
         }
         if (direction == Direction.LEFT) {

src/test/java/domain/LadderTest.java

@@ -1,8 +1,8 @@
 package domain;
 
 import domain.ladder.Ladder;
-import domain.ladderFactory.FixedLadderFactory;
-import domain.ladderFactory.LadderFactory;
+import domain.ladder.ladderFactory.FixedLadderFactory;
+import domain.ladder.ladderFactory.LadderFactory;
 import domain.direction.Direction;
 import dto.UserInputDto;
 import org.junit.Before;