Name: プログラミングボール #1 円対円の衝突 C++ (Programming Balls #1 Circle Vs Circle Collisions C++)
Uploaded: 2021-01-14T10:16:10.000Z
Duration: 32 min 29 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

In this video, we're going to be programming balls.

Yes, Let's get all the giggling out the way.

Now I'll show you what I mean when I say balls, I really mean the two day equivalent circles on in this video.

We're going to be looking at building a collision on the response engine for circle Circle interactions.

So, for example, and in here, you can see I've got some circles in the console.

I can't pick up a circle, and I could move it around and we can see that it interacts and collides with the other circles in the field.

Red lines indicate that two circles Aaron Collision and we can see quite happily that circles can push circles in larger chains.

In addition to just the static responses we see here.

We're also going to add dynamic responses, so by giving the circle some rudimentary physics, we can get them to interact with accurate collisions.

I really mean approximate collisions on We also consider this road be a complete physics engine because we're not going to be considering the rotation or angular velocity off the circular objects.

In this simulation, the larger the circle, the bigger its mass.

So if we take a small circle, say this one, for example, on a meat it a large one at the bottom, it bounces off with little effect on the largest circle.

However, if we do it the other way around, take the big circle on hit the little one.

There's a considerably bigger impact now.

We can impart lots of energy into the system and what should come to a nice, stable conclusion.

Now it's my intention to do several videos where we keep adding to this basic engine.

Because cynical versus circle collisions are useful in not just games.

With also simulations on, you'll be surprised where else it can be useful.

There's no getting away from it with these sort of things, we need to do some maths.

However, I hope to demonstrate that the maths isn't really that complicated, and in fact, to do this particular program, he's only a handful of lines of code.

As usual, we're going to use the one loan coded console game engine to do the visualization and user input, which is a class that we override to particular methods on the on user create, which loads the resources on the on news update, which is performed once every frame.

I've subclass the council game engine with a class called Circle Physics and created an instance of it, and I'm going to construct the console to be 160 characters wide by 120 characters tall, where each character is eight by eight pixels.

You may notice this looks a little different from the previous videos, because I've also tried to capture the error.

I've noticed that some of you, when you're trying to create consoles on displays which are too small for the size that you're requesting, you're getting around the cryptic error message.

I should also say that over the Christmas break, I've made some small changes to the council game engine.

Nothing will stop it being backward compatible with all of the other videos.

I just added more features, and we'll see those over the coming videos.

I have touched on physics on quite a few videos already, particularly asteroids game.

The Flappy Birds game on to decode it yourself worms.

So I'm not going to go through all of the basics off Kinnah Matics again, However, most of our objects here are going to be a circle on a circle is represented by a point which will call P X on P Y.

But I'm also going to add to my circle object the velocity vector V X on D V y.

I'm also going to add an acceleration factor, a x and A y.

And as before, if we integrate the acceleration vector over time we get the velocity.

And if we integrate the velocity over time, we get the position.

So let's start by creating a structure that represents the circles.

I'm going to call it ball because I reckon most of my demonstrations will involve some sort of ball physics.

So allowed to the position vector the velocity vector onto the acceleration factor.

Also at the Radius, you notice amusing floating point for all of these.

I'm also going to go ahead and add an integer, which is the I D and we'll see why that's useful.

Later on, before we get stuck into all of the physics and collision code, let's just draw the ball to the screen.

All of the balls here are going to be represented with wife frame models because the council game engine provides the drawer wire frame functionality.

And if you remember, this is a vector off pers off floats, so that each per contains an X and Y coordinate, and it will link all of the coordinates together with straight lines.

So if we want something that represents a circle, we've got to build up a circle out of straight line segments.

We only need one model of a circle because well created as a unit circle on will scale it accordingly.

Depending on the Radius will create the resource in the on user, create function.

So I'm going to start by adding a single point to the center of the circle.

Each circle is going to consist of 20 segments, and I'm going to use our old friends co sign and sign to create the X and Y coordinates off the points that lie on the circumference of the circle around its middle point.

Of course, on, because model circle is a vector, I can simply just push back the new groups of coordinates.

Our ball simulation will contain many balls.

So I'm going to create a vector to stall them all in, And I'm also going to add a utility function to make it more convenient to add balls to this vector.

So here I specify the location on I set the velocity and acceleration vectors to zero so it's not going to move.

Were to set the idea of the ball based on the current size of the vector.

So as we add more balls to the vector, the idea increases, meaning each ball will get a unique I.

I'm making an assumption that will never remove balls from the vector on.

Once the ball has been set up, we'll put it in the back of the vector.

So it's not some balls to the simulation for convenience.

I'm just gonna throw in a default radius variable in case we want to change this later on, and I'm going to add two balls based on the screen.

Positions will be in the middle of the screen, are vertically, but they'll be offsets to the left and right horizontally.

Drawing the balls is very simple as usual.

The first thing we'll probably want to do is clear the screen because we always want to start from a blank canvas and to draw the balls.

I'm going to create a little four loop that automatically ITA rates through all of the elements of the vector, and we're going to use the model off the circle that we've created.

Remember, that's a unit circle, so we're going to scale.

It will take the current balls position to offset the wife frame model.

And if you remember in the Worms game, the circle actually has a line going from the middle point to the edge of the circle.

On this week, we can use as an indication off the velocity or the direction that the ball is traveling in.

Of course, we don't want to move this line around manually.

What we want to do is rotate the entire wife very model on.

We can do that quite easily with the eight and two F function using the bowls, current velocity components in the Y axis on in the X axis.

Finally, we want to scale the bull points radius.

I'm going to draw it as white, solid pixels.

Let's take a look so that we have the screen with two balls.

Let's start with a rather naive implementation off collision detection.

I We're going to test every object against every other object.

I'll create two little four loops, which automatically scroll through the vector off balls on the 1st 1 is going to represent the current ball.

The 2nd 1 is going to represent the target ball Now.

There's one thing to make sure, and that is that we don't test a ball against itself because it will always collide with itself.

And this might cause interesting results in the physics simulation.

So it's important that we filter out self collisions.

So I'm going to use that the ideas that we specified in order to test for this, And if the ideas are not the same, then we know that we're not testing a ball against itself.

So the first thing we should check is half the balls actually collided on.

The way to do this is to see if they overlap, and this is quite simple trigonometry because they have overlapped.

If the sum of the radius is of the two balls is less than the distance between their centers.

So we'll calculate this distance and use this radius on this radius.

And if we know that this condition is true, where a distance is less than the radius is some together, then there's an overlap.

The balls have collided, and in fact we could be really precise by also suggesting that we can tell when the balls are just touching, too.

I feel that knowing whether the two balls overlap is quite a useful utility tohave.

So I'm going to wrap it up in a little lamb to function.

Do circles overlap and the parameters were going to pass through to this lambda function Are the coordinates off?

字幕リスト動画再生

プログラミングボール #1 円対円の衝突 C++ (Programming Balls #1 Circle Vs Circle Collisions C++)

assume

determine

scale

accurate