Moving Objects with Vectors

Movement Vectors

We can also use vectors to represent movement within our world. Our objects have a current position, and some position they want to move to. We can represent the difference between these two positions as a vector:

To determine the position of an object after applying a movement, we add the movement vector to the current position vector.

For example, let’s imagine our character was initially at position { 5, 1 } and a movement vector of { 1, 3 } was applied. The character's new position will be the result of adding those two vectors: { 5 + 1, 1 + 3 } which is { 6, 4 }:

Let’s add a Move() method to our Character class to support this, using the += operator we overloaded within our Vec2 type:

1// Character.h
2#pragma once
3#include "Vec2.h"
4
5class Character {
6public:
7  Vec2 Position { 5, 1 };
8    
9  void Move(const Vec2& Movement) {
10    Position += Movement;
11  }
12};

1// main.cpp
2#include <iostream>
3#include "Vec2.h"
4#include "Character.h"
5
6int main() {
7  Character C;
8  std::cout << "Starting Position: " << C.Position;
9  
10  Vec2 MovementVector { 3, 2 };
11  std::cout << "\nMovement Vector: " << MovementVector;
12  
13  C.Move(MovementVector);
14  std::cout << "\nNew Position: " << C.Position;
15}

1Starting Position: { x = 5, y = 1 }
2Movement Vector: { x = 3, y = 2 }
3New Position: { x = 8, y = 3 }

Normalizing Vectors

When we’re implementing logic using vectors, it is often useful to work with normalized vectors, that is, vectors that have a length of $1$. We previously saw how we could calculate the length (also called the size or magnitude) of a vector using the Pythagorean theorem:

We made this available as the GetLength() function within our Vec2 struct. A normalized vector shares the same direction as the original vector, but it has a length of 1:

To calculate the normalized form of some vector, we divide the vector by its own length.

Let’s imagine we have the vector { 234, 105 }. Applying the Pythagorean theorem, we'd find the length of this vector turns out to be approximately 256. So, to normalize this vector, we’d divide it by that value:

1// main.cpp
2#include <iostream>
3#include "Vec2.h"
4
5int main() {
6  Vec2 V { 234, 105 };
7  std::cout << "Vector Length: " << V.GetLength();
8  std::cout << "\nNormalized: "
9    << V / V.GetLength();
10}

This yields approximately { 0.91, 0.41 }:

1Vector Length: 256.478
2Normalized: { x = 0.912359, y = 0.409392 }

If we calculate the length of this new vector, we'd find it to be approximately 1.0, as planned:

1// main.cpp
2#include <iostream>
3#include "Vec2.h"
4
5int main() {
6  Vec2 V { 234, 105 };
7  Vec2 Normalized {V / V.GetLength()};
8  std::cout << "Normalized Length: "
9    << Normalized.GetLength();
10}

1Normalized Length: 1

That means { 0.91, 0.41 } is the approximate normalized form of { 234.0, 105.0 }. We can add a new Normalize() method to our Vec2 type to encapsulate this logic. We’ll also add a check to ensure we don’t try to divide by zero:

1// Vec2.h
2#pragma once
3
4struct Vec2 {
5  float x;
6  float y;
7
8  Vec2 Normalize() const {
9    float Length{GetLength()};
10    if (Length == 0.0f) {
11      return Vec2{0, 0};
12    }
13    return *this / Length;
14  }
15  
16  // ...
17}

Math: Unit Vectors and Notation

If a vector has a length of $1$, it is called a unit vector. For example, $(1.0, 0.0)$ and $(0.0, 1.0)$ are both unit vectors. The vector we calculated in this section - $(0.91, 0.41)$ - is also a unit vector.

In mathematical notation, a unit vector is typically represented using the ^ symbol, called a circumflex or hat. For example, the unit vector associated with a vector called $A$ would be $\hat{A}$.

As we’ve seen, the equation for calculating a unit vector involves dividing a vector by its length. We represent the length of a vector using vertical bars, such as $\lvert A \rvert$. Combining all these conventions, we have:

Limiting Movement Speed

Typically, we don't want our objects to immediately teleport to their destination. Instead, we usually want characters to move towards a location over multiple steps. For example, in a turn-based game, it might take a character 3 turns to reach a destination, or 10 seconds in a real-time game.

For now, we’ll limit how far our Character objects can move on each invocation of the Move() function. Later in the chapter, we’ll use these techniques for real-time movement where our objects take a tiny step toward their destination on each frame.

Let’s start by adding a MovementSpeed variable to our Character class, controlling how fast they can move:

1// Character.h
2#pragma once
3#include "Vec2.h"
4
5class Character {
6public:
7  Vec2 Position { 2.0, 6.0 };
8  float MovementSpeed { 3.0 };
9};

We then need to update our Move() function to constrain the movement speed based on this variable. This has three steps:

1. Create a normalized vector from the target vector - that is, a vector with length 1 representing the direction we want to move.
2. Multiply the direction vector by the character's MovementSpeed to create a new vector representing the direction and distance the character should move in this step
3. Prevent the Character from "overshooting" the intended destination.

1. Normalizing the Movement Vector

Let’s update the Move() vector of our Character class to get the normalized form of their movement vector. We can then calculate our constrained movement vector by multiplying the normalized form with the character's maximum MovementSpeed.

This ensures the character moves in the same direction requested by the input vector, but doesn't move further in that direction than their movement speed allows:

1// Character.h
2#pragma once
3#include "Vec2.h"
4
5class Character {
6public:
7  Vec2 Position { 2.0, 6.0 };
8  float MovementSpeed { 3.0 };
9
10  void Move(const Vec2& Movement) {
11    Vec2 Direction{Movement.Normalize()};
12    Vec2 ConstrainedMovement{Direction * MovementSpeed};
13  }
14};

2. Updating Position

Next, let’s update the Character object’s Position based on this new movement vector, thereby making the character move as far as they can in the direction of their goal:

1// Character.h
2#pragma once
3#include "Vec2.h"
4
5class Character {
6public:
7  Vec2 Position { 2.0, 6.0 };
8  float MovementSpeed { 3.0 };
9
10  void Move(const Vec2& Movement) {
11    Vec2 Direction{Movement.Normalize()};
12    Vec2 ConstrainedMovement{Direction * MovementSpeed};
13    Position += ConstrainedMovement;
14  }
15};

3. Prevent Overshooting

In this code, the character will always move the maximum distance permitted by their MovementSpeed. This means if the distance indicated by the Movement vector is shorter than the Character's maximum movement speed, they will move too far and overshoot the intended destination.

We can check for this scenario, and fix this with an if statement. If the length of the input vector is less than or equal to the character's maximum MovementSpeed, we can just move the full length of that vector in this step:

1// Character.h
2#pragma once
3#include "Vec2.h"
4
5class Character {
6public:
7  Vec2 Position { 2.0, 6.0 };
8  float MovementSpeed { 3.0 };
9  
10  void Move(const Vec2& Movement) {
11    // Can the character reach their destination immediately?
12    if (Movement.GetLength() <= MovementSpeed) {
13      Position += Movement;
14      return;
15    }
16  
17    Vec2 Direction{Movement.Normalize()};
18    Vec2 ConstrainedMovement{Direction * MovementSpeed};
19    Position += ConstrainedMovement;
20  }
21};

Moving Towards a Target

Having our Move() function that accepts a specific movement vector is useful but, to make our class friendlier to use, we’d typically want to offer alternative movement options too. For example, supporting an action like "move towards this target position" is likely to be a helpful addition.

If we have two points in space, represented by the vectors $A$ and $B$. The vector that moves from $A$ to $B$ is the vector returned by subtracting $A$ from $B$, that is $B-A$:

Let’s use this to add the MoveTowards() function to our Character class to:

1// Character.h
2#pragma once
3#include "Vec2.h"
4
5class Character {
6public:
7  Vec2 Position { 2.0, 6.0 };
8  float MovementSpeed { 10.0 };
9  
Move Function (Unmodified)|Show
10  void Move(const Vec2& Movement){/*...*/}
22
23  void MoveTowards(const Character& Target) {
24    Move(Target.Position - Position);
25  }
26};

Moving Away From a Target

We might want to make an evasive archer character that prefers to fight at range, moving away from her targets if they get too close.

To make a character move away from a target, we can simply invert the order of the operands to the - operator:

1void MoveTowards(const Character& Target) {
2  Move(Target.Position - Position);
3}
4
5void MoveAway(const Character& Target) {
6  Move(Position - Target.Position);
7}

This works because of a useful property of vectors we covered in the previous lesson: the vectors $A$ and $-A$ have the same length, but point in opposite directions.

Summary

This lesson demonstrated some core, practical applications of vector math. Using our custom Vec2 type, we implemented character movement that handles position tracking, speed limitations, and direction-based movement in a natural way.

Key takeaways:

• Vectors provide a powerful foundation for movement systems
• Position vectors track object locations within the game world
• Movement vectors describe position changes over time or space
• Normalizing vectors creates unit vectors (length = 1) that preserve direction
• Normalized vectors are useful for things like speed-limited movement systems
• Vector subtraction calculates the movement required to reach a target position
• Proper handling of edge cases (like zero-length vectors) is crucial for robust systems