04-01. Polyhedral dice

In this programme we'll learn about generating random numbers, which is useful for games.

This is a simple programme that will simulate rolling a classic six sided dice.

We start by creating our boilerplate code.

In this programme we also have a new section called Globals, which I'll explain in a moment, followed by our subprograms and main programme.

Let's write the first command in the globals section and talk about it.

Static Random.

Randomgenerator, new random, open and close brackets, semicolon.

Notice that random is a kind of new data type we haven't seen before.

It's actually a class and randomgenerator, is a variable.

We've already learned that variables can only be used within the subprogram in which they're declared.

They are known as local variables because they are local to and belong to the subprogram they are declared within.

Generally speaking, you should be declaring variables within a subprogram because they use memory to store values only when they're needed and then when the subprogram exits or returns, the memory is given back to the operating system to be used for something else.

Using memory like this is considered good practise.

However, in this programme we're going to learn that it's possible to declare variables outside of a subprogram and that makes them global variables, hence declaring them in the global section.

Global just means all the subprograms within the same class can use them at any time.

But the downside is they hold the memory for the entire time the programme is running.

This is acceptable for very small programmes, but programmes requiring a lot of data would be hogging the memory unnecessarily.

So in most cases they're not used with random numbers.

There's a reason to use a global variable.

Random is a special class built into the system commands that calculates a sequence of numbers that appear random.

This sequence is stored in our random generator variable.

We don't want to waste time processing a new sequence of random numbers every time we ask for one.

Instead, we'll use one set of numbers.

The first time we ask for a number we want the first one in the sequence.

And the second time we ask for a number, we want the second one in the sequence.

So this is a good case for using a global variable.

We've sacrificed memory for execution speed.

The compromise and decision between speed and memory is one that occurs regularly in programming.

This is a bit overkill in this programme because we only want one number, but we're laying the foundations for more interesting programmes later by learning These things in small steps.

Let's write a subprogram to roll a six sided dice.

Static int rolledice no data to receive, so open and close brackets.

We used int because we want a whole number one to six.

Int result of the roll equals our random number generator's next number, which is in the range of 1 and 7.

The upper bounds are exclusive, hence why this is 7 and not 6.

Slightly confusing, but just remember to add 1 to whatever the maximum number is that you want.

You may have noticed that we use the dot syntax here, just like the writeline Command.

And because Next requires data, the numbers 1 and 7, they're separated with a comma and enclosed in brackets.

Now, in the main programme, we can make use of our dice roller.

Int number equals the return value from our rolldice subprogram.

Put that on the screen with console, WriteLine and string formatting $urolleda followed by our number variable.

We can now run the programme and we got two as our random number.

If we run the programme again, we may get a different number.

Because it calculates a new sequence of numbers, there's actually no such thing as a random number in a computer.

They're deterministic.

That means they are simply calculations that produce what look like a random sequence to a human being.

For example, take 23 divided by 7.

It gives you a seemingly random sequence of numbers after a decimal place.

2, 8, 5, 7, 1 and 4.

Although the pattern does then repeat, so it can be exploited.

The number used in the calculation is known as a seed.

That's how early computer games were often exploited by players, by working out the sequence of random numbers being used.

It's these kinds of calculations that produce random numbers in a computer, albeit the calculations are more sophisticated.

In the case of C, it uses the number of clock cycles since the computer was switched on as the seed for the calculation.

That means if you turn two identical computers on at the same time, they would generate the same random numbers.