COLTON OGDEN: All right. Good evening, everybody. Welcome back to GD50. This is lecture six. And today we're going to be venturing out of the 8-bit world and back into a more modern era of gaming. We're talking about Angry Birds today. I have pretty fond memories of Angry Birds, actually. It was the first mobile game that I remember playing where I realized that mobile was actually a viable platform for gaming. I played it, I think, back in 2009, was when it was first released. And I really enjoyed it. It has a very simple formula. The goal, if you're unfamiliar, is you have birds that you control by a sling shot on the left side of the screen. And then these pigs that have stolen your eggs, you're trying to destroy them or kill them by knocking down their fortresses made out of various materials, wood, glass, metal. And you get a few different bird types. But the gist of it is, basically, just sling shot a bird into some structure, knock it down. And the whole entire underlying mechanism for how things work is via a physics engine, which we'll talk about today in lecture, called Box2D Probably the most ubiquitous 2D physics engine. But that's the overall structure of the game. It's literally just throwing things into structures, knocking them down. And then that tactile and fun game play makes for really great mobile gaming. And I enjoyed it a lot back in the day. This is a screenshot of the first level in the first Angry Birds, which most people I think have probably seen. This is a sample from one of their newer games. As you can see, it's taken a whole new layer here. There's stone and a bunch of intricately varying structures and new creatures and stuff like that. The game has changed a lot, but the formula has stayed the same. And today we'll explore the foundation of what makes this game work. And the topics today, a smaller than usual. But Box2D, we can consider as being a pretty large topic. We'll be talking about Box2D, which is the physics engine we'll be using today in lecture. And via Love2D, which has its own wrapper for Box2D. And we'll also talk a little bit about mouse input, which you haven't really done a lot. But it's very apt, especially in the context of mobile gaming. Because mouse input and touch input are synonymous. But first, let's get a lecture demo. If we have a volunteer come up on stage to showcase what I've put together here. So let me make sure I'm in the right directory here. So whenever you're ready, go ahead and press Enter. So this is a little demo I put together to demonstrate the concepts we'll talk about today in class. This is just the Start screen, but it already shows Box2D representing a bunch of these square shaped aliens, which we'll actually be what we're trying to target in the game. But notice that they all fell and had their own collision and their own physics that took place, and I didn't have to manually code rotation and stuff like this. This is all stuff that Box2D takes care of for us. And we'll see it used to great effect soon. If you go ahead and just click anywhere on the screen, we'll go to the main part of the game. So this is a very simple representation of what Angry Birds is. You start on the left side of the screen. You have a bird, in this case an alien, we used a free art pack that uses aliens instead of birds, but it's the same concept. You have an alien that you can click and drag. So if you click it and then drag around, you can see the trajectory that you'll have when you let go of the mouse. So we're simulating where it's going to go via these purple circles. And then the goal in Angry Birds is to throw the bird into, or the alien, into the fortress guarding the pigs, or in this case, square shaped aliens. So if you go ahead and just launch the bird by letting go of the mouse you'll see. Oh, there we go. And we knocked down the. OK. What happened was we shot the alien into the structure. It destroyed one of the wooden blocks guarding the other alien. And then, as soon as that happened, the top box, because these are all being simulated via Box2D's physics engine, that other box was detected as being unsupported. So it fell down, it hit the other alien. And we've coded it so that when a collision occurs between an obstacle and our alien of sufficient speed, it should kill the alien. Which is how it works in Angry Birds. So if you'll try it again. And this time we hit both of those at the same time. So it triggered both of those being deleted. But this guy is still alive. So after it stops moving, which is similar to how it behaves in the original game, it's going to let us try again to shoot. So if we try one more time. And then we launch and hit it, we kill it and then we get a victory. So that's the overall underlying foundation for what Angry Birds is. Obviously we're using a very simple representation. It doesn't have a lot of the frill that Angry Birds does. But we could easily build upon this and create a fully fleshed out game very similar to Angry Birds. So thanks, Steven. I appreciate the demonstration. So that's our goal today. We'll be talking about how to construct a very basic but functional simulation of what Angry Birds is at its core. Which is just flinging things into obstacles, destroying them, and ultimately destroying the things that they're protecting, the aliens, the pigs that are in the base game. So here's a shot of what the different sprite sheets we're going to be using are. There's a really great sprite sheet that I got off of Open Game Art. Kenny is the artist. He makes a lot of great art. If you notice, it's very similar looking to the art that we use in the Mario lecture. Actually, it's the same artist. So if you're ever looking for assets, he's got a ton of awesome assets on open game art. So we have a set of aliens, square and round shaped. I decided just arbitrarily we made the round shaped aliens the birds. So we shoot those into the structures that are protecting the square shaped aliens. The square shape aliens will be the bad guys in this case. And then we have another sprite sheet down here below on the left side. Which just, I used the tile here just to make a ground element. The rest of these you could easily include in the game if you wanted to, but we're only using the ground here. And then notice here, we have this large sprite sheet which has a bunch of different shapes and sizes of materials. The whole sprite sheet comes with metal and explosive and glass sheets as well. But just for simplicity we only use the wood here. But notice that we have entirely whole pieces and then we have pieces that are partially destroyed and then pieces that are hollow. You could easily model all of these in your game and use them. But we only decided to use just a couple of these, which was just the horizontal and the vertical ones that are completely whole. These, unfortunately, don't have quite the same systematic layout as the sprites that we used before. They're not laid out in a grid evenly spaced. So in this case, in util dot Lua, I ended up hard coding the different XY width and height quads for each of these, which is what you have to do in a situation where you're interacting not with tiles per se, but with more organic shaped objects. So it can take a little more time to end up constructing all of the quads for your objects when you have a sprite sheet like this. But, fortunately, you only have to do it once. Here's a few useful links before we get started in talking about what Box2D is and how to use it, and basically how it's called love dot physics, effectively, in love2D. The first two links are documentation for love 2D, what the functions and objects are that we'll be talking about. And a simple tutorial that talks about how to make a ball bounce in love 2D using Box2D. The third is a great resource that I used actually to learn most of what I know about Box2D, especially in the context of this lecture. So it talks about a lot of different concepts. It talks about all the things that we'll be talking about. And then it goes into a lot more detail about how you can go about constructing a lot of really cool, crazy things like tanks and pulleys and a whole bunch of different things that are worth looking into if you're looking into potentially making a physics based game. Obviously we won't be going into things of that complexity here. But you could easily do it with Box2D. It makes it very, very possible. So the very first thing that we should talk about when we want to construct a game, or simulation, or whatever we want to do, with Box2D is we need some sort of system that will actually perform the simulation for us. And the fundamental core of what a Box2D app or game is, the core is the world object. So there is a world that you can think of as sort of being your world, but what it effectively is is a machine that simulates all of the pieces that you've told it interact with each other in Box2D. So Box2D has a set of objects called fixtures and bodies. Those perform the physical interactions. And it's up to the world to update all of those and apply the relevant forces and physics calculations that resolve collisions and do all sorts of things. All of the things that Box2D does for us, the world takes care of this for us. So we don't have to manually go through and update every single object with its velocity that we've done before and check for collisions. The world does this for us, and resolves them based on how we tell it to resolve them. And the world also possesses, like an actual world would, gravity on the x and y-axis. In this case, we have gravity applied on the y-axis going down, so it's a positive value. We set it to 300 in this distro, but you can set it to whatever you want. Setting a lower gravity would have the effect of making it feel like we're on the moon or something. Making it feel like we're on a different planet. So that's what the world is. The world simulates everything. And we'll go through just a few terms here before we look at some source code. But there's a few terms that we need to understand before we can really understand what Box2D is doing. And this is the function that we use to create a new world in love2D. Very simple, love dot physics dot new world. And this love dot physics is just a name space that encapsulates all of the Box2D functions and objects that love2D has access to. So anything that you see in love dot physics is effectively a wrapper for Box2D. And to clarify about Box2D, Box2D is just a library that's written in C++ that you can plug-in pretty much anywhere you want to. Unity uses it and, actually, most 2D game engines that I've ever seen including Live GDX, for example, which is a very large Java 2D game framework uses Box2D. You can use it anywhere. In this case we're using love2D's own wrapper for it. So the people that created love 2D, they took Box2D and then they just put a bunch of Lua functions around them, around all the objects and functions to make it possible to use it in the same style that we use the rest of the framework. This is how you create a new world. This is the first step in getting your Box2D simulation working. So any questions so far as to how we can get that going? OK. So beyond the world object, which is the foundation, sort of sets up our stage, you can think of it as our stage, we need bodies to actually interact with each other. So a body is just an abstract container. It basically holds a position and a velocity. And you attach things to it via what are called fixtures that allow you to give the body a shape, and therefore a collision box, and therefore allow it to interact with other things. But a body is essentially all the disparate things in your scene interact with each other and move around. And so to create a new body we just do love dot physics dot new body. We pass in the world, so therefore when we do this, the world has a reference to this body now. And every time we call update on our world, which we'll see in the source code, it will know, OK, I have a reference to this body, perform all of the relevant checks on the collision for that body and all the fixtures that it contains. Update its position, updates velocity, and so forth. And not only a world, but it also gets an x and a y, which will place it in the world on instantiation. The last parameter here, type. There are three fundamental types of bodies which we'll see in love 2D, static, dynamic, and kinematic. And that basically influences how it'll interact with the other objects, the other bodies, in our scene. So we have the world, which encapsulates everything, all the bodies, all the fixtures. And then we have the bodies, which are the entities in our game world that have position and velocity, effectively. The last key ingredient here that will allow us to create interactions between the bodies that we have are fixtures. And fixtures, all a fixture is, is this abstract object that will allow you to attach a shape to a body. So bodies are shapeless by default. They don't have a shape. They are just a container that has position velocity, effectively. But they don't interact with anything else. And they don't know how to interact with anything else until you give them a fixture. And the fixture you will give the body and a shape. So for example, if you want the bird that we were looking at earlier, the alien, the round alien, we create a body for it in our world, which doesn't mean anything yet. But we say, I'm going to attach a fixture to that alien. I'm going to give it a circle shape. And it'll then know whenever it performs any calculations, that that alien should interact with things as if it were round. And therefore trigger collisions based on a circular hitbox, as opposed to a rectangular or polygonal hitbox, as we'll see. Fixtures, in addition to attaching shapes to bodies, which will, as said here, influence how they collide with other bodies, they have density, which we'll see. So that things with higher density obviously will fall faster, or not fall faster, but they will influence things as if they have more weight. They will push things farther when they collide with them. They also have friction and they have restitution. Restitution is bounciness. So if something, if we had our alien, no restitution when it hits the ground it'll just fall flat. But if we give it a higher restitution it will actually bounce when it hits the ground. And therefore interact with the world a little bit differently. So when we want to take a fixture and apply a shape to a body, we have a few different shapes that we can apply to it that are given to us by default in love 2D. So circle shape, rectangle shape, edge shape. These are just, effectively, how we define how our bodies interact with other bodies. How, for example, if it's something that's circular it should roll when it's moving along the ground. Or when it hits something the corner obviously of it won't hit something because it's rounded, as opposed to something that has a square hit box, it'll affect things in a slightly different way. And we can define arbitrarily shaped hit boxes, thanks to the polygon shape. If we want something to be shaped like a pentagon, for example, and have it roll around and behave like such, we can just define a polygon via a set of vertices. And then affix that to a body and it will behave as if it were pentagon shaped. And this is how you would instantiate just as we've seen with love dot physics dot new world and love dot physics dot new body, love dot physics dot new fixture takes in a body and a shape, and will apply that shape to the body. And the world after that will know exactly how to collide with things. And so the last thing, the last slide we'll look at here before we start looking at source code is what the different body types are. So I alluded to having three different body types before, static, dynamic, and kinematic. So a static body will exist in our world but not actually be affected by gravity or the collision of anything else. Things can hit it and bounce off of it and do their own thing, but the static body will never be influenced by something else. It exists as some sort of permanent structure, almost like the ground. You don't really affect the ground by moving into it and bouncing into it, unless you do it with enough force. But in our Box2D world, a static body cannot be influenced by anything else. A dynamic body is the opposite. It has the full simulation of Box2D. Gravity affects it, things collide into it, it will bounce off of them. It'll do what you would expect a normal body to do. If I throw a ball in this room and it hits the wall, it's a dynamic body. The walls are the static bodies in this case. And then a kinematic body is a hybrid between the two. It's something that can move and can rotate and do things, but it's not influenced by other objects colliding with it. So, for example, if I have a platform that's just spinning indefinitely, but it's not being affected by gravity and it doesn't move when I hit it, that's a kinematic body. It's still moving and it's semi-static and it influences other things, but it's not purely static. It does have a little bit of behavior that it can grant it. So let's go ahead and look at a few examples now and see how this actually looks in code. So I'm going to go into an example, if you're looking in the distro, there is an example called static. So we'll take a look here and see what a static body looks like in our scene. And for all of these examples leading up to Angry Birds, we're just going to render everything with shapes for simplicity. But this, as anti-climactic as it is, is a full Box2D world with just a single static body. And it's just this square here, colored white. The static body doesn't move, it doesn't do anything. Nothing can influence how it moves or behaves. But it exists in our world as a permanent fixture. And if we had dynamic bodies and we threw a dynamic body at it, for example, the dynamic body would bounce off, the static body would stay there permanently. So let's go ahead and take a look at what the source code looks like for that. So I'm here in main dot Lua of our static file. And just as we've seen before, we needed to find a world. So I have a world here on line 45. Love dot physics dot new world, no x-able gravity, but we are going to have 300 units of positive gravity on the y-axis, which is going from top to bottom. We need a body for our square that's in our game world, our static square. So we're going to go ahead and define a new body here. Love dot physics dot new body takes in the world, recall, because that's how our world's going to have a reference to that body, doesn't know about it unless we pass it into here, our new body constructor. And then I'm just going to put it right in the middle of the screen. So virtual width divided by 2 and virtual height divided by 2. The difference between Box2D bodies and things that we've drawn before or seen before is that everything is defined by its center point, as opposed to its top left. So I'm able to say virtual width divided by 2 and virtual height divided by 2 here. But I don't actually need to say virtual width divided by 2 minus whatever the half of that square is. By default, the center point is the XY of that object. And this last string here in the constructor for our new body, static, tells the constructor that this is going to be a static body specifically, not a dynamic body and not a kinematic body. So we have a body and it's static, but it doesn't have a shape, it doesn't really know how to interact with anything else in our world. So we're going to give it a-- we're going to create a new shape first. So love gives us a few functions in the form of new X shape. We have new rectangle shape, new circle shape, new edge shape, a few other ones. We're just going to create a new rectangle of width and height of 10. So that's what the 10 and 10 are here. Then we're going to create a new fixture. We're going to affix the box shape to our body with this function. And then once we do that, all we have to do is then render a polygon with fill and then we get the coordinates for our-- or the vertices for our polygon by saying, body get world points. So that's a function off of any Box2D body that will basically get where it is in the world and all of its vertices. And then you just pass in the shape that you want to get the points for. And that will end up just exploding here into a set of vertices that fill up this love dot graphics dot polygon. And the end result of that is we get a square. And we specifically use polygon instead of love dot graphics dot new rectangle because that's what the get world points function explodes out to. It doesn't explode out to the number of arguments that would satisfy love dot graphics dot rectangle. So not a very exciting example. But this is basically the foundation of a full Box2D application. So any questions as to how this works at all? AUDIENCE: Yeah. I'm wondering. How does it determine the center of a abnormal shape? Not like a polygon, square, rectangle, or circle. COLTON OGDEN: The center of an abnormal shape. I'm not entirely sure. The circle is just-- AUDIENCE: [INAUDIBLE] COLTON OGDEN: Yeah. I'm not entirely sure about a polygon though. I haven't looked into that into too much detail. I can explore that and see. That's something that I think Box2D is-- the actual library implements that and calculates that. Probably based upon calculating the area of-- and to repeat for the camera if I didn't repeat already, it's how does Box2D calculate the center point of something non-symmetrical, like a polygon? And best I can understand is that it would do an area calculation off of it and figure out where all the vertices tend towards, I guess. But, yeah, that's something that's implemented in the library. I'm not entirely sure. I can look into it and see and then I'll post in the Slack. AUDIENCE: It seems like [INAUDIBLE] you did have that, it would be difficult to place in a very precise spot. COLTON OGDEN: Yeah. If it were-- yeah. If we did have an odd shape to get it placed in a exact spot. Yeah, I'm not entirely sure. I'd have to explore that a little bit. Interesting idea though. But, yeah, that's essentially how we get a Box2D world up and running. We have a static body. It's not terribly interesting. But with one change-- so I have a separate example called dynamic in the source code distro. But all we need to do to really see the difference between a static and dynamic body is on line 48, just change static to dynamic, save it, and then rerun it. And then we'll immediately see that it's affected by gravity and it moves downwards as we've told the world that our gravity is set to positive 300. And so that behaves how we would expect it to. Now, there's nothing else in the scene so it's not particularly interesting. So I've created a another example called ground. So let's go ahead and look at that. So if we want more interesting behavior, what do we need to do in a nutshell? AUDIENCE: Have more shapes and make a ground. COLTON OGDEN: Some more shapes and make a ground. Exactly. That's a simple way we can start to get instantly a sense of how powerful Box2D is. Just introduce more shapes that interact with each other in different ways. So ground is an example that just introduces a ground into our scene, so that we can see the box fall down and actually collide with something else. And Love2D makes this nice and easy. Excuse me. They have a actual edge shape that will allow us to basically form where the ground is. Anything that collides with this-- it's effectively a line. But no matter how fast anything moves in are scene, the body will not move past that line. So it's a nice, easy way of getting a ground in our scene without having to implement a polygon that maybe has two vertices going left to right on the screen. So that's what we do here. We have a ground body, which is a static body, recall. Because the ground shouldn't move. We're going to change the box into a dynamic body, but the ground shouldn't move. The ground should be unaffected by anything. It's going to be static in our scene. And it's going to have an edge shape. So notice here, we take 0, 0 as the XY. And then a virtual width is zero. So with shapes, when we define them here, it's not going to draw the shape at 0, 0, at virtual width in 0. This is relative to wherever the body is located. So wherever our body is, this shape will be drawn with these coordinates, this X and Y and this width and height, relative to that. And specifically, relative to the center point of wherever we place a body. So if this ground is set to 0, 0 at virtual width and zero, where do we need to place the actual body for it to render the ground appropriately? AUDIENCE: The middle bottom. COLTON OGDEN: Yeah, so we place it towards the middle bottom. So we actually end up placing the body itself here at virtual height minus 30. And when we affix this edge shape to the body, we'll end up, even though it says 0, 0 virtual width zero, it's relative to wherever the body's XY are. So it's actually going to be 0 virtual height minus 30, virtual width zero will be where that edge exists. And then lastly, just as we did with our box, we need a ground fixture so that the ground body knows how it should interact with other things. So we're going to affix the edge shape, which is just a line, to our ground body. And then here we do love dot graphics-- just as we did with the love dot graphics dot polygon for our box, we're going to do love dot graphics dot line for our ground body. And we're going to do the exact same thing, get world points and get points passing the edge shape here. And I'm also setting a line width of 2 just so we can see it a little bit better. And I'm going to color it red. Again, I colored the box up here green. So go ahead take a look at what this looks like. So I'm going to go into ground. And so notice-- and I also added a little bit of restitution to the-- as I said before, restitution is a quality that a fixture can have which gives it bounciness. So rather than just falling flat down onto the ground, it bounces a little bit as well. And we can see the interaction, so I'll play it one more time. It starts in the middle. And then as soon as it hits the ground body that we created before, the edge shape, it bounces a couple of times. But it shows that the box is dynamic, but the ground is static. Nothing influences the position of the ground. It gets hard set and will stay there permanently. So that shows a nice, easy simple demonstration of an interaction between a static and a dynamic body. I'm going to go ahead and pull up another example here. So kinematic, recall, what was the difference between a kinematic and a static or dynamic body? AUDIENCE: Kinematic can move but not influence other shapes. COLTON OGDEN: Correct. So a kinematic body can move. You can ascribe it positional velocity or angular velocity, it's rotation. But when something collides with it, it's not going to be influenced by it. It's going to influence the body that it collides with. It's going to affect it in some way, but nothing colliding with the kinematic body is going to have an effect on its position or its velocity. It's something that exists and does something programmed and will just do that indefinitely, but it will interact with other dynamic bodies as we have programmed. And it will not interact with other kinematic bodies either. They will almost pretend that each other doesn't exist. If you overlap a static and a kinematic body or kinematic and a kinematic body, they render on top of each other, but they don't actually influence each other's position or anything like that. So I'm going to go ahead and run the kinematic example. So here we have a few things going on. We have the box body that we had before, the dynamic box that falls from the middle of the screen. We have the ground on the very bottom to catch it. But we have three kinematic boxes in the very center that are spinning that influence the green box when the green box collides with them. So as you can see, it tosses it around and then the green body falls back to the bottom. And in this example I've taken away its restitution. So as soon as it hits the ground, it just falls flat. Just like that. And so, as you can see, these blue bodies, they're moving. They have angular velocity indefinitely. Specifically 360 degrees per second. And they will stay in that exact position and rotate in that exact way forever. But as soon as they interact with a dynamic body, they actually cause a collision with that dynamic body. And the collision resolves and this green body gets tossed around because it's dynamic. It will basically do whatever it can to interact with the game world as long as it's interacting with other bodies and resolving its collision that way. And so that's the key example between what the three different bodies are fundamentally. And with these three body types you can construct pretty much any scene that you want to. And obviously the bodies and the fixtures can get insanely complex. I mean, we can look back here at this first example. These structures are a composition of many different types of dynamic bodies that have been given anchors and joints and all sorts of other things to make them look as if they're big constructions. But at the end, they're all just a bunch of little bodies that are welded together, fixtures that are welded together. And these fundamental building blocks are how you construct scenes like this. Put a bunch of these blocks together, weld them together with joints, in this case. We won't cover joints in the context of this lecture. But if you're wondering how all of these individual things can be collideable while still constructing these massive scenes and having physics applied to them, they're just jointed together using weld joints or other types of joints, pulley joints depending on what they are. In this case, there is two circle shapes here, circle fixtures, that are the wheels on this cart and then they're welded to the flat constructions here. Allowing those to be dynamic allows the wheels to roll, and therefore carry the other load with it. Same with this bridge. I forget the exact name of the joint, but it's a chain of fixtures together that are welded by a specific kind of joint. And by putting them together in this way, you get a bridge and all sorts of things that you could think of, including tanks, which is in the notes here. This third link, one of them talks about how to implement a tank by having treads going around circles and then a massive body. You could do anything with Box2D, it's an awesome library. In the context of Angry Birds, really we just scratched the surface for what is possible here. So I'm going to demo now. Actually, I enjoyed, I think, this demo, this bit of code, more than I enjoyed the Angry Birds implementation. And it's a program that I wrote called Ball Pit. Oh, by the way, before I get into that. So I'll leave that as a little teaser, I guess. Looking at kinematic, really quickly. We're going to look and see that I've created a table for the kinematic bodies, a table for the fixtures, and then one shape. Because you only need one shape actually, and you can apply one shape to as many bodies as you want to as long as they all have the same shape. I just create three kinematic bodies here. So spacing them out relative to the center with this math here. They get the string kinematic. And that's really the key difference. And then before finishing, I make sure that I set them to have an angular velocity. So this is how you spin something. If you want to set something to spin indefinitely, just set an angular velocity. In this case, 360 times degrees to radians. And that's just a formula written out as a constant, which is just the number-- I forget offhand what exactly the formula is. But it's up here. It's degrees to radians 0.01745329, et cetera. But just like pi, it's a number that you can use to multiply a number in degrees, and you'll get a number in radians. And there's the reverse up there as well. We have to do this because Box2D expects, for any types of rotation, it expects it in radians. I prefer thinking in degrees. So I passed in 360 times degrees to radians. And so we render down here, just as we did with the box body. We render the kinematic bodies, polygon fill, kinematic bodies at i get world points kinematic shape get points. Nothing terribly different. The only real key difference is that we've added kinematic as a string to the constructor for the body. And we've added some angular velocity. And recall, this will make it spin indefinitely, but it will never be influenced-- its angular velocity will never be influenced, its position will never be influenced by anything else in our scene. So now with that out of the way, I'm going to pull up Ball Pit. And maybe I'm just a little bit too excited about this. But I enjoyed this a lot. So what it is, is this is like a bigger demonstration of putting all these pieces together. We have a bunch of circle shapes. They're all interacting with each other. They all have physics. And then I have a larger shape here, this square, which has a higher density than everything else. And by pressing Spacebar I can just dive into-- throw it into the ball pit, and it'll cause an interaction with everything else. And a bug slash feature that I discovered about this is that if you press Spacebar over and over again, it never resets its velocity. So it just slams down into the ball pit. So it's just kind of fun, and I think there might actually be possibly a game idea in here. But, I mean, well, what are the pieces here? What's different about this? AUDIENCE: They're all dynamic shapes. COLTON OGDEN: Yeah. So they're all dynamic shapes. Except for the ground at the very bottom. And also, hidden from view are actually two more static shapes on the left and right. Because if we didn't have those, all of the balls would fall to the side out of view. But yeah, we have the static delimiters for our scene. But we have a bunch of dynamic bodies, the balls are all dynamic. And then the square is also dynamic. And then, like I said before, the only real difference between them is that obviously the square is a rectangle. But it also just has a higher density. And so by giving it a higher density it pushes everything else-- oh, what happened there? That was weird. It pushes-- I think it went to sleep because we didn't do anything for a while. But it's able to fall through everything else because it knows that it's heavier, and that it should push and apply a larger force to everything else that's around it. And so by using these fundamental building blocks of what Box2D is, you can construct a lot of really cool simulations and other fun programs and actually get interesting game ideas. I'm inclined to believe that Angry Birds started out as somebody messing around with the Box2D, or physics engine like this. And it was inspired by some other game that I should look into a little bit. But the creators of that game, presumably, found this physics engine and were like, oh, this is cool. I'm going to put a tower of blocks here and just throw something at it. And then they realized, oh, we can make a game out of this. And so I encourage you, if you're ever curious to just experiment with things like that. We could probably turn this into a game. I don't know. I like this a lot. It's a good segue from the abstract, for lack of a better word, examples that we used earlier, and merges it more into the realm of how can we make something fun with this? And so that's how we're going to start moving into the distro today. So the main topic of today's lecture is Box2D and how we use it to make a game. Another thing that we should consider is mouse input. We haven't really used it yet. And I believe I've mentioned it before, slightly offhand. But Love2D makes it super easy. It's just like we do with keyboard input. We just have a couple of callbacks that are in main dot Lua, mouse pressed and mouse released. The difference between these and key pressed and key released is that they also get an X and a Y. Because usually, when you click the mouse or release the mouse, you want to know where it happened because that's obviously pertinent to what you're doing when you're using a mouse. So these are fired by Love2D every time you click or release a mouse button. And they get the X the Y and the key, and you can do whatever you want with those. And just as we've done in prior lectures so that we can use mouse input in other modules besides main dot Lua, there's a function called love dot mouse dot key pressed and key released that I implemented in main dot Lua. You can check those out. They're very similar to how we did the input tables for the keyboard before. But they allow us to use this functionality inside of other functions, other modules, besides main dot Lua. So let's go ahead and start looking at-- this is where we're going to start looking at the distro for Angry Birds and how we can take all these pieces and form them into an actual game. So the first thing we'll do, we'll take a look at just a couple of things and then we'll take a short break and then we'll get more into the meat of it. But let me go ahead and clear out all of these. And then we're going to pull up-- so the distro is in Angry 50. And so main dot Lua is here. So not a whole lot is different in here. So we have two states in our game. So we had a start and a play state, as we saw before. The start state is like we've done before. The only difference is in this start state, well, for one, it's running a Box2D simulation. And two, we're actually using mouse input. So actually, let's look at main so you can see where I've added this, which is different than before. So we have love dot key pressed, as we've seen before. But we also have mouse pressed and mouse released. And then mouse was pressed and mouse was released. So those are the main differences in main dot Lua this time, as opposed to last prior lectures, which we only had keyboard input. And as you can see here, we have input tables for keys pressed and released on the mouse. And so we initialized those to empty on every update frame just like we've done with the keyboard. And then the input tables get updated in the callback functions as we've done before. And so that's basically all that's different about main dot Lua this time. And that's how we've tied together the new mouse functions that we've just looked at into our game. The states that exist in our game are play state and start state. So very simple. Very similar to last week where we looked at Zelda, we only basically had a start state and a play state. The start state, we can see here, just to tie together the last bit of our usage of the mouse. Love dot mouse dot was pressed 1. Does anybody know what this 1 is? AUDIENCE: Is that left click? COLTON OGDEN: It is left click. So Love2D assigns integer values to all of your mouse buttons. And 1 is traditionally the default value for left click. Some frameworks will use 0. But Lua, 1 index so start with 1 instead of 0. The thing about the start state here that's kind of cool and interesting. So I'm going to go ahead and play it again, the game. So we start off and right off the gate, just to make things interesting rather than just have a static screen that says Anger 50 click to start, we're actually running a Love2D, a Box2D simulation here. It's a world with a bunch of squares. And so what kind of bodies are all of these? AUDIENCE: [INAUDIBLE]. COLTON OGDEN: They're all dynamic bodies. And we've encapsulated them all, just as we did before in the ball pit example, with some invisible static bodies on the left, right, and bottom of the screen. Because if we didn't have those static bodies they would just fall all the way down. And the nice thing is we don't actually have to render anything. So if you want maybe an invisible barrier for something in your game, or you want to encapsulate something, something physical, you don't have to render anything. You can just have arbitrarily shaped and positioned static bodies. And that will act as a container. So that's all we're doing there. We have a container set for all of our little square alien guys. And by creating, I think, a hundred of them and just letting them drop, we have this interesting visual start to our game with very, very minimal effort. So we can take a look at this. So in our start state init, as I said before, we have a world. We obviously need a member of new world. Anytime we do any Box2D stuff you have to start by having a love dot physics dot new world, else you won't be able to run any simulations. Going to create a ground, walls, and then a bunch of aliens. So this here, we can see that we have a table that we're inserting aliens into. But we have a class called alien. So anybody want to ballpark what an alien class ultimately encapsulates or ultimately is? AUDIENCE: Probably the way it looks, like the skin. COLTON OGDEN: It is, yeah, that's definitely a part of it. So the way it looks, or it's skin. So it does have a reference to that. And then more functionally, it also possesses a body and a fixture. So rather than having a bunch of bodies and fixtures that are separated out and maybe just in tables at the surface level of whatever, our level, just wrap them in a class. And then we just can maintain a reference to each individual alien's body and fixture that way. So it's a little bit more encapsulated. It's a little bit more object oriented, little bit cleaner in my opinion. The alien class can take square or round as its-- well, it can take anything you want to as its type. So this will ultimately decide how it's rendered and what shape it gets. But if it's square, which is the default, so if you just create an alien with no type, it will get a love dot physics dot rectangle shape. So as we saw before, that's just a box. And then if not, we just default to circle shape. But you could program it to take in whatever shape you want, and then just give it that shape. And you don't really have to do much in terms of coding how it interacts with anything else in terms of collision, at least. Because, thankfully, Box2D will know, OK, it's a circle. It should spin around and interact with things like a circle. Or it's a rectangle so it should interact with things like it's a box. Just nice and convenient. And then we'll just create a fixture here. This set user data function here is important because we'll see in the context of how we actually resolve collisions in a customized way, we'll need user data to be able to differentiate what gets collided in our world. But at the moment you can just know that this basically allows us to pass in-- to set arbitrary data onto a fixture. So we can say, fixture set user data alien, the string alien. And what that means is that fixture has some customized metadata about it that says, this is an alien. It's whatever we want to do with it. We could give this a table as well. We could just say, the user data is a table and then has a bunch of information that we can then use at collision time to perform different work on it. But this set user data function is how we are able to resolve collisions between obstacles and aliens differently than, say players and aliens, or even the alien and the ground. Because when we do any Box2D collision, right, the world's taking care of the collisions for us. How do we tell the world, OK, when I hit the ground I want to play a sound, but not do anything. If I hit this box at this velocity, I want it to destroy it. If I hit the alien, I want the alien to disappear and I want to show a victory label. How do we do all these different things? We do that with what are called collision callbacks in the context of Box2D. And we'll see how that works. But suffice to say, user data will be very important coming forward. And then this launched false, actually we don't end up using this so this is irrelevant. But it has a render function here, which just takes in the bodies X and Y and will draw it at the angle that it's at. So that's an important thing. When we before, what we were doing is drawing things via shapes. So love dot graphics dot polygon, love dot graphics dot circle, love dot graphics dot line. But if we want to draw a sprite instead, we need to draw it at the right position, first of all, right? And then things also rotate in Box2D. So we need to draw it at the right angle. So what we do is we can actually query the body for its X. We can query the body for its Y. And we can also query the body for its angle. And then we can draw the texture and the quad that we want to using those XY and the angle, and that will have the effect of drawing a sprite in the world that mirrors what's going on in Box2D, rather than just a simple shape. So that's as simple as it is for drawing a sprite instead of a shape. You can see here, the 17.5 17.5. Does anybody know what that's for? AUDIENCE: Not sure. COLTON OGDEN: So 17.5 17.5 at the end is half of the width and half of the height of the aliens. So aliens are 35 by 35 in this game. We pass those in. This is the center of origin. So when we rotate something by center of origin, it basically describes where the rotation is going to take place. So if it's rotated about the top left and we rotate something, it's going to have the effect of the sprite going around in a circle in sort of an odd way. If we rotate the sprite based on the center of origin of the actual sprite itself, that will have the effect of rotating the sprite on its center. So you can set that origin wherever you want to and it'll perform a 360 degree rotation about that point. And we're setting that point to half-- to basically the middle of where we're drawing the sprite. So that will have the effect of when we give it this angle here, self dot body to get angle, the rotation will take place in place. It won't take place-- it won't be some sort of weird about the top left corner rotation, which is not what we want. So when you see center of origin being modified like that, you can assume that it's because we have an offset and we're trying to find the center of where we're drawing and rotate about that to do an in place rotation. But not necessarily, you could also draw something. You could also, maybe you want something some sort of magical ball of energy to rotate about a rod or something. And so you want it to rotate around a different center, or whatever you want arbitrarily. But typically, at least mostly that I've seen, this is useful for making sure that your rotations, your in place rotations, are accurately rendered. So any questions about how the alien class works? All right. So that's the alien class. That's the basically the fundamental building block of our game. The other part is the obstacle. We have obstacles and we have aliens. The obstacles and aliens are actually very similar. So what's the difference between-- I mean, ultimately, how are they similar? AUDIENCE: They're both dynamic [INAUDIBLE].. COLTON OGDEN: They're both dynamic bodies, yeah. Really, the only thing that's different about a obstacle and an alien is what we do with them in our scene and how they're rendered. But they function very similarly. They're just dynamic bodies that we give a shape to and we render them with that shape. In this case, the obstacle constructor, we've decided to design it such that it could take a shape horizontal or vertical, which is similar to the type that we saw before with the alien, where it could be square or circular. In this case, if we look back at our sprite sheet back here, we can see there's a ton of different shapes. But the only two shapes that we're going to use in the context of this game, just for this demonstration, are the horizontal, clean wooden shape here and the vertical one that's right here. And so in order to find those out I had to open up basically this sprite in my sprite editor, figure out where the XY width and height were, and then create a quad manually off of that. And then I edited the util dot Lua-- or not util dot Lua, the dependencies dot Lua here. Normally we just create gframes and then we use generate quads. And you can do that like with the aliens and with the tiles, the tiles being this sprite sheet that-- this one right here. These are 35 by 35. These are 35 by 35. These are not 35 by 35. These are a bunch of different shapes and sizes. So I went through and gframes wood is for manually created quads here. And then there's four because I also added the semi broken shapes as well. But we don't actually use those. But you could decide to turn these into these on collision, perhaps maybe if the velocity isn't strong enough to break it necessarily, but you want to have some sort of feedback that you collided with it. You can just set maybe the frame to 1 or 2 on collision for that object, instead of 2 and render it appropriately. But if you're dealing with a sprite sheet and that sprite sheet has odd distribution of its sprites, sometimes you have to figure out where the offsets are manually and do it that way. The ideal is that you don't have to and that you can do it programmatically. But it really depends on the game, what your domain is and what objects you're interacting with in the scene. Any questions on the why or how as to that? Cool. So back to the obstacle. So they're horizontal or vertical, and what that does is it sets the frame to 2 or 4. And the 2 or 4 being in gframes that would, the 4 quads that I had a hand, figure out the coordinates for. And really, it's not a whole lot different at that point. If it's a horizontal or a vertical shape, then we need to set its width and height appropriately. Because it's going to have a different width and a different height. If it's vertical, obviously the height is higher than the width. And if it's horizontal, the opposite is true. But they're both a rectangle shape. So you can pass in the width and the height after you calculate that, and give it the right shape, and then ascribe it a fixture. And then set user data in this case, we set user data to obstacle. So now that obstacle, the fixture specifically, knows that it's an obstacle, as opposed to being an alien, as opposed to being anything else, as opposed to being the ground. And so when we explore in a few minutes what the custom collision, world collision callbacks, that we can actually define all this interesting collision behavior for, this user data is going to be relevant. And then we render it just like we render the alien as before. So any questions on obstacles and aliens, how they differ, how they're the same? Cool. All right. Let's take a five minute now. When we get back, we're going to actually look at the play state. We're going to look at what makes a level. And we're going to actually look at how we can customize the world to resolve collisions in ways that are relevant to our game behavior. As in, how to make things break when we collide with them, how to make the victory screen pop up when we've destroyed the bird, so on and so forth. All right. Welcome back. So before we took a break, we were talking about the aliens and obstacles that are in our game world that interact with each other. They are the backbone of what makes our games slash Angry Birds work. You throw aliens into the obstacles, obstacles break, the bad pigs slash aliens die and then you score points. But we actually have to model these interactions and we have to tell our game, our world, what to do when these collisions happen in order for things more interesting than just things bouncing off each other to work. That's the default behavior. Box2D's goal, by default, is when two things overlap, assuming that they're dynamic or at least one of them is dynamic, is to push the dynamic bodies away until they no longer overlap via either position or rotation. But that's not the gist or the goal of our game. Because what we want to have happen is different things happen and certain things to disappear and to break and all sorts of other things to happen when different kinds of objects interact with different kinds of objects at differing speeds. So in order to do this, we need to define collision callbacks for our world. So a callback, recall, is a function that gets called back when something happens. It's just something that will get called at a specific time or later on. And we can define these callbacks for our world such that when two things collide with each other, it will execute this call back and then perform the corresponding logic that we've defined therein. And with every collision in Box2D, there are four callbacks that take place. There's begin contact, so when two things begin to overlap or begin to contact one another. End contact, so once that ends, once two objects are pushed away from each other. Presolved, which happens right before the collision actually gets solved in Box2D, meaning that the things get pushed away from each other. And then postsolved, meaning right after they get pushed away from each other. And the postsolved in particular is interesting because it gets the information about how the collision needed to resolve. So how much velocity or rotation needed to happen within that interaction. And we will not be using end contact, presolve, or postsolve. We will only be using begin contact because, really, that's all we need in order to model the behavior that we're looking for. Because anything that happens in our game we can just figure it out as soon as two objects touch each other. And these are things, if you're interested in a tutorial that goes over these in perhaps a little bit more detail, there's a link here in the slides. But I'll show you how to actually implement these callbacks yourself. You do this via a function called world set callbacks, in this case, F1, F2, F3, F4. And recall, because Lua is a dynamic language where functions are first class objects, you can pass in functions as arguments to other functions. And that's what we're doing here. So this is assuming that we have four functions we've defined called begin contact, end contact. presolve, or postsolve. Their actual names don't matter at all. These are just the de facto names for them. What matters is that you have the logic there and you pass in function objects that perform something. And you can pass in all empty functions and Box2D will still behave as normal. These are only for when you want more complicated behavior out of your game than just things bouncing off of each other and moving relative to one another. So does that make sense? So we'll see how this actually works. We're going to go ahead and open up level dot Lua. So level dot Lua is a container class that basically has our game level in it, including the world and all the entities. And we update it and are able to model, effectively, like a level from Angry Birds. That's really what it is. It has a world. So the level has its own world with 300 positive Y gravity, as we saw before. It has a table called destroyed bodies. And we'll see that in a second. And then here we have four functions. Starting on line 22, we have begin contact, which is a long function. And then we have end contact, presolve, and postsolve. Those are the four callback functions that I alluded to just a few seconds ago. They take in slightly different signatures. The first three take A, B, and collision. And then the last one takes in A, B, collision, and then a normal impulse and a tangent impulse, which are the forces that it needed to apply in order to push apart the two objects. Like I said, we won't be using these three functions. But there might be a situation where you need to use those functions. Maybe you want end contact because, in your game, two objects attached to one another, when they collide maybe they're magnetic or something, and then once they pull apart maybe you want a particle effect or something to show that they've separated or something. And then presolve and postsolve. Presolve, offhand I can't think of a use case, but postsolve could be useful for, depending on your game, whether you need to just figure out maybe the amount of force that they needed to separate. Maybe you multiply that by some amount and cause some sort of dramatic effect. Those are ultimately dependent on the domain of your game. The important function that we'll be using today is the first one, begin contact. And notice, that we've defined these four functions, even if these three are just empty. But we pass in, as I said before, the set callbacks function takes in those four functions. And notice another interesting thing, because of Lua's dynamic nature, line 11 you can see that we have level init, which is the constructor for our level class. Within the constructor we are defining more functions. You can define functions as many layers deep as you want to. And you can even return functions from functions, which are called higher order functions. Really do whatever you want to. In this case we're just defining the collision callbacks here inside of our init. But you could put the most anywhere you want to. You can have them outside of the class, you can have them wherever you want. You can have them be global functions in your main dot Lua, which I don't know how I feel about that. But you can do whatever you want to as long as the functions exist and you can reference their symbols, you can pass them into self dot world set callbacks. And now, whenever a collision happens in the world period, it's going to call all four of those functions at each stage of each collision. So you could see that potentially getting a little bit hairy if you were to scale high enough with all of your logic. If you had a million lines of code in each of these and its executing million lines of code per collision, you could run into trouble. But, fortunately, we're not going anywhere near that. The gist of begin contact, so it takes in an A and a B and a collision. We don't end up using the collision itself, we just use the A and the B because that's all we need for our game world. The A and the B are what? Do we know what the A and the B are? AUDIENCE: Probably the two objects [INAUDIBLE].. COLTON OGDEN: The two objects. Do you know whether it's a body or a fixture? AUDIENCE: It would the fixture. COLTON OGDEN: It would be the fixture. The fixtures collide with each other, not the bodies. So when you have a body, recall that the fixture attaches the shape to a body. The body is just a position and velocity container for a bunch of fixtures, the body is. Each individual fixture collides with other things, other fixtures in your game world. And so, recall that before we had fixture set user data because that's what we ended up needing to have data on when we do the collisions. We check to see via get user data what something is or what metadata we've given to that fixture. And then we can then separate different classes of objects this way. We can say, oh, this object was an alien, or this object was an obstacle, or this object was the ground. And then we can say, oh, did we collide with an alien? Was the collision between an alien and the ground? If it was, OK, let's play a bounce sound effect. And if it was between an alien and the other alien, the player and the other alien, and the velocity was fast enough, OK, the alien should die. Right? We can do arbitrary things. And so the way that I've programmed it here such that we can see what two things interacted with each other, and this is a very simple use of user data. All we we're doing in this code base is just assigning strings to fixtures, but you could assign tables to fixtures with arbitrary amounts of data and do all sorts of things. In this case, we're only using strings. So I create a table, an empty table, and then I just assign at table, at that string, true. And then I can just query that table. Do I have a key player and a key alien? Do I have a key obstacle and a key obstacle? This is how you can figure out what your two objects were. Because A could be a player and B can be an obstacle. A can be an obstacle and B could be the player. So you have to take both of that into consideration. So it allows us to do if types obstacle and types player, so a collision between the player and an obstacle, if it's fast enough, then we can destroy the obstacle. This is what we do here. So I take the absolute value of the velocity on the X and Y. So I do vel X vel Y gets the body's linear velocity. So linear velocity is just where it's moving in the world. And it returns two values because velocity has an X and Y component. And then we sum it here by taking its absolute value of both parts and adding it together. So if it's moving fast on the x-axis, but not fast on the y-axis, or if it's not moving fast on either, or if it's moving fast on both, we have a sense, in general, what's the average velocity of our object. If it's moving fast on any of the axes, we can assume that that's sufficient force to cause an object to get destroyed, right? So we do if the velocity is greater than 20, just an arbitrary value that I came up with that seemed appropriate, then we're going to do this. Table dot insert self dot destroyed bodies, which we saw earlier. And then the obstacles body. Now, why are we inserting that value here as opposed to, maybe just destroying it inside this function? AUDIENCE: Destroying the fixture. COLTON OGDEN: Destroying the body. The fixture, yeah, in this case. AUDIENCE: I mean the fixture, sorry. Because you're still referencing it later in the code. COLTON OGDEN: You're still referencing later in the code. Box2D maintains a reference to all of the bodies, all of the fixtures in your world, regardless of whether you've deleted them or not. But if you delete them while it's in the middle of a, like checking for collision, it'll try to do another collision with that destroyed body and you'll get a crash or a stack overflow error. I found I experienced both of those. You don't want to ever delete or destroy anything while inside a collision callback for your world. It will cause horrible things to happen. So what we do is we maintain a reference to everything that we're going to destroy by just inserting it. So if we do table dot insert the body of whatever we want into destroyed bodies, we can then loop over that after the world updates. And then just destroy them one by one outside of the update function. And the reason that we are passing in the body and not the fixture is when we destroy a body, it destroys all the fixtures associated with that body as well. So we're just destroying the top level container here. In this case, it doesn't matter too much whether we destroy a fixture or a body because it's a one to one relationship. But if you had, let's say, a body that has five fixtures on it. And if that entire thing collides with something else and you want to destroy that entire thing, you want to destroy the body, not an individual fixture. Because when you destroy the body, it destroys all the fixtures, not just the one fixture. So that's we're deleting the body, adding the body to destroyed bodies, and then later performing a delete off of that. The function is destroy here. So on line 157-- well, 155 to 159, this is where we actually iterate over everything that we wanted to flag, or that we've flagged as destroyed, and we destroy it. So if not body is destroyed, destroy it. And then once we destroy it, we're going to go down here and end up actually removing the obstacle and the alien class from our list of aliens and obstacles. Because that maintains a reference to what we're drawing and we want to also delete that. So not only do we want to delete the object from the world, we want to delete the objects that we've created that are a wrapper for the bodies and fixtures and also the drawing of our aliens so it no longer gets drawn to the scene, basically. So yeah, don't ever delete a body or a fixture inside your callbacks. Always flag them and delete them afterwards. Basically, don't delete in the middle of a world update function call, which we see here. Notice that this takes place, 152, were doing self world update. And then on 155 to 159, we've populated destroyed bodies via the collision callback that we defined up above. So in here, this is where we can actually destroy everything. This is outside of the update function, here, the world update function. We don't need to worry about stack overflow or a segfault, which we get by deleting something while it's in the middle of processing its collisions. So unfortunate bug. If you ever find yourself running into stack overflows or segfaults in your collision callbacks, make sure you're not deleting anything. But we can see here, it's very similar, the behavior we defined between obstacles and the player, between obstacles and aliens, and between the player and alien. Ultimately, it's check to see whether the average of its velocity is greater than a certain number, in this case, 20. And if it is, flag it as destroyed. So if the player hits the alien, destroy it. If a obstacle hits the alien, destroy it. And it's similar to how it works in Angry Birds. When you throw something at a structure in Angry Birds and a piece of debris falls off of it and hits the pig, usually kills the pig too. And if your bird hits the pig, that usually kills the pig. But if you're not moving fast enough or if a piece of debris isn't moving fast enough, it'll just nudge the pig, it won't actually kill the pig. So that's why we're taking all of this into consideration. We're not just doing a blind delete off of the body's in our code, we're actually making sure, is it also moving fast enough, i.e. does it have enough force? And if it does, then perform the code, then perform the deletion or flag it as being deleted. And so once again, that's why user data is important. Because that's how we're able to-- because notice in the callback we just get an A and a B. And those are always going to be fixtures. Fixtures, in order for it to know what kind of a fixture it is, whether it belongs to a player or an alien, we need to give it some information. So the set user data flags the fixtures as being of a specific type. And then we can fetch it here with get user data and then actually perform the relevant game logic. Any questions as to how this works? AUDIENCE: Are you checking for if two obstacles knock into each other? COLTON OGDEN: Am I checking with two obstacles collide with each other? I might not be. In that case-- you should. In that case, since we're not, they'll just bump into each other. But, yeah, if we wanted two wooden obstacles to destroy each other if they hit fast enough, you would just do the same thing here. If types obstacle, I guess. But in this case, because they're both the same key, you would have to do if types-- let's see how we're doing it again. So types obstacles is true, types obstacles is true. You would say if types obstacle and not types alien, not types player, not-- there's a cleaner way to do it. AUDIENCE: Like a series of [INAUDIBLE] statements. COLTON OGDEN: Yeah. AUDIENCE: [INAUDIBLE] statements. COLTON OGDEN: Yeah. That's true. Yeah, there's a lot of ways. And if I were to re-engineer this, I would also abstract out this code and make it a function. Because it's pretty much the same code between all three of these. But just to illustrate and just for simplicity because it's pretty similar interactions, didn't really put too much engineering forethought into it. Definitely if you expand upon it, I would recommend doing that. But that's the gist of making our world behave beyond just resolving collisions and pushing obstacles away from each other, which is the default behavior. So we set the callbacks. We're good. Now things, when we interact with each other, they'll behave differently, they'll trigger different behavior. We have this thing called a launch marker, an alien launch marker. Anybody know what that might be? AUDIENCE: Is that the little dots that show the trajectory? COLTON OGDEN: Yeah, so it's the dots that show the trajectory. It's one, the alien being rendered on the left side of the screen without any physics applied to it, that's click and dragable. And it also renders a trajectory. And when you release the mouse, it launches an actual Box2D alien traveling in the direction that that trajectory foretells. If we look at alien launch marker here, it basically maintains a reference to whether we're aiming or not. So it's got a couple of states. It's got a launch state and an aiming state. An alien that we'll have a reference to eventually, which will spawn and will give it an impulse. So an impulse is effectively setting its velocity immediately to some value, as opposed to something over time. We can apply force to an object, which would be like you driving your car up against something and then gradually accelerating, that's applying force. And we can also apply impulse by going full speed with our car and hitting an object, and that will have the effect of applying an impulse at a certain velocity. When we drag our alien and then we release it, we want to apply an impulse in the opposite direction of where we're dragging based on a certain amount. I scaled it by 10, but you can have it be arbitrary. And then the trajectory models where it's going. And the trajectory is calculated via these lines here. So from line 90 to 104. There is a formula for, in that Box2D set of tutorials, that actually shows you how to calculate an estimated trajectory given a starting impulse and a starting position. Which is this formula here. It's semi-complicated. The article goes into detail as to how it works, but it effectively calculates 1/60 of a second, assuming that we're running our simulation at 1/60 of a second, it will, over 90 iterations here, 1 to 90, calculate each individual step of that simulation. And then I only render every 5 here. So if i is mod 5 s 0, then I'll actually end up drawing a circle at trajectory X, trajectory Y. Trajectory X and Y being here. Shifted X, shifted Y being the starting location. And then we multiply i by 1/60 of a second, which will give us the scalar for this impulse here. And then with gravity we have to do this i squared plus i times 1/2 times the gravity on the y-axis times 1/60 squared. The article goes into a little bit more detail as to how it works. But that's it converted into source code. But it's effectively a gravity simulation and a velocity simulation over time. And by rendering it based on 90 iterations, which is one and a half seconds, at 1/60 of a second we can forecast where exactly we're going. And then when we apply this impulse, X and Y, the ball will actually travel, the alien will actually travel in that direction at that exact trajectory. That's the complicated part of the launch marker. The other part is that it has a couple of states, like I said before. So when we click and we're not launched, it should go into aiming mode. And so if we're aiming then we're going to set a rotation to-- actually, rotation is not relevant because this was before I ended up using the predictive trajectory method. The shift at X and Y though, those are relevant because that's the starting location for your trajectory. That's wherever your mouse is. And we clamp it so that it doesn't go past a certain limit on the left or the right, so that it stays within a box area. But this will be whenever you let go of the mouse, that will be where we spawn the Box2D alien and apply an impulse in a negative direction relative to where we move the mouse. So if we move the mouse to the left and down, it's going to negate that with an impulse going up and to the right, if that makes sense. And that's what's shown by the trajectory. And then, aside from that, it renders different things depending on whether or not-- what state we're in. So if we haven't launched, it will render just the alien. If we're in aiming mode then it should actually render and calculate the trajectory. Otherwise, it would just render the alien. And so once we release the mouse, so was released 1 and were aiming, launched is true, spawn an alien. So we create a new alien with self world, it's round. We started at shifted X and shifted Y. We set its linear velocity to the same values that we calculated before. So it's base X minus shifted X times 10. So the times 10 is a scalar amount. And then the base X is where we've moved it, effectively. Or, no. Base X is where it starts and shifted X is where we've moved it. And so by subtracting shifted from the base, we get the negative direction that we want to effect the impulse. And then the impulse is set here with linear velocity. And then we also set it to have a restitution of 0.4. Recall, restitution is bounciness. So our alien bounces a little bit when it hits the ground. And then anybody know what angular damping might be? Any guesses? Angular damping is when it rotates, basically, friction on its rotation. So that when it rotates on the ground, it doesn't roll indefinitely. If we don't set that, it'll just roll forever and ever and ever and ever. Which is not what we want. We want it to stop at a certain point because once it stops, we know, OK, now we can get the next alien ready to launch. And that's the gist behind the launch marker. How we render trajectory. For the math on that, a little bit more in detail, I would explore that URL. It goes into it into pretty good detail. I use that as a reference for creating this bit of code here. But yeah, effectively, is it's just rendering a bunch of circles with that trajectory and calculating it over 90 ticks, 90 frame iterations. Back to the level. Sorry, any questions overall as to how the launch marker works? AUDIENCE: No. COLTON OGDEN: Cool. All right. So then we have an alien's table, an obstacles table, edge shape for the ground. And then we just create an alien to destroy. Spawn a few obstacles here. So in this case, two vertical obstacles and a horizontal one. Positioned such that the horizontal one is over the vertical ones and they're spaced apart such that the aliens are in the middle of them. Then the ground here, we give the ground some friction, 0.5. And that's pretty much it for setting up our level. So if we wanted to, after this point, we have the foundation necessary to really spawn arbitrary levels with admittedly simple obstacles at this point. But we could set-- because all we're doing here is just simple insertions to our aliens and obstacles table, we could create pretty much any level just by, maybe in data, specifying level could be like a table and then aliens could be another table. And then maybe all it is just a like X equals some value, and then Y equals some value. And then obstacles is the same thing. And then all we do is just we iterate over this level definition and we just say, new alien for every table here. And then new obstacle for every table in here. And then now your levels are data driven. It's easy just to make levels. You don't have to code, really, much. And you can put this in a separate file. Be like, levels dot Lua, and then just load individual levels at a time. Level 1 equals-- levels would be the top level container. And then you would have 1 equals all of this, and then 2 equals another one, 3 equals another one. And then you're not really programming as much as you are just laying things out in data. Super nice and concise. That's a nice thing about a language like Lua, is that you can, and it's the same thing in JavaScript with JSON, you can just define things as data and then write a script to go over it and construct your actual relevant data structures that way-- in your code that way. When you have the foundation like we have now where you can think in terms of obstacles and aliens, you can construct levels like so. And obviously you could go a lot more complicated with this. All we're doing is having very simple almost boring static obstacles. They're not static in a technical sense because they're dynamic objects, but all they really do is just stand there and then fall over. But if you wanted a pulley system or maybe something that's shaped in a giant head or something, you can create arbitrarily complex objects that way using joints. And if you're curious, I recommend to look into the documentation for Love2D a little bit more. Especially their weld joints are what you would use to combine pieces in arbitrary shapes. But you could easily take this to the next level and start to create in that same level definition, arbitrarily shaped, welded together obstacles. But that would be, I think, a next step if you're looking to take this beyond just one level. I would say, think in terms of, how can I get my game world represented in a very simple data like way? Because not only does it make it easier for you to create content, it allows you to shift that burden to somebody else and allow you to give the task of creating levels less to a programmer and maybe more to somebody who has just a design background who isn't as comfortable writing code. And allow you to create the engine that constructs the game world based off of this data. Any questions as to how we've set things up here? OK. So we have the ground, we have a background. A background is just a simple class that renders a static image that you can scroll the image with left or right, but we don't end up using it much. It's relevant in Angry Birds because in Angry Birds they have a camera, and the camera pans left to right depending on how far away the fortress is from your sling shot. So that's in there if you want to experiment with it at all, and experiment with a moving camera. Maybe use timer dot tween to tween the camera or just to have it track the alien if you want larger worlds. But we don't end up using it in the distro as much. Our update function is simple. We update the launch marker, update the world, and then we process all the bodies that we flagged as being destroyed, which we've already seen. We reset destroyed bodies to an empty table because we've processed all of them. We actually remove from our level the obstacle objects so that they're no longer rendered, and we no longer try to reference the bodies that are destroyed. And then notice here too, when we destroy the obstacle, we're playing a sound effect inside this bit of code. So we can just do g sounds. I put five wooden sound effects in there just for variability. It'll pick a random one. And then using to string at the number, just create break one, two, three, four, five here. And then stop and play it. Same thing here. I have a sound called kill for when we destroy an alien. So when we flag an alien as destroyed and we remove it from the scene, we should also call that sound effect. And then if the alien stops moving in our scene, the player, we can get a reference to it here, self dot launch marker dot alien, as opposed to any aliens in our scene. When it stops moving, so we get the average of its velocity and if it's less than 1.5, so not perfectly still, because it's tedious to wait that long, but almost still, we destroy the alien and then we create a new launch marker. We destroy the alien so that the world doesn't keep a reference to it and then we just create a brand new marker, which has the effect of instantiating a new alien there when we relaunch. And then here, if there are no more aliens in our scene, if we've destroyed all of the aliens, in this case there's only ever one, but there could easily, with a little more work, be a few more aliens in the scene, if it's set to zero, then go back to the start. Which we saw before when we finally killed the alien. And then all we're doing here is deferring rendering to the individual objects we want to render, the launch marker, the alien, the obstacle. We render ground tiles. So recall, from our ground example before we were just using a line, an edge shape to represent the ground. But if we look at our game, it's a little hard to see because I'm in 720, but there's actually a ground tile here at the very bottom, a bunch of them. And even though we have all of those tiles, all we're doing to detect collision is just an edge shape. So what we're doing is just beyond having the edge shape in our scene, we draw that tile, which is frame 12 in our sprite sheet from negative virtual width to virtual times 2. So three screen widths total. And then we just do it in increments of 35 pixels because that's how wide the tile is. And that'll just create a bunch of the same tile at the very bottom of our screen. So just a graphical thing, not really necessarily functional. We have the edge shape already in our scene, but just to make the ground look a little larger than one pixel tall. And then if we haven't launched anything, we should display some instructions here. And then if we're at no aliens left, then we should display the victory screen. And the victory thing will last for just a little bit of time, because even though self dot aliens is zero, this bit of code doesn't register until after the velocity of our moving alien slows down sufficiently. So this will get called when we're just about to finally stop moving, and then we check to see, oh, OK, do we indeed have no aliens left? If not, time to go back to the start. We've completed a level. And then you obviously would just change this to go to be next level if you ended up implementing more levels in your game besides just one. Beyond that, that's pretty much all of the code that's in this example. It's fairly, I would say, unsophisticated relative to prior examples. But mainly, the burden is learning how to use the physics engine, the Box2D physics engine, which itself is quite a few functions. It's some of the longest documentation on Love2D's wiki, I think. But the principles are pretty simple, in my opinion. I think it's actually quite easy to get rolling with a lot of cool features. The vast majority of which I don't think we even really cover, at least in terms of what you can do with compound objects and joints and things like that, which really start to go into the world of more sophisticated and interesting physical simulations. Things like I alluded to before, pulleys and tanks and other things like that. Some features that we could look at potentially expanding upon if we wanted to make our game more interesting, is more shapes for our objects. So if we look at our sprite sheet here, we can see there are things like roofs and circles and things like that. So more interesting obstacles beyond just square rectangular shaped obstacles. Go back to-- like I said before, compound obstacles. So a bunch of things put together via joints. So pulleys, there's motors, weld joints, which you can use to-- you can affix a roof to a square and then have two pieces that are tied together. And you can make arbitrarily complex and shaped things and just be really interesting. And that big thing, that body with all these fixtures, will collide just as any other thing would, thanks to Box2D. As I alluded to before, instead of having levels to be hard coded into our level class, maybe define them in a Lua file called levels dot Lua. And then just have aliens be a table, obstacles be a table, and then whatever else, however more complicated you want to get with your game. You can add more things. But just have it be represented as simple data structures. So aliens that maybe have different shooting mechanics. So if you've played Angry Birds you're familiar with the fact that some birds will split off into multiple birds. Some birds will dive and go super fast and break through all the obstacles in their path. Some birds will explode, and then their explosion affects all of the obstacles around them. So there's a lot of different game play mechanics you can implement using different types of birds or aliens. And then different obstacle materials is another direction we could go. And it's supported out of the box with the sprite sheet that I provided because it has sheets for metal and glass and explosive material. So there's a lot of different interesting things you could do just by changing up what materials you're using in the game. And obviously those will have different densities and behave in different ways. So assignment five is a fairly simple assignment. So this is just as I alluded to before. The task here is to split the bird that you shoot by pressing Spacebar when it's in the bird-- the alien, when it's in the air, press Spacebar and have it split into three. So you have your one that you're shooting already. So it should just shoot off two more. One that's angled higher, one that's angled lower. And all of those should be interactable with your game world. And that's really it. So if you can do that then it'll show that you know how to effect the Box2D game world. Next time, next lecture, we'll be talking about-- the theme is going to be Pokemon, but we'll be talking about more generally RPGs and turn-based games of that nature. It won't maybe necessarily look quite as pretty as this. But we'll be striving for a similar over world that we can walk around and then engage in fairly simple turn-based battles and stuff like that. And also, we'll be talking about user interfaces and things like dialogue and stuff like that. But that was it for lecture six, Angry Birds. I'll see you next time. Thank you.