# Introduction to Game Development (E07: vectors)

In this episode we're going to be looking at the Vector structs, which we use to store
things like: positions, velocities and directions.
When we're working in 3 dimensional space, we need three values to define a vector - one
for the x axis, one for the y, and one for the z. This is called a Vector3. When we're
working in 2D space and no longer require the z axis, we can switch to using a vector2
Let's take a brief look at vectors. Say I define a Vector2 with an x value of -4 and
a y value of 3. The usual definition of a Vector states it as a quantity having direction
as well as magnitude, or in other terms, length. We can calculate this magnitude using the
theorem of Pythagoras: so in this case the magnitude is equal to the sqrt(-4^2 + 3^2);
which is 5. To calculate the direction of the vector, we have to normalize it. To do
this we just have to divide both the x and y values by the magnitude: so -4/5 = -.8,
and 3/5 = .6; The significance of what we've just done is that, if we calculate the magnitude
of this direction: sqrt(-.8^2 + .6^2); we'll get a value of 1.
As a practical example of why this is important, say we create a vector2 from the player's
input. Imagine the player is holding down the left and up key, so we have an input vector
(-1;1). Now say we want to move the player object a distance of 3 units in that direction,
so we multiply this input vector by 3, giving us (-3;3). We then move the player object
-3 units on the x axis, and 3 units on the y axis. But, if we measure the distance the
player has moved, we can see it is about 4.2, instead of the 3 we intended. The mistake
we've made has allowed the player to travel faster when moving diagonally. And its an
easy mistake to make, so remember, if you want to treat a vector as a direction, normalize
it first. I find it helpful to think of a normalized vector as fitting perfectly inside
of a unit circle. Our unnormalized input vector with a value of (-1; 1), clearly lies outside
the circle, whereas if we normalize it by dividing it by its magnitude - that being
root(2) - it will have a value of approximately (-.71;.71).
Now because vectors conveniently define an x, y, and potentially z value, we use them
in programming to define, not only directions and velocities, but also simply a point in
space. Say we have a vector representing the current
position of the player object at (-4;1), and then another vector representing the position
of an enemy object over here at maybe (2;3). Now if we were to subtract the enemy's position
from the player's, we'd end up with a new vector of (-6; -2). Considering this new vector
as a position would be quite meaningless, however considered as the displacement between
the player and the enemy, it can be very useful. Its magnitude is the distance between the
two, and if we normalize it, we get the direction from the enemy towards the player. Both of
these, of course, are very useful to be able to calculate.
The vector structs - Vector2, Vector3, and even Vector4 - already exist as part of the
unity library, which we are given access to by the line 'using UnityEngine' at the top
of our code. All the same, we're going to be creating our own rudimentary version of
the Vector3 struct, just so we have a better understanding of what's going on when we use
Vectors in our code.
Now you might be wondering what a struct actually is. Structs are similar to classes, in that
they act as a container for some code. There are some important differences between the
two, but we're going to worry about those in a later episode. I like to think of structs
as a way of grouping related variables together to form a single, custom variable type. Say
for example we have an Enemy class, which needs to keep track of a vector for its current
velocity, and a vector for the position the target its chasing. We could have six float
variables: 3 defining the velocity, and 3 defining the target's position. By creating
a vector struct, however, which groups together these x, y, and z floats, any time we need
to represent a set of 3 numbers, we can simply use this custom Vector variable.
Inside the vector struct would be a bit of code called the constructor. We'll talk about
this in detail when we look at structs properly, later on the series. But this basically enables
us to set the values inside the vector by writing = new Vector3(3,4,5);
We can also get or set the values of the x y and z axes individually by writing, for
example, velocity.x = 5; Unity's implementation of the vector structs
also contain handy methods for doing things like getting the magnitude of a vector, or
the normalized value of a vector.
As a last note, I would like to talk about what sort of operations are defined for vectors.
We can multiply a vector by a number, which has the effect of multiplying each of the
individual axes by that number. The same goes for division.
We can also add two vectors together, which simply adds the like axes together. x + x,
y +y and so on. The same applies with subtratction. These are the only basic operations that are
defined for Unity's vector structs. Multiply or divide a vector by a number, and add or
subtract two vectors. Fancier operations like the dot and cross product, we will discuss
in a later video.
For now, we've learned some of the basics about vectors and how they are represented
in Unity, so next video we will be able to use this knowledge to do cool things like,
make a cube move around our game world, and have a sphere chase after it. I'll see you
then.