Standard Library Maths Helpers

In the previous lesson, we talked about exponents and square roots. Lets see how we can implement them in C++

Exponentiation

We saw how we could do something like $2^3$ is equal to $2 \times 2 \times 2$, or $8$. This is sometimes also called raising 2 to the 3rd power.

We'd like to be able to do this in code. One way we might be to have a function we can call with two numbers - a base and a power. For example, $2^3$ might come from:

1pow(2, 3);

Or, more generally, we'd have two variables like $x$ and $y$, and we could calculate $x^y$ by doing:

1pow(x, y);

We perhaps know how we could create such a function - that function might involve a loop that multiplies x by x until some condition involving y is no longer true. Fortunately, the standard library has already implemented this, and many more maths helpers for us.

CMath

To access the standard libraries math utilities, we need to include <cmath>:

1#include <cmath>

After including cmath or math.h the pow function is now available within the std namespace:

1std::pow(x, y);

Like with any namespace, if we have an appropriate using statement, we can omit the scope resolution:

1using namespace std;
2
3pow(x, y);

Square Root

Implementing a function that calculates the square root ourselves would be a bit more difficult, with what we've learnt so far.

Fortunately, CMath gives us access to the std::sqrt function too:

1#include <cmath>
2
3std::sqrt(25); // 5

Implementing Vector Length and Distance

With these new functions at our disposal, we can now update our Vector3 struct with the ability to return its length, as well as the distance to another vector.

1#include <cmath>
2
3struct Vector3 {
4  float x;
5  float y;
6  float z;
7  
8  float GetLength() {
9    return std::sqrt(x * x + y * y + z * z);
10  }
11  
12  float GetDistance(const Vector3& Other) {
13    using namespace std;
14    return sqrt(
15      pow(x - Other.x, 2) +
16      pow(y - Other.y, 2) +
17      pow(z - Other.z, 2)
18    );
19  }
20};

With these new additions to our toolbox, we are now able to introduce the concept of attack range to our characters.

For example, by comparing the WorldPosition of our character to the WorldPosition of its target using the GetDistance function, we can see how far away the two objects are.

This would allow us to prevent our character from attacking an enemy that is too far away. We could also implement behaviours like character doing more damage to targets in melee range.

In the next lesson, we will take this further, and introduce some additional vector math. This will allow us to implement rules around how characters can change their WorldPosition, giving us the groundwork for character movement. See you there!

Next Lesson

Implementing Movement using Vectors

Learn some more vector math, and see how we can use it to implement gameplay movement.

ContinueView Course