Random Number Generation

We'll be able to write code like this, where our Character does between 15 and 25 damage on each attack, and has a 20% chance to dodge incoming damage:

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  int Health { 100 };
10
11  void TakeDamage(int Damage) {
12    if (Random::Bool(DodgeChance)) {
13      return;
14    }
15    Health -= Damage;
16  }
17
18  void Act(Character* Target) {
19    Target->TakeDamage(
20      Random::Int(MinDamage, MaxDamage)
21    );
22  }
23};

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 in 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}

Generating our random numbers involves 3 steps:

1. A seeder, that will create an initial "random" number for us
2. An engine, that will use the initial seed value to efficiently generate an endless supply of more random numbers
3. A distributor that will convert these random numbers into the desired range, such as from 15 to 25 in our combat example

Let's get started!

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 unpredictable data, and then perform mathematical operations to convert that data to an unpredictable 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> header 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}

The process of generating 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 mathematical 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 initialize 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}

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 values 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. Below, we've called our object get. To generate a random number in this range, we then "call" get, passing in our engine:

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

Let's see all our components working together:

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  int Int(int min, int max) {
11    uniform_int_distribution get{min, max};
12    return get(engine);
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. Below, we log out three random numbers from 1-10:

1// main.cpp
2#include <iostream>
3#include "Random.h"
4
5int main() {
6  std::cout << Random::Int(1, 10) << ", "
7    << Random::Int(1, 10) << ", "
8    << Random::Int(1, 10);
9}

15, 1, 7

Below, we use it in our Character class to make Act inflict a random amount of damage based on the MinDamage and MaxDamage class variables:

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

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 center of the range, the more frequently it will be chosen. In this example, 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:

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 performs a critical strike 10% of the time.

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

Let's 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.

Let's make this available as Random::Bool():

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}

Let's see it in action:

1// main.cpp
2#include <iostream>
3#include "Random.h"
4
5int main() {
6  for (int i{0}; i < 8; ++i) {
7    if (Random::Bool(0.2)) {
8      std::cout << "Dodge, ";
9    } else {
10      std::cout << "Hit, ";
11    }
12  }
13}

1Hit, Hit, Dodge, Hit, Hit, Hit, Hit, Dodge,

And let's add it to our class:

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

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.

Let's 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 or checking the documentation we see that random_device uses an unsigned integer.

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

1// Random.h
2#pragma once
3#include <iostream>
4#include <random>
5
6namespace Random {
7  using namespace std;
8  random_device seeder;
9  unsigned int seed { seeder() };
10  mt19937 engine { seed };
11
12  void PrintSeed() {
13    cout << "Seed: " << seed << '\n';
14  }
15
16  int Int(int min, int max) {
17    uniform_int_distribution get { min, max };
18    return get(engine);
19  }
20}

And let's use it:

1#include <iostream>
2#include "Random.h"
3
4int main() {
5    using namespace std;
6    Random::PrintSeed();
7    cout << Random::Int(1, 100) << ", "
8         << Random::Int(1, 100) << ", "
9         << Random::Int(1, 100);
10}

Running this code yields output similar to:

1Seed: 141102604
260, 78, 47

Of course, running the code a second time would generate a 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 user) wanted.

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

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

Finally, let's make use of it in our code, to let us exert some control over our randomness:

1#include <iostream>
2#include "Random.h"
3
4int main() {
5  using std::cout;
6  // We can still get random numbers:
7  cout << Random::Int(1, 100) << ", "
8       << Random::Int(1, 100) << ", "
9       << Random::Int(1, 100) << "\n\n";
10
11  // But now we can create reproducible results:
12  Random::Reseed(141102604);
13  Random::PrintSeed();
14  cout << Random::Int(1, 100) << ", "
15       << Random::Int(1, 100) << ", "
16       << Random::Int(1, 100) << "\n\n";
17
18  cout << "Let's go again - ";
19  Random::Reseed(141102604);
20  Random::PrintSeed();
21  cout << Random::Int(1, 100) << ", "
22       << Random::Int(1, 100) << ", "
23       << Random::Int(1, 100) << "\n\n";
24}

Our output is this:

119, 4, 97
2
3Seed: 141102604
460, 78, 47
5
6Let's go again - Seed: 141102604
760, 78, 47

In this lesson, we explored the fundamentals of implementing randomness in C++ by enhancing a simple combat system. We delved into the concepts of random number generators, distributions, and the practical application of these concepts in a game-like scenario. The key topics we learned included:

• Understanding the role of randomness in software.
• Learning to implement random number generation in C++, including the use of std::random_device, std::mt19937 (Mersenne Twister), and different types of distributions.
• Developing Random::Int and Random::Bool functions to generate random integers and booleans within specified ranges or probabilities.
• Grasping the importance of seeding in random number generation and how operating systems generate seeds from various sources of entropy.
• Gaining insights into controlling and reproducing randomness, including the use of seeds for debugging and creating repeatable scenarios in our programs.