* Add function that returns playername/framenumber/score string for each frame to be displayed

* Add function in NormalFrame that responds to requests for score info

* Modify functions in NormalFrame so that a toString call would return an entire score string

* Modify functions in ScoreMarker so that it returns mark string from given parameters

* Create Frame interface and override toString method

* Modify Frame interface to abstract class

* Add score class which is responsible for keeping score for each player

* Add input validating functions

* Modify so that more responsibility is given to Marker

* Create funtions that tell strikes and spares

* Delete unused class

* Modify toString function of SecondThrow to match desired string

* Add class to abstract bonus throw on the last frame

* Abstract score that helps determine strike or spare

* Modify so that last frame inherits properties of a normal frame

* Restructure classes to implement polymorphism

* Complete toString conversion logic

* Apply polyphorphism on Score objects

* Automate score updates

* Create user prompt

* Restructure packages

* Create Frames class

* Create Main

* Add string formatter that pads frame string

* Add label frames

* Add function that takes input and updates scores repeatedly

* Fix bug that did not print out the correct string

* Complete whole implementation

* Restructure packages

* Refactor code

* Refactor code so it is more readable

* Modify test code to reflect changes in code

* Increase the level of encapsulation by disallowing inheritence and using interfaces

* Remove unnecessary interface Score

* Reduce number of if statements

* Refactor code

* Make fields that can be final final

* Create Frame class with functions that check for its status

* Create abstractions of Player and BowlingGame

* Add input validation

* Fix bug in input validation

* Create ScoreCalculator class

* Add functions to initialize game

* Add functions that calculate frame final score

* Create toString methods

* Complete printer function for marking figures

* Restart project and implement logic that checks whether each bowl/frame is played

* Add functions that check for strike and spare

* Restart project and abstract classes frames and bowls

* Add function that updates the status of the corresponding bowl object

* Create Frame interface

* Restart and create frame states

* Add function to differentiate between firstbowl and secondbowl

* Set up status changing logic and score updating logic

* Restructure packages

* Add function that calculates additional score for each frame

* Recreate function that calculates addition scores

* Refactor code to delegate score update to status object

* Refactor code

* Minor type fix

* Have Frames keep the instance of the next frame

* Refactor code

* Add override annotations

* Create player class that implements printable interface

* Override toString methods

* Add user prompt, formatter, and main

* Override last frames toString method

* Create various status classes for last frame

* Add separate status for last frame

* Add function that calculates last frame score

* Add override annotations

* Complete draft fulfilling step2 requirements

* Fix bugs that made the program unable to exit

* Include frame number when prompting for bowl

* Replace unnecessary frame list with just one frame instance

* Create wrapper class frames

* Create score class for last frame

* Add score calculation after each bowl

* Finish implementing score calculation - bug exists for double strike

* Fix bug that caused miscalculation

* Fix bug that did not show score for strike frames

* Fix bug in determining whether the game has ended

* Add separate classes for the last frame

* Remove unnecessary code is last frame status implementations

* Complete logic that passes on accumulative score on normal frames

* Complete calculating accumulative total score for whole

* Remove unnecessary code and use constants to represent literals

* Restructure packages and rename classes

* Use interface frame instead of an abstract class frame

* Improve way of determining the end of game

* Remove unncessary score object in frame

* Remove duplicate classes and restructure packages

* Fix bug where final score would not show

* Remove unnecessary logic for calculating the total score

* Replace hard-coded numbers with constants and use void instead of boolean where appropriate

* Add input validation by creating Pins class

* Complete tests and refactor code

* Fix frame interface name to fit convention

* Fix bug where 9th frame score was not calculated properly

* Allow multiple players

* Fix bug where status/score were not updated properly

* Refactor and test all combinations for last frame

* Modify test code to reflect changes in production code