Description
Background
Farkle is a dice game designed for two or more players. Gameplay consists of throwing six dice and gaining points based on single rolls or special combinations of dice rolls described below. When the first player reaches 10,000 points, each other player gets one more turn to attempt to beat the first player’s score. After this special set of turns is taken, the player with the top score wins.
In order to get on the scoreboard, you must have a running total of at least 500 points before you stop rolling. Once a player is on the scoreboard, they may choose to stop rolling at any time during their turn. Once a player chooses to finish a sequence of rolls, their score is added to the scoreboard and their turn ends.
Each turn starts by rolling all six dice. After each roll, set aside the dice that are worth points and roll the rest. You must remove at least one die or combination of dice that are worth points after each roll while keeping a running total of your points for the turn. If you are able to set aside all six dice, you can roll the dice again to start the process over and build up additional points or you can keep the points you have and end your turn. If you can not set aside any dice after a roll, this is called a “Farkle”. When a Farkle occurs, points are not added to the scoreboard and play passes to the next player. A Farkle may happen on the first roll or any subsequent rolls.
Here is an example of the game: https://www.youtube.com/watch?v=zpdHZ8AUAtQ
(Instructions continue on the next page)
Single 1 |
= 100 |
Four of any number = 1,000 |
Single 5 |
= 50 |
Five of any number = 2,000 |
Three 1’s = 300 |
Six of any number = 3,000 |
|
Three 2’s = 200 |
1-6 straight = 1,500 |
|
Three 3’s = 300 |
Three pairs = 1,500 |
|
Three 4’s = 400 |
Four of any number with a pair = 1,500 |
|
Three 5’s = 500 |
Two triplets = 2,500 |
|
Three 6’s = 600 |
||
Implementation Requirements
-
Must produce a working program that implements the game play described in the Background and Scoring section of this document.
-
Rand() should be used to simulate the dice rolls.
-
All functions should be 15 lines or less. Whitespace, single curly braces, and the function header do not count.
-
Use of one dimensional arrays is required.
-
Use of references and pointers is required.
-
The user should see their running score total for their turn at all times.
-
The user should be able to choose which dice to remove from the rolls during their turn.
-
Error handling for all user input should be implemented.
-
The scoreboard for all players should be displayed at the end of each turn.
-
The program should always state whose turn it is.
-
The program should allow as many players as the user request, but there should be a minimum of two.
-
No memory leaks allowed (see valgrind).
-
No global variables allowed.
-
No segmentation faults allowed.
(Instructions continue on the next page)
Design to be submitted to recitation.
Implementation: 80 pts
Auto deductions:
Memory Leak: -10 pts
Global Variables: -10 pts
Segmentation Faults: -10 pts
Style and Code Quality: 20 pts
Extra Credit: 10 pts
Extra Credit
Log all testing activity that you conduct on your program. You should produce a table as follows:
Date |
Function |
Preconditions |
Expected |
Actual |
Hypothesis |
How |
and |
or |
to get to |
Post |
Post |
on the |
the |
Time |
Procedure |
testing |
Conditions |
Conditions |
cause of |
issue |
Being |
scenario |
the issue |
was |
|||
Tested |
fixed |
|||||
… |
… |
… |
… |
… |
… |
… |
Note, this is not the same as the testing table you normally produce for your recitation designs. This is a log of all the issues you’ve encountered in developing your program and how you fixed these issues. By recording what goes wrong, you should be able to better recognize common mistakes and identify how to fix them quickly. This table should span multiple pages for this program.