## Subtitles section Play video

• [BELL RINGING]

• 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

• 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

• 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--

• 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

• 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.