Homework 1, Beetle.

Short Description:

Goals

• Refreshed your programming skills.
• Learned/Refreshed enumerated or strong classes.
• Learned/Refreshed operator overloading.
• Learned/Refreshed modular compiling, header files, make.

Formal Description

The game of beetle is a simple die game for children. I am using the rules found here.

A random player begins the game by rolling the die. Using the below reference, the player will then draw the body part correlated to the number they rolled. The next player will then roll the die and draw their body part.

1. Body
2. Head
3. A leg
4. An eye
5. An antenna
6. The tail

You'll be sure to encounter a few challenges as you sketch your beetle. A body must be drawn before any other parts. A beetle without a body cannot have legs or a tail, after all! Furthermore, the head must be drawn before the eye and antenna can be added. Rolling a 1 and 2 is essential to completing your drawing. If you roll a number associated with a body part that cannot be drawn, your turn is skipped and the next player rolls. The first player with a fully sketched beetle is the winner!

We are going to write a simulation of this game.

Initially we will develop the game as written, but eventually we will want to expand this game to include bugs with more/different parts. In addition we will develop this game for two players, but we may expand that in the future as well.

The Die Class

The die class has the following interface:

• Constructor:
  • DieDynamic has two optional parameters, a number of sides and a seed.
  • DieStatic has a required parameter, the file that contains the rolls.
• Roll will provide a random value between 1 and the number of sides.
• Record will start the dynamic version recording.
• Note: the die must be passed by reference.

#include "Die.h"
...
int main() {
    // pick one of these
    // This one is for recording the game.
    DieDynamic die;
    die.Record("Afile.dice");
    // This one is for replaying the game
    // DieStatic die("Afile.dice");
    ...  

Note, you can't copy the die, and it must be passed by reference. A function that uses the die might be:

void RollDie(Die & theDie){
    int roll{theDie.Roll()};

    cout << "You roll a " << roll << endl;
    roll = theDie.Roll();
    cout << "The second roll is " << roll << endl;
} 

We will discuss UML diagrams this semester. Here is the one for the die class.

Your output should match the output in AGame.txt provided below. Briefly:

• Each turn should be well documented.
  • Start with "Player n is taking a turn!" where n is replaced with the player number (1 or 2)
  • Tell the result of the die roll: "\tThe player rolls a w." where w is replaced the die roll.
  • Tell the equivalent part "\tThis is article x.", where
    • article is
      • a for leg
      • an for eye and antenna
      • the for body, head, tail
    • x is the name of the body part.
  • One of the following phrases.
    • "\tThe player needs this part."
    • "\tThe player does not need this part."
  • One of the following phrases
    • "\tAdding a y, the player now has z."
    • "\tThe player can't take the y because they don't have a body."
    • "\tThe player can't take the y because they don't have a head."
      • Where y is replaced with the name of the part
      • And z is the number of those parts the player has.
  • Example:

    Player 1 is taking a turn!
            The player rolls a 1.
            This is the body.
            The player needs this part.
            Adding a body, the player now has 1.  

• At the end of each round, print the "drawing" for each player.
  • The phrase: "Player n's bug is:", where n is replaced by the player number
  • Each possible body part in order, right justified, occupying 15 spaces.
  • The number of each body part the player has, right justified occupying 10 spaces.
  • The statement "\tThis is not a finished bug.", where the not is omitted if the bug is finished

  • Player 1's bug is:
               body         1
               head         1
                leg         6
                eye         2
            antenna         2
               tail         1
            This is a finished bug.
            

• For every round print a double blank line and a line with 40 _ characters.

•         This is not a finished bug.
  
  ________________________________________
      

• Any additional formatting, (blank lines, spaces, ...) that appear in the example output file.

Provided Files

• Makefile
• Die.h, the header file for my die class.
• Die.cpp, the implementation file for my die class.
• AGame.rolls, a precomputed set of rolls for a game.
• AGame.txt, the text output for the game with the above rolls.

Notes

• You must use the provided files unchanged.
  • Do not change: Die.h, Die.cpp, Agame.*
  • You may change Makefile.
    • But only to add more files and objects.
    • The CXXFlAGS line must remain, unchanged, and be used to compile.
• Your program must compile on cslab103 with the give makefile.
• You should only roll the die one time for each player for each turn.
• Please name your game beetle.
• Eventually you can tell if your program passes my standards for "correct behavior" if you can
  • Use DieStatic die("AGame.dice") to declare your die.
  • Run beetle | diff - AGame.txt and produce no output.
    • If you do this:
      • lines starting with < are your output.
      • lines starting with > are the standard output.

      • 20c20
        <       This is not a finished BuG.
        ---
        >       This is not a finished bug.  

        This example indicates that the output differs on the 20th line. The programmer printed BuG, but the standard wants bug.

Required Files

Submission