Step3 볼링점수판

src/main/java/bowling/App.java

@@ -17,7 +17,7 @@ public static void main(String[] args) {
             frameNumber = bowlingGame.pitchingBall(count);
 
             Frames frames = bowlingGame.getFrames();
-            OutputView.printScoreScreen(username, frames);
+            OutputView.printScoreScreen(username, frames, bowlingGame);
         }
     }
 }

src/main/java/bowling/BowlingGame.java

@@ -11,14 +11,15 @@ public BowlingGame() {
     }
 
     public FrameNumber pitchingBall(int hitCount) {
-        if (frameNumber.isSameNumber(FRAME_SIZE)) {
-            return frames.pitchingLast(frameNumber, hitCount);
-        }
         this.frameNumber = frames.pitching(frameNumber, hitCount);
         return this.frameNumber;
     }
 
     public Frames getFrames() {
         return frames;
     }
+
+    public FrameNumber getFrameNumber() {
+        return frameNumber;
+    }
 }

src/main/java/bowling/FinalFrame.java

@@ -0,0 +1,22 @@
+package bowling;
+
+public class FinalFrame extends Frame {
+
+    @Override
+    public boolean strikeCondition() {
+        return (!hitRecords.hitTimes(HIT_TWICE) || hitRecords.isRecordAllStrike()) && bowlingPin.isZero();
+    }
+
+    @Override
+    public boolean finishFrame() {
+        boolean result = hitRecords.hitTimes(HIT_TRIPLE) || failedBounsFrame();
+        if (clearAllFrame()) {
+            chargeBowlingPin();
+        }
+        return result;
+    }
+
+    private boolean failedBounsFrame() {
+        return hitRecords.hitTimes(HIT_TWICE) && !clearAllFrame();
+    }
+}

src/main/java/bowling/Frame.java

@@ -1,89 +1,64 @@
 package bowling;
 
-import java.util.ArrayList;
 import java.util.List;
 
 public class Frame {
-    private static final int HIT_ONCE = 1;
-    private static final int HIT_TWICE = 2;
-    private static final int HIT_TRIPLE = 3;
+    protected static final int HIT_TWICE = 2;
+    protected static final int HIT_TRIPLE = 3;
 
-    private BowlingPin bowlingPin;
-    private final List<HitRecord> hitRecords;
+    protected BowlingPin bowlingPin;
+    protected final HitRecords hitRecords;
 
     public Frame() {
         this.bowlingPin = new BowlingPin(BowlingPin.MAX_PIN_NUMBER);
-        hitRecords = new ArrayList<>();
+        this.hitRecords = new HitRecords();
     }
 
-    public boolean finishLastFrame() {
-        return hitThreeTimes() || hitDouble() || failedBounsFrame();
-    }
-
-    private boolean failedBounsFrame() {
-        return hitTwice() && !clearAllFrame();
-    }
-
-    public void hitBowlingPin(int count) {
+    public BowilingTerm hitBowlingPin(int count) {
         bowlingPin = bowlingPin.hitPins(new BowlingPin(count));
-        BowilingTerm bowilingTerm = BowilingTerm.MISS;
-        if ((hitRecords.isEmpty() || hitRecords.size() == HIT_TRIPLE || hitStrike()) && bowlingPin.isZero()) {
-            bowilingTerm = BowilingTerm.STRIKE;
-            hitRecords.add(new HitRecord(count, bowilingTerm));
-            return ;
+        if (hitRecords.hitOnce() && bowlingPin.isZero()) {
+            hitRecords.addSpare();
+            return BowilingTerm.SPARE;
         }
 
-        if (hitRecords.size() == HIT_ONCE && bowlingPin.isZero()) {
-            bowilingTerm = BowilingTerm.SPARE;
-            hitRecords.add(new HitRecord(count, bowilingTerm));
-            return ;
+        if (strikeCondition()) {
+            hitRecords.addStrike();
+            return BowilingTerm.STRIKE;
         }
 
-        if (count == 0) {
-            bowilingTerm = BowilingTerm.GUTTER;
-            hitRecords.add(new HitRecord(count, bowilingTerm));
-            return ;
+        if (count == BowlingPin.ZERO) {
+            hitRecords.addGutter();
+            return BowilingTerm.GUTTER;
         }
-        hitRecords.add(new HitRecord(count, bowilingTerm));
+        hitRecords.addMiss(count);
+        return BowilingTerm.MISS;
     }
 
-    private boolean hitStrike() {
-        for (HitRecord hitRecord : hitRecords) {
-            if (!hitRecord.hitAll()) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    public boolean finishFrame() {
-        return clearAllFrame() || hitTwice();
+    protected boolean strikeCondition() {
+        return bowlingPin.isZero();
     }
 
-    public boolean hitDouble() {
-        if (hitRecords.size() != HIT_TWICE) {
-            return false;
-        }
-        return hitStrike();
+    protected boolean finishFrame() {
+        return clearAllFrame() || hitRecords.hitTimes(HIT_TWICE);
     }
 
     public void chargeBowlingPin() {
         bowlingPin = new BowlingPin(BowlingPin.MAX_PIN_NUMBER);
     }
 
     public List<HitRecord> getHitRecords() {
-        return hitRecords;
+        return hitRecords.getHitRecords();
     }
 
     public boolean clearAllFrame() {
         return bowlingPin.isZero();
     }
 
-    public boolean hitThreeTimes() {
-        return hitRecords.size() == HIT_TRIPLE;
+    public void calculateBonus(int hitCount) {
+        hitRecords.calculateBonus(hitCount);
     }
 
-    public boolean hitTwice() {
-        return hitRecords.size() == HIT_TWICE;
+    public HitRecords hitRecords() {
+        return hitRecords;
     }
 }

src/main/java/bowling/Frames.java

@@ -1,39 +1,36 @@
 package bowling;
 
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.ListIterator;
 
 public class Frames {
-    private final List<Frame> frames;
+    private final LinkedList<Frame> frames;
 
     public Frames(int size) {
-        this.frames = new ArrayList<>();
-        for (int i = 0; i < size; i++) {
+        this.frames = new LinkedList<>();
+        for (int i = 0; i < size - 1; i++) {
             this.frames.add(new Frame());
         }
+        this.frames.add(new FinalFrame());
     }
 
     public FrameNumber pitching(FrameNumber frameNumber, int hitCount) {
         Frame frame = frames.get(frameNumber.retrieveIndexNumber());
-        frame.hitBowlingPin(hitCount);
-        if (frame.finishFrame()) {
-            return frameNumber.next();
+        BowilingTerm bowilingTerm = frame.hitBowlingPin(hitCount);
+
+        if (!bowilingTerm.equals(BowilingTerm.STRIKE)) {
+            ListIterator<Frame> frameListIterator = frames.listIterator(frameNumber.retrieveIndexNumber());
+            while (frameListIterator.hasPrevious()) {
+                Frame previous = frameListIterator.previous();
+                previous.calculateBonus(hitCount);
+            }
         }
-        return frameNumber;
-    }
-
 
-    public FrameNumber pitchingLast(FrameNumber frameNumber, int hitCount) {
-        Frame frame = frames.get(frameNumber.retrieveIndexNumber());
-        frame.hitBowlingPin(hitCount);
-        if (frame.finishLastFrame()) {
+        if (frame.finishFrame()) {
             return frameNumber.next();
         }
-
-        if (frame.clearAllFrame()) {
-            frame.chargeBowlingPin();
-            return frameNumber;
-        }
         return frameNumber;
     }
 

src/main/java/bowling/HitRecord.java

@@ -4,6 +4,10 @@ public class HitRecord {
     private final int hitCount;
     private final BowilingTerm bowilingTerm;
 
+    public static HitRecord of(int count, BowilingTerm bowilingTerm) {
+        return new HitRecord(count, bowilingTerm);
+    }
+
     public HitRecord(int count, BowilingTerm bowilingTerm) {
         this.hitCount = count;
         this.bowilingTerm = bowilingTerm;

src/main/java/bowling/HitRecords.java

@@ -1,11 +1,72 @@
 package bowling;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class HitRecords {
-    private List<HitRecord> hitRecords;
+    private static final int HIT_ONCE = 1;
 
-    public HitRecords(List<HitRecord> hitRecords) {
-        this.hitRecords = hitRecords;
+    private final List<HitRecord> hitRecords;
+    private Score score;
+
+    public HitRecords() {
+        this.hitRecords = new ArrayList<>();
+        this.score = Score.ofZero();
+    }
+
+    public boolean hitOnce() {
+        return hitRecords.size() == HIT_ONCE;
+    }
+
+
+    public void addRecord(HitRecord hitRecord) {
+        this.hitRecords.add(hitRecord);
+    }
+
+    public void addStrike() {
+        this.hitRecords.add(HitRecord.of(10, BowilingTerm.STRIKE));
+        score = Score.ofStrike();
+    }
+
+    public void addSpare() {
+        this.hitRecords.add(HitRecord.of(10, BowilingTerm.SPARE));
+        score = Score.ofSpare();
+    }
+
+    public void addGutter() {
+        this.hitRecords.add(HitRecord.of(0, BowilingTerm.GUTTER));
+        score = Score.ofMiss(hitSum());
+    }
+
+    public void addMiss(int count) {
+        this.hitRecords.add(HitRecord.of(count, BowilingTerm.MISS));
+        score = Score.ofMiss(hitSum());
+    }
+
+    public boolean isRecordAllStrike() {
+        return hitRecords.stream()
+                .allMatch(HitRecord::hitAll);
+    }
+
+    public boolean hitTimes(int hitTwice) {
+        return hitRecords.size() == hitTwice;
+    }
+
+    public List<HitRecord> getHitRecords() {
+        return hitRecords;
+    }
+
+    private int hitSum() {
+        return hitRecords.stream().mapToInt(HitRecord::getHitCount).sum();
+    }
+
+    public void calculateBonus(int hitCount) {
+        if (score.remainBonus()) {
+            score = score.addBonusScore(hitCount);
+        }
+    }
+
+    public Score getScore() {
+        return score;
     }
 }

src/main/java/bowling/Score.java

@@ -0,0 +1,47 @@
+package bowling;
+
+public class Score {
+    private final int hitCount;
+    private final int bonusCount;
+
+    public static Score ofZero() {
+        return new Score(0, -1);
+    }
+
+    public static Score ofStrike() {
+        return new Score(10, 2);
+    }
+
+    public static Score ofSpare() {
+        return new Score(10, 1);
+    }
+
+    public static Score ofMiss(int hitCount) {
+        return new Score(hitCount, 0);
+    }
+
+    private Score(int hitCount, int bonusCount) {
+        this.hitCount = hitCount;
+        this.bonusCount = bonusCount;
+    }
+
+    public boolean remainBonus() {
+        return bonusCount != 0;
+    }
+
+    public Score addBonusScore(int hitCount) {
+        return new Score(this.hitCount + hitCount, bonusCount - 1);
+    }
+
+    public int getHitCount() {
+        return hitCount;
+    }
+
+    public int getBonusCount() {
+        return bonusCount;
+    }
+
+    public boolean isMiss() {
+        return hitCount != 10;
+    }
+}

src/main/java/bowling/Scores.java

@@ -0,0 +1,12 @@
+package bowling;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Scores {
+    private final List<Score> scores;
+
+    public Scores() {
+        this.scores = new ArrayList<>();
+    }
+}