Let's make words.

I'm sure most of you are familiar with worms.

It's a side scrolling game where you have teams of worms that battle each other with trajectory based weaponry.

The landscaping worms is randomly generated each time, and we can see we've got here the green landscape versus the blue sky or non landscape.

And I can press the M key to randomly generate to reigns as necessary using the pearly noise function.

And this this is a multi part video.

We won't be looking at the entirety of worms in this intro demonstration.

Instead, I'm going to show you what we're going to achieve today, which is the addition of units which you can see have collision detection and response with the terrain will also add arbitrary explosions so I can click somewhere and it causes an explosion on also damages the terrain with with a crater onder.

If you cause an explosion near a unit, it blasts them around screen.

Very nice.

On the final part will be adding is sequences an event.

So here we're creating a weapon object, which one collides, sort of combines all three things together.

Now, even though I'm splitting this project across several videos, there's still quite a lot to get through, so I'm going to be going through a slightly quicker pace than normal.

After all, a lot of the techniques we see in this video are based upon techniques I've already talked about in previous videos.

So it's all coming together to form one nice project at the end of the year.

And, of course, I'm going to be using the one lone Koda council game engine.

And I've already taken the liberty of just deriving a quick base class from this.

It does nothing other than implement the unused created on user update functions.

And in my in Maine, I'm constructing a console, which is 256 characters wide by 160 characters tall, and each character is going to be six by six pixels.

Just a quick introduction to, say, a big thank you to all the people that have joined the Discord server.

There's almost 100 loan code is out there now, and if you're interested in joining in and getting involved in the chapters, quite a lot of talent on that chat server.

Then I suggest you look at the leaks below for an invite to the discord.

Now I may be boring, but it is very important that with any big project you form a plan before starting on worms is no different.

I know that I've got randomly generated terrain sze on these around them we generated to the pixel level.

And given that worms is a game about accuracy, I think it's important that we have pixel level collisions.

So that's the first requirement.

Worms is again all about trajectories, so assuming you've got a little unit here and he can fire his weapon across the terrain, the terrain gets altered and then causes multiple more trajectories for debris and possibly all the units.

But when debris lands on the surface, it doesn't just immediately come to a stop.

It carries on bouncing a little bit, so we know we're going to need a very simple physics engine.

Well, both of these are hard.

Let's do what we can to simplify them, yet keep them working in a way which is suitable for game play.

And the first approximation I'm going to make is that even though sprites are traditionally rectangular.

I'm going to assume that all objects in my physics engine are circular, and so I've got a unit object, a debris object.

And even though we didn't see it, I've got a missile object.

Now, in a lot of games, when you want to do collisions with maps, you do things like make assumptions that the map is in fact created out of straight lines.

And so then, doing circular with straight line collisions is quite simple or circular, with polygon collisions is quite a simple thing to do.

But that's not how the original worms works it all.

And we want to try and retain the look and feel off that game, so we will have to do a per pixel collision detection routine for a circle.

And although we won't do it in this video circle circle collisions are actually quite easy to do.

On may be useful, for example, if we want units to knock all the units.

As you can see, there's quite a lot to do.

But I'm going to let object oriented programming and pull him officer, help us out.

Everything that can move in my game is going to be derived from a class which represents a physics object on this class will be abstract, but it'll contain useful information such as position, velocity, acceleration and a flag that represents whether it is moving or not a stability flag.

I'm also going to define a pure virtual method, which makes this object abstract draw, which will be used by sub classes to draw themselves on the screen, the missile and debris sub classes.

We're going to be represented by wire frame objects using the code that we made for the code it yourself asteroids video.

This is because I want the missile and debris to rotate to represent the angle is traveling in the third subclass unit or worm is going to be represented by a sprite.

I don't need these to rotate, and so each subclass will implement its own version of the drawer function, using the correct technique required.

This is a simple yet powerful use of polymorphism because I don't need to maintain any object management code.

In fact, all I'm going to do is have a list of the objects which I can.

Then it's direct through, calling the drawer routines and updating the physics.

But let's start at the beginning.

Let's create control the terrain as the terrain needs to be accurate.

Id a per pixel level.

I'm just simply going to create a map on this map is just a two dimensional array, in this case, 1024 by 512 pixels off unsigned charts.

At the moment, the map is just going to be filled with zeros and ones.

It's going to be one wherever there is land and zero wherever there isn't land.

You might think I could use use billions for this.

However, later on, I might want to add two different types of land or different colors to give it some texture.

And so, in the unused create function, I'm just going to allocate the memory for that two dimensional right and then use the members set command to clear it all to zero.

Why not?

I'm going to separate out the map generation to a create map function because I still want the ability to scroll through maps and interrogate them and find ones that I like.

Now.

I also know that my maps are going to require Perlin noise, so I'm just going to cook and paste absolutely character for character from the pearly noise video, The pearly noise one D function.

It's just a reminder takes account off the number of elements in the array a cedar, a full of noise.

The number of octaves were interested in generating on the bias, which was how do the octaves relate to each other?

And of course, we haven't output variable, too.

I'm not going to go into what pearly noises please click on the link above to find out.

But to use the pearly noise function, we need to prepare some data we need.

A one dimensional array, which represents the surface that is generated on this array, will be filled with heights.

We also need a second rate, which is going to be filled without noise values.

I'm just going to use the brand function to generate some noise going toe hack the pearly noise just a little bit by setting the first value to 0.5 because my pearly noise operates between zero and one.

This means that my first element will be halfway up.

It also means that the last element in the array will be halfway up because the pearl annoyed samples of it fixed interval.

This means that my terrain will both start and end halfway off the screen, and this just adds a little bit of consistency to the Syrian generation.

Otherwise, we could have two range, which stop at the very top of the screen and offer no place for the place to fight.

Or they could operate at the very bottom of the screen and actually have little tiny islands and bubbles with no land for the worm's toe walk.

Now we can call the pearly noise one D function.

Now.

Don't forget that the F surface variable is one dimensional, but I've got a two dimensional bit map representing the terrain.

So instead, what I need to do now is scroll through all of the elements in my map and compare them to the heights in the surface array.

Now all of my raise assume that top left is 00 And given that land is usually below the sky, I'm therefore checking that if the current pixel in the map is greater than the corresponding pixel in the surface map, set it to land or else leave.

It's a sky, and that's all that's required.

I'm just gonna tidy up those to dynamically allocated a raise.

Just so there's something there at the start I'm going to call the crate might function after I've created the map array in my own user.

Create function theon user update function for this project is going to get quite complicated, and occasionally we're going to have to throw in code just for debugging and checking on.

They sit in one of those cases.

I'm going to make it that whenever the user releases the M key, it's going to call the create map function again so I can create new maps whenever I want.

Drawing the landscape Terrain is quite simple.

I just iterated through all of the pixels on the screen, given by a screen with and screen height.

Find the location in the map and choose whether the droids are sky or ass terrain.

But we're missing one important thing here.

The size of my terrain Map 1024 by 512 is much larger than the size of my counsel, so I can't fit the whole map on my console display.

I'm gonna have to create a camera and some camera control code to choose which part of the map we display on screen.

I'm going to our two more variables camera position, X and camera position.

Why they're going to be floating point.

I'd like to build to control the camera by moving the mouse cursor to the edge of the console.

And when I do the map scrolls in that particular direction at this particular speed on for this project, you'll see me using lots of hard coded numbers, which I've already decided that the best value after all, it would be quite a frustrating and boring video.

What should be randomly trying numbers to see if it works by using the consul variables for mouse?

I can check.

Is the mouse within say, for example, on the left hand side, five pixels in from the edge.

And if it is, I want to update my cameras exposition using F elapsed time to make it smooth.

In fact, I'm going to do this for all four edges of the council.

But this leads to a rather dangerous situation that the camera could exist outside of the map space, which means we'd be drawing random elements of memory and all sorts of chaos would ensue.

So I'm going to maintain control over the camera by clamping its to the edges off the map.

So now when we draw a map in the draw landscape routine, I'm going to offset it by our camera positions, going to convert them to interview, Of course.

And we're using the now very established technique off.

Why multiplied by with plus X toe work out where we are in the two D array?

I think we're ready to take a look now.

So the council was started open.

We're in the sky, so if I move the cursor down, yep, that's good.

It's girls down the screen and up the screen on across the screen, in both directions, and we can find all the way to the edge when we see it stops automatically.

So we're not going to be looking at parts of the terrain, which we shouldn't be able to see.

Very nice.

If I pressed the M key, I'm not moving the mouse, but I'm generating different terrain teach time.

What we should notice, though, is that the terrain all start from the same point, and they do, and that's because we fix the first value to 0.5.

Of course, I could fix it to, say 0.25 and it would be higher.

Opal, lower down.

We've now created a two dimensional pixel level map that represents that serene, in fact, represents a very large terrain, and we could make it larger by playing with numbers.

And you can look at the pearly noise video that I've done earlier this year to look at the premises for generating pearly noise to generate different types of terrain.

I know that in original words, the terrain could have overhangs and floating islands in the sky and gaps, and these are all achievable, too.

But they probably did start with an element of pearly noise somewhere.

But to keep this video movie, I'm not going to do that.

We're just going to have a single terrain, right?

Let's get stuck into the fun stuff now and create our physics engine going to start by defining a base class called C physics object, And I'm gonna have some directly accessible properties just to annoy people that represent the position, the velocity on the acceleration they're all going to be in floating point.

In fact, the whole physics engine is going to be a floating point physics engine.

I'm also going to add a default constructor, which allows us to set the position.

There were two other variables.

We're interested in a radius, which represents the collision boundary of the object on the flag that represents whether the object is stable.

Stability is quite an important thing to know in a physics engine.

Firstly, if an object is stable, we don't need to perform or computation on it.

If it's not moving, we don't need to do collision checks, for example.

But in our game, it's also quite important to let's say, the worm has just been blown around on the terrain and he's finished bouncing around.

How do we know when to pass control on?

So the next word in the plan we said that see physics subject was going to be abstract because it defines a virtually pure draw method.

This draw method takes some parameters, the first being a pointer to the console game engine.

And this is quite important because my physics object sits outside of any of my console game engine stuff.

Yet I do want to exploit some of the drawing routines, such as drawing wire frame models and sprites.

So this is a way of getting the instance of the game engine into the object code.

I've also got two other arguments offset X and offset.

Why, As you can probably guess, these are going to be related to the camera on not the objects position in the world space.

To help debugged the physics engine, I'm going to create a dummy object which inherits from the sea physics objects.

In fact, I'm going to call it see dummy only to create a constructive for my dummy objects.

I was just passes through the X and Y position in world space because my based classes abstract.

I need to implement the draw method somewhere.

Now I'm going to add something which I'm sure is going to cause me no end of bother in the YouTube comments and on the discord server, I'm going to have a private static variable to a vector of pers of floats.

Now, this vector of pers afloat is exactly the same data time we used in the code it yourself asteroid video.

In fact, this is how we're going to start a wire frame model on.