Add (Level 0.5) to allow the user to repeat dice determining with another range if so desired. (i.e. "Do you desire it? yes" or "Do you desire it? no")
Add (Level 3) to use functions wisely to break your program into manageable pieces! Some suggestions:
entry of a range
deciding if a number is a standard die size
asking the user a yes/no question
down-ward test
up-ward test
printing a die-roll
printing a range
printing all results
printing string messages (prompts, welcome, closing, etc.)
Add (Level 1) to place your down-ward (adjustment is decreased) and up-ward (adjustment is increased) testing functions and the die-roll printing function and the 'is it a standard die size' function into a 'dice' library — especially if you add them to the dice library you wrote before).
In fact, if you do add them to the library from the earlier program (yes, either one of those will do), add another (Level 0.5).
(Note that if you had either of those prior libraries, it would already contain a function to print a die-roll and so you can re-use that one instead of writing another. It still counts toward satisfying the above 'use functions' option.)
Also, you can add another (Level 1) if you use either default arguments or overloading to combine the two adjustment testing functions into a single function.
Add (Level 2) to recognize other possibilities like the 4d3 mentioned above. Let's see, that was max/min is even, not a die size, but max/min divides a die size evenly and the user says this is okay. Yeah...that's it...
Add (Level 1) to allow the user to enter their range with either [ ] or ( ). Recall from math that ( ) on an interval means non-inclusive and so you'll have to adjust the end-point they enter to account for that. Luckily we are always dealing with integers, so non-inclusive of 4 just means to move to 5 (if we are the min) or to move to 3 (if we are the max).
Always print your report in terms of an inclusive range — with [ ].
Add (Level 1) to allow the user to use either a comma, the two dots (as above), or a dash to separate their range end-points. For example, the 5 to 15 range might be [5..15] as before or [5,15] with a comma or [5-15] with a dash.
More Thought Provoking Questions
What happens when their range has negative values in it? (i.e. Will this cause trouble with the dash as separator idea?)
(Do not worry, though, they are not allowed to enter decimal values, so the '..' should not ever give trouble.)
Add (Level 2) to account for ranges that are entirely negative: [-10..-5]. (*ahem* d6-11)
| | | | | even divide? |
round | min | max | adj | max/min | die size? | action
--------+------+------+------+----------+---------------+----------------------
0 | -10 | -5 | 0 | NA | NA | try negative adj? yes
| | | | | even divide? |
round | min | max | adj | max/min | die size? | action
--------+------+------+------+----------+---------------+----------------------
0 | -10 | -5 | 0 | 0 (R-5)| no, no | min++; max++; adj--
1 | -9 | -4 | -1 | 0 (R-4)| no, no | min++; max++; adj--
2 | -8 | -3 | -2 | 0 (R-3)| no, no | min++; max++; adj--
3 | -7 | -2 | -3 | 0 (R-2)| no, no | min++; max++; adj--
4 | -6 | -1 | -4 | 0 (R-1)| no, no | min++; max++; adj--
5 | -5 | 0 | -5 | 0 | yes, no | min++; max++; adj--
6 | -4 | 1 | -6 | 0 (R1) | no, no | min++; max++; adj--
7 | -3 | 2 | -7 | 0 (R2) | no, no | min++; max++; adj--
8 | -2 | 3 | -8 | -1 (R1) | no, no | min++; max++; adj--
9 | -1 | 4 | -9 | -4 | yes, um... | min++; max++; adj--
10 | 0 | 5 | -10 | ..... | ..... | adj is -10, cont? yes
10 | 0 | 5 | -10 | NA | NA | min++; max++; adj--
11 | 1 | 6 | -11 | 6 | yes, yes | DONE
REPORT: roll d6-11 to get [-10..-5]
Some of that checking could have been avoided if we simply skipped over all of those potential 'rolls' where the number of dice was negative, of course...
You can add (Level 0.5) to simply skip negative dice counts — and the 0 dice count — altogether.)
But, maybe someone would want us to report that -(1d6)-4 is also going to give [-10..-5]... (It may be interesting to note how the -1 can be factored out! -(1d6+4) would also give [-10..-5]!) (But definitely note that this is not actually a negative dice size or negative dice count — it is a negating of the dice roll result!)
Add (Level 1) to allow for negative dice by negating the dice part of the roll result.
Add (Level 1) to account for ranges accidentally entered in backwards: [15..5]. (*ahem* Morons...swap...much better.)
Add another (Level 1) to break this code into two re-usable functions — the detection and the swapping. (Hint: one will call the other and the 'main' — or some other function — will call just the 'outer' one.)
Add (Level 1) to give them a default value when entering things like the number of tries before you stop to ask if you should continue. (That is, if they simply hit Enter, you should set the default value. If they type a value and hit Enter, use the value they typed.)
(Hint: What would signal that they've hit Enter at all?)
(Hint 2: Should you do something before you prompt to make sure this 'signal' was in answer to the question you just asked?)
(Hint 2a: Perhaps it would be best if all input to your program were simply cleaned up after...)
(Hint 2b: Think about the fun we had with using getline() inside a simple yes/no loop...)
For instance:
How many negative adjustment trials before I stop and ask to go on? [10]
15
Would set the negative adjustment continue questions to go off at 0, -15, -30, ... Whereas:
How many negative adjustment trials before I stop and ask to go on? [10]
Would set the negative adjustment continue questions to go off at 0, -10, -20, ...as the default.
Add another (Level 1) to place this 'blank entry' support code into a re-usable function. (It might be re-usable in combination with the time entry program, for instance...*grin*)
Add (Level 0.5) to validate all of their yes/no entries. (i.e. do not let them by until they've entered [a word that begins with] either a 'y' or an 'n'.)
Add another (Level 1) to place this y/n validation into a re-usable function.
Add (Level 2) to protect all numeric input from translation failure as well as stupidity. (i.e. number of tries before asking to continue can not be 0 and also can not be a word; it can be negative, however: -10 is divisible by both 10 and -10 and so it will work fine.) (Range end-points can be any whole value but not words or decimals.)
For range end-points, give a clear message as to which end-point(s) had a problem. Always give a clear message as to what the user should do to fix the problem.
Add another (Level 1) to place the numeric validation code into a re-usable function. Remember that you can make the function more re-usable by returning to the caller with cin either clear() or set to failure when there was trouble. But you'll still be responsible for printing an appropriate message:
Enter your desired range: [n..38]
Invalid minimum! Discarding the 38 maximum.
Enter your desired range: [5..n]
Invalid maximum! Discarding the 5 minimum.
Enter your desired range: [m..M]
Invalid minimum! Invalid maximum! Discarding whole entry!
(The question is, "Is it the me that wrote the validation function or the me that called it?" Interestingly, the answer is, "Both!") (Hint: Consider the 'invalid' part a validation response and the 'discarding' message a main-program level of information. As to the word following 'Invalid'...or even that part, too...I'm thinking a string argument might be appropriate...yeah...)
Add (Level 1) to place all of your input validation functions (the last three options, for instance) into a library. (These might even go along with functions you've created for another lab into a common library...)
Add (Level 2) to allow the user to choose if they want all possible combinations printed or just the first one found. (This'll be especially handy if you've done the non-standard dice (i.e. 4d3) option. Often d2 will be found and reported quickly even though there is a real die option that has yet to be found.)
For this, you'll also have to stop every 'x' tries to ask if you should continue. (Above this value was every 10 tries during the negative checks. If you did the option to let the user enter this value, for negative checks, you'll have to let them enter this one as well. Sorry, no extra levels this time...)
The option above (and this entire program discussion, really) are focused on rolling a single size of die but in multiples and with an adjustment added on. What if your user is willing to mix and match different sizes of dice in the same roll? Then the [5..15] we started out with, for instance, could be had by rolling d4+d8+3. (That is, roll a 4-sided die and an 8-sided die, add their pips, and then add 3.)
And [4..12] can be gotten with d4+d6+2. (So we kinda lied above when we said you couldn't get it with standard die sizes — you can, but it takes multiple sizes in a single roll!)
But the coolest one yet is 3d4+d12-3 gives us [1..21]. Pretty sweet!
Add (Level 4) to handle this kind of thing. (Hint: You'll find a vector of die sizes representing how many times that size die is in the roll handy...)
(Warning! Combining this option with the previous option is dangerous and potentially painful! But boy is it fun!)
(Double secret warning! Combining this option with non-standard die sizes is so harmful as to be considered illegal! Don't try this — anywhere!)
Just FYI, even though different ways are available to create the same spread of values with dice rolls, they are quite different probabilistically. For instance, here are the graphs of the probability density functions for the two ways to make [1..21]:
![[1..21] PDF Graphs](rolls.jpg)
As you can see, the [5..17] portion of the range is quite different between the two sets of dice.
Add (Level 4) to allow the user to specify a list of die sizes to accept rather than just going with the standard sizes. (This must adapt to the non-standard option as well!) Doing this will turn nice simple branches into loops running along a vector of values. In fact, it is reminiscent of this other lab coming up in Portfolio III.
Speaking of the negative adjustment side, you start to wonder about the numbers in the example. It seems you could have detected mathematically that there was no hope quite a ways before the -10 adjustment. Also note that the user does not have all the information your program does inside — notice how bland the screen interaction would have been:
$ ./devdice.out
Welcome to the Developer's Dice Program!!!
Enter your desired range: [4..12]
Thank you!! Calculating...
Problem! We've hit a negative adjustment of -10 and still have not
located a dice roll candidate. Should we continue the search? no
*sigh* You cannot achieve a range of [4..12] by rolling standard die sizes.
Thank you for using the DDP!!
Endeavor to have an enclosed day!
$
Add (Level 2) to add code to detect mathematically that there is no hope of coming up with a negative adjustment dice-roll instead of having to bother the user. (Unless of course, they want you to...)
Add (Level 1.5) to place this whole program into a menu system along with the either the adjusted dice statistics program or the dice statistics project version.
(Yes, you can still get the Base Level + Options for that lab/project as well — as extra credit — if you did not already hand it in for portfolio I — unless you hand in extra modifications as extra credit and do not try to claim the old levels from the first portfolio you already got as credit...um...yeah. But you'll have to hand the extra credit one in separately!)
Your menu should look something like this:
Dice Menu
1) Calculate dice Statistics
2) determine Roll for Range
3) Quit
Add (Level 1.5) to add a submenu for the extra questions you've had to ask in this lab (some in the main part and some in the options). It will look something like this (if all options are filled):
Options Menu
1) Detect that negative adjustments are Hopeless [NO]
2) Pause calculations every [10] tries to ask "go on?"
3) include All roll combinations [YES]
4) allow nonStandard dice sizes [NO]
5) allow die portion of roll to be Negated [NO]
6) Return to dice Menu
The parts in [square] brackets show the current setting for the options (do not auto-detect hopelessness of negative adjustments, do all combinations, stop every 10 tries to ask if you should continue or not, do not allow non-standard dice, do not allow negated rolls). The user should stay in the sub-menu until they choose option 6/R/M to return [control] to the main menu. (Note that 'control' can return to part of a program via flow control mechanisms — not just a function return!) That way the user can change multiple options before starting the next range test.
(Yes, you can still do the Enter for default entry value option above within this submenu. It's level counts separate — aka 'in addition to' — this one's.)
(Remember, you may not have all these options for them to set. It will depend on if you've done any/some/all of the options above.)
BTW, this will modify the main menu to:
Dice Menu
1) Calculate dice Statistics
2) determine Roll for Range
3) set roll-determining Options
4) Quit
(There were no option questions for the old dice lab or the dice project...)
Add (Level 2) to use a switch to good effect in your standard die size determining code. (This option is unaffected by that code being placed in a function. i.e. you still get this level as well as that one...)
In fact, you can take this option again...and again! Each time you take it, it's level will be cut in half. You can take it for using a switch for processing your menu. And you can take it a third time for the submenu option.
More options coming soon..?