[송지은] 사다리타기 제출합니다.

src/main/java/controller/LadderController.java

@@ -0,0 +1,31 @@
+package controller;
+
+import domain.Ladder;
+import domain.LadderGame;
+import domain.LadderHeight;
+import domain.LadderWidth;
+import domain.Players;
+import domain.Prizes;
+import domain.GameResult;
+import view.InputView;
+import view.OutputView;
+
+public class LadderController {
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        Players players = inputView.askPlayers();
+        Prizes prizes = inputView.askPrizes();
+        LadderHeight height = inputView.askHeight();
+        LadderWidth width = new LadderWidth(players.size());
+        LadderGame ladderGame = new LadderGame(players, prizes, new Ladder(height, width));
+        outputView.printLadderGameBoard(ladderGame);
+        GameResult gameResult = ladderGame.play();
+        String query = inputView.askResultName();
+        if (query.equals("all")) {
+            outputView.printResultAll(gameResult);
+            return;
+        }
+        outputView.printResultSingle(gameResult.getResultByPlayerName(query).getPrize());
+    }
+}

src/main/java/domain/Bridge.java

@@ -0,0 +1,20 @@
+package domain;
+
+public enum Bridge {
+    CONNECTED,
+    NOT_CONNECTED;
+
+    public String display() {
+        if (this == CONNECTED) {
+            return "-----";
+        }
+        return "     ";
+    }
+
+    public static Bridge fromBoolean(boolean connected) {
+        if (connected) {
+            return CONNECTED;
+        }
+        return NOT_CONNECTED;
+    }
+}

src/main/java/domain/GameResult.java

@@ -0,0 +1,24 @@
+package domain;
+
+import java.util.List;
+
+public class GameResult {
+    private final List<Result> results;
+
+    public GameResult(List<Result> results) {
+        this.results = results;
+    }
+
+    public List<Result> getResults() {
+        return results;
+    }
+
+    public Result getResultByPlayerName(String name) {
+        for (Result result : results) {
+            if (result.getPlayerName().equals(name)) {
+                return result;
+            }
+        }
+        throw new IllegalArgumentException("해당 이름이 없습니다.");
+    }
+}

src/main/java/domain/Ladder.java

@@ -0,0 +1,36 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Ladder {
+    private final Lines lines;
+
+    public Ladder(LadderHeight height, LadderWidth width) {
+        this.lines = new Lines(createLines(height, width));
+    }
+
+    private List<Line> createLines(LadderHeight height, LadderWidth width) {
+        List<Line> list = new ArrayList<>();
+        Line previousLine = null;
+        for (int i = 0; i < height.getValue(); i++) {
+            Line current = new Line(width, previousLine);
+            list.add(current);
+            previousLine = current;
+        }
+        return list;
+    }
+
+    public List<String> getLadderBody() {
+        return lines.drawAll();
+    }
+
+    public LadderResult play() {
+        int columnCount = lines.getColumnCount();
+        List<Position> positions = new ArrayList<>();
+        for (int i = 0; i < columnCount; i++) {
+            positions.add(lines.moveAll(new Position(i)));
+        }
+        return new LadderResult(positions);
+    }
+}

src/main/java/domain/LadderGame.java

@@ -0,0 +1,43 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LadderGame {
+    private final Players players;
+    private final Prizes prizes;
+    private final Ladder ladder;
+
+    public LadderGame(Players players, Prizes prizes, Ladder ladder) {
+        if (players.size() != prizes.getPrizes().size()) {
+            throw new IllegalArgumentException("참여자 수와 결과 수가 일치해야 합니다.");
+        }
+        this.players = players;
+        this.prizes = prizes;
+        this.ladder = ladder;
+    }
+
+    public GameResult play() {
+        LadderResult ladderResult = ladder.play();
+        List<Result> results = new ArrayList<>();
+        for (int i = 0; i < players.size(); i++) {
+            int finalIndex = ladderResult.getPositions().get(i).getValue();
+            String playerName = players.getPlayers().get(i).getName().getValue();
+            String prize = prizes.getPrizeAt(finalIndex).getValue();
+            results.add(new Result(playerName, prize));
+        }
+        return new GameResult(results);
+    }
+
+    public Ladder getLadder() {
+        return ladder;
+    }
+
+    public Players getPlayers() {
+        return players;
+    }
+
+    public Prizes getPrizes() {
+        return prizes;
+    }
+}

src/main/java/domain/LadderHeight.java

@@ -0,0 +1,16 @@
+package domain;
+
+public class LadderHeight {
+    private final int value;
+
+    public LadderHeight(int value) {
+        if (value < 1) {
+            throw new IllegalArgumentException("사다리의 높이는 1 이상이어야 합니다.");
+        }
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/domain/LadderResult.java

@@ -0,0 +1,15 @@
+package domain;
+
+import java.util.List;
+
+public class LadderResult {
+    private final List<Position> positions;
+
+    public LadderResult(List<Position> positions) {
+        this.positions = positions;
+    }
+
+    public List<Position> getPositions() {
+        return positions;
+    }
+}

src/main/java/domain/LadderWidth.java

@@ -0,0 +1,16 @@
+package domain;
+
+public class LadderWidth {
+    private final int value;
+
+    public LadderWidth(int value) {
+        if (value < 2) {
+            throw new IllegalArgumentException("사다리의 넓이는 2 이상이어야 합니다.");
+        }
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/domain/Line.java

@@ -0,0 +1,74 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class Line {
+    private final List<Bridge> bridges;
+
+    public Line(LadderWidth ladderWidth, Line previousLine) {
+        this.bridges = createBridges(ladderWidth, previousLine);
+    }
+
+    private List<Bridge> createBridges(LadderWidth ladderWidth, Line previousLine) {
+        List<Bridge> list = new ArrayList<>();
+        Random random = new Random();
+        boolean previousConnected = false;
+        List<Bridge> previousBridges = null;
+        if (previousLine != null) {
+            previousBridges = previousLine.getBridges();
+        }
+        for (int i = 0; i < ladderWidth.getValue() - 1; i++) {
+            boolean connected = determineConnection(previousConnected, random, previousBridges, i);
+            list.add(Bridge.fromBoolean(connected));
+            previousConnected = connected;
+        }
+        return list;
+    }
+
+    private boolean determineConnection(boolean previousConnected, Random random,
+                                        List<Bridge> previousBridges, int index) {
+        if (previousConnected) {
+            return false;
+        }
+        if (previousBridges != null && previousBridges.get(index) == Bridge.CONNECTED) {
+            return false;
+        }
+        return random.nextBoolean();
+    }
+
+    public List<Bridge> getBridges() {
+        return bridges;
+    }
+
+    public String draw() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("|");
+        for (Bridge bridge : bridges) {
+            builder.append(bridge.display());
+            builder.append("|");
+        }
+        return builder.toString();
+    }
+
+    public Position move(Position position) {
+        int current = position.getValue();
+        if (canMoveLeft(current)) {
+            return new Position(current - 1);
+        }
+        if (canMoveRight(current)) {
+            return new Position(current + 1);
+        }
+        return position;
+    }
+
+    private boolean canMoveLeft(int current) {
+        return current > 0 && bridges.get(current - 1) == Bridge.CONNECTED;
+    }
+
+    private boolean canMoveRight(int current) {
+        int columnCount = bridges.size() + 1;
+        return current < columnCount - 1 && bridges.get(current) == Bridge.CONNECTED;
+    }
+}

src/main/java/domain/Lines.java

@@ -0,0 +1,39 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Lines {
+    private final List<Line> lines;
+
+    public Lines(List<Line> lines) {
+        this.lines = lines;
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+
+    public List<String> drawAll() {
+        List<String> drawn = new ArrayList<>();
+        for (Line line : lines) {
+            drawn.add(line.draw());
+        }
+        return drawn;
+    }
+
+    public Position moveAll(Position position) {
+        Position result = position;
+        for (Line line : lines) {
+            result = line.move(result);
+        }
+        return result;
+    }
+
+    public int getColumnCount() {
+        if (lines.isEmpty()) {
+            return 0;
+        }
+        return lines.get(0).getBridges().size() + 1;
+    }
+}

src/main/java/domain/Name.java

@@ -0,0 +1,16 @@
+package domain;
+
+public class Name {
+    private final String value;
+
+    public Name(String value) {
+        if (value.length() > 5) {
+            throw new IllegalArgumentException("이름은 최대 5글자여야 합니다.");
+        }
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/domain/Player.java

@@ -0,0 +1,13 @@
+package domain;
+
+public class Player {
+    private final Name name;
+
+    public Player(Name name) {
+        this.name = name;
+    }
+
+    public Name getName() {
+        return name;
+    }
+}

src/main/java/domain/Players.java

@@ -0,0 +1,19 @@
+package domain;
+
+import java.util.List;
+
+public class Players {
+    private final List<Player> players;
+
+    public Players(List<Player> players) {
+        this.players = players;
+    }
+
+    public List<Player> getPlayers() {
+        return players;
+    }
+
+    public int size() {
+        return players.size();
+    }
+}

src/main/java/domain/Position.java

@@ -0,0 +1,24 @@
+package domain;
+
+public class Position {
+    private final int value;
+
+    public Position(int value) {
+        if (value < 0) {
+            throw new IllegalArgumentException("Position은 음수일 수 없습니다.");
+        }
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public Position moveLeft() {
+        return new Position(value - 1);
+    }
+
+    public Position moveRight() {
+        return new Position(value + 1);
+    }
+}