[사다리 미션] 황승준 미션 제출입니다.

README.md

@@ -1,3 +1,43 @@
-- [x] 연결 여부는 랜덤으로 결정한다.
-- [x] 사다리는 라인이 겹치지 않아야 한다.
+# java-ladder
+
+자바 사다리 미션 저장소
+
+## 개요
+
+참여자와 상품을 입력 받아 랜덤 사다리를 만들어 참여자와 상품을 연결시켜주는 게임이다.
+
+## 요구사항
+
+### 사람(Person)
+
 - [x] 사람의 이름은 1자 이상 5자 이하여야 한다.
+
+### 참여자(Participant)
+
+- [x] 참여자들은 사다리에서 자신의 위치를 갖고 있다.
+- [X] 참여자들은 정해진 라인을 따라 이동한다.
+
+### 참여자들(Participants)
+
+- [x] 참여자들의 이름은 중복이 될 수 없다.
+- [x] 각 라인의 출발점에는 하나의 사람만 있을 수 있다.
+
+### 상품(Prize)
+
+- [x] 상품은 금액으로 이루어져 있다.
+- [x] 상품의 금액이 값을 표현한다.(vo를 표현할 수 있는 말이 무엇이 있을까?)
+
+### 라인(RowLine)
+
+- [x] 라인들의 각 지점은 오른쪽, 왼쪽, 아래쪽 방향성 중 하나만을 가질 수 있다.
+- [x] 라인이 연결성은 겹치지 않아야 한다.
+- [x] 라인의 연결 여부는 랜덤으로 결정한다.
+
+### 사다리(Ladder)
+
+- [x] 여러개의 Line이 모여 하나의 사다리를 만든다.
+
+### 사다리 게임(LadderGame)
+
+- [x] 참여자들을 라인 따라 이동해 상품과 최종적으로 연결을 맺는다.
+- [x] 게임이 완료되어야 최종 게임 결과를 확인할 수 있다.

src/main/java/LadderGame.java → src/main/java/LadderGameApplication.java

@@ -1,7 +1,7 @@
 import view.InputView;
 import view.OutputView;
 
-public class LadderGame {
+public class LadderGameApplication {
     public static void main(String[] args) {
         LadderGameController ladderGameController = new LadderGameController(
                 new InputView(),

src/main/java/LadderGameController.java

@@ -15,22 +15,29 @@ public LadderGameController(InputView inputView, OutputView outputView) {
     }
 
     public void ladderGame() {
-        List<Person> participants = readParticipants();
+        List<Person> people = readParticipants();
         List<Prize> prizes = readPrizes();
 
-        checkPrizeCountValidation(participants.size(), prizes.size());
+        validateInputsCount(people.size(), prizes.size());
 
         int height = readLadderHeight();
+        int width = people.size();
 
-        Ladder ladder = new Ladder(height, participants.size(), new RandomLadderGeneratorImpl());
+        LadderFactory ladderGenerator = new RandomLadderFactory(height, width);
+        Ladder ladder = ladderGenerator.newInstance();
 
-        outputView.printResult(participants, ladder, prizes);
+        Participants participants = Participants.fromPeople(people);
+        LadderGame ladderGame = new LadderGame(participants, ladder, prizes);
 
-        Statistic statistic = new Statistic(ladder, participants, prizes);
+        outputView.printResult(ladderGame.getParticipants(), ladderGame.getLadder(), ladderGame.getPrizes());
 
-        printSpecificParticipantResult(statistic, participants);
+        ladderGame.start();
 
-        outputView.printParticipantsPrizesResult(statistic.getParticipantPrize(), participants);
+        GameResult gameResult = ladderGame.getParticipantsPrizes();
+
+        printSpecificParticipantResult(ladderGame.getParticipants(), gameResult);
+
+        outputView.printParticipantsPrizesResult(ladderGame.getParticipants(), gameResult);
     }
 
     private List<Person> readParticipants() {
@@ -65,29 +72,23 @@ private String readParticipantName() {
         return name;
     }
 
-    private void printSpecificParticipantResult(Statistic statistic, List<Person> participants) {
-        while(true) {
+    private void printSpecificParticipantResult(Participants participants, GameResult gameResult) {
+        while (true) {
             String name = readParticipantName();
 
             if (name.equals("all")) {
                 break;
             }
 
             Person person = new Person(name);
-            checkParticipantValidation(participants, person);
-            outputView.printParticipantPrizeResult(statistic.getParticipantPrize(person));
+            Participant participant = participants.getParticipantByName(person);
+            outputView.printParticipantPrizeResult(gameResult.getPrize(participant));
         }
     }
 
-    private void checkPrizeCountValidation(int participantCount, int prizeCount) {
+    private void validateInputsCount(int participantCount, int prizeCount) {
         if (participantCount != prizeCount) {
             throw new IllegalArgumentException("The number of participants does not match the number of prizes.");
         }
     }
-
-    private void checkParticipantValidation(List<Person> participants, Person person) {
-        if (!participants.contains(person)) {
-            throw new IllegalArgumentException("참여자가 아닙니다.");
-        }
-    }
 }

src/main/java/domain/Direction.java

@@ -1,5 +1,11 @@
 package domain;
 
 public enum Direction {
-    LEFT, RIGHT, DOWN
+    LEFT(-1), RIGHT(1), DOWN(0);
+
+    final int offset;
+
+    Direction(int offset) {
+        this.offset = offset;
+    }
 }

src/main/java/domain/GameResult.java

@@ -0,0 +1,15 @@
+package domain;
+
+import java.util.Map;
+
+public class GameResult {
+    private final Map<Participant, Prize> gameResult;
+
+    public GameResult(Map<Participant, Prize> gameResult) {
+        this.gameResult = gameResult;
+    }
+
+    public Prize getPrize(Participant participant) {
+        return gameResult.get(participant);
+    }
+}

src/main/java/domain/GameState.java

@@ -0,0 +1,7 @@
+package domain;
+
+public enum GameState {
+    READY,
+    PROGRESS,
+    FINISH,
+}

src/main/java/domain/Ladder.java

@@ -3,70 +3,13 @@
 import java.util.List;
 
 public class Ladder {
-    private final List<Line> lines;
-    private final int ladderWidth;
-    private final int lineHeight;
-    private final RandomLadderGenerator randomLadderGenerator;
+    private final List<RowLine> columnLines;
 
-
-    public Ladder(int lineHeight, int ladderWidth, RandomLadderGenerator randomLadderGenerator) {
-        this.randomLadderGenerator = randomLadderGenerator;
-        this.ladderWidth = ladderWidth;
-        this.lineHeight = lineHeight;
-
-        List<Line> lines = this.randomLadderGenerator.generateLadder(lineHeight, ladderWidth);
-        checkLadderValidation(lines);
-        this.lines = lines;
-    }
-
-    public List<Line> getLines() {
-        return lines;
-    }
-
-    public int getLadderWidth() {
-        return ladderWidth;
-    }
-
-    public int getLineHeight() {
-        return lineHeight;
-    }
-
-    private void checkLadderValidation(List<Line> lines) {
-        for (int i = 0; i < lineHeight; i++) {
-            checkRowValidation(i, lines);
-        }
-    }
-
-    private void checkRowValidation(int columnIndex, List<Line> lines) {
-        List<Direction> rowDirections = lines.stream()
-                .map(l -> l.getPoints().get(columnIndex))
-                .toList();
-
-        int rowSize = rowDirections.size();
-        int rightCount = 0;
-
-        for (int i = 0; i < rowSize; i++) {
-            if (rowDirections.get(i) == Direction.RIGHT) {
-                checkRightValidation(i, rowSize, rowDirections);
-                rightCount++;
-            }
-
-            if (rowDirections.get(i) == Direction.LEFT) {
-                checkLeftValidation(rightCount);
-                rightCount--;
-            }
-        }
-    }
-
-    private void checkRightValidation(int columnIndex, int rowSize, List<Direction> rowDirections) {
-        if (columnIndex == rowSize - 1 || rowDirections.get(columnIndex + 1) != Direction.LEFT) {
-            throw new RuntimeException("사다리가 잘못 만들어졌습니다.");
-        }
+    public Ladder(List<RowLine> columnLines) {
+        this.columnLines = columnLines;
     }
 
-    private void checkLeftValidation(int rightCount) {
-        if (rightCount == 0) {
-            throw new RuntimeException("사다리가 잘못 만들어졌습니다.");
-        }
+    public List<RowLine> getLines() {
+        return columnLines;
     }
 }

src/main/java/domain/LadderFactory.java

@@ -0,0 +1,5 @@
+package domain;
+
+public interface LadderFactory {
+    Ladder newInstance();
+}

src/main/java/domain/LadderGame.java

@@ -0,0 +1,84 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LadderGame {
+    private final Participants participants;
+    private final Ladder ladder;
+    private final List<Prize> prizes;
+    private GameState gameState;
+    private Map<Integer, List<Integer>> result;
+
+    public LadderGame(Participants participants, Ladder ladder, List<Prize> prizes) {
+        this.participants = participants;
+        this.ladder = ladder;
+        this.prizes = prizes;
+        this.gameState = GameState.READY;
+    }
+
+    public void start() {
+        gameState = GameState.PROGRESS;
+
+        Map<Integer, List<Integer>> gameResult = new HashMap<>();
+
+        int participantsCount = participants.getParticipantsCount();
+
+        for (int i = 0; i < participantsCount; i++) {
+            Participant participant = participants.getParticipantByIndex(i);
+            Integer startPosition = participant.getPosition();
+            List<Integer> participantPositions = moveParticipant(participant);
+            gameResult.put(startPosition, participantPositions);
+        }
+
+        result = gameResult;
+
+        gameState = GameState.FINISH;
+    }
+
+    private List<Integer> moveParticipant(Participant participant) {
+        List<Integer> participantPositions = new ArrayList<>();
+
+        for (RowLine rowLine : ladder.getLines()) {
+            int currentPosition = participant.getPosition();
+            Direction direction = rowLine.getPositionDirection(currentPosition);
+
+            participant.move(direction);
+
+            participantPositions.add(participant.getPosition());
+        }
+
+        return participantPositions;
+    }
+
+    public GameResult getParticipantsPrizes() {
+        if (gameState != GameState.FINISH) {
+            throw new RuntimeException("게임이 진행중입니다!");
+        }
+
+        Map<Participant, Prize> participantsPrizes = new HashMap<>();
+
+        for (Integer startPosition : result.keySet()) {
+            List<Integer> positions = result.get(startPosition);
+            Integer lastPosition = positions.get(positions.size() - 1);
+
+            participantsPrizes.put(participants.getParticipantByIndex(startPosition), prizes.get(lastPosition));
+        }
+
+        return new GameResult(participantsPrizes);
+    }
+
+    public Participants getParticipants() {
+        return participants;
+    }
+
+    public Ladder getLadder() {
+        return ladder;
+    }
+
+    public List<Prize> getPrizes() {
+        return prizes;
+    }
+}

src/main/java/domain/Participant.java

@@ -0,0 +1,38 @@
+package domain;
+
+import java.util.Objects;
+
+public class Participant {
+    private final Person person;
+    private int position;
+
+    public Participant(Person person, int position) {
+        this.person = person;
+        this.position = position;
+    }
+
+    public void move(Direction direction) {
+        position = position + direction.offset;
+    }
+
+    public String getParticipantName() {
+        return person.name();
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Participant that = (Participant) o;
+        return Objects.equals(person.name(), that.person.name());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(person.name());
+    }
+}