Step2 - 볼링 점수판(그리기)

src/main/java/bowling/App.java

@@ -0,0 +1,22 @@
+package bowling;
+
+import bowling.domain.Hit;
+import bowling.domain.Name;
+import bowling.domain.Round;
+import bowling.view.InputView;
+import bowling.view.ResultView;
+
+public class App {
+
+    public static void main(String[] args) {
+        Name name = InputView.inputName();
+
+        Round round = new Round();
+        ResultView.printRound(name, round);
+        while (!round.isEnd()) {
+            Hit hit = InputView.inputPins(round.getCurrentFrameNumber());
+            round.hit(hit);
+            ResultView.printRound(name, round);
+        }
+    }
+}

src/main/java/bowling/domain/Frame.java

@@ -0,0 +1,16 @@
+package bowling.domain;
+
+public interface Frame {
+
+    void play(Hit hit);
+
+    FrameStatus getFirstStatus();
+    FrameStatus getSecondStatus();
+    FrameStatus getThirdStatus();
+
+    Hit getFirstHit();
+    Hit getSecondHit();
+    Hit getThirdHit();
+
+    boolean isEnd();
+}

src/main/java/bowling/domain/FrameStatus.java

@@ -0,0 +1,11 @@
+package bowling.domain;
+
+public enum FrameStatus {
+    BEFORE,
+    PLAYING,
+    SKIP,
+    STRIKE,
+    SPARE,
+    MISS,
+    GUTTER;
+}

src/main/java/bowling/domain/Hit.java

@@ -0,0 +1,43 @@
+package bowling.domain;
+
+public class Hit {
+    public static final int MIN = 0;
+    public static final int MAX = 10;
+    private final int hit;
+
+
+    public Hit(int hit) {
+        validate(hit);
+        this.hit = hit;
+    }
+
+    private void validate(int hit) {
+        if (hit < MIN || hit > MAX) {
+            throw new IllegalArgumentException("범위를 벗어나는 점수가 입력되었습니다.");
+        }
+    }
+
+    public Hit plus(Hit target) {
+        return new Hit(hit + target.hit);
+    }
+
+    public boolean isMin() {
+        return hit == MIN;
+    }
+
+    public boolean isMax() {
+        return hit == MAX;
+    }
+
+    public int getScore() {
+        return hit;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Hit)) {
+            return false;
+        }
+        return hit == ((Hit) obj).hit;
+    }
+}

src/main/java/bowling/domain/LastFrame.java

@@ -0,0 +1,122 @@
+package bowling.domain;
+
+public class LastFrame implements Frame {
+    private Hit first;
+    private Hit second;
+    private Hit third;
+
+    @Override
+    public void play(Hit hit) {
+        if (getFirstStatus() == FrameStatus.BEFORE) {
+            firstThrow(hit);
+            return;
+        }
+        if (getSecondStatus() == FrameStatus.BEFORE) {
+            secondThrow(hit);
+            return;
+        }
+        thirdThrow(hit);
+    }
+
+    private void firstThrow(Hit hit) {
+        this.first = hit;
+    }
+
+    private void secondThrow(Hit hit) {
+        this.second = hit;
+    }
+
+    private void thirdThrow(Hit hit) {
+        this.third = hit;
+    }
+
+    @Override
+    public FrameStatus getFirstStatus() {
+        return getNormalStatus(first);
+    }
+
+    @Override
+    public FrameStatus getSecondStatus() {
+        if (first == null || second == null) {
+            return FrameStatus.BEFORE;
+        }
+        if (first.isMax()) {
+            return getNormalStatus(second);
+        }
+        Hit sum = first.plus(second);
+        if (sum.isMax()) {
+            return FrameStatus.SPARE;
+        }
+        if (second.isMin()) {
+            return FrameStatus.GUTTER;
+        }
+        return FrameStatus.MISS;
+    }
+
+    @Override
+    public FrameStatus getThirdStatus() {
+        if (first == null || second == null || third == null) {
+            return FrameStatus.BEFORE;
+        }
+        if (!canPlayThird()) {
+            return FrameStatus.SKIP;
+        }
+        if (third.isMax()) {
+            return FrameStatus.STRIKE;
+        }
+        if (third.isMin()) {
+            return FrameStatus.GUTTER;
+        }
+        if (second.isMax()) {
+            return FrameStatus.MISS;
+        }
+        Hit sum = second.plus(third);
+        if (sum.isMax()) {
+            return FrameStatus.SPARE;
+        }
+        return FrameStatus.MISS;
+    }
+
+    private FrameStatus getNormalStatus(Hit hit) {
+        if (hit == null) {
+            return FrameStatus.BEFORE;
+        }
+        if (hit.isMax()) {
+            return FrameStatus.STRIKE;
+        }
+        if (hit.isMin()) {
+            return FrameStatus.GUTTER;
+        }
+        return FrameStatus.MISS;
+    }
+
+    @Override
+    public Hit getFirstHit() {
+        return first;
+    }
+
+    @Override
+    public Hit getSecondHit() {
+        return second;
+    }
+
+    @Override
+    public Hit getThirdHit() {
+        return third;
+    }
+
+    @Override
+    public boolean isEnd() {
+        if (first == null || second == null) {
+            return false;
+        }
+        if (third != null) {
+            return true;
+        }
+        return !canPlayThird();
+    }
+
+    private boolean canPlayThird() {
+        return getFirstStatus() == FrameStatus.STRIKE || getSecondStatus() == FrameStatus.SPARE;
+    }
+}

src/main/java/bowling/domain/Name.java

@@ -0,0 +1,21 @@
+package bowling.domain;
+
+public class Name {
+    private final String name;
+
+
+    public Name(String name) {
+        validate(name);
+        this.name = name;
+    }
+
+    private void validate(String name) {
+        if (name.length() != 3) {
+            throw new IllegalArgumentException("이름은 3글자로 입력되어야 합니다");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/bowling/domain/NormalFrame.java

@@ -0,0 +1,83 @@
+package bowling.domain;
+
+public class NormalFrame implements Frame {
+    private Hit first;
+    private Hit second;
+
+    @Override
+    public void play(Hit hit) {
+        if (getFirstStatus() == FrameStatus.BEFORE) {
+            firstThrow(hit);
+            return;
+        }
+        secondThrow(hit);
+    }
+
+    private void firstThrow(Hit hit) {
+        this.first = hit;
+        if (hit.isMax()) {
+            second = new Hit(0);
+        }
+    }
+
+    private void secondThrow(Hit hit) {
+        this.second = hit;
+    }
+
+    @Override
+    public FrameStatus getFirstStatus() {
+        if (first == null) {
+            return FrameStatus.BEFORE;
+        }
+        if (first.isMax()) {
+            return FrameStatus.STRIKE;
+        }
+        if (first.isMin()) {
+            return FrameStatus.GUTTER;
+        }
+        return FrameStatus.MISS;
+    }
+
+    @Override
+    public FrameStatus getSecondStatus() {
+        if (first == null || second == null) {
+            return FrameStatus.BEFORE;
+        }
+        if (first.isMax()) {
+            return FrameStatus.SKIP;
+        }
+        Hit sum = first.plus(second);
+        if (sum.isMax()) {
+            return FrameStatus.SPARE;
+        }
+        if (second.isMin()) {
+            return FrameStatus.GUTTER;
+        }
+        return FrameStatus.MISS;
+    }
+
+    @Override
+    public FrameStatus getThirdStatus() {
+        return FrameStatus.SKIP;
+    }
+
+    @Override
+    public Hit getFirstHit() {
+        return first;
+    }
+
+    @Override
+    public Hit getSecondHit() {
+        return second;
+    }
+
+    @Override
+    public Hit getThirdHit() {
+        return new Hit(0);
+    }
+
+    @Override
+    public boolean isEnd() {
+        return first != null && second != null;
+    }
+}

src/main/java/bowling/domain/Round.java

@@ -0,0 +1,50 @@
+package bowling.domain;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Round {
+    private static final int ROUND_COUNT = 10;
+    private final List<Frame> frames;
+
+    public Round() {
+        frames = IntStream.range(0, ROUND_COUNT - 1)
+                .mapToObj(i -> new NormalFrame())
+                .collect(Collectors.toList());
+        frames.add(new LastFrame());
+    }
+
+    public void hit(Hit hit) {
+        Frame last = getLastPlayingFrame()
+                .orElseThrow(() -> new IllegalStateException("모든 프레임이 종료되었습니다."));
+        last.play(hit);
+    }
+
+    public boolean isEnd() {
+        Optional<Frame> last = getLastPlayingFrame();
+        return last.isEmpty();
+    }
+
+    public int getCurrentFrameNumber() {
+        Optional<Frame> last = getLastPlayingFrame();
+        if (last.isEmpty()) {
+            return ROUND_COUNT;
+        }
+        Frame currentFrame = last.get();
+        return frames.indexOf(currentFrame) + 1;
+
+    }
+
+    private Optional<Frame> getLastPlayingFrame() {
+        return frames.stream()
+                .filter(frame -> !frame.isEnd())
+                .findFirst();
+    }
+
+    public void forEach(Consumer<Frame> consumer) {
+        frames.forEach(consumer);
+    }
+}

src/main/java/bowling/view/InputView.java

@@ -0,0 +1,23 @@
+package bowling.view;
+
+import bowling.domain.Name;
+import bowling.domain.Hit;
+
+import java.util.Scanner;
+
+public class InputView {
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public static Name inputName() {
+        System.out.print("플레이어 이름은 (3 english letters)?: ");
+
+        String name = scanner.nextLine();
+        return new Name(name);
+    }
+
+    public static Hit inputPins(int frame) {
+        System.out.printf("%d프레임 투구: ", frame);
+
+        return new Hit(scanner.nextInt());
+    }
+}