Skip to content

Latest commit

 

History

History
112 lines (95 loc) · 3.8 KB

README.md

File metadata and controls

112 lines (95 loc) · 3.8 KB
Raw

The Two Pine Games

example workflow

This project handle the bowling scores rules described in the specs and here.

It's a command-line application to score a game of ten-pin bowling. You can find the rules here.

Two Pines Application receives a file path containing a list of scores for each player as we you can see in the next example:

Jeff	10
John	3
John	7
Jeff	7
Jeff	3
John	6
John	3
Jeff	9
Jeff	0
John	10
Jeff	10
John	8
John	1
Jeff	0
Jeff	8
John	10
Jeff	8
Jeff	2
John	10
Jeff	F
Jeff	6
John	9
John	0
Jeff	10
John	7
John	3
Jeff	10
John	4
John	4
Jeff	10
Jeff	8
Jeff	1
John	10
John	9
John	0

... and should generate a file with with the result of the match:

Frame		1		2		3		4		5		6		7		8		9		10
Jeff
Pinfalls		X	7	/	9	0		X	0	8	8	/	F	6		X		X	X	8	1	
Score		20		39		48		66		74		84		90		120		148		167		
John
Pinfalls	3	/	6	3		X	8	1		X		X	9	0	7	/	4	4	X	9	0	
Score		16		25		44		53		82		101		110		124		132		151

Mandatory Features

  • Each line represents a player and a chance with the subsequent number of pins knocked down.
  • An 'F' indicates a foul on that chance and no pins knocked down (identical for scoring to a roll of 0).
  • The columns in each row are tab-separated.

About the solution

The soolution has be coded defining the following important interfaces:

                     +-----------+  +----------------------------------------+
                 +---+  Reader   |  | model                                  |
+------------+   |   +-----------+  |                                        |
|            |   |                  |   +------+   +--------+   +--------+   |
| Controller +---+------------------+---+ Game +---+ Player +---+ Frame  |   |
|            |   |                  |   +------+   +--------+   +--------+   |
+------------+   |   +-----------+  |                                        |
                 +---+  Printer  +--+                                        |
                     +-----------+  +----------------------------------------+
  • Controller: Orchestrates the overall flow. It only needs a reader and a printer.
  • Reader: Defines the interface that should implemented to read data to calculate scores.
  • Printer: Defines the interface that should implemented to print the result.
  • Game: Defines the interface to interact with the model.
  • Player: Defines the "api" to interact with the player.
  • Frame: Defines the common api for all kinds of frames. All of them implements Frame's methods.
  • NormalFrame: Defines the methods for a normal frame (try 1 + try 2 < 10).
  • SpeareFrame: Defines the methods for a frame with two tries and score == 10.
  • StrikeFrame: Defines the methods for a frame with one try with score == 10.
  • LastFrame: Defines the methods for the last frame (special case).

Important Note 1: Calculating score of each frame

In order to calculate the score of each player, I coded a double dispatch strategy between the player and frames. So, when the player iterates the list of frames, calls a frame method sending itself as a parameter. Some frames "knows" which method the player must call to be able to calculate your own score.

Important Note 2: Printing the results

To print the entire model (player, frames, and tries) I coded the solution by relaying on the Visitor Pattern. I believe that is an elegant solution to resolve this task in this context. Maybe are more lines of code, but the solution is more legible and extensible.

Build and Running

$ cd cmd/twopines
$ go build
$ ./twopines path_to_file.txt (you can try samples in assets folder)

## Sample:
$ ./twopines ../../assets/scores.txt