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.