Using Randomness in C++

The ability to simulate randomness plays a surprisingly big role in creating software. In the context of graphics, for example, we often use randomness to simulate natural phenonema, like wind and other random effects.

In a role playing game it can be used implement things like:

• Loot Drops
• Damage Ranges
• Dodge Chances

We'll implement the last two of these in this lesson. This will mean our combat outcome is not always the same.

We'll be able to write code like this:

1class Character {
2  // Each attack can do between 15 and 25 damage
3  int MinDamage { 15 };
4  int MaxDamage { 25 };
5  
6  // Character has a 20% chance to avoid damage
7  float DodgeChance { 0.2 };
8  
9  void Act(Character* Target) {
10    Target->TakeDamage(
11      Random::Int(MinDamage, MaxDamage);
12    )
13  }
14  
15  void TakeDamage(int Damage) {
16    if (Random::Bool(DodgeChance)) {
17      return;
18    }
19    Health -= Damage;
20  }
21};
22

The new concepts here, and the key to getting this working, are these Random::Int and Random::Bool functions.

We'll create these functions in a file called Random.h that we can include into our other files as needed. We will also wrap our code in a namespace.

1// Random.h
2#pragma once
3
4namespace Random {
5  // Our code here
6}
7

Generating our random numbers involves 3 functions:

1. A seeder, that will create an initial unpredictable number for us
2. An engine, that will use the initial seed value to generate an endless supply of random numbers for us
3. A distributor that will convert these random numbers into the desired range, or the desired type

Lets get started!

Seeding a Random Number Generator

The process of getting a random number from a computer is not as simple as it might seem. Computers are, by design, deterministic machines.

Instead, how we simulate randomness is to source some input that is unpredictable, and then perform mathematical operations on that input every time we want to generate a new random number.

This initial unpredictable input is called the seed. In this lesson, we will simply ask the operating system to provide this seed.

To get access to this, we need to <include> the random module from the standard library. We can then create a variable of type std::random_device.

1// Random.h
2#pragma once
3#include <random>
4
5namespace Random {
6  using namespace std;
7  random_device seeder;
8}
9

C++ Random Number Engines

The process to generate a seed is quite resource intensive, so it is not something we want to do frequently.

Instead, the best practice is to take that seed, and pass it into a random number engine that can quickly generate new numbers.

A common mathmatical algorithm for doing this is called the Mersenne Twister

An implementation of this is also available in the standard library, under std::mt19937. We can initialise our engine using this algorithm, passing it a seed value generated from our seeder.

1// Random.h
2#pragma once
3#include <random>
4
5namespace Random {
6  using namespace std;
7  random_device seeder;
8  mt19937 engine { seeder() };
9}
10

Random Number Distributions

Typically, when we are using randomness, we want it to be constrained to a certain range of possibilities.

For example, we want a damage value to be somewhere between 15 and 25.

To do this, we need to remap the possible outputs from our random number engine to the inputs within this range.

The standard library has std::uniform_int_distribution which can help us here.

To use it, we create an object of this type, calling the constructor with two integers - the lower and upper limit of the range. To generate a random number in this range, we then "call" the object, passing in our engine.

1std::uniform_int_distribution get { 1, 10 };
2
3// Get a random integer from 1 to 10
4get(engine);
5

Lets see all our components working together:

1#pragma once
2#include <random>
3
4namespace Random {
5  using namespace std;
6  random_device seeder;
7  mt19937 engine { seeder() };
8
9  int Int(int min, int max) {
10	uniform_int_distribution get { min, max };
11	return get(engine);
12  }
13}
14

Now, within any of our other classes, we can import this header file, and start generating random integers. We just need to call Random::Int with a lower and upper limit:

1#include "Random.h"
2
3class Character {
4  // Each attack can do between 15 and 25 damage
5  int MinDamage { 15 };
6  int MaxDamage { 25 };
7  
8  void Act(Character* Target) {
9    Target->TakeDamage(
10      Random::Int(MinDamage, MaxDamage);
11    )
12  }
13};
14

Uniform and Normal Distributions

Here, we're using a uniform distribution, but other options are available. In a uniform distribution, each number in the range is equally likely to be chosen. In this example where our range is 15-25, a uniform distribution means that 15, 17 and 19 are going to be equally common results.

Another common strategy is to use a normal distribution. In a normal distribution, the closer a number is to the centre of the range, the more frequently it will be chosen. In this exampe, that means 15 will rarely occur, 17 will be more common, and 19 will be chosen frequently.

If we choose 100 random integers from 15-25, the following chart shows how frequently we might expect each number to be chosen, depending on our choice of distribution:

Random Booleans in C++

A typical requirement involves causing an event to happen a specific proportion of the time. For example, maybe a character dodges 20% of attacks, or they perform a critical strike 10% of the time.

It would be useful to be able to encapsulate this within our Random namespace.

Lets use a different distributor function this time - std::uniform_real_distribution distributes our random numbers to a range of possible floats.

By distributing from 0.0 to 1.0, and then comparing it to our desired probability, we can return true that proportion of the time.

1#pragma once
2#include <random>
3
4namespace Random {
5  using namespace std;
6  random_device seeder;
7  mt19937 engine { seeder() };
8
9  int Int(int min, int max) {
10	uniform_int_distribution get { min, max };
11	return get(engine);
12  }
13
14  bool Bool(float probability) {
15	uniform_real_distribution get { 0.0, 1.0 };
16	return probability > get(engine);
17  }
18}
19

And lets see how we can use it in one of our classes:

1#include "Random.h"
2
3class Character {
4public:
5  void TakeDamage(int Damage) {
6    if (Random::Bool(DodgeChance)) {
7      return;
8    }
9    Health -= Damage;
10  }
11  
12private:
13  // Character has a 20% chance to avoid damage
14  float DodgeChance { 0.2 };
15  
16  int Health { 500 };
17};
18

Controlling and Reproducing Randomness in C++

When working with randomness, we often also want some visibility or control of what is happening. For example, it can be difficult to reproduce a bug, or replay a sequence of events, if we have no control over the seed of our random number generator.

Often, we may even want to give users control over the seed. This is common in strategy games for example, where the map might be randomly generated, but we want users to be able to provide the seed.

This allows them to replay a map they enjoyed, or share it with their friends. Without being able to control the seed, that is impossible.

Lets begin by updating our code to store the seed we use as a variable, so we can see what it is. By using auto deduction ot checking the documentation we see than random_device uses an unsigned integer.

We'll also add a PrintSeed function, so we can see what value was chosen.

1#include <iostream>
2#include <random>
3
4namespace Random {
5  using namespace std;
6  random_device seeder;
7  unsigned int seed { seeder() };
8  mt19937 engine { seed };
9
10  void PrintSeed() {
11    cout << "Seed: " << seed << endl;
12  }
13  
14  int Int(int min, int max) {
15    uniform_int_distribution get { min, max };
16    return get(engine);
17  }
18}
19
20int main() {
21    using namespace std;
22    Random::PrintSeed();
23    cout << Random::Int(1, 100) << endl;
24    cout << Random::Int(1, 100) << endl;
25    cout << Random::Int(1, 100) << endl;
26    return 0;
27}
28

Running this code yields the output:

1Seed: 141102604
260
378
447
5

Of course, running the code a second time would generate totally different output. But, now that we know the seed, we could use that to get the same results again, if that is what we (or our player) wanted.

Lets add a Reseed method to our Random namespace, which can be called any time we want to reproduce the same results:

1#include <iostream>
2#include <random>
3
4namespace Random {
5  using namespace std;
6  random_device seeder;
7  unsigned int seed { seeder() };
8  mt19937 engine { seed };
9
10  void PrintSeed() {
11    cout << "Seed: " << seed << endl;
12  }
13  
14  void Reseed(unsigned int NewSeed) {
15    seed = NewSeed;
16    engine.seed(NewSeed);
17  }
18  
19  int Int(int min, int max) {
20    uniform_int_distribution get { min, max };
21    return get(engine);
22  }
23}
24

Finally, lets make reuse of it in our code, to let us exert some control over our randomness:

1int main() {
2  using namespace std;
3  // We can still get random numbers:
4  cout << Random::Int(1, 100) << endl;
5  cout << Random::Int(1, 100) << endl;
6  cout << Random::Int(1, 100) << endl << endl;
7  
8  // But now we can create reproducible results:
9  Random::Reseed(141102604);
10  Random::PrintSeed();
11  cout << Random::Int(1, 100) << endl;
12  cout << Random::Int(1, 100) << endl;
13  cout << Random::Int(1, 100) << endl << endl;
14
15  cout << "Lets play again!" << endl;
16  Random::Reseed(141102604);
17  cout << Random::Int(1, 100) << endl;
18  cout << Random::Int(1, 100) << endl;
19  cout << Random::Int(1, 100) << endl;
20}
21

Our output is this:

119
24
397
4
5Seed: 141102604
660
778
847
9
10Lets play again!
1160
1278
1347
14

In the next lesson, lets apply the techniques we learnt in this section to create more interesting character types!