because you would have a random integer between 0 and 5. However, most dice are numbered 1–6. Therefore, the next step is to add 1 to big. Looking at the same example, bigger is big + 1, or 3.04637195637746. The last step is to lop off the decimal part of the number, which is easily done by casting bigger to an integer.
It might help you understand the results if you run the program a few times and watch the relationships between the numbers.
When you understand how the pattern works, you might prefer to put all the steps together. The line in the program that looks like this
die = (int)(generator.NextDouble() * 6) + 1;
does exactly that. It gets a double from the generator, multiplies its value by 6, casts the result as an integer, adds 1, and copies the result to the die variable. Either approach is acceptable, but most programmers use the second technique because it’s easier to type.
Trick You can use a similar technique to simulate any kind of random number you want. If you want to duplicate the 20−sided die used in certain board games, simply replace the value 6 with 20 in the preceding expression.
Creating the Math Game
You now know everything necessary to put together the simple Math Game from the beginning of this chapter. The game itself is not complex when you know how all the pieces work.
Designing the Game
The first thing to think about is the general design of the game. This might seem like the easiest step, but often it is the most difficult and frequently overlooked. In this case, I was looking for a simple game that would illustrate the concepts of variables and branching behavior. I also wanted to generate random math problems that would be appropriate for children in elementary school. The program should present four problems, one each of addition, subtraction, multiplication, and division. The answers should always be positive integers. When players finish the quiz, they should get a numeric score and some feedback about their score.
In the Real World
It’s smart to think about exactly what you want your program to do and even to write it down before you start programming. Later, you’re bound to get tied up in details. When things go wrong, you will be glad to have a plan you can fall back on.
Creating the Variables
I started my program by doing the normal modifications of the default code and adding a few key variables:
using System;
50
namespace MathGame
{
///<summary>
///Simple Math Game
///Asks four math questions
///Using Random Numbers
///Andy Harris, 11/7/01
///</summary>
class Game
{
static void Main(string[] args)
{
int a, b, c, guess, |
score; |
|
score = 0; |
|
|
//create the random |
number |
generator |
Random roller = new |
Random(); |
|
Console.WriteLine("Welcome to the math Game! I'll give you some simple problems to solve.");
I created variables for a and b, which will be the two random numbers in each problem. I also created the variable c to hold the sum or product of a and b. The variable guess holds the user’s response to questions, and score keeps track of the number of questions the user answers correctly. Note that you can create several variables with the same int statement.
Also notice that I set the value for score to start at zero.
The program will use many random numbers, so I created a random object named roller to make the numbers. Finally, I added a greeting so that the user would have some idea of what’s going on.
Managing Addition
The addition problem sets the stage for all the other questions:
//addition
a = (int)(roller.NextDouble() * 10) + 1; b = (int)(roller.NextDouble() * 10) + 1; c = a + b;
Console.Write("What is {0} + {1}? ", a, b); guess = Convert.ToInt32(Console.ReadLine());
if (guess == c) { score++;
}
The program gets a value for a that is between 1 and 10. I multiplied the double value from roller by 10, added 1, and converted it to an integer. The program gets a similar value for b. The c variable is calculated by adding a and b. The program writes out the question to the screen, interpolating the values for a and b.
The next line gets a response from the console, converts it to an integer, and then sends the resulting value to the variable guess.
Finally, the program checks whether the guess is correct. If so, the value of score is incremented. Note the line that increments the score.
51
score++ is a special shorthand for score = score + 1. Because you frequently need to increment by 1, the ++ operator is a very handy little shortcut.
In the Real World
When developers set out to improve on the C language, they wanted to illustrate that it was better than C, so they named it C++. Because C# is supposed to be an improvement over C++, I wonder if it should be named C++++!
Managing Subtraction
You might be tempted to duplicate the addition code four times and simply change the operators from addition to the other math operations. However, this will cause some problems. Remember that you want to keep your results all positive integers. Because both a and b are random, how will you ensure that a minus b is always positive? One solution is to subtract b from a if a is bigger, or a from b if b is bigger. However, there’s a more elegant solution. Look at the code and see whether you can figure it out before I explain it:
//subtraction
a = (int)(roller.NextDouble() * 10) + 1; b = (int)(roller.NextDouble() * 10) + 1; c = a + b;
Console.Write("What is {0} − {1}? ", c, a); guess = Convert.ToInt32(Console.ReadLine());
if (guess == b) { score++;
Nothing says that the user has to be given the random values! What I did was get two random values, as before, and add them together so that c is the sum of a and b. I then asked the user what c minus a is, knowing that the response would be b.
Managing Multiplication and Division
The multiplication and division segments of the code are very much like the addition and subtraction sections. For the division problem, I multiplied a and b and asked the user what c divided by a is, knowing that, again, the answer would be b.
//multiplication
a = (int)(roller.NextDouble() * 10) + 1; b = (int)(roller.NextDouble() * 10) + 1; c = a * b;
Console.Write("What is {0} * {1}? ", a, b); guess = Convert.ToInt32(Console.ReadLine());
if (guess == c) { score++;
}
//division
a = (int)(roller.NextDouble() * 10) + 1; b = (int)(roller.NextDouble() * 10) + 1;
52
c = a * b;
Console.Write("What is {0} / {1}? ", c, a); guess = Convert.ToInt32(Console.ReadLine());
if (guess == b) { score++;
}
Checking the Answers
All that remains is to analyze the score. This is easily done with a switch structure:
Console.WriteLine("Score: {0} out of 4", score);
switch (score)
{
case 4:
Console.WriteLine("You're a genius!"); break;
case 3:
Console.WriteLine("You're pretty smart!"); break;
case 2:
Console.WriteLine("You could do better"); break;
case 1:
Console.WriteLine("You could use some practice"); break;
case 0:
Console.WriteLine("Maybe you were good at gym class in school"); break;
default:
Console.WriteLine("Hey, something went wrong here!"); } // end switch
The switch statement simply checks all the possible values of score and sends an appropriate (and occasionally condescending) message to the user. Note that I added a default clause, even though it should not be possible for score to have a value besides 0, 1, 2, 3, or 4. Things can and do go wrong in programming, so if something does go wrong here, having a message on the screen to note that an error occurred is much better than having the program crash.
Waiting for the Carriage Return
I like to let the screen stick around until the user gets a chance to read it, so I added the Please press Enter key code at the end of this program, as I do in all my console programs. I also ended all the structures, watching out for indentation and comments:
//hold the screen to see results Console.WriteLine(); Console.WriteLine();
Console.WriteLine("Please press enter key to quit"); Console.ReadLine();
} // end main } // end class
}// end namespace
53