Merge pull request #8 from mjung1798/master

kmj - 사다리게임

Author: jyami-kim

build.gradle

@@ -13,4 +13,5 @@ repositories {
 
 dependencies {
     testCompile group: 'junit', name: 'junit', version: '4.12'
+    testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
 }

src/main/java/LadderGame.java

@@ -1,4 +1,27 @@
+import domain.ladder.Ladder;
+import domain.ladderCalculator.LadderIO;
+import dto.GameStartOption;
+import view.InputView;
+import view.OutputLadder;
+
 public class LadderGame {
 
+    public static void main(String args[]) {
+        InputView inputView = InputView.of(System.in);
+        GameStartOption gameStartOption = inputView.initGameStartOption();
+        Ladder ladder = Ladder.of(gameStartOption);
+        LadderIO ladderIO = LadderIO.of(gameStartOption);
+        OutputLadder ladderPrint = OutputLadder.of(ladderIO, ladder);
+
+        ladderPrint.drawUserNames();
+        ladderPrint.drawOutput();
+        ladderPrint.drawResults();
+
+        while (true) {
+            String ask = inputView.showResultUser();
+            ladderPrint.showLadderResult(ask);
+        }
+
+    }
 
 }

src/main/java/domain/converter/OutputConverter.java

@@ -0,0 +1,26 @@
+package domain.converter;
+
+import domain.ladder.Ladder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class OutputConverter {
+    private List<Row> rows = new ArrayList<>();
+
+    private OutputConverter(Ladder ladder) {
+        for (int location = 0; location < ladder.getHeight(); location++) {
+            rows.add(Row.of(location, ladder));
+        }
+    }
+
+    public static OutputConverter of(Ladder ladder) {
+        return new OutputConverter(ladder);
+    }
+
+    public List<Row> getRows() {
+        return new ArrayList<>(rows);
+    }
+
+
+}

src/main/java/domain/converter/Point.java

@@ -0,0 +1,47 @@
+package domain.converter;
+
+import domain.ladder.Bridge;
+
+import java.util.Optional;
+
+public class Point implements Comparable<Point> {
+    private Integer pillarNum;
+    private Bridge bridge;
+
+    private Point(Integer pillarNum, Bridge bridge) {
+        this.pillarNum = pillarNum;
+        this.bridge = bridge;
+    }
+
+    private Point(Integer pillarNum) {
+        this.pillarNum = pillarNum;
+    }
+
+    public static Point of(Integer pillarNum, Optional<Bridge> bridge) {
+        if (bridge.isPresent())
+            return new Point(pillarNum, bridge.get());
+        return new Point(pillarNum);
+    }
+
+    public boolean isBlankPoint() {
+        return bridge == null;
+    }
+
+    @Override
+    public String toString() {
+        return "pillarNum:" + pillarNum + "/" + "bridge:" + bridge.getLocation();
+    }
+
+    public Integer getPillarNum() {
+        return pillarNum;
+    }
+
+    public Bridge getBridge() {
+        return bridge;
+    }
+
+    @Override
+    public int compareTo(Point o) {
+        return pillarNum.compareTo(o.pillarNum);
+    }
+}

src/main/java/domain/converter/Row.java

@@ -0,0 +1,39 @@
+package domain.converter;
+
+import domain.ladder.Ladder;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Row implements Comparable<Row> {
+    private Integer location;
+    private List<Point> points;
+
+    private Row(Integer location, Ladder ladder) {
+        this.location = location;
+        this.points = findLocationBridge(ladder);
+    }
+
+    public static Row of(Integer location, Ladder ladder) {
+        return new Row(location, ladder);
+    }
+
+    private List<Point> findLocationBridge(Ladder ladder) {
+        return ladder.getPillars().stream()
+                .map(pillar -> Point.of(pillar.getPillarNum(), pillar.getLevelBridges(location)))
+                .collect(Collectors.toList());
+    }
+
+    public Integer getLocation() {
+        return location;
+    }
+
+    public List<Point> getPoints() {
+        return points;
+    }
+
+    @Override
+    public int compareTo(Row o) {
+        return location.compareTo(o.location);
+    }
+}

src/main/java/domain/factory/PillarFactory.java

@@ -0,0 +1,35 @@
+package domain.factory;
+
+import domain.ladder.Bridge;
+import domain.ladder.Pillar;
+import domain.maker.PillarMaker;
+import dto.GameStartOption;
+
+import java.util.List;
+
+public class PillarFactory {
+
+    public static final int MINIMUM_PILLAR_NUM = 0;
+
+    public Pillar createFirstPillar (GameStartOption gameStartOption) {
+
+        List<Bridge> bridges = PillarMaker.of().createBridgesInThisPillar(gameStartOption);
+        Integer pillarNum = MINIMUM_PILLAR_NUM;
+
+        return Pillar.of(bridges, pillarNum);
+    }
+
+    public Pillar createNotFirstPillar (GameStartOption gameStartOption, Pillar previousPillar) {
+
+        List<Bridge> bridges = PillarMaker.of().createBridgesInThisPillar(gameStartOption, previousPillar);
+        Integer pillarNum = nowPillarNum(previousPillar);
+
+        return Pillar.of(bridges, pillarNum);
+
+    }
+
+    private Integer nowPillarNum(Pillar previousPillar) {
+        return previousPillar.getPillarNum() + 1;
+    }
+
+}

src/main/java/domain/ladder/Bridge.java

@@ -0,0 +1,32 @@
+package domain.ladder;
+
+public class Bridge {
+    private Integer location;
+    private LinkedType linkPillarDirection;
+
+    private Bridge(Integer location, LinkedType linkPillarDirection) {
+        this.location = location;
+        this.linkPillarDirection = linkPillarDirection;
+    }
+
+    public static Bridge of(Integer location , LinkedType linkPillarDirection){
+        return new Bridge(location, linkPillarDirection);
+    }
+
+    public Integer getLocation() {
+        return location;
+    }
+
+    public LinkedType getLinkPillarDirection() {
+        return linkPillarDirection;
+    }
+
+    public static Bridge createOneRightBridge(Integer location) {
+        return (new Bridge(location, LinkedType.RIGHT));
+    }
+
+    public static Bridge createOneLeftBridge(Integer location) {
+        return (new Bridge(location, LinkedType.LEFT));
+    }
+
+}

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

@@ -0,0 +1,53 @@
+package domain.ladder;
+
+import domain.maker.LadderMaker;
+import dto.GameStartOption;
+
+import java.util.List;
+import java.util.Optional;
+
+public class Ladder {
+
+    private List<Pillar> pillars;
+    private Integer width;
+    private Integer height;
+
+    private Ladder(GameStartOption gameStartOption) {
+        this.width = gameStartOption.getLadderWidth();
+        this.height = gameStartOption.getLadderHeight();
+        this.pillars = LadderMaker.of().createLadder(gameStartOption);
+    }
+
+    public static Ladder of(GameStartOption gameStartOption) {
+        return new Ladder(gameStartOption);
+    }
+
+    public Pillar getPillarByNum(Integer pillarNum) {
+        return pillars.stream()
+                .filter(p -> p.getPillarNum() == pillarNum)
+                .findFirst()
+                .orElseThrow(IllegalArgumentException::new); // optional orElse에 null 던지지 말기 throw Exception
+    }
+
+    public List<Pillar> getPillars() {
+        return pillars;
+    }
+
+    public Integer getWidth() {
+        return width;
+    }
+
+    public Integer getHeight() {
+        return height;
+    }
+
+    public Pillar getNextPillar(Pillar nowPillar, Integer nowLocation) {
+        Optional<Bridge> linkBridge = nowPillar.getLevelBridges(nowLocation);
+        if (!linkBridge.isPresent())
+            return nowPillar;
+        return linkBridge.get().getLinkPillarDirection() == LinkedType.RIGHT ?
+                getPillarByNum(nowPillar.getPillarNum() + 1) :
+                getPillarByNum(nowPillar.getPillarNum() - 1);
+    }
+
+}

src/main/java/domain/ladder/LinkedType.java

@@ -0,0 +1,5 @@
+package domain.ladder;
+
+public enum LinkedType {
+    RIGHT, LEFT
+}

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

@@ -0,0 +1,47 @@
+package domain.ladder;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class Pillar {
+
+    private List<Bridge> bridges;
+    private Integer pillarNum;
+
+    private Pillar(List<Bridge> bridges, Integer pillarNum) {
+        this.bridges = bridges;
+        this.pillarNum = pillarNum;
+    }
+
+    public static Pillar of(List<Bridge> bridges, Integer pillarNum) {
+        return new Pillar(bridges, pillarNum);
+    }
+
+    public Integer getPillarNum() {
+        return pillarNum;
+    }
+
+    public List<Bridge> getBridges() {
+        return bridges;
+    }
+
+    public Optional<Bridge> getLevelBridges(Integer level) {
+        return bridges.stream()
+                .filter(bridge -> bridge.getLocation().equals(level))
+                .findFirst();
+    }
+
+    public List<Integer> getBridgesLocations() {
+        return bridges.stream()
+                .map(b -> b.getLocation())
+                .collect(Collectors.toList());
+    }
+
+    public List<Integer> getBridgesDirectionLocation(LinkedType linkedType) {
+        return bridges.stream()
+                .filter(b -> b.getLinkPillarDirection() == linkedType)
+                .map(bridge -> bridge.getLocation())
+                .collect(Collectors.toList());
+    }
+}