javajigi · Apr 9, 2018 · Apr 5, 2018 · Apr 5, 2018 · Apr 5, 2018 · Apr 5, 2018
diff --git a/src/main/java/BowlingMain.java b/src/main/java/BowlingMain.java
@@ -0,0 +1,25 @@
+import domain.Player;
+import view.InputView;
+import view.OutputView;
+
+import static view.InputView.getScore;
+
+public class BowlingMain {
+
+    public static void main(String[] args) {
+        Player player = InputView.getPlayer();
+        while (!player.isFinish()) {
+            doGame(player);
+        }
+    }
+
+    private static void doGame(Player player) {
+        try {
+            player.recordScore(getScore(player.getCurrentFrameNum()));
+            OutputView.printResult(player);
+        } catch (IllegalArgumentException e) {
+            InputView.printMessage(e.getMessage());
+            doGame(player);
+        }
+    }
+}
diff --git a/src/main/java/domain/Player.java b/src/main/java/domain/Player.java
@@ -0,0 +1,37 @@
+package domain;
+
+import domain.frame.Frames;
+import domain.frame.result.FrameResults;
+
+public class Player {
+    private PlayerName name;
+    private Frames frames;
+    private FrameResults results;
+
+    public Player(String name) throws IllegalArgumentException {
+        this.name = new PlayerName(name);
+        frames = new Frames();
+        results = new FrameResults();
+    }
+
+    public String getName() {
+        return name.getName();
+    }
+
+    public boolean isFinish() {
+        return frames.isFinish();
+    }
+
+    public FrameResults recordScore(int score) {
+        results.addResult(frames.getCurrentFrameIdx(), frames.recordScore(score));
+        return results;
+    }
+
+    public int getCurrentFrameNum() {
+        return frames.getCurrentFrameNum();
+    }
+
+    public FrameResults getResults() {
+        return results;
+    }
+}
diff --git a/src/main/java/domain/PlayerName.java b/src/main/java/domain/PlayerName.java
@@ -0,0 +1,35 @@
+package domain;
+
+public class PlayerName {
+    public static final int LENGTH = 3;
+    private String name;
+
+    public PlayerName(String name) {
+        if (!isValidNameLength(name)) {
+            throw new IllegalArgumentException("이름은 " + LENGTH + "자로 해야함");
+        }
+
+        if (!isValidEnglishName(name)) {
+            throw new IllegalArgumentException("영어만 입력 해야함");
+        }
+        this.name = name;
+    }
+
+    public static boolean isValidNameLength(String name) {
+        return name.length() == LENGTH;
+    }
+
+    public static boolean isValidEnglishName(String name) {
+        char[] convertName = name.toCharArray();
+        for (char ch : convertName) {
+            if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public String getName() {
+        return name;
+    }
+}
diff --git a/src/main/java/domain/Score.java b/src/main/java/domain/Score.java
@@ -0,0 +1,29 @@
+package domain;
+
+import java.util.List;
+
+public class Score {
+    public static final int MIN = 0;
+    public static final int MAX = 10;
+    private int score;
+
+    public Score(int score) {
+        if (!isValidRange(score)) {
+            throw new IllegalArgumentException("유효하지않은 범위의 점수입니다");
+        }
+        this.score = score;
+    }
+
+    public static boolean isValidRange(int score) {
+        return score >= MIN && score <= MAX;
+    }
+
+    public static boolean isScoreLimit(List<Score> scores) {
+        return scores.stream().mapToInt(scoreInstance -> scoreInstance.score).sum() == MAX;
+    }
+
+    public boolean isOverRecord(List<Score> scores) {
+        int existingSum = scores.stream().mapToInt(scoreInstance -> scoreInstance.score).sum();
+        return existingSum + this.score > MAX;
+    }
+}
diff --git a/src/main/java/domain/Scores.java b/src/main/java/domain/Scores.java
@@ -0,0 +1,30 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Scores {
+    private static final int LIMIT_NUM = 2;
+    private List<Score> scores = new ArrayList<>();
+
+    public Score addScore(int number) throws IllegalArgumentException {
+        Score newScore = new Score(number);
+        if (scores.size() != 0 && newScore.isOverRecord(scores)) {
+            throw new IllegalArgumentException("합산 : " + Score.MAX + "점을 넘을 수 없습니다");
+        }
+        scores.add(newScore);
+        return newScore;
+    }
+
+    public boolean isFinish() {
+        return isLimitSize() || isScoreLimit();
+    }
+
+    public boolean isScoreLimit() {
+        return Score.isScoreLimit(scores);
+    }
+
+    public boolean isLimitSize() {
+        return scores.size() == LIMIT_NUM;
+    }
+}
diff --git a/src/main/java/domain/frame/Frame.java b/src/main/java/domain/frame/Frame.java
@@ -0,0 +1,10 @@
+package domain.frame;
+
+public interface Frame {
+
+    String addScore(int score) throws IllegalArgumentException;
+
+    boolean isFinish();
+
+    String convertScore(int score);
+}
diff --git a/src/main/java/domain/frame/Frames.java b/src/main/java/domain/frame/Frames.java
@@ -0,0 +1,52 @@
+package domain.frame;
+
+import utils.FrameFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Frames {
+    public static final int LIMIT_NUM = 10;
+    private List<Frame> frames;
+    private int nextFrameIdx;
+
+    public Frames() {
+        frames = new ArrayList<>();
+        nextFrameIdx = 0;
+    }
+
+    public String recordScore(int score) {
+        Frame currentFrame = getCurrentFrame();
+        String convertedScore = currentFrame.addScore(score);
+        if (currentFrame.isFinish()) {
+            nextFrameIdx++;
+        }
+        return convertedScore;
+    }
+
+    public Frame getCurrentFrame() {
+        try {
+            return frames.get(nextFrameIdx);
+        } catch (IndexOutOfBoundsException e) {
+            int frameNum = nextFrameIdx + 1;
+            frames.add(FrameFactory.of(frameNum));
+            return frames.get(nextFrameIdx);
+        }
+    }
+
+    public int getCurrentFrameIdx() {
+        return nextFrameIdx;
+    }
+
+    public int getCurrentFrameNum() {
+        return nextFrameIdx + 1;
+    }
+
+    public boolean isFinish() {
+        return frames.size() == LIMIT_NUM && frames.stream().allMatch(Frame::isFinish);
+    }
+
+    public static boolean isLast(int frameNum) {
+        return frameNum == LIMIT_NUM;
+    }
+}
diff --git a/src/main/java/domain/frame/LastFrame.java b/src/main/java/domain/frame/LastFrame.java
@@ -0,0 +1,48 @@
+package domain.frame;
+
+import domain.Score;
+import domain.Scores;
+import domain.frame.result.ScoreMessage;
+import domain.frame.status.FrameStatus;
+
+public class LastFrame implements Frame {
+    private FrameStatus status;
+    private Scores scores;
+    private Score bonusScore;
+
+    public LastFrame() {
+        scores = new Scores();
+        status = FrameStatus.getInitStatus();
+    }
+
+    @Override
+    public String addScore(int score) throws IllegalArgumentException {
+        if (status.isBonus()) {
+            bonusScore = new Score(score);
+            return convertScore(score);
+        }
+        scores.addScore(score);
+        status = status.changeStatus(scores);
+        return convertScore(score);
+    }
+
+    @Override
+    public String convertScore(int score) {
+        if (scores.isFinish()) {
+            return ScoreMessage.convertMessage(score);
+        }
+        return status.convertScore(score);
+    }
+
+    @Override
+    public boolean isFinish() {
+        if (!status.isFinish()) {
+            return false;
+        }
+
+        if (!status.isBonus()) {
+            return true;
+        }
+        return bonusScore != null;
+    }
+}
diff --git a/src/main/java/domain/frame/NormalFrame.java b/src/main/java/domain/frame/NormalFrame.java
@@ -0,0 +1,31 @@
+package domain.frame;
+
+import domain.Scores;
+import domain.frame.status.FrameStatus;
+
+public class NormalFrame implements Frame {
+    private FrameStatus status;
+    private Scores scores;
+
+    public NormalFrame() {
+        scores = new Scores();
+        status = FrameStatus.getInitStatus();
+    }
+
+    @Override
+    public String addScore(int score) throws IllegalArgumentException {
+        scores.addScore(score);
+        status = status.changeStatus(scores);
+        return convertScore(score);
+    }
+
+    @Override
+    public String convertScore(int score) {
+        return status.convertScore(score);
+    }
+
+    @Override
+    public boolean isFinish() {
+        return status.isFinish();
+    }
+}
diff --git a/src/main/java/domain/frame/result/FrameResult.java b/src/main/java/domain/frame/result/FrameResult.java
@@ -0,0 +1,19 @@
+package domain.frame.result;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.stream.Collectors.joining;
+
+public class FrameResult {
+    private List<String> results = new ArrayList<>();
+
+    public void add(String resultMessage) {
+        results.add(resultMessage);
+    }
+
+    @Override
+    public String toString() {
+        return results.stream().collect(joining("|"));
+    }
+}
diff --git a/src/main/java/domain/frame/result/FrameResults.java b/src/main/java/domain/frame/result/FrameResults.java
@@ -0,0 +1,44 @@
+package domain.frame.result;
+
+import domain.frame.Frames;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FrameResults {
+    private List<FrameResult> results = new ArrayList<>();
+
+    public void addResult(int frameIdx, String convertedScore) {
+        if (!isExistFrameResult(frameIdx)) {
+            results.add(new FrameResult());
+        }
+        FrameResult result = results.get(frameIdx);
+        result.add(convertedScore);
+    }
+
+    public boolean isExistFrameResult(int frameIdx) {
+        try {
+            results.get(frameIdx);
+            return true;
+        } catch (IndexOutOfBoundsException e) {
+            return false;
+        }
+    }
+
+    public int getSavedSize() {
+        return results.size();
+    }
+
+    public int getMaxSaveSize() {
+        return Frames.LIMIT_NUM;
+    }
+
+    public String getFrameResultMessage(int frameIdx) {
+        try {
+            FrameResult frameResult = results.get(frameIdx);
+            return frameResult.toString();
+        } catch (IndexOutOfBoundsException e) {
+            return null;
+        }
+    }
+}