A vector can be described as an entity with a direction and a magnitude. We can use them to represent aspects of our game objects, for example, velocity and acceleration, that can be used to create movement. Taking velocity as an example, to fully represent the velocity of our objects, we need the direction in which they are travelling and also the amount (or magnitude) by which they are heading in that direction.

Let's define a couple of things about how we will use vectors:

The preceding figure shows the vector v1(3,-2) which will have a length of √(32+(-22)). We can use the x and y components of a vector to represent our object's position in 2D space. We can then use some common vector operations to move our objects. Before we move onto these operations let's create a vector class called Vector2D in the project. We can then look at each operation we will need and add them to the class.

#include<math.h>
class Vector2D
{
public:
  Vector2D(float x, float y): m_x(x), m_y(y) {}

  float getX() { return m_x; }
  float getY() { return m_y; }

  void setX(float x) { m_x = x; }
  void setY(float y) { m_y = y; }
private:

  float m_x;
  float m_y;
};

You can see that the Vector2D class is very simple at this point. We have our x and y values and a way to get and set them. We already know how to get the length of a vector, so let's create a function for this purpose:

float length() { return sqrt(m_x * m_x + m_y * m_y); }

Now since we have our basic class in place, we can start to gradually add some operations.

Addition of two vectors

The first operation we will look at is the addition of two vectors. For this we simply add together the individual components of each vector.

Let's make use of overloaded operators to make it easy for us to add two vectors together:

Vector2D operator+(const Vector2D& v2) const
{
  return Vector2D(m_x + v2.m_x, m_y + v2.m_y);
}

friend Vector2D& operator+=(Vector2D& v1, const Vector2D& v2)
{
  v1.m_x += v2.m_x;
  v1.m_y += v2.m_y;

  return v1;
}

With these functions we can add two vectors together using the standard addition operators, for example:

Vector2D v1(10, 11);
Vector2D v2(35,25);
v1 += v2;
Vector2D v3 = v1 + v2;

Multiply by a scalar number

Another operation is to multiply a vector by a regular scalar number. For this operation we multiply each component of the vector by the scalar number:

We can again use overloaded operators to create these functions:

Vector2D operator*(float scalar)
{
  return Vector2D(m_x * scalar, m_y * scalar);
}

Vector2D& operator*=(float scalar)
{
  m_x *= scalar;
  m_y *= scalar;

  return *this;
}

Subtraction of two vectors

Subtraction is very similar to addition.

Let's create some functions to do this for us:

Vector2D operator-(const Vector2D& v2) const
{ 
  return Vector2D(m_x - v2.m_x, m_y - v2.m_y); 
}

friend Vector2D& operator-=(Vector2D& v1, const Vector2D& v2)
{
  v1.m_x -= v2.m_x;
  v1.m_y -= v2.m_y;

  return v1;
}

Divide by a scalar number

By now I am sure you have noticed a pattern emerging and can guess how dividing a vector by a scalar will work, but we will cover it anyway.

And our functions:

Vector2D operator/(float scalar)    
{
  return Vector2D(m_x / scalar, m_y / scalar);
}

Vector2D& operator/=(float scalar)
{
  m_x /= scalar;
  m_y /= scalar;

  return *this;
}

Normalizing a vector

We need another very important operation and that is the ability to normalize a vector. Normalizing a vector makes its length equal to 1. Vectors with a length (magnitude) of 1 are known as unit vectors and are useful to represent just a direction, such as the facing direction of an object. To normalize a vector we multiply it by the inverse of its length.

We can create a new member function to normalize our vectors:

void normalize()
{
  float l = length();
  if ( l > 0) // we never want to attempt to divide by 0
  {
    (*this) *= 1 / l;
  }
}

Now that we have a few basic functions in place, let's start to use these vectors in our SDLGameObject class.

This function will use vector addition very soon, but for now we just add 1 to the current position to get the same behavior we already had. We can now run the game and we will see that we have implemented a very basic vector system. Go ahead and play around with the Vector2D functions.

We previously had to separately set the x and y values of our objects, but now that our position is a vector, we have the ability to add a new vector to it to update our movement. We will call this vector the velocity vector and we can think of it as the amount we want our object to move in a specific direction:

We set the m_velocity x value to 1. This means that we will add 1 to our m_position x value each time the update function is called. Now we can run this to see our object move using the new velocity vector.

Not all of our objects will move along at a constant velocity. Some games will require that we gradually increase the velocity of our object using acceleration. A car or a spaceship are good examples. No one would expect these objects to hit their top speed instantaneously. We are going to need a new vector for acceleration, so let's add this into our SDLGameObject.h file.

Vector2D m_acceleration;

Then we can add it to our update function.

void SDLGameObject::update()
{
  m_velocity += m_acceleration;
  m_position += m_velocity;
}

Now alter our Player::update function to set the acceleration rather than the velocity.

void Player::update()
{
  m_currentFrame = int(((SDL_GetTicks() / 100) % 6));

  m_acceleration.setX(1);

  SDLGameObject::update();
}

After running our game you will see that the object gradually picks up speed.