Here we are.

I think this really is the last video in chapter 1 on vectors.

I'm going to add one more detail to this example

of the random walker, which is no longer called a walker.

I'm now calling it a mover.

And where I last left off with this example is

every time I click the mouse, the mover

picks a new random velocity that can

be seen here in the constructor p5.vector.random2d.

Now, you know that's a static function because I

made a whole video about that.

And then that velocity-- every frame is added to the position.

And the mover is drawn as an ellipse at that position.

So I want to add one more concept to this video.

And that is the concept of acceleration.

Acceleration will act as the building block for all

of the examples I'm going to show you in chapter 2

because of Newton's second law, force

equals mass times acceleration.

So acceleration plays a key role in any kind of physics engine

or physics simulation.

But right now, we're not going to worry

about the physics aspect of this and just add

the idea of acceleration.

Our mover object currently has a position and a velocity.

And we've established that the position is a vector that

describes relative to the origin where that object is

in two-dimensional space.

The velocity describes how the position changes over time.

So on a frame-by-frame animation,

the position is here.

Then the velocity is added to the position.

And its new position is here.

And if its velocity remains constant,

it would keep just moving like this.

This velocity would be applied, applied, applied.

However, acceleration can be described as the change

in velocity over time.

So if this object, this mover, were to accelerate,

maybe you-- and the typical way you

might think about that acceleration

is it's getting faster.

So we could imagine it that way.

First, its velocity is this.

Then it's like this.

Then it's like this.

So it's accelerating and moving larger steps each frame.

But acceleration just means the change in velocity.

And remember, velocity is a vector.

So that could mean it's changing its direction

or its magnitude could be slowing down.

That's an acceleration speeding up, turning.

All of those combined together-- that's an acceleration.

It's just another vector.

And it goes into our--

what I'm calling the motion 101 algorithm.

And that motion 101 algorithm can be found right here

in the update function.

Add the velocity to the position--

this.position.addvelocity-- and right

before that, this.velocity add this.acceleration.

So now there we go.

Why isn't it accelerating?

It's not accelerating.

It's not changing its magnitude or direction

because the acceleration is 0.

So let's give it something.

Let's also give it a random vector.

Ooh.

So now you can see that it's speeding up.

Now, the acceleration here is constant.

And it's almost as if there's this big fan

right in the center that's just pointing

in a direction and blows the mover off in a direction.

You could see that it's-- turns ever so slightly.

This is most likely because whatever velocity it picks

is not the same direction as its acceleration.

To demonstrate what's happening here a bit more clearly,

I might do something like set the magnitude

of the acceleration to something much smaller.

So I'm still picking a random unit vector in some direction,

but then setting the magnitude to 0.01.

And you can see now it's turning around.

And I could also go back to putting the background

and setup.

That might help us see the path that it's taking.

And we got-- here we got an acceleration

in a different direction from the initial velocity.

I could also reset the acceleration

to something random every time an update--

let me take this and put it here,

take this off, run it again.

So this is something resembling that original random walk.

But the acceleration is cumulative.

It's accumulating into the velocity.

So if it's picking it in the same direction

randomly a few times in a row, it's

going to build up enough speed and fly off in that direction.

Now, there is another useful vector function

that I haven't mentioned to you that's

similar to the normalize function that I could use here.

And it's the limit function.

What limit does is take any vector

and cap its magnitude at a certain amount.

So if I say limit 5 and this vector has a magnitude of 15,

it will take that vector and shrink it down,

set its magnitude to 5.

The difference between limit and, say,

set magnitude or normalize is if it's less than 5,

it's not going to raise it up to 5.

It's going to leave it at, say, 2.

So back in the code, what I can say

is any-- after I apply the acceleration,

let's make sure the velocity doesn't get too large.

And I can say limit.

I don't know.

I'm just going to say limit it to 2.

So it's a pretty strict limit there.

And then if I run the sketch, what this-- this

is now really looking much more like that random walk before.

But I am using the concepts of acceleration and velocity.

And so now this would allow me to do a lot more stuff

with a random walk.

And that's going to come as I get

to more stuff and more and more of these examples in chapter 2.

But ultimately, what I want to show

you here is what happens when I calculate

a very specific acceleration, like one that points

towards the mouse location.

Still I might say you could pause the video here and try

all sorts of other algorithms for calculating acceleration.

What if you used Perlin noise for the acceleration

or what if you had the acceleration based

on some vector that's based on some other type of data that's

coming into your system?

But for this particular example, I

can return to everything that I did in the previous video,

which is I have the position.

I have the mouse.

And now I just want to do that same exact math operation,

mouse minus position.

Set the magnitude to something fixed.

And apply that as the acceleration.

Let's see what happens.

Start by creating a vector at the mouse location.

[MUSIC PLAYING]

Then I'm going to set the acceleration

to the result of subtracting the mouse minus this object's

position.

Then I'm going to set the magnitude of that to 0.1.

And I'm picking that arbitrarily.

Now, I have a three-step process.

Calculate the acceleration.

Apply the acceleration to the velocity.

Limit the velocity.

Then apply the velocity and position.

Let's take out the limit just for right now.

Maybe we don't need it.

Amazingly, we get this result that's

something like an elliptical orbit.

You would think the object would just be going straight

towards the mouse.

So if this is the mouse right here and this is the object

and it's going in this direction,

basically, I'm taking this and applying it

as the acceleration.

So if I take this acceleration vector

and apply it to the velocity, velocity plus acceleration

equals the new velocity, which is this.

And then add.

So then it's over here.

Then this is the vector I add to it.

So we take this velocity at acceleration.

And now this is the new velocity.

See how I'm ending up in this path?

Now, depending on the relative strength of the acceleration,

then I might be sucked into where I'm--

these-- what I'm being attracted to much more quickly or I

might spiral around it.

And we can experiment with that as a variable.

So for example, what if I said instead of 0.1,

set magnitude to 5?

Well, you can see now it's really going out of control.

So maybe this is where I want to limit the velocity.

And you can see now I've done that.

It can't move very fast.

But it's going to-- remember, that acceleration

is super strong.

It's going to move right to it.

And in fact, it's actually going to stop at it because it--

if it gets past it, it's going to tell it to slow down and go

back in the other direction.

And maybe I want to limit this and set this here.

There's so many different ways.

I don't know what I'm trying to do here.

But you can see I can get very different kinds of qualities

of how this object follows the mouse based on this model

by playing with what the velocity's limit is

and what the strength of the acceleration is as well.

Now, how I actually calculate the acceleration

and how I think about this particular mover

object in a world that a lot of different things

could affect its acceleration-- that's really where I'm going.

And that's really the model of forces.

So there's really this idea of a force.

There's this force that's pulling

the object towards the mouse.

But what if there were other forces?

What if there's forces that are coming

from the walls of the canvas, so to speak, the edges?

What if there was just this wind force or gravity or other types

of things, friction force?

So this is where I'm going in chapter 2.

I am going to calculate a variety of different force

vectors and put them all into the object's acceleration.

Now you have something you can really

play with as an exercise.

Can you create a simulation with an object

moving around the canvas that all of its motion

emanates from its acceleration?

What are other ways you could calculate the acceleration

to create some type of dynamic motion?

And so this wraps up this section on vectors.

I'm sure I missed so many things about vectors.

And there's many more math operations

with vectors and other things to think about and consider.

And hopefully, I'll continue to touch

on those as I go on and on to more and more examples.

If you make something, share it with me

at thecodingtrain.com in the comments here.

If you have questions, you can also ask them.

You could join the Discord to ask your questions there.

And I will be back in section 2 to talk about Newton's laws

of motion and forces.

[MUSIC PLAYING]