Homework 1, Chicago!

Short Description:

Using the struct based die routines developed in class, implement the game Chicago.

Goals

When you finish this homework, you should have:

Demonstrated you ability to employ an externally developed utility library.
Demonstrated your ability to compile and execute code.
Demonstrated your ability to use a Makefile to compile multiple programs.
Demonstrated your ability to work with code written in multiple files.
Begun to think about the relationship between code and data.

Formal Description

For this program, you will work with the die library developed in class. You should use my implementation of this library. They are provided here:

Remember, to use IniTDie correctly, you should have seeded the random number generator. You are ultimately responsible for creating two programs. These programs

must use the die library supplied above and no other random mechanisms.
must not access the fields of the die structure directly, but should do so through the provided interface.
must use the above provided files without alteration in any way. The code in die.h and die.cpp must not be changed. To enforce this, I will overwrite your versions of die.h and die.cpp with these files when I compile your program.

[5 points] Write a test driver called dieTest.cpp. This test driver should use much of the code developed in class. This program should test the die library by performing the following:
- Provide a visual inspection
  - Given two die:
  - Roll A then B 10 times and print the results.
  - Roll B then A 10 times and print the results.
  - Each set of rolls should start with the same die, IE pass them by value to the function that performs the experiment
  - ```
  DieT dieA, dieB;
  ...
  DoInspectionTest(title, dieA, dieB);
  DoInspectionTest(title, dieB, dieA);
  ...
  void DoInspectionTest(string title, DieT a, dieT b){
      cout << title << endl;
```
- Your results should look something like this:
```
  Visual Inspection Test
  Rolling A then B:
                     A                   B
                     6                   3
                     4                   3
                     6                   1
                     4                   1
                     2                   4
                     1                   1
                     6                   1
                     4                   1
                     5                   3
                     5                   3
  Rolling B then A:
                     B                   A
                     3                   6
                     3                   4
                     1                   6
                     1                   4
                     4                   2
                     1                   1
                     1                   6
                     1                   4
                     3                   5
                     3                   5 
```
- I believe that we will have done most of this in class.
- Test to see if the die are independent
  - Declare two six sided die.
  - Starting from the new state for each die, record 1,000 values for the roll of the first die followed by the roll of the second die. Passing the dice by value will be helpful in this case.
  - Starting from the new state for each die, record 1,000 values for the roll of the second die followed by the roll of the first die. Again, you will probably want to pass the dice by value.
  - Compare the results these two processes and report if they die do not have the same values.
  - This extends the above test by adding a programmatic test of rolls the pragmatically.
  - The test should print results similar to :
  - ```
  Independence Test
      Rolling A then B 1,000 times.
      Rolling B then A 1,000 times.
  one of the following
      Comparing the results ... They are the same!
  or
      Comparing the results ... They differ in 722 places!
```
- Test to see if the die is uniform
  - Roll a n sided die 1,000,000 times.
  - Record the number of times each side appears.
  - Report report the number of times each side appears, along with a percentage of the total rolls accurate to 1 decimal place.
  - The report should look something like this:
```
Uniform Test
A 3 sided die was rolled 1000000 times. The results were:
              333414      33.3%
              332735      33.3%
              333851      33.4% 
```
  - You should do this for 2 ≤ n ≤ 20
  - While we could add a statistical test to see if this is likely uniform, we will not do that.
[10 points] Implement the dice game Chicago.
- I fond this game here
  
  Chicago
  Chicago, also commonly known as Rotation, is a fast-paced dice game that can easily be enjoyed in both small and large groups.
  What You'll Need:
  - 2+ Players
  - Two Dice
  - Scoresheet (Optional)
  How to Play
  The goal of Chicago is to roll every possible number combination that can be made with two dice. There are 11 possible combinations, and you'll have 11 chances to roll. Each round has a target combination, which starts at 2 and goes up to 12 in the same sequence. For example, if you are in Round 8, the target score is 9. If a player rolls any combination that adds up to 9, they will score that number. If they do not, they'll earn zero points for that round.
  The game starts when the starting player rolls both dice. Remember, the target score for the first round is 2. If the player rolls two 1's, they'll score the two points. If not, no points will be awarded and the play moves on to the next player.
  After 11 rounds, add up the total score of each player. The player with the highest cumulative score wins!
- The game above assumes that you are playing with six sided dice. Your program should allow play with any type of die between a two sided die (coin) and a 100 sided die.
- You should ask the user for the number of players before the game begins, This should be between 2 and 5 inclusive. Your program should not accept an invalid number of players.
- Your should ask the player for the number of sides for each of the two die, this should be between 2 and 100 inclusive. Your program should not accept an invalid number of sides.
- Your input should contain the following:
  - The results of each player at each turn.
  - The final scores and indicate who won.
  - Example Output:
```
Enter the number of players (1-5) => 2
Enter the number of sides (1-100) => 3
Enter the number of sides (1-100) => 3

2 players are using a d3 and a d3.
Targets are from 2 to 6.

Round 1, aiming for a target of 2
        Player 1 rolls a   2 and a   3 for a score of   5, NO Score!
        Player 2 rolls a   3 and a   1 for a score of   4, NO Score!

Round 2, aiming for a target of 3
        Player 1 rolls a   1 and a   1 for a score of   2, NO Score!
        Player 2 rolls a   1 and a   3 for a score of   4, NO Score!

Round 3, aiming for a target of 4
        Player 1 rolls a   1 and a   2 for a score of   3, NO Score!
        Player 2 rolls a   2 and a   3 for a score of   5, NO Score!

Round 4, aiming for a target of 5
        Player 1 rolls a   1 and a   2 for a score of   3, NO Score!
        Player 2 rolls a   3 and a   3 for a score of   6, NO Score!

Round 5, aiming for a target of 6
        Player 1 rolls a   3 and a   3 for a score of   6, Score!
        Player 2 rolls a   2 and a   3 for a score of   5, NO Score!

Player 1 scores   6, winner!
Player 2 scores   0 
```
  - You do not need to copy the output format exactly but
    - It should contain all information contained in the example.
    - It should be at least as readable as the example.
    - All numbers should line up in the output, I used setw(3) for most numeric output where dice were involved.

Notes

Use constants appropriately.
Use identifiers that follow the local programming convention. Pay particular attention to making meaningful identifiers.
Use many small functions.
Do not use any members of the standard algorithm library, and only strings from the standard container library (no stringstreams, lists, vectors, maps, ...)
You may not use anything from the random portion of the standard library. There really is no need, DiceT provides all the randomness you need for this project.
Use only programmatic items we have discussed.
You would be silly not to do a design for these programs, even though they are short.
If you need help with an algorithm let me know.
If you work with a collaborator, human or AI, make sure that you note this in comments in your main code.
Remember, you are stating that you understand all of the material when you turn it in. You may be subjected to a code review if I believe it is warranted.
If you follow my naming convention, this Makefile should work for you.

Required Files

A tar or zip file containing all source code required to build this project. This includes

testDriver.cpp, a test driver that exercises all functions of the dice utility
chicago.cpp, an implementation of the game Chicago.
A valid Makefile.

Submission

Submit the assignment to the D2L folder homework 1 by the due date.