Pygame Tutorial for Beginners – Python Game Development Course

Alright guys, welcome to this Python game 
development video series. And we will be   using the famous pi game library of Python to 
create this school space in reader game. And   we are going to go really in depth into the spy 
game and learn about a lot of different concepts.   And specifically, we will be learning a 
lot about like new parts of Python that   you haven't explored yet. And new parts of pi 
game, like moving characters, shooting bullets,   understanding game concepts like game loops and 
stuff like that. So if you haven't ever created   a game, or you have only created a very basic 
game, this would be a very good starting point   for you guys. So before we get started on all of 
that cool stuff, learning about game development   and stuff like that, you should make sure that the 
basic stuff is installed. So first basic stuff is   obviously Python. So if Python is not installed, 
if you're using Python for the first time,   just go to python.org. And then click on downloads 
and just download the latest version of Python.   After downloading Python, we are going to be using 
ID which is basically a cooler way to write code   of Python.

So I'm going to be using pi charm. And 
if you don't want to buy the professional version,   although you have a 30 day trial, which you can 
use for this course. But if you don't want to buy   it, just download the community version, which is 
free, and you won't need more than the community   version. But if you're using something like 
Sublime Text, or maybe the main Python terminal,   that's also fine, it won't matter. But if you want 
to follow along completely, make sure that you   download pi charm.

And thirdly, you can just have 
a look at the PI game website that we are going   to be using to create our game. So you can just 
have a look at it, it's not really necessary. But   you can just have a look at what has been done 
with this PI game and look at the Games maybe   and you know, just kind of get ideas. So let's 
get started. Make sure that you have downloaded   Python, after you have downloaded pi jam, it 
will look somewhat like this. Now that we have   everything installed, we need to make sure that 
we have this new project over here. So for that,   just go to file, click on new project. And then 
right down the project name over here, I have   already created the project and I'm calling it 
Space Invaders because this is the game that we'll   be creating, and probably have already played 
this game when you were a child.

But the main   idea is that there is a ship at the bottom and 
is going to hit the enemies that are at the top   by shooting a bullet. And every time you hit an 
enemy, your point increases and the enemies slowly   come down. If it touches the spaceship, you lose. 
And the final score is what how many enemies you   have shot. So that's the basic idea of the game. 
But you'll understand more as we go through the   videos. So after you have created this project, 
we are going to create a new file over here and   we're just going to call it main because most 
of our code is going to go inside this main dot   Python file. And after that, we need to install 
pi game. So if you're using terminal, you can just   open up your terminal by typing in cmd. And you 
can just type in pip install pi game. And this is   for people who are not using pi charm, or you're 
using something else like Sublime Text or Python   terminal.

But if you're using pi charm, what you 
would do is you would go to File and then you   would go to settings and in settings, you would 
go to project name, the whatever name you have   given if you want to follow along called spacing 
reedham. And then go to project entrepreneur. And   over there you can see I've already installed 
pi game. And if this PI game is not already   installed, just go to this plus sign over here 
and search for pi game by game and then you can   select it and click on Install package and this 
will install pi game onto your computer. Now I've   already installed pi game, so I'm not going to 
install it again. And after that you can just type   in by import pi game. And if this doesn't show 
an error, that means that pi game is installed on   your computer. So this is pretty much it. This was 
a pretty small video, just an introduction video,   we're going to be doing a lot of cool stuff. 
From the next video, we are going to be creating   our game, we are not going to go into theory and 
stuff, we're just going to start with practical   stuff and actually start creating a game.

So we 
are going to be creating a game window next time.   So as you can see, this pie chart has a window 
right now. So we are going to be creating this   kind of a window in the next video with a cross 
button over here. So I'll see you over there.   And just to recap, what we did in the last 
video was installed by game and in this video,   we are going to be creating our first Python 
game window using pi game.

So obviously the first   thing we need to do is import pi game into our 
program. And hopefully you have already created   this mean.py file, if you haven't just created 
right now. And first of all, we are going to   import pi game. And then we need to initialize pi 
game to access all of the code methods and all of   the other stuff that is inside this PI game 
module. So to initialize this PI game module,   what we need to do is just type in pi game.in 
it so whenever from now on to create a game or   create a new game.

Just make sure you add this 
line otherwise your Python or pi game code is   not going to work. So let me just add a little 
bit of comment. We're here saying initialize the   PI game. Alright, so after initialization, we have 
to create our screen. And pi game makes it really,   really easy. It's just one line of code. It's 
crazy. So we just want the right screen. And   this is our variable.

And we can just write pi 
game. And this is to access the methods that are   inside this pygame module. And we need to access 
the display dot set mode method. And then inside   these brackets, we need to add another bracket. So 
this is a tuple, make sure you add another bracket   inside it, otherwise, it's not going to work. 
And our people mess up over here and then ask,   why is it not working? It's because you haven't 
added another bracket over here. And then inside   it is going to take in two values, the height and 
the width of the window that you want to create.   So I'm just going to give it for now a value of 
800 pixels of height and 600 pixels of width.   So this should be good.

And let me just add a 
comment, create the screen. And let me just format   this properly. So this is all you need to create 
a screen. But as you will see, after we run this   program that it has won me bad thing about it. So 
as you can see the game window was created. But   after a few seconds is just went away. Let me show 
it to you guys again. So after we click on Play,   it stays there for like one or two seconds, then 
it goes away. And this is because our Python   program goes through these three lines, and then 
just exits the program. And therefore you can't   see that screen for a long time. Because it just 
takes one or two seconds for this program to run.   And that's it.

So one way to bypass that is just 
create an infinite loop over here. And this also   has problems. But just to show you guys that it 
works, I'm going to do it. And I'm going to make   sure that my task managers open because this 
will hand my computer. So make sure that your   task manager is also open. Because this will Hank 
the window, at least that you're working on. But   just to show you guys, I'm going to run this 
and you will be able to see that the window is   there.

But it is totally hand. So you can see the 
window is there. But it's nothing is working over   here. And this cross button is not working. Let me 
just go back over here and close my Python window,   click on end task and it has been closed. Now why 
is it hanging? Why is it not just closing down by   pressing this cross button? It is because we don't 
have an event of a quit function over here. So   there is no way to quit the program. Our program 
is just inside this while loop and is now able   to end and Windows make sure that that program 
gets high. And that's why we need to add a quick   functionality to our PI game game window. Just 
like this window has on pressing this close button   this window closes.

So for that we are going to 
be using something known as events. Now we'll get   into events more a little bit later. But for right 
now just understand that event is anything that is   happening inside your game paint. By game window, 
I just mean a window inside which your game is   being played. So anything happening inside that 
game window is basically an event. So for example,   if you press arrow keys or anything on your 
keyboard, you move your mouse that is an event   and even when you press this close button, that 
is also an event in pygame.

So this pressing of   the close button is actually known as a quit 
event in pygame. So we are going to make sure   that we exit this loop when this close button is 
pressed. So for that, what we are going to do is   we are just going to create a variable, let's call 
it running and we are going to give it a value of   true. And inside this while loop we are instead of 
just typing in while true to make it an infinite   loop, let's call it while running. And whenever 
we want to break outside of this infinite loop,   we're just gonna turn the variable of running 
into false, and it will automatically break this   while loop. So if you don't know the basics of 
Python, or programming, basically, while true runs   infinitely and when this value of true is turned 
to false, it comes out of the loop.

But we're not   going to go into much into that because that's 
just like very basic programming. So anyways,   after writing while running, what we need to do is 
go through the list of events that are happening   inside our game window. So for that, we are going 
to create a for loop and create a variable event.   And then we are going to loop through all of 
the events that are happening inside our game   window. How do you do that pygame makes it really 
easy.

Just type in PI game dot event dot get and   then brackets and this makes sure that all of 
the events that are there that are happening,   get into this pygame dot event dot gate. And then 
we can loop all of these events using the for loop   and one by one check. If this cross button has 
been pressed, and women whenever this cross button   is being pressed, we'll just turn this while loop 
into false so this is pretty easy. So inside this   for event we're gonna check if the close button 
has been pressed.

And how do you do that just type   in if event dot type equals equals two, and then 
we are going to check whether the event in PI game   is quit or not. If it's great, then we're going 
to change the value of running into false. So   this is pretty easy. So we have changed the value 
of true into false whenever the close button is   being pressed. And this close button is basically 
a quit event. And we are going to loop through   all of the events to find this create event. So 
we're going to go into more into events a little   bit later.

But for right now, just understand this 
is what we are doing. So let's just play this and   understand whether it's working or not. Let's see. 
So right now you can see that we do system is not   initialized, it's giving us an error. It says pi 
game dot event dot gate. Alright, so the problem   is that we have misspelled This is not pygame dot 
small letter squared is just pi game dot quit. And   that's pretty much it. So when you are dealing 
with a lot of syntax, you have to make sure that   you write the correct one but small problem, we 
are going to click on play. And now you can see   that this is working and our window is not going 
anywhere the computer is not hanging, it's looking   pretty good. Alright guys, let me just go through 
this once more what we are doing over here. So we   have created our screen, we have initialized our 
PI game. And then over here we have created a game   loop.

So let's actually call it the game loop 
over here, we're just going to add a comment   that says game loop. So this is an infinite loop, 
which makes sure that the game is running always,   and the window doesn't close down. And we know we 
want to do something like move a bullet or move   a play or something like that move a human being 
inside a game window, we have to make sure that we   do stuff inside this while infinite loop which 
only exists when this close button is pressed.   And we have implemented that close functionality 
over here by pressing by getting the events all   of the events using this PI game dot event dot get 
method.

And then we are looping through all of the   events. So if more events are added, for example, 
if somebody presses an arrow key to move forward,   that is also going to be looped in does pygame 
dot event dot loop. And then we can add another   condition that if arrow key is pressed move 
that player but more of that in the future.   For right now just understand, we looked at event 
dot type equals two pi game dot quit and then we   change the running into false to make sure that 
we come out of this while loop.

And I know guys,   I'm revealing a lot of stuff right now. But this 
is like the basics of game development. So I want   to make sure that you guys understand it properly. 
Anyways guys, this is pretty much it for this   video. In the next video, we are going to change 
the title and add some stuff into our game window.   So I'll really look forward to that. So right 
now it's just blank. And it's just saying my game   window is not cool. So we're going to look into 
that in the next video. I'll see you over there.   So in the last video, we learn how to create this 
game window using pi game. So this window is a   little bit not personalized, because it says pi 
game window over here. The background is weird,   the logo is not there. So in this video, we are 
going to be learning about three main things.   So first thing is how to change the caption 
of this window instead of pygame window will   make it something say something like Space 
Invaders, we're going to learn how to change   the logo of this window right now is like 
a snake or a turtle or something like that,   and how to change the background color of this 
window.

Now these three things are very basic,   but obviously very important when you're creating 
a game. So let's get started on that. And first   thing we're going to do is obviously just comment 
that so that you guys can come back to this code   and look what's happening. So we're going to 
write a comment title and icon and after that,   we are going to change the caption or the title 
of our window and pygame makes it very, very easy,   you just write it by game dot display. Because 
we are meddling with the display of our windows   we have to write in on display, and then dot 
set underscore caption and there it requires   the title of the window let's just call it 
Space Invaders because that is what we are   creating. And then we are going to create the 
image so you must have been seeing this UFO dot   png image over here we are going to be using this 
image in just a second I'm going to show you how   you can get this image but before that, let me 
just add this icon inside our program.

So for   that this is also very easy. First of all, what 
you can do if you want to get the same image is   that you can go to this website known as flat 
icon.com and then search for spaceships or any   kind of icon so I've searched for spaceship and 
I got this cute UFO icon. So to download this,   you can just click on Download collection and 
make sure that you select PNG and then 32 by   32 pixels size. So whenever you're working 
with an icon and pygame make sure you select   the 32 into 32.

I haven't experimented with 24 
or 16 pixels. It might work but I'm just going   to go with 32 into 32 pixels. You can select 
any other icon if you want. So I selected this   icon and I just downloaded it into my project and 
here is UFO dot png. Now to add this inside our   Python program it's pretty easy Just type in icon 
equals two pi game dot image because we are using   an image, so we are going to be using the image 
module that is inside pi game. And then dot load,   we want the image to load. And then we just 
write the name of the image. So in my case,   it's UFO dot png. So we are going to use that UFO 
dot png. And then the next line is pretty simple,   we are going to use the same dot display that 
we did with the title. And we're just going to   write that over here. And then just said, snort 
showing by this, I think it's set underscore   icon. So you can use that. And then you just 
type in the variable name of icon over here,   that we have created.

And this will make sure 
that the icon has been added. So let's just run   this and see if it's working or not. So as you 
can see, the icon is also working and the Space   Invaders is there. So this is looking pretty good, 
we have learned how to add an image, not exactly   an image just icon over here and change the title 
of our window. So this is looking pretty good. The   third thing we need to learn is how to change the 
look or the background of our window. So for that,   we need to use something known as screen dot fill. 
So we are going to go inside our while running   loop and over here we are going to write screen. 
So anything that you want to be persistent inside   our game window that you want to make sure that 
appears continuously, it can be an image or it   can be some text, it has to go inside this running 
infinite while loop. That is where we are going to   change the color inside this running infinite 
while loop.

So we're going to just state screen   dot fill. And then inside this, we're going to 
create a tuple make sure you add another bracket   inside it. So there are two brackets, and then 
you give it three values of RGB. So we're going to   give it I'm going to explain what RGB is in just 
a second, I'm just gonna give it a value of 000.   Right now, just to understand this RGB means is 
red, green, and blue. And basically every color in   this world is made up of these three values.

And 
one more, you can see a PCT, but let's not go into   that. So RGB basically stands for red, green, and 
blue. And this is the values these are the three   values that you can use to basically implement any 
color on the screen. So this makes sure and this   value goes from zero to 255. So you can make it 
255. But not more than that. And you can use it in   a combination. So they say we want just a pure red 
color. So we'll say red, we want to 55 and then   green zero and blue zero. And similarly, if you 
just want a green color, we can say zero to 55,   and blue as zero now what if we wanted a light, 
light green color, we can lower down this value   to maybe like 150. So this will be a lighter 
version of pure green. So this is how it works,   basically. And just to show you guys a more better 
version of RGB, or what you can do with RGB. If   you haven't understood it properly, let's go to 
Google.

And you can just type in color to RGB   and go to any website. But I'm just going to go to 
this reputable website. And over here you can see   these RGB values. So obviously, I told you red 
is 255 00 line is 255 03, this, and similarly,   and so on. So let's go with this red color 
right now. And you can choose any values. And   there are a lot more colors, you can even make 
your own colors by trying out different three   values. So just experiment with it a little bit. 
So I'm going to just choose the red color.

So we   are going to go back to our code and I'm going 
to write down to 55. But this is not going to   work even though we have tried, but this is not 
gonna work just telling you in advance. So you   can see that it's not working, it's just a black 
screen. So over here, we need to use something   known as update. So right now our display is not 
updating. So that's why pygame provides a method   known as display update to make sure that if we 
add anything inside our display window, it gets   updated inside this while running loop. So we for 
that is pretty easy, just make sure that you add   it after every game. So it's pi game dot display. 
So let's just try display dot update.

And that's   it. So we have to add a couple of lines inside 
your pipe icon game code. The first line is this   init line. And obviously you need to make a screen 
but two lines that are always going to be there is   this init line. And the second line that's always 
going to be there is this update line because you   want to update your screen because your players is 
going to move away the bullets are going to moving   to Amy's going to move moving the score is going 
to be changing.

So you want to make sure that your   display is always updating and by display I just 
mean the game window that we are working on. For   this program. It means this screen variable. So 
anyways, so now we have updated it. Let's give   it a shot. Let's click on Play and as you can see 
now it's in red color. So it looks good. We have   changed the title. We have changed the logo and 
our screen is updating to read, I don't like it,   I just wanted to show you guys that you can change 
the color and maybe we'll change it to something   a little bit more funky in the later videos right 
now I'm just going to go with black that is 000.   And that's pretty much it.

So guys, I'll see 
you in the next video where we are going to be   finally adding images and our player that is maybe 
a spaceship some kind inside our game window. And   so I'll see you there where we are going to learn 
how to add images inside our game. So peace out.   So in the last video, we learned how to add 
a caption and a logo and how to change the   background screen of our game window. In this 
video, we are going to learn how to add an   image to our game window, which is pretty cool and 
pretty easy because of pygame. But first of all,   let's look at the player PNG which we are 
going to add inside our game window which   is kind of a spaceship which is shooting being 
sort of its arms.

So if you want this image,   you can just go to flat icon.com and download 
this image. Obviously you can use any other image   you want. But I'm just going to stick with this 
image. And you can go to download collection. And   obviously search for arcade space over here. 
If you want this exact image and then choose   PNG and choose a 64 by 64 pixel. Obviously, you 
can resize it in pygame.

But I've seen that it's   better if you already get the image of the size 
that you want. In this case, I want a 60 by 64 by   64 pixel version. So I'm going to take that, and 
I've already added it to my project over here.   So after you have done that over here, then you 
can come back and we can start adding the image.   But before we even start that, I just want to 
discuss what is this 806 100 I have put over here,   I wanted to discuss this because this 800 is the 
width and the 600 is the height, I think I might   have said something wrong about this. In the 
starting videos. This 800 is actually the width   and not the height and the 600 is the height. So 
if you look at our window, this is the x axis,   you can think of this window as an x and y axis 
window. So if we go from left to right, this is   an X axis.

And if you could go from top to bottom, 
this is a Y axis. So it's always starts from zero   comma zero, which is at the top left corner, 
and then we as we go on the right hand side,   the x value starts to increase. And on this top 
right corner, the x value is 800. Because that   stands for width. And now if we go from top to 
bottom, the value of y increases while the x   value remains the same. So over here, the value 
is 600.

But the value of x is zero. So if you   don't understand it a lot, don't worry about it. 
Just think of it as this left, left to right is   basically x. and the value right now of this whole 
window is 800 in terms of its width, and the value   from top to bottom is 600. And the value at the 
bottom is 600. And if you want to go into into the   middle, it's approximately 300. Not approximately 
exactly it's 300. So why I'm telling you this,   because we want to place our image in a particular 
position. So that's why we need to give it in stat   coordinates. Obviously, you can experiment with 
coordinates a little bit, but we'll go into it.   So let me just add a comment over here so that we 
know that we are talking about the player and then   we need to add the player image which is pretty 
easy like we have done it in the in terms of the   logo.

So let's just copy and paste this over here 
and change the UFO to player dot png. And then we   are going to give it the x and y axis. Where do 
you want the image to be positioned. So let's   create two more variables. Let's call this player 
x. And we're going to give it the value of 370.   And I'm going to go into why we give these values 
to player x and player y. So these variables   basically represents the coordinates that we want. 
And over this, we are going to give the buyer the   value of 480. So why have we done that. So if we 
look at this window, we want to clear image to   appear somewhere over here, which is exactly the 
half of the screen width. So we want it to appear   at the starting of the game, at least we want 
it to appear in the middle. And we want it to   appear in the lower half of this window.

So the y 
axis should be closer to 600. Because this point   is 600. If you guys remember this lower part, so 
you want it to appear a little bit above it. So we   can give it a value of about 480 or 450, whatever 
you guys want. And then the x value we're giving   it 370 which is a little bit half less than half 
of the width. So the width is 800. And if we go   a little bit less than this, this is 370. Because 
we have to consider the size of the image itself.   If we give it exactly the value of 400 then it's 
not going to fit perfectly. That's why we have   given these values so you can see that the 370 is 
somewhat half of 800 and this purity is close to   600. Obviously when we change the values, you will 
understand this concept a little bit better and   feel free to change this values and see the effect 
it has.

Now after this, we're just going to create   a function and we are going to call it player. 
Now I'm going to go into why we are creating a   function. But let's just create a function for 
now. And then we're going to use a method known   as screen dot blit. So grid basically means to 
draw, so we are drawing an image of player on to   our screen. And this screen is actually known as 
the surface of our game, we'll go into what it is   surface, which later I know I'm saying that 
a lot, but it's not relevant to this video,   but just understand that we are drawing this image 
of player dot png on our game window, by using   this method known as dot blade.

And dot blade 
blade actually means to draw. So we after loading   the image, you also need to draw it on the screen. 
So that's why we are using this screen dot blade   method. And over here, it requires two parameters 
or values. The first value is of the image itself.   So we are going to give it the image. And the 
second thing it requires are the coordinates.   So we are going to give it the coordinates of 
player x and player y. So the x and y coordinates.   After this, we are going to call it I'm just 
going to ask you guys a question, Where do you   think we should call this player, we want this 
player to appear in every frame of the screen,   we don't ever want this player to disappear. 
If you guys said inside this while loop,   you guys are correct.

So we are going to call this 
player method inside over here. So let's just call   it and we're going to just call it over here, like 
this, and make sure that display method is called   after this screen dot fill method. Otherwise, 
this player won't appear on the screen. Why do you   think that is, this is because the screen is drawn 
first. And then on top of the screen, we draw a   player or a spaceship.

If the opposite was true, 
then the spaceship will be drawn underneath the   skin, the screen, not the skin, but then it will 
be drawn underneath the screen. So that is why we   always want it to be drawn after screen dot fill. 
Actually, let's change let's remove this position   to from there to over here somewhere. So that we 
guys know where this so because we are going to   be adding a lot of images and stuff.

That's why 
we need to make sure that this screen dot fill is   just above everything, and all the other things 
and drawn on top of the screen. Alright guys,   so this is pretty much it. Let me just add another 
comment, I don't know where it disappeared, the   standard for RGB, and red, green, blue, just to 
make sure that you guys still remember what this   is. Alright, so this is looking pretty good. And 
our player should appear on the screen. So let's   run it. And then we'll just go through all of this 
stuff again to see what is happening. Alright,   so as you can see, our image has appeared on the 
screen. So first, we loaded the image in display   an image variable, we pointed out the x and y 
values and the x and y values were dependent   on the screen size that we gave over here.

806 
100 because he wanted it to appear in the let   me just close this one, the old one. All right. 
And because he wanted it to appear in the middle,   that is why we gave it the value of approximately 
half of the screen. For example, if I gave it the   value of let's say just to experiment, let's say 
we gave it the value of let's say 750 that is   close to right hand side, and we reloaded it. 
And let's wait for it. Okay, as you can see,   it appeared on the right hand side. So you can 
see that the x value has increased. And similarly   if we decrease it to, let's say about 30. I'm 
just showing you this to guys so that you guys   can understand the x and y positions clearly, 
you can see that it appears on the left hand   side. So let's change it to back to about 370. 
And similarly in y if we change this to maybe   30 you will see that it appears on the top of the 
screen instead of at the bottom of the screen.

So   as we get go down, we are getting closer to that 
600 value. So we are going to from zero to 600.   So let's get back to 480. And hopefully now you 
guys have understood properly the meaning of this   x and y axes. So anyways, after that we created 
this function known as player and inscribed   that we drew this image onto the screen and 
it required two values the image the x and   y coordinates and then to make sure that this 
player is always shown on the screen we added   it to this wild game loop infinite loop. So guys, 
this is pretty much it for this video. I might be   repeating a lot of things a lot of times that 
might be a little bit irritating for some guys,   but hopefully you guys understood it properly. 
In the next video we are going to learn how to   move this player from left hand side to right 
hand side using our arrow keys on a keyboard.   That's going to be really exciting.

Let's wait 
for that. So as in the next video, peace out   In the last video, we learned how to add an image 
inside our game window. In this video, we are   going to learn how to move this image left, right 
or top or bottom. So basically we are concerned   about the movement of an object inside our game 
window. Or anything that we draw it can be image,   it can be an text after you watch the 3d game 
and understand how the mechanics of movement   in a game works.

So just to make sure that you 
guys understand it, I have created an image so   that you guys can understand what we are going 
to do, and the basics of movement of an image   or anything that you want. So obviously, we have 
created a game window. This is argument though it   is 800 wide, that is 800x axis, and then it's 
600 is height. That is you can see it on this   as y axis. And our spaceship currently is at 
370 pixels.

As we have added this over here,   that is the player x s ad 370 pixels. Now if we go 
back to our image, what if we wanted this image to   move from over here to over here, we can just add 
five pixels to our already existing 370 pixels and   this image will move in the right hand direction. 
And now what if we added five pixel continuously,   so this five pixel will be added continuously, 
this image will continue to move towards the   right hand side.

So for example, we can add 
a functionality which adds five pixels to our   existing 370 pixels in a while loop, some kind of 
a while loop. And this will happen continuously   after every iteration of our loop. Similarly, 
if we want to move it to the left hand side,   we can just decrease some value from our 370 
pixel value. That is we can decrease some x   player x value and we will move towards the left 
hand side.

And similarly if we want to move up,   we can subtract some y values. So currently, the y 
value of this is 480. So if we subtract some value   from this 480, it will move towards up direction 
and if we add some value, it will move in the   downward direction. So adding and subtracting 
values from x and y coordinates have a current   position of the object or in this case, patient 
can lead to a movement of that object. And we have   to add it to a while loop because we want it to 
happen continuously. So if we go back to our code,   we need to add one thing before I can show 
you guys how we can add values to our player   x and player by or we how we can subtract it.

So 
before that we need to make some changes, because   currently there is no way to manipulate the x and 
y coordinates from our while running loop. And if   you didn't understand what I meant by this over 
here, don't worry about it. When we actually write   the code, you'll understand what is happening and 
what I mean by increasing the x value to move it   towards the right hand direction.

Basically, if 
you move it very, very quickly, it won't seem that   the image is moving, it will just seem like that 
the spaceship is continuously moving. Because of   the effect of persistence. In our eyes, we can't 
see things that are happening very, very quickly.   Like magicians do, they create illusions by moving 
things really really quickly. And the persistence   in it tells us that the image hasn't been erased 
and then created over here, it just assumes that   the image has moved on the right hand direction 
if you're adding the five value to our already   existing x coordinate. So anyways, we need to do 
something so that we can manipulate the value of   player x and player y from the running y Lu.

So 
what we can do is go to this def player function   and over here at x comma y, so that we can send 
in the values of the new x&y coordinates that we   want. And then instead of player x and player 
y, we can just add x and y. So that the values   that we send to this player instead of the last 
value is that it caught from player x and player   y. Instead of that the new values that we send in 
of x and y are being shown on the screen are being   drawn on the screen. So now we have to go back to 
the place where we are calling this function. So   over here, right now let's just write in player 
x and player y. And you will see that there has   been no change. So let me just exit this first and 
then play it again. Let's play it. So you will see   that there has been no change because you're not 
manipulating the player x and player y value right   now.

So let's go through this once as to what's 
happening over here. So first, it goes to this   code, it creates the spaceship, then it takes the 
coordinates of the x and y of your player or the   spaceship, and then there is this player exchange. 
Let me remove this right now we don't need it. And   then if we go down, we have created this function 
of death player x comma y. And then this is being   drawn on the screen. So this code hasn't been 
executed yet because it is inside this wandering   while running loop. But the program just sees 
that this exists. Now when we go down over here,   then this player thing is called and it takes the 
player x and player y value from here and sends   it to this Deaf player function and it Inside 
x and y, currently the 370 and 480 exists.

So   this image is being drawn at this coordinate. 
Now what if we change the value inside a while   running function. So for example, let's say we 
increase the value of player x by something small,   this let's, let's increase continuously by five. 
So this will move really, really quickly, and you   won't be able to see the image moving towards the 
right hand side. But I just want to show it to you   guys for the speed. So you can see how quickly it 
moved, I hope you call it, this will slow it down,   I'm just going to give it the value of 0.1. so 
that you guys can see it properly. And you will   see that it is moving in the right hand side 
direction slowly. So why is this happening.   So every time this while loop is running, the 
player x coordinate increases by 0.1. And this   value is sent over here and this function player 
function, and then it is sent to this new player   function.

And a new image is basically drawn on 
a new coordinate and the original image is being   removed. So for example, let's also just, let's 
make it 0.2. And this time, we are also going to   print out the value of player x so that you guys 
can see that the player x value is increasing from   our original value. So here, you can see it being 
increased by 0.1. And it's going on, let's stop it   right now. And let's actually try it to move it in 
the left hand left hand side direction, so let's   give it a minus value of 0.1.

So now we want to 
decrease the value. So instead of increasing the   value, we want to decrease the value and move it 
towards the left hand side. So let's play it again   this time, and hopefully, let's just remove the 
player of the print function because we don't need   it. So now let's play it. And you can see it's 
moving towards the left hand side. And similarly,   if we do instead of the x coordinate, we do the y 
coordinate and decrease its value is going to go   towards the up direction.

So let's reload it. 
And you will be able to see that it's moving   towards the up direction. And similarly if we 
add stock, it is going to go down. So hopefully   you guys understood the mechanics of a movement of 
an object. Just to reiterate, why is this movement   happening? Why is when when we are decreasing, the 
value in y is going up. So because at the bottom,   the value of y coordinate is 600.

So if we 
decrease the value, it is going up. So over here,   it's about 480. And if we decrease it more, it's 
going to go towards up direction. And similarly   if we increase it, it's gonna go below more 
than 600 coordinates. So right now you can see   there are some, some fallacies with this system. 
Right now, we can't control where this is going,   and you will be able to see that it just goes 
outside the screen. So we need to do a couple   of things.

First, we need to make sure that we can 
control the movement of the spaceship in the left   and the right hand direction using an arrow keys 
on the keyboard. And the second thing we need to   do is add a boundary so that the spaceship 
doesn't go beyond our game window right now   is just disappearing by going outside the game 
window. So we'll be handling these two things   in the next and the coming videos. In the next 
video, we are going to learn how to add keyboard   support to our game. So basically, we are going to 
control our spaceship using arrow keys. And that's   going to be really exciting. So I'll see you in 
the next video. This is pretty much it for this.   And the last video we learned about the movement 
mechanics of the objects in our game window.

So   for example, if you do player y equals two 
minus equals to 0.1, then it will move in   the other direction. So if I run this man, you 
can see that our spacious is moving in upward   direction. But right now we don't have any way to 
control the spaceship, we can't control it using   our keyboard. And this is exactly what we will be 
learning in this video. So what we'll be doing is   that when we press a left arrow key on a keyboard, 
the spaceship is going to move towards the left   hand side. And when we press the right hand side 
arrow key, then a spaceship is going to move on   the right hand side. So what is the algorithm 
to do that? So first of all, we are going to   check whether any each stroke is being pressed 
on our keyboard, and after we check that we are   going to check whether the keystroke pressed is 
either left hand side arrow key or the right hand   side arrow key.

So we are going to do that. So 
let me just write down an if condition. Let me   just remove this over here, we don't need it. So 
after that, let me just tell you one more thing.   So any keystroke that is pressed on a keyboard is 
actually an event. And as we have discussed before   that an event is anything that is happening inside 
our game window, any kind of input control.

So for   example, if we move a mouse, we click somewhere 
we close this is Windows. So this is a quit event.   And similarly when we whenever we press any key 
stroke on our keyboard, it is a key stroke event.   So for example, every event gets logged inside 
this pygame dot event dot get and we loop through   all the events that are being stored inside it. 
And then after every iteration. So for example,   let's say in the first iteration of this while 
loop, a keystroke is not being placed but on the   10th iteration. A keystroke is being pressed and 
it will get stored inside of spy game dot event   dot get And we'll be able to loop through that. 
And check whether a keystroke has been pressed   or not. So, inside this, I'm just going to write 
an if condition, which says actually before that,   let me just add a comment so that you guys 
understand what we are doing.

I'm going to write   if key stroke, the stroke is pressed, check, 
whether is right, or left. So this is basically   what we'll be doing. Not keystroke or keystroke. 
Oh, god, I'm gonna mess up my spelling. Alright,   keystroke. Can't get this feeling right. All 
right. So anyways, how do you check whether   keystroke is being pressed or not by gay makes 
it really, really easy. It's kind of an event,   which is pygame dot key down. So this basically 
check if any keystroke it doesn't have to be left   or the right it can be alphabet, a even backspace 
or space, it basically checks if any keystroke is   being pressed. So first, we are going to do 
that we are going to write if event dot type,   which we did inside this if condition. So we 
have to go actually inside this for loop. So   we'll just press this tab button over here. Let's 
press this. So now we are inside this event for   loop.

And now we are looping through all the 
events that are there. And if the event dot   type is equals equals to pi game dot key key down, 
then this means that a keystroke has been pressed   on a computer. And now we have to check whether 
the keystroke that was pressed is left. Alright,   so this is also pretty easy. We just again 
type event dot this time we type in dot key   because we want to find out the key that is being 
pressed. And we just type in PI game dot key left,   key left. And this will just check whether the key 
that has been praised is the left arrow or not.   If that is the left arrow, it says for right now 
print.

Left arrow is pressed. And after that I'm   going to write again, I'm just going to copy and 
paste this over here. Like this, and over here,   I'm just going to write right. And instead of 
K underscore left, I'm going to add the right.   Alright, so basically what this does is it checks 
with any keystroke is pressed and then it checks   whether the keystroke that is being pressed, 
is left or right. And after that we are going   to check when the keystroke is being released. 
So after pressing down on the left arrow key,   when we remove our finger from that left arrow 
key, that is known as the removal of the keystroke   or the key up. So key down is pressing that key 
or pressing any button on the keyboard and key up   is basically releasing that press. So we're going 
to check for that over here if event dot type is   equals equals to pi game dot key up. So hopefully 
we'll be able to find that key up over here.

And   then over here, we're just going to check if 
it was the left key or the right arrow key,   and then we are going to print something so 
that is pretty simple. We can just copy this   from here. Let's copy this, paste this and we are 
going to give a condition that if the left or the   right arrow key was pressed, so we can just copy 
this from here and put this colon mark. And then   over here, we're just gonna write key keystroke 
has been released this series so you guys know   what is going on. And I want you to write this 
code down and then actually try it out yourself   so that you guys know what's happening behind the 
scenes. So now we can just press on Play and over   here is going to do nothing. But on our print 
screen over here we are printing all of these   things. So let's press the left arrow key and see 
if something happens.

So we have to first activate   our window over here, and then we can press the 
left arrow key and we can see that the left arrow   is pressed. And when I remove my finger, it says 
keystroke has been released. Now what if I keep   pressing on a left arrow key if I keep pressing, 
it will just say left arrow is pressed and the   keystroke has been released. And similarly if I 
press the right arrow key, it says right arrow is   pressed.

But if I press any other key, it prints 
nothing. So let's actually create a statement   over here to let's say, a keystroke is pressed 
so that we know when any other key is pressed,   it also runs. So over here, we can just press the 
left arrow key again, as you can see, a keystroke   is pressed left arrow key is pressed and keystroke 
has been released. But if you press something   else, let's say enter, it just says a keystroke 
is pressed and not the left and the right arrow   key. And that means that our keyboard strokes are 
working. So now we can just minimize it and we're   going to create a new variable over here. And this 
will signify the change that we want an x so if we   want the X to move in right hand direction, 
we need to add value to this 370 existing   value and we wanted to move on the left hand side 
direction we need to decrease value from eight. So   I'm going to just call it over here create a new 
variable And call it player x underscore change   equals two and right now I'm going to give it a 
value of zero.

And inside our if conditions when   the left key is pressed, I want it to increase 
by 0.1. And when sorry, decreased by 0.1, and   we're gonna change this 0.1 number, it basically 
signifies the speed with which you want the object   to move. And in this case, it's spaceship, 
how quickly you want the spaceship to move,   and we are going to change it later. And even in 
this video, we will see how it goes if it moves   too slowly or too fast. But anyways, right, now we 
are going to decrease the value when the left key   is pressed and increase the value when the right 
key is pressed.

So what kind of change Do we want   in our x, when we want the left arrow keys press, 
so we're going to just right over here, player x,   and it's called change, and we want to decrease 
the value by 0.1, let's say and when the right   arrow key is pressed, we want to increase this 
change by 0.1. So let's remove this minus value   from over here. And when the key is released, 
we want the spaceship to stop moving. And that   is why we want the change to be zero when our 
keystroke is released. So over here, we are just   going to paste this over here. So this is looking 
pretty good. Let's actually remove this comment   from here.

And then we can just add this player 
exchange to our existing player x x coordinate,   so I'm just going to write here x plus equals 
two, and then player exchange. So doesn't matter   whether we are adding over here because we have 
given a term value of minus 0.1. And over here   we are given it a positive value. So whenever 
something is added, and the value is negative,   so I'm just going to give you an example. Alright, 
so that you guys can understand this arithmetic   properly. You might be thinking that why are we 
adding over here because we want to subtract 0.1,   right, so let's say our current value is 
370. Let's actually take a smaller value,   let's take our player x coordinate is five. And 
then when we do plus equal to So this basically   means equals to five plus, and then the value that 
is player x underscore change.

So right now this   value is minus 0.1. If the key left is activated, 
so this value will we actually minus 0.1. So after   this arithmetic is processed, this will turn 
actually into, so let me just add arrow key,   this will actually turn into five equals to 
five, minus 0.1. And similarly, if we add,   then the addition is pretty, pretty obvious. So 
we can just add 0.1. And this will remain the   same just 0.1. And the value will be 5.1. So this 
is how this operator over here works. So we don't   need to worry about whether we are subtracting or 
adding if we have added our arithmetic operator   over here, in this case, it smiles. So this should 
be working, let's run our main.py file and see if   it is working. So let's activate it. And over 
here, when you press a left arrow key, our ship   is moving.

And when we press the right arrow 
key, our ship is moving and we when we release   the keystroke, it is still moving. Why is that the 
case. So let's go over here and see. All right,   so here the place x underscore change is 0.1. 
So we have to change it to value zero, because   we don't want it to move, you can actually change 
it to 0.1 to see how it works, how the spaceship   is stopping.

So let's try it again. Now when we 
move on the right hand direction, and we release,   the keystroke, the ship actually stops. So 
this is looking pretty good. But Asli, this,   the speed is a little bit slow. So I'm going to 
increase the value to 0.3. And now if we run it,   our speed should be sufficiently well. So this is 
looking pretty good in future will change 0.3 to   a higher value when we use the clock concept. But 
we are not using it right now. So this is looking   pretty good as patient is moving perfectly. And 
just to recap, what we did in this video was first   we checked whether any keystroke has been pressed 
on the keyboard. And then if the left keystroke is   pressed, then we increase or decrease the value 
of player exchanged by 0.3. And if our right   key is present, we increase the value by 0.3. And 
whenever our keystroke has been released, we make   sure that the player x coordinate stops changing. 
And that is why we have given it the value of zero   to make sure that the spaceship stops and doesn't 
go on.

And then we just use this arithmetic thing   over here which increases the value of player 
x or decreases the value of player x depending   upon the value of this player x underscore change. 
So this guy's is looking pretty good in the next   video. If you have any queries please ask them 
and questions. So this is pretty much it for this   video. In the next video, we are going to give 
our spaceship an enemy because right now is the   space it's looking very lonely for a spaceship. 
It's just going in the space and it's not finding   any planets or any enemies. So it's thinking about 
its existence and the meaning of life. So what's   happening with me, so we are going to give it a 
meaning in the next video. So I'll see you whether   in the last video we learn how to move our 
spaceship using our keyboard and the left   hand The right hand side direction. And this 
video I was about to give it some enemies.   But then I realized our spaceship is just 
moving out of the screen when you go to the   left and when we go to the right.

So why is 
this happening. So when it goes to the right,   this right border of the spaceship of our game 
window, it actually reaches the 800 width that   we have said. And when it goes beyond this 800, 
it goes to maybe 810 and 105 pixels. So this no   restriction right now to the spaceship movement 
in the left and the right hand side direction.   And similarly, when it moves to the left hand 
side, it goes in a little bit lesser than zero   angles goes into minus territory, because this x 
coordinate is an integer this that's why it can   go to negatives.

And even it can go to minus 
450, or something. So what what should we do,   so what we are going to do is that when it teaches 
the zero coordinate, then we are going to any time   it goes into negative stuff, we are going to 
make sure that it stays at zero by using an if   condition. So we are going to basically tell our 
spaceship that, hey, if your x coordinate reaches   zero or less than zero, make sure it turns back 
to zero. And similarly on the right hand side,   we are going to tell our spaceship, if your x 
coordinate reaches this 800x coordinate path,   then I don't want you to go beyond it and change 
your x coordinate to 800 again, so every time it   goes beyond 800, it's going to just delete itself 
and go back to 800. But it's going to happen so   quickly that the eyes won't see it. And it will 
look like that the spaceship can't go beyond 800.   So let's do that.

That's right. And if condition 
just beyond this arithmetic operator we have over   here. And as I said, we are just going to write 
player x, if this player x becomes less than zero,   that is the x coordinate becomes less than zero, 
then we are going to change the value of player   X to zero. And similarly if our let's write f l 
f, player x becomes greater than or equal to 736   pixels.

So why are we taking this 730 by 36 pixels 
instead of 800 pixels. So because our pixel,   we have to take into consideration the size 
of our spaceship. So if you remember the PNG   size of the spaceship is 64 by 64 pixels. So the 
width of this spaceship is 64 pixels. That is why   we are subtracting 64 from 800. And that means 
736 pixels. So if we chose any other number,   for example 800, then it will stop at this point 
and not before that, but we wanted to stop over   here and not allow any part of spaceship to 
appear beyond the game window.

So that's why   we are choosing this 736 pixel number, we 
just subtracted 64 from 800. And over here,   we are just going to change the value of whenever 
it goes beyond 736 we want it to again go seven to   two back to 730 6x coordinate. And this will mean 
that it will look that it cannot go beyond what is   actually but it's just deleting that spaceship and 
creating a new one sn 36x coordinate picks it. So   let's check this out. And hopefully it works well. 
let's reload it and see if it works or not.

So as   you can see when I press the right arrow key 
doesn't move beyond this. And feel free to try   it yourself and change the x coordinates just 
experiment with it a little bit. So the last   video is pretty long. And this video is pretty 
short. So that's good. So in the next video,   we're finally going to create an enemy 
for a spaceship so and see you over there.   The last video we learned how to create boundaries 
for our spaceship so that it doesn't go out of   bounds.

And this video we are going to give it 
our first enemies have already downloaded an enemy   image which looks like a happy Space Invader. It's 
not going to be so happy when we shoot it with our   spaceship. But anyways, let's get this icon from 
flat icon calm just like we always have and search   for Space Invaders. And I'm going to go with this 
red space and you can select whatever you want   and download the 64 by 64 picture as usual, and 
obviously in the PNG format. So now we can go back   to our code and just like we did with a player, 
we can add this enemy dot png inside our code. So   let's do that. Let's just copy this whole code and 
just add it below the player change it to enemy.   So we're gonna change everything to enemy so we 
just have to rename everything. It's called an   enemy and then I'm just gonna copy and paste this 
in the remaining areas. So let's just copy and   paste everything and instead of the player dot png 
we are going to call it the enemy dot png and make   sure you rename the PNG file otherwise you tried 
if you read enemy dot png is not gonna work.

But   anyways, so we need to also create this function 
again. So let's just copy and paste this too.   So we're gonna paste this over here instead of 
player. We're gonna call it enemy and everything   else should come in the same. Let's format it 
properly. Another thing is in PI charm if you want   to format everything properly if you have written 
code that's not formatted and doesn't look good,   what you can do is you can just press Ctrl, Alt, 
and L, and it will format everything properly   inside your code. So it's just Ctrl L. So as you 
can see, it says imports optimized, it will just   make your code look good. So again, the command 
is Ctrl, plus alt, plus L on your keyboard. So   anyways, now that we have the function of the 
enemy, let's just go down below and add the enemy   over here so that we can call the function while 
our while loop is running.

So let's add the enemy   over here. And instead of the player x, let's just 
call it enemy. And instead of the player x, we're   going to call enemy x. And instead of player y, 
we're going to give it a value of and revive. So   right now you can see that the coordinates are the 
same as all the spaceships.

So this should overlap   our spaceship. So let's see if it's overlapping 
or not. So right now, it's not overlapping. Let's,   let's actually check out why is that happening. 
So this is because inside our enemy function,   we have not renamed this to enemy dot m g. So 
let's do that. Let's rename it enemy dot image,   and then just reload it, and this should work 
properly. So now you can see that the enemy is   on top of the spaceship, but he's not we want, we 
want the enemy to be like somewhere on the top. So   maybe in the middle, but on the top, so we can 
let the enemy x remain the same. But I'm going   to change the enemy y to something else. Let's 
give it a value of 50. I've already tried it   out and 50 looks pretty good. So let's see how 
it looks.

Alright, so our spaceship is moving,   and we have an enemy. But the problem 
with this enemy is that it's not moving,   it's very boring. So we're going to fix 
that in the next video. But for right now,   what I want is that this enemy should appear in 
the random places. So whenever we kill an enemy,   it is going to appear again or in a game terms is 
going to respond again.

So I wanted to respond in   different places, maybe on different x axis. 
So maybe like maybe over here, over here,   update scale, and maybe in y should also appear 
in different places. So maybe next time over here,   and it's same over here. So you want it to appear 
in different places. So every time it reloads.   Basically, we want it to appear in different 
places. And even at the starting of the game,   it should not be constant, it should be totally 
random. So what we are going to do is we are   going to make this enemy x and enemy y actually 
random. So we have to first write down the line   that actually helps us randomize values. So we 
are going to import a package known as random. And   this is pretty easy to do. So let me just minimize 
this over here and then scroll down and over here,   we are just going to write instead of 370, we're 
just going to write random dot Rand int.

So this   is a method inside the random package to choose 
a random integer between two values. And then we   have to give it the value that we want. So we want 
a starting value and an end value. So in our game,   we want it to appear anywhere between zero and 
800. So we are going to give it the starting   value of zero, and the end value of 800. And 
similarly with why we wanted to give a value   between maybe 50 and 150. So let's change this to 
5050 should be the starting point. So the minimum   height should be 50. And then it can go down over 
here, let's say 150. It's approximately 150. So   I'm going to give it a value of 150. Alright guys, 
so this is looking pretty good. Let's just try   it again and see if it works.

So let's run main. 
Alright, so this is working it respond over here,   let's reload it to see if it responds somewhere 
else. Let's just reload it and see where this time   it appears. This time it appears over here. Let's 
try the third time third time is a charm. And it   always works. So this time it appears over here. 
So our program is looking pretty good. We have   created an enemy and it is responding in different 
places.

So this is just looking pretty good. In   the next video, we are going to make sure that our 
enemy moves. So right now our enemy is stationary,   it's not moving from the left or the right and 
it's not going down. So we are going to make sure   that we rectify that in the next video is going 
to be really exciting. So I'll see you over there.   So in the last video, we created our enemy 
and made sure we applied randomization to our   enemies so that when it gets destroyed and created 
again it should appear in random places.

So as you   can see when we reload our program is going to 
respond in a different place. So in this video,   we are going to make sure that our enemy is moving 
so imagine that there are multiple enemies right   now there is just when one enemy and we haven't 
created multiple enemies, so there is not any   problem. But imagine there are multiple enemies 
and they're moving from left to right.

And they're   also when they hit the boundary they come a 
little bit down. So that's what we are going to be   focusing on today. We are not going to be creating 
multiple enemies but we are going to be focusing   on the movement of this one single enemy and then 
we can apply it to multiple enemies. But let's for   right now just focus on one enemy. So what exactly 
do we want from this enemy? What kind of movement   Do we want. So what we wanted to do is move from 
right to left in x direction. So for example,   this enemy will move in the right hand side. And 
when it hits the boundary that is about 736 or 800   pixels, it should change its direction and move 
towards the left hand side, and when it reaches   the left hand side, then again when it hits that 
zero coordinate x coordinate direction, again   changes direction and move towards the right hand 
side. So this is the movement in the x direction.   Now there is also a movement in the y direction. 
So whenever it hits a boundary, whether it can   be right boundary or the left boundary, then it 
should come a little bit down.

So that imagine   there are multiple enemies, and we are trying to 
shoot all of those enemies down. So how will the   game get over. So whenever these enemies hit the 
boundaries and come down at one point of time,   they are going to hit the spaceship as they are 
coming down, and then we'll make it Game Over,   like in the classic Space Invaders, so we need to 
execute the x movement. And as well as we need to   execute the Y movement, this always is going to 
be very easy, because you already know how to move   the spaceship, and we are going to do the same 
thing that we did in the player. So first of all,   we will just scroll up, let's minimize this over 
here. So we're going to slow up and because our   enemy is going to have the exchange as well as 
our y movement.

So I'm just going to copy this   over here and also make sure that we add our 
by movement. Now enemy exchange over here,   we are going to give it the value of 0.3. Maybe 
in future we'll speed it up because a spaceship is   also at the speed of an exchange of 0.3. Maybe 
we will change it upon future. But right now   I'm just going to give it a value of 0.3.

No, I'm 
not giving it a value. So for example, in player,   we haven't, we have just given it a value of zero 
over here. And below over here, we have changed   its direction by typing in negative and positive, 
we are not going to do this with our enemy   V is going to provide the value of 0.3 over here. 
Now if you scroll down, we're just going to do   the same thing that we did with our player. So 
for example, over here, we made sure that if it   hit the boundary, so this is the algorithm 
basically, you can call it the algorithm,   but it's pretty simple. So whenever it hits the 
zero coordinate, we change its value to zero. And   whenever it gets greater than says 36, we make 
sure that it coordinates Kate to send 36 again,   and this prevents the spaceship from going out of 
bounds.

So this is a kind of way of checking the   boundary. So we can do the same thing with our 
enemy. So let me just copy and paste this over   here. And instead of everywhere player, we're just 
going to call it enemy. So it should be in small.   So over here, also, let me just copy actually and 
me and paste it everywhere, this is going to make   sure that we save up some time, not a lot of time. 
But so let's face this enemy over here, over here,   I wish there was a quicker way to do it, but 
it's not.

So anyways, now I'm just going to add a   comment over here so that you guys can understand 
what we are talking about over here. So checking   for boundaries of spaceship, so it doesn't go 
out of bounds. And over here we're gonna write,   maybe enemy movement, enemy movement. And this 
looks pretty good. Instead of restricting us, what   we want is whenever a boundary is hit, we want it 
to go someplace. So for example, when it hits that   left boundary, we want to increase the value of 
x so that it starts going in the right hand side   direction.

And similarly when it hits this right 
hand side boundary, then we want to decrease the   value of x. And this will keep on happening 
because it's inside our while loop. So now   we are going to use the same arithmetic operation 
that we use with our players. So if we scroll up   a little bit, you can see when we wanted to change 
directions we gave, when we wanted to move towards   the left, we gave it a value of minus and when 
you wanted to move towards the right, we gave it   a positive value of 0.3. And then we just added 
because of this arithmetic property. So we are   going to do the same thing over here. So instead 
of enemy x equals to zero, what we are going to   do is we are going to write and meet exchange 
equals to 0.3. And so that basically when it   hits this left hand side that is zero coordinate, 
it can start going towards a positive direction   that is it should start increasing the x value. 
And similarly we want when we want it to go left   hand side we are going to change it to a minus 
value.

So we're going to give it a value of minus   and this should be enough guys. So actually, if I 
scroll up, you can see that I've put the value of   enemy x underscore change equals 0.3. We can leave 
it to zero or we can leave it as 0.3. It doesn't   really matter. Let's run it and see if it works. 
Let me just close down the previous implementation   so that we don't get confused. And I'm just 
gonna run it again run main.

And hopefully the   enemy will start moving. So you can see that the 
enemy is moving from left hand side to right hand   side. And actually, this looks pretty awesome. 
So now you can see that it's not moving in the   y direction is just moving in the x direction. 
So what we want is that when it hits the right   boundary, it should move downwards. Or even if it 
hits the left boundary, it should move a little   bit downwards.

So what I'm going to do is I'm 
going to go over here, and I'm going to add any y   change equals 240. So that we can move it down by 
40 pixels. So why When do we want it to move down,   we want it to move down when it hits the boundary, 
that is the geo coordinate or the 736 coordinate,   so we can just increase the value of y over here. 
And that should be enough.

So I'm just going to   write in me, y plus equals two, and then we want 
the enemy y change, just let it let's just paste   over here. And then we can do the same thing over 
here. Let's not erase that, we'll just add it over   here. So now let's just reload it and see how it 
looks. Now you can see when it hits the boundary,   it actually goes a little bit down. So you can 
imagine multiple enemies, when they're hitting the   boundary they are going down. So it's gonna be a 
little bit difficult for a spaceship to eliminate   all of them, but it's going to try its best. 
And when this enemy reaches the spaceship, we   are going to give it our game over. And depending 
upon how many enemies we can hit with our bullet,   which we'll be creating mostly in the next video 
or in the coming videos. Depending on how many   enemies he can eliminate with that bullet, the 
score is going to be according to that.

So you   can kind of get the idea of the game with this 
video as to how the game was going to look. So   today we are going to be learning about adding 
background image to our PI game. So right now   if we open up our space invader game, you 
will be able to see that we have an image   we have in spaceship, but it's happening in the 
black background, which doesn't look that good,   we need to add some kind of a space background 
to make it very cool. So what I'm going to do is,   I'm already downloaded an image of a background 
that is background dot png. And it's some what   looks like this. So how did I get this image. So 
what I did was I went to this website fault free   pic.com p ik and then free free pick.com. And 
I searched for this text which says colorful   spaceship background. Obviously, feel free to get 
an image from wherever you want. But make sure you   get an image that's 800 to 600 pixels wide is that 
size, because our game window is of that size.   As you can see, we are made again window of this 
area.

So what I did was I went over there and you   can choose any of these images. But the image that 
I chose was this one, and then I used illustrator,   so free pick is a website was going to give you a 
lot of Illustrator Photoshop stuff, and you have   to edit it out to make it your own. So I removed 
all of the weird stuff that we didn't want,   for example, this rocket, this text and stuff. 
So I removed all of that stuff.

And if you know   illustrator, feel free to make a new image on 
your own. So what I'm going to do for you guys,   if you're not able to get this image on your own 
is that I'm going to attach it to the description   or attach it somewhere so that you guys can 
get this image, just look at this videos,   text. So what I'm going to do is after we download 
this background image to our project folder,   make sure you do that, then we're just going to 
add it to our windows.

So over here, how do we   add images to our program is just by pygame dot 
image dot load. So I'm going to do that. So I'm   going to add a comment, let's say and we are going 
to write just background, just write background.   And then I'm going to create a variable called 
background, I'm going to do the same thing   that we did with the wrist. So I'm just going to 
copy and paste it over here. And instead of UFO,   I'm going to write background. So obviously my 
images of 800 into 600 pixels. So make sure it   is of that size. So now that we have added it, 
if we run it right now is not going to appear   because it just appears for a second and then 
it disappears, we want it to persist. So how do   we make it persist is by adding it to our while 
loop.

So we need to make sure that we go to our   while loop over here and we are going to add it 
below this screen dot fill because if we don't,   then this black color is going to be on top of our 
background image which we don't want. So what I'm   going to do is I'm just going to add another 
comment over here. It's gonna say background   image, and we forgot the B's. So let's add B and 
then over here, we're just gonna do the screen.   Just typical thing we do when we want to add an 
image which is screen, dot blit.

So basically   draw the background image and then we need the 
variable of the image so that is background.   And then we need to add the coordinates of our 
image so we just wanted to appear from the top   left corner severe Going to add zero comma zero. 
And that should be pretty good. So let's run our   main.py program, let's run main. And you will 
be able to see that our background is there.   But the problem with a background and NP and 
a spaceship is now that they are moving very,   very slowly. And why is this so? Pause this video 
and figure it on your own territory, pretty cool.   But I'm just gonna explain it over here. So our 
background, PNG is actually 226 pixels, sorry,   226 kB, so it's a little bit heavy. But what 
happens is when this while loop is running, every   iteration of this while loop previously used to 
happen really, really fast. But now because it has   to load this hairy background image, the iteration 
of this while loop, every iteration is a little   bit more slow.

So that is why whenever we are 
increasing the value over here, so for example,   we are increasing the value of player, it is too 
small. So whenever this while loop is going, it's   just increasing the value by 0.3, which is very 
slow. And that's why it's not able to move around   a lot. So what we are going to do is we are going 
to increase the value to five of our players. And   I'm going to change the value of our enemies. 
So let's see where as enemies. So here are our   enemies, I'm going to give it a value of let's 
say, four, I just want these enemies to be a   little bit slower than aspasia. Because when they 
are going to be multiple enemies, then we don't   want them to appear like really, really fast.

So 
let's reload it now and see if it works. So it's   still slow. Why is this happening? a spaceship 
has increased its movement, but the enemy is still   slow. So let's see if somewhere our old values are 
still persisting. So enemy we have changed the x   value over here. So let's go up and see where 
we have not changed the value. So over here, the   enemy exchange is still 0.3. So we have to change 
it over here to let's make it four. And now we can   reload it and you will be able to see that the 
enemy is moving at a good speed. So now we have   the background image, we have our spaceship and 
we have our enemy. The only thing missing is the   bullets because we don't have the bullets right 
now to kill this enemy. So in the next video,   we are going to make our bullets or get started 
with making our butt so i'll see you are there.   In this video, we are going to learn how to shoot 
our bullet inside our game window.

So as you can   see, I'm shooting a bullet and the enemy. So right 
now the bullet is not hurting the enemy because we   haven't implemented a collision yet. But more 
than that in the future videos. In this video,   we're just going to learn how to shoot a bullet. 
So let's get started. But before we get started   with the code, I just wanted to explain a couple 
of things. And the first thing I wanted to explain   is what's the starting position of the bullet. 
So when we are in the middle of the window that   is at 370 pixel x coordinate approximately, 
it's shooting from the top of our spaceship,   but if we move left, it still shooting at the x 
coordinate of our spaceship, it doesn't matter   where our spaceship is, the x coordinate of the 
bullet is going to be always equal to that of   our spaceship, just the starting positions. For 
example, if you shoot the bullet right now, even   if we move our spaceship, the bullet is not moving 
with our spaceship, just the starting position of   the bullet is equal to that of our spaceship.

So 
that is the first thing and the second thing is   that as we shoot the bullet, the bullets of y 
value is decreasing. So because at the bottom,   the value is 600 y coordinate, and as we go up the 
value of y decreases and add the top is actually   zero. So at the top, the y coordinate of y of a 
bullet is going to be zero. So we have to decrease   the value from about 480 pixels. So because this 
480 coordinate y coordinate and we are going to   decrease it as we go towards the top. So right now 
you can see that it's disappearing at the top. So   the third thing I want to talk about before we go 
into code, because it's so important to understand   is the state of the bullet. So right now when 
you can't see the bullet its state is at ready.   But when you can see the bullet state is going 
to be at file. So right now it's not appearing   on the screen. That is That means that we are 
reading the bullet for fire. And when it shoots,   you can see the bullet and that means the bullet 
has been fired.

So let's not do between that   firing period anything. So this is what it means. 
Obviously, we are going to understand this more as   we write down the code. So let's get started 
with that. So the first thing we need to do   is add an image of a bullet inside our project 
folder now already added as you can see on the   left hand side bullet dot png, and it kind of 
looks like this. So how can you get this image   so you can just go to flat icon.com like we have 
done previously and searched for this bullet.

And   you can just download this bullet from here. And 
obviously you can choose any bullet that you want,   and even through Google or something but make 
sure when you download this image it's 32 by   32 pixels. This bullet is not the same as I'm 
using but if you want you can just go to the   sixth or seventh page of this flat icon.com and 
you will find the same image but feel free to use   this image it doesn't make a lot of difference. 
So now we have downloaded this bullet PNG make   sure it's 32 by 32 pixels. Let me just close 
this Photoshop. This is the background, we made   the last video. So after adding the bullet dot 
png, we are going to add it into our byte code.   So over here just below the enemy, we're just 
going to copy this enemy because we don't want   to create everything again.

And instead of enemy, 
we're just gonna write bullet. And we are going to   replace everything of our enemy with our bullets. 
So let's call it a bullet. And then I'm just   going to copy and paste everything. So politics 
bullet why and just paste it but at exchange,   and some of these values we are not going to use. 
So for example, bullet is not going to move in the   x direction. So using this x underscore change is 
useless. But still, we are going to just keep it   over here just for this sake of conformity. 
But anyways, in this bullet x and bullet y,   we are going to give the value of zero bullet 
x because we are going to be changing the value   inside our while loop. But bullet y is going to be 
at 480 pixels. Why is that because our spaceship,   as you can see as clear why is at 480 pixels. 
So at that level, the bullet is always going to   be short.

And so if I run this main program over 
here, you can see that a spaceship is over here.   And what's happening to her enemy, let's reload 
it. Let's see if we have done something to enemy   No. So as you can see, when we move, our spaceship 
is not moving in the y direction, so we need to   shoot our bullet from its top of his nose, which 
is at 480 pixels of y coordinate.

That's why we   have code and this 480 over here. And then we are 
going to add another variable which is going to be   bullet state. So this is the state I was talking 
about a few seconds ago. So we are going to add   a variable bullet state and we are going to give 
it a value of ready. So let me just add a comment   actually over here so that you guys remember what 
this release date is what is y est.

So readystate   basically means you can't see the bullet on the 
screen. And fire. So bullet is currently moving.   Alright, so this is the state we are going to be 
using to basically differentiate between whether   the bullet is in motion or it's in a state of 
constant and it's not being fired right now is   going to help us decide the movement dynamics of 
our bullet. So now we have created another bullet   state equals ready and now we are going to create 
a function known as fire bullet that is going to   be called whenever we press our spacebar. So in 
our game, when we press our spacebar of bullet   is being fired, so that is what you want.

And 
pressing the spacebar when it gets fired. So and   what happens when we press spacebar, we want this 
function of fire underscore bullet to be called.   And we are going to do the same thing over here we 
are going to call the x and y variables. And just   below that, we are going to access this bullet 
underscore state variable equals to ready inside   our function. Now how do you do that, we need 
to create this bullet underscored state function   as global so that it can be accessed inside this 
function.

So I'm just gonna write global and then   call it state. And now we can access the value 
of this bullet state from inside this function.   So after this, after we press space, the bullet 
is actually being fired. So now you can see it   on that screen. So we need to change the state of 
the bullet equals to file. So now it's not ready,   it's actually being fired currently in motion. 
After that, we just need to make sure that it   appears on the screen. So I'm going to write 
skinning dot plate, we need to draw the bullet   on the screen. And then I'm going to write the 
name of our bullet image bullet image. And then   we are going to write the coordinates of where do 
we want it to appear. So we just wanted to appear   on x comma y the values that you are getting 
from the function. Now we want this values to be   at x plus 16 and y plus 10.

Why is that? So let me 
just format everything properly. And you can press   Ctrl Alt plus L if you're using pi charm to make 
sure that it looks good. So why are we doing this   Xpress 16 why plus 10. This is to make sure that 
the bullet appears on the center of our spaceship,   if you don't do plus 16 is going to appear on 
the left hand side of the spaceship a little   bit. I've already tried it out. So that's why a 
note section is the correct value. And this Why   is just make sure that it appears a little bit 
above spatial just to give it an illusion of the   bullet being fired from the top of the nose and 
not from the center of the spaceship.

And now   before we go into the while loop, I just want 
to change the value of change in y because I'm   pulling is moving in the right direction. And 
this is the value that we give to the enemy.   We don't want the bullet to move this fast we want 
it to move at the speed of 10.

So let's close this   window now. And let's just go below and what we 
want over here is that if an arrow key of space,   not an arrow key, if a keystroke or space on 
our keyboard is pressed, then we want to call   that fire underscore bullet function. So let's 
create that over here so that we can just copy   and paste this line. And then at the end, we can 
just add the value of space, okay, underscore   space. And this is going to make sure that we can 
capture the value of space. And what we want when   you press a space, we want the Firebird function 
to be called. And now what are the values inside   this. So right now we are going to give it 
a value of clear eggs. But you'll understand   why this is strong. But this is just like a logic 
error. So I'm not gonna worry about it too much,   but I'm gonna tell you why it's strong. And we 
are going to fix this in this video. So let's try   it if event dot key pygame dot k underscore space 
fire underscore bullet player x comma, y.

So let's   run this right now and see how it looks. Obviously 
it's not complete, not even close to complete,   but we're gonna it's gonna look how it looks. So 
right now you can see bullet is not there. But   when we press the space, nothing is happening and 
the enemies appearing for some reason. Over here,   if you speak, if you've seen yet near the 
spaceship, the enemy is appearing, because we   haven't changed the name of our image.

So let's go 
to the bullet. And over here instead of enemy we   are going to call it bullet. I know when I was 
recording this and you I was just writing the   slide, you guys must have screamed that, hey, this 
should be bullet dot png not enemy dot png word,   no worries, we have changed the value. And if we 
come back, you can see that you can't really see   the bullet over here. But it's actually appearing 
but it's appearing so fast that you can't see it.   So actually, let me just change it to enemy 
again so that you guys can at least see it.   It's happening behind the screen. So let me run 
this. And when we press face, you can see that   the enemy is appearing at near the spaceship, you 
can see this, this is happening.

So this is how   the bullet is also appearing. But right now you 
just can't see it. So let's change this back to   bullet dot png. To put a dot png so we need to 
do a couple of things. So why is it appearing   and disappearing so quickly, what we need to do 
is we need to make sure that it persists in the   background. And when we need anything to persist 
in pygame, we added to our infinite while loop. So   right now this code is only being called when we 
press the spacebar we want this bullet to appear   and not disappear really really quickly. So we 
are going to add another comment over here. And   we're going to call this bullet movement bullet 
movement. And over here, we are going to just   change the values and first check the maybe the 
state of our bullet.

So right now our state is   when you press the spacebar, then the state 
changes to fire. But at default, the state   always remains at ready. So as you can see that 
the bullet underscore state is equal to ready. And   when we press the spacebar, the fire underscore 
grid function is called and inside the function,   the state changes to file. So outside over here we 
can write and condition if bullet state is fire,   then we can actually move the bullet in front of 
the spaceship and make sure it decreases in y.   So we're going to add some values and we're going 
to call this Fireblade function again over here,   and we're going to get rid of value of clear x, 
and we're going to give it a value of y.

And just   below this, we are going to decrease the value of 
our bullet just like we discussed at the starting   of the video, minus plus minus equal minus equal 
to bullet y change which is currently 10. So let's   run this program now and see if it works. So this 
is our spaceship and what's happening to our enemy   y is going crazy. Let me just reload this what's 
what's up with this enemy. Alright, so now you can   see that the bullet is moving.

But this this there 
are two problems in this first, we can only fire   one bullet. So you can see after we have fired one 
bullet, we can't fire another bullet. So that's   one problem. And the second problem is that when 
we fire the bullet, when we move our spaceship,   the bullet is moving with aspiration. Just to 
give you guys another view, when you press space   the bullet is going and when we move the spaceship 
the bullet is actually moving with the spaceship.   So we will be solving both of these problems in 
the next video. For right now I'm just going to   give you a recap so that you guys can understand 
properly what is going on. So let's go The moment   you press the spacebar, so when you press the 
spacebar, this event of spacebar is triggered and   this fire grid function is called.

And over here 
we sent two values that is the current position of   player x and a bullet y value. The bullet y value 
is for at y coordinate and the player x is the   movement where the spaceship is the x coordinate 
of the spaceship and that is partly the reason   why the bullet is moving in the direction of the 
spaceship but we are going to tackle that in the   next video. So for right now we are calling this 
fire bullet function whenever the space key is   pressed, and we're transferring the value of 
player x and bullet y to our fire underscore   unit function. Now this fire blade function is 
due to changing the state of our bullet state   underscore to fire so that when we execute this 
y loop All this code can be executed. So we are   finding firing the bullet and to find the ability 
first need to show it on the screen.

So we are   blurting it out or drawing it on the screen. And 
we have changed the value of 16. And why. So just   to show you guys why we have changed the values, 
let me actually remove the x and y values, so that   you guys can see the difference. So I'm just going 
to turn play and I'm going to shoot a bullet. As   you can see, the bullet is being shot a little 
bit from the left hand side and we want it to   be shot from the middle of the screen. That is why 
I did that. So the middle of the spaceship not in   the from the middle of the screen to be exact. But 
anyways, after we did this fire in this corporate   function has been called the bridge state has 
been returned to fire. And then we go to this   infinite while loop which is running but it wasn't 
running because before running the spacebar or   before pressing the spacebar, the bullet state 
was ready. So all of this code was not getting   executed. But after pressing the spacebar, the 
bullet state has been changed to fire.

So now we   can put blade this out on the screen by calling 
this fire unders component function. And we can   start actually changing the location of the bullet 
by moving it in the upward direction by reducing   the value of y. So guys, this was the logic of 
our bullets. In the next video, we are going to   tackle the two problems that we have discussed 
in this video. So I'll see you over there.   The last video we learned how to shoot a 
bullet.

But there are a couple of problems   with our program right now we can shoot only 
one bullet at a time. And that said that's it   for the whole game has a pretty big problem. And 
the second problem is that the bullet is always   following our spaceship doesn't matter where it 
goes, bullet will follow it and we want it to   have an individual path. So for example, we wanted 
to have, we want the bullet to have the starting   point of our spaceship, the x coordinate our 
spaceship, but when we move the spaceship,   that bullet should continue on its original x 
coordinate and not of our current spaceship. So   these are two problems we are going to solve. 
Let's solve the first problem first of having   multiple bullets. So for that, what we are going 
to do is we are going to add an if condition.   So right now, if you watch over here, when the 
bullet goes up, it goes to the zero coordinate,   and then we are not doing anything to a bullet.

So 
it just keeps on going into negative values. And   we are not removing the bullet from our screen. 
So what we need to do is as soon as it crosses   the zero coordinate, we need to make sure that it 
resets to the value of 480. So as soon as soon as   it goes above zero coordinate, two things are 
going to happen first is going to reset to 480   pixels of y. And the second thing is because you 
can't see it on the screen anymore, because it   has gone beyond zero y coordinate, we are going 
to change the state of a bullet to ready again,   so that we can fire it the next time. So let me 
just add an if condition this beneath this bullet   movement, which says if bullet y is less than 
equals to zero because above zero is going to   be negative values. And over here we are going to 
do two things. First is we are going to reset the   state of the bullet that is the bullet Why should 
be reset it to 480 again, and the second thing is   we need to change of the bullet state.

So bullet 
state is going to be ready again. And let's make   sure that we don't misspell anything. And we are 
going to format this properly. Press Enter and   now let's reload it and you will be able to see 
that our bullet is multiple. So right now you can   see we are short one bullet, then we can shoot 
another bullet and it keeps on happening. And   now that we have fixed the first problem, let's 
focus on the other problem. And that is that the   bullet is following our spaceship.

So why is this 
happening? This is happening because in our code,   we are still using the player x value. So if we go 
to our space condition, so after pressing space,   we are using the player x value. And even 
in our bile if condition code of over here,   we are still using the player x value. So it's 
alright that we want the starting position of our   bullet to be at the spaceship that we just removed 
this recording thing. So at the starting position,   we want the bullet to be at the x coordinate 
of a spaceship. So when you press space,   the bullet starts from the spaceship and not 
from somewhere else. So for example, over here,   we want to x coordinate of a bullet to be that 
of the x coordinate of our spaceship.

But when   we move after firing the spaceship, the x 
coordinate shouldn't follow the spaceship.   So that is the problem that we are having. So how 
do we solve that. So instead of using the bullet,   the space player x value everywhere, which is just 
use when you press the spacebar, one value of the   x coordinate just should be just saved.

So we're 
gonna do that we're just going to write bullet x,   we haven't used this variable yet. And we are 
going to save the value of player x over here.   And then instead of player x, we are going to send 
the value of bullet X to our fire bullet function.   And we are going to do the same thing over here 
in our if condition so instead of player x,   you're going to use the value of bullet x and 
that should solve the problem. So let's run our   main program again and see if it works. So this 
is a spaceship. And now if we move our spaceship,   the bullet is not following our spaceship. So, 
we had what we have done is when the spacebar is   pressed, then we are saved the current spaceship x 
coordinate inside our bullet X variable.

And then   we are using that everywhere instead of just using 
player x. So now that we have fixed that there is   one more problem to fix, which I've just realized. 
So the problem is that after pressing if we press   the spacebar again, so for example, we press 
the spacebar, the bullet is going. And then if   you press the spacebar multiple times this bullet 
is going to change just keep on moving according   to our spaceship. So multiple spacebar changes 
its x coordinate. And why is that happening. So   while the bullet is a moving condition, it's in 
fire condition. Even in that condition, we can   press our spacebar, so we have to make sure that 
we can only press the spacebar when it's in ready   condition.

So we're going to add a if condition 
over here, which says if bullet state is ready,   let's add double quotes for the string. If 
the police state is steady, only then we can   fire another bullet, otherwise we can't fire the 
bullet. So after our bullet goes above this zero   coordinate or our bullet is in ready state only 
then we can fire another bullet. So now if you   play space, all the errors have been fixed. Except 
this first one, I don't know what happens to is   sometimes. Alright, so let's shoot. And you can 
see that after it has crossed the zero coordinate,   and it resets to 40 y coordinate again, only then 
we can shoot another bullet.

So this is looking   pretty good guys, we have finally completed the 
bullet module. This was a pretty long module   because there were a lot of complications in it 
and a lot of things to understand. So let me just   recap so that you guys can understand everything 
properly. So if anybody has understood everything   perfectly, you guys can just stop this video. 
So what happens when you press the spacebar,   when you press the spacebar First, it checks 
whether a bullet is already on the screen or not.   If it's not on the screen, then it makes sure that 
it gets the x coordinate of our spaceship, let me   just add a comment so that you guys can understand 
get the current x coordinate of the spaceship.

So   it gives the current x coordinate of the spaceship 
and stores it inside this variable bullet x and   then it fires the bullet using this bullet X 
variable. And this bullet Y variable basically   which we have said before that is 10 because we 
want the bullet to move at the speed of 10 or   change its y value at every vile iteration at 10. 
So after we do that it goes to this fire bullet   function and over there it changes the state to 
fire and then it creates that bullet. After it   changes its state to fire it goes to this while 
loop iteration I checked, it says if bullet state   is fire, and it keeps on firing the bullet. If we 
don't have this fire underscore bullet statement,   then the bullet won't appear on the screen. So 
anything that we want to be persisted inside, our   game needs to be included inside our while loop. 
That is why we have this function inside our while   loop. If this statement was not there, the bullet 
wouldn't be there. So that is why we need to make   sure that the bullet is continuously appearing on 
the screen after every iteration of while loop.

So   after it fires a bullet it keeps on changing 
its y coordinate. Because of this statement,   it happens that it goes above the screen. So 
after it goes above the screen this if condition   is activated, and it resets the bullet to 480 y 
coordinate and then it resets the bullet state to   ready again. And then we can press the spacebar 
again and everything happens again. Basically,   it's saved again the x coordinate of a spaceship 
but I'm not going to go into all of that.

So guys,   that is pretty much it for this video. 
In the next video we are going to create   multiple enemies. So right now there is only 
one enemy so it's very easy for our spaceship,   or maybe depending upon what I want. And 
maybe I'm going to teach you guys how to   shoot this enemy. So right now this enemy 
can pass through the bullet and nothing   is happening to him. So we are going to 
probably discuss that in the next video.   So in the last video, we created multiple 
bullets, instead of shooting just one bullet,   we can shoot multiple bullets at the enemy and 
we don't have to, you know, just just shoot one   bullet during the whole game. But as you can see, 
our bullet is going through the enemy and it's   not colliding and nothing is happening when the 
bullet hits the enemy not the score is increasing   and the enemy is also at the same place.

It's not 
responding anywhere, which we want. So in this   video, we are going to learn about the collision 
concept how to make sure that the two objects have   collided. And that's a very important concept in 
gaming. So what do We'll be doing is that let me   just actually reload this game so that we can see 
the bullet and the enemy properly. So what I'm   going to be doing is we are going to calculating 
the distance between the bullet and the enemy.   And if the distance is short enough, then we 
conclusively say that the bullet has collided.   So the bullet has an X and Y coordinates where 
it goes up through the screen. And similarly,   this enemy also has an X and Y coordinate, when it 
goes through the screen on left, right or up and   down. So we are going to use all of these four 
coordinates, that is the x coordinate and the x   coordinate of our bullets and the y coordinates 
of both our bullet and an enemy to calculate the   distance between them.

So now what I want you 
guys to do is go to Google and type in distance   between two coordinates. And we're gonna take you 
to this website math planet.com. And over here,   there is this equation, which says distance 
equals to x coordinate minus x coordinates of   other objects squared plus y coordinate of one 
object and y coordinate of the object square,   and then a square root of the whole thing. And 
this x two and x one doesn't matter, whatever is   at front because and by the end of the day, we are 
squaring this. So obviously, you must have learned   this in school or in college. But if you haven't, 
don't worry about it, just go through this article   a little bit, you just need to execute this code 
in this equation in our Python.

So even if you   don't understand what this is doing, we are going 
to learn how to actually implement our equation   in Python. So that is going to be really helpful 
for you guys. So keep this equation in mind. And   let's go back to our code, and just beneath this 
fire underscore bullet function, we are going to   create a new function, and we're gonna call it is 
coalition.

So this function is basically going to   help us with define whether a collision between 
the bullet and an enemy has occurred or not. So   he's going to take four values, the x coordinate 
of the enemy, the y coordinate of the enemy,   the x coordinate of the bullet, and similarly, 
the y coordinate of our bullet. And now we are   going to create a variable known as distance, so 
this distance will store the distance between the   bullet and our enemy. And how do we calculate 
this distance, obviously, using this equation,   so distance equals two, and then we're gonna 
do a square root. So to do a square root, or do   any kind of mathematical operations, you need to 
import something known as math.

So if you go up,   I haven't imported math yet. So I'm just gonna 
write import math. So I'm going to import that.   And then First of all, we want to do the square 
root. So let me go over here and just write   math.sq Rt. So this is the basically the function 
or the method for doing square root, and then   apply some brackets. Now we need the Nv x and the 
bullet x, and we need to subtract it according to   the formula. But before we even that, we need to 
square it. So if we go back to our equation, you   can see after the square root, the x two minus x 
one is being squared. So we also need to implement   that mathematical formula. So we're just gonna 
write math dot POW. So this stands for power,   and then it requires two values, the x and the y. 
So we're going to do that. So we're going to just   write comma two, because we want it to be squared, 
and then over here, we are going to give it the   value of enemy x minus enemy y.

Alright, so this 
is looking good, we have executed the first part   of our equation, now we have to execute the second 
part of the equation that is plus y two minus   y one and two squared. So we are going to go 
back over here and inside our math.pi. So this   is this part math.pi x two, and this is enemy, 
not any y. This is politics, sorry about that.   And then we are just going to write plus, and 
then we are going to write math dot POW again,   because we need another power and requires to two 
values first is the par value, so we want it to be   squared again.

And then we just need to subtract 
the anyway when you move y and me y minus bullet   y. And this should give us the value. Obviously, 
we need to close this Math Math dot square root,   so we're going to apply another bracket but looks 
like it's an extra bracket. So what we are doing   is math dot pow, we are doing x two minus x one or 
x minus x one minus x doesn't matter, squared it   and then math.pa y two minus y one squared. So 
just to make sure that these two are separate,   we are going to apply another bracket over here. 
So I'm going to also do this with this one.

Let's   not blunder Alright, so there is some problem 
over here. So this is the problem. So let's   apply a bracket over here instead of that, 
and this is looking pretty good. So now what   we are going to do is we are going to write an if 
condition if this distance is less than 27 pixels,   then return us the value of true that is the 
collision has occurred, else return us the value   of false. So we're going to write f condition and 
return false. I mean, we didn't need to write the   Save condition. We could have just return false 
over here, but I just wanted to make sure that   you guys understood. All right, let's format 
it properly obviously immunity format meeting   in PI charm, make sure you press Ctrl Alt plus L 
LS for I don't know Lula something. So make sure   you press Ctrl Alt plus L if you're using Python, 
it should format everything beautifully. Alright,   so our escalation function is complete. 
So now what we are going to do is,   we are going to scroll down, and we are going to 
write inside our while infinite loop over here,   just below this enemy x or even the politics, we 
are going to add a comment that's going to stand   for collision so that we know that we are 
writing the code for collision.

And over here,   we can just check whether a collision is happening 
or not. So I'm going to create a variable called   collision and then I'm going to call this 
escalation function. And over here, we are   going to set the value of enemy x and y. And over 
here in all of this code inside this while loop,   we are manipulating the value of x and y of 
enemy and the bullet. So this is the right   place to call this escalation function. So here we 
are just going to write bullet x comma y. Alright,   so this is looking good. So this is collision is 
going to store the value of true and false and if   the collision has occurred is going to store the 
value of collision of true in collision. Alright,   so this is looking good. And then we're going 
to write a condition if condition. So what do   you want us to do if the collision is occurring? 
Basically, that is what our program is asking.

So   what do we want after a collision has occurred. 
So the first thing that we want is to reset the   bullet to its starting point. So we are going 
to reset the bullet y at 480. And then because   the bullet is not being shown anymore, we want to 
change the state of the bullet to ready. So let's   change the state of the bullet to ready by writing 
bullet state equals to reading. And then the last   thing we want to do is obviously increase the 
score. So I'm just going to create a new variable,   let's say, let's actually just go over here so 
that it's close by and we are going to write   the value of score equals to zero. All right, so 
that's looking pretty good. So I'm going to just   scroll down, and over here, I'm going to write 
score score by missing the variable of score   squared plus equals to one. So this will increase 
the value by one every time we hit our enemy.

And   after that, we are just going to print out our 
score. So I'm just going to print it out on the   screen. So now let's just run our program and 
see if everything is working or not. So I'm just   going to run the main program. And over here, we 
are going to shoot our bullets. And hopefully,   if it hits, and I'm not a bad player, as you can 
see the score increased by one. So let's try to   hit it again. And as you can see, the score is 
increasing by one. But when we are not hitting it,   the score is not increasing. So let's try 
to make our score at least five. All right,   all right, so the score is five.

So what one 
thing you must have noticed is that the enemy   is still on his current path. And it's not 
responding to its default location. So we   need to fix that. So what we are going to do is we 
are going to right change the value of player x,   the enemy x and the enemy by over here. So I'm 
just gonna scroll up and check out where we have   declared the value of enemy x and y. So I'm just 
going to copy this, and I will paste this inside   our F collision, obviously, like this code can 
be optimized, we can create a new function for   all of this stuff that is happening over here. 
But maybe we can do that in the later videos,   all the optimization classes and functions, we'll 
see whether we do that or not, because this is not   such a complicated program.

But maybe we will. So 
now what will happen is that the enemy x and the   enemy y will get restarted or respond to a default 
location, and will respond to a random integer   that is between zero to 800. And why is 50 to 150. 
Obviously, we already discussed what this does, it   basically gives a default position to the enemy. 
So let's give it a shot again. And we're gonna run   the mean again and see if it works. So let me just 
wait for it. Alright, so our enemy is actually   just going back to its new location. Alright, 
let's just wait for the enemy to come back a   little bit down so that we know that our code 
is working properly. So let's shoot it. Alright,   so our game is responding properly, our enemies 
respond properly, and it looks good. So one   thing you might have noticed that when it comes to 
this right hand side of the screen, it just drops   down. Even if you're trying it on your own. If an 
enemy response towards the right hand side of that   window of a window, it just goes down.

So why is 
that happening? that is happening because when we   respond our enemy or just be when you're creating 
the movie or giving it a value of zero to 800. And   but inside our code we have written in over here 
that if the enemy x is greater than 736, make sure   you change its y value. So there will whenever 
our enemy is responding with a greater value than   736 it's immediately going down without a chance 
to go left. That's why we need to make sure that   over here when we are creating the enemy that 
we don't increase the value till 800 only it is   736 Just for safety, we are going to write 735. So 
obviously, we need to make sure that the same 35   also goes in when a collision has occurred. So I'm 
just going to copy that over here too. Alright, so   this looks good. We have also fixed an error.

So 
this is looking pretty good. Alright. So Alright,   look enemies responding properly. Let me just 
shoot it again. All right. So alright guys. So   this is pretty much it for this video. In the 
next video, we are going to learn how to create   multiple enemies. So right now there is only 
one enemy. So the game is pretty easy, you can   just play it really easy, and actually is pretty 
fun to play. While I'm recording this video i'm   also playing. But anyway, guys, let me just recap 
actually quickly so that you guys can understand.   So if you already understand the video, just 
go to the next video, but for people who have   not understood properly, so we have created a 
function called is collision where you have four   coordinates to off enemy coordinates and to have 
bullet coordinates. And we have used all of these   four coordinates in this formula, which we got 
from typing and distance between two coordinates   this formula and then we try to execute this 
formula inside our code. Obviously, before   you shall start doing this man thought squad, 
make sure that you import math.

And after that,   we made the square root. And then inside this 
week, using the dot POW function, we squared it   just like we have done in this formula x two minus 
x squared squared. So we needed to make sure that   we squared it and make sure that the brackets are 
correctly placed. Because if you guys are typing   the code, it might like it might you might mess 
up somewhere. So make sure you guys are typing   this code properly, line by line. All right, all 
obviously, I will upload all this code on GitHub,   so you'll find it somewhere over there. And by the 
end of this series, I'll upload it after recording   all the videos.

So you can wait for it a little 
bit or you can find it in the description or   attachments or something. So math.pi and e x minus 
bullet x, you guys understand all of this stuff,   and then how this 27 network number came to be. So 
I just tried and tested what was the proper number   for distance between enemy and bullet to call 
it a collision. And I just by trial and testing,   I came on this number if the distance between 
the bullet and the enemy is less than 27,   I'm going to call it a collision.

And then if 
the collision has occurred, it will return true   and obviously we are calling this function over 
here if collision. So if a collision has occurred,   what do we want from a program, we first of all, 
we want to reset the vials of blood to 480 that is   the starting position of the spaceship and then 
we are going to change the state of course to   ready because you can't see the bullet anymore. 
And when you can't see the bullet anymore, the   state is ready.

And then we increase the score by 
one and we printed out the score and then we made   sure that the enemy respond to its new location. 
Alright guys, so this is basically a way to just   to track back a little bit this is just a way to 
kill the enemy and then make sure that we also   create a new enemy. Alright guys, that's pretty 
much it for this video. Thank you for hanging out   in the next video we are going to learn how to 
create multiple enemies, so I'll see you there.   In this video, we are going to learn how to create 
multiple enemies.

And in the previous video,   we learned about how the collision system works. 
So for example, if we shoot the enemy is going   to respond to a new place, as well as increase 
our score. So how do we make sure that multiple   enemies appear on a screen so for example, six 
enemies so what we can do one idea is that we can   store all of these six enemies in a list or an 
array but in Python is called a list. So we are   going to store all of the enemies in a list and 
display them one by one on the screen.

But it's   going to happen so fast that it will look that 
all the six enemies are appearing simultaneously   on the screen. So we are going to turn all of 
these variable into a list variable and how do   you do that you simply copy the variable name 
and equal to and brackets. So this signifies   an empty list. There is nothing inside this list 
and we are going to use a for loop to put values   inside this list.

But we have to do it with all 
of the variables. So let's do that. So let's do   it with enemy x and then enemy y. So I'm gonna 
copy this, copy this paste over here. Let me   just copy everything first and then I'm going to 
add the square brackets not the neatest way but   the quickest way and then I'm just gonna copy 
all of these square brackets quickly. Alright,   and how do you add values inside a list so 
right now this is an empty list and how do you   add values to a list is by using a method known 
as dot append.

So instead of equals two we are   going to use dot append over here. But even before 
that we are going to create a variable known as   num of enemies which stands for number of enemies 
and we can change this variable whenever we want   to increase the number of enemies. So we are going 
to create a for loop for i in range and inside   this we are in a port number of enemies. So this 
loop for right now is gonna run six times and six   of our enemies are gonna be created. Obviously you 
we want all of these values to be out added to the   list that we have created of all the variables. 
So what we are going to do instead of equal to,   we are going to write dot append.

And this is 
going to add our current value inside our list.   So for example, the first enemy image is going to 
be stored inside this enemy image list. So we are   going to do all of this with all of the variables. 
And you don't need to do it with any new via   change because these are like constant values, 
but whether just for the sake of simplicity,   we are going to do it with all of them. 
Alright, so let me just do it with all of them,   I'm going to copy this dot append everywhere.

So 
just to do it quickly, again, not the neatest way,   but the quickest way and that is what we want, 
just the quickest way. And let me just add the   practice after everyone so that there are no 
errors. And it looks neat. Alright guys, so   this is looking pretty well. So whenever our code 
is going to run, it's going to go through this,   and it's gonna create six number of enemies. 
But if you scroll down inside our while loop,   you can see that we don't specify which enemy x 
do we want to move. So this is the code that we   are using for the enemy to move towards the left 
hand side or the right hand side and a downward   movement.

But if we don't specify which enemy x 
we are talking about, because if you notice above,   we have declared six enemy x. And because we 
have created a variable called as enemy x we have   created an empty list. So each time this for loop 
is going to run is going to enter a new value of   enemy x and scientists and we x list. So we need 
to make sure that our program understands which   enemy x we are talking about.

So we are going to 
create another for loop over here and we're going   to do the same thing that we did over there number 
of enemies. And the idea is pretty intuitive,   you just need to change every value over here to 
basically inside a square bracket just specify   which value you're talking about. And this is a 
way to reference something inside a list obviously   if you know less you probably already know about 
this. So anyways, we are going to do this we are   going to I this I bracket everywhere. So let me 
just copy and paste this everywhere so that our   program knows which anyway we are talking about 
which enemy wide change we are talking about. Let   me just copy this everywhere. All right, this is 
looking pretty good. And then we also need to make   sure that a collision is also inside our enemy. 
So we are going to copy all of this code from   over here. And we are going to place this inside 
our while loop because we need to make sure that   we calculate the collision for every let me just 
paste this so you can see over here that currently   our collision is it's not inside our for loop but 
actually inside here it's actually inside a for   loop but make sure that it's not inside this 
lF condition or the if condition otherwise,   it's not going to work a lot of people make this 
mistake that they don't pace the collision part   correctly or don't pace anything properly.

So 
anyways after making sure that you have pasted   is probably inside our for loop we are also going 
to change these let me just press it here alzette   we are going to make sure that our Python 
program knows which and the x coordinates   we are talking about. So let me just paste it 
over here. Alright, so this is looking pretty   good. We also need to make sure that we add 
it over here. So basically, wherever we are   talking about the enemy or the coalition, you 
need to make sure that our program knows which   coordinate or which enemy we are talking about. 
And then the last thing we need to do is whenever   we are calling the enemies for example over here 
calling the enemy function and this is where we   will basically blitting the enemy we also need 
to make sure that we add which image do we want   to be plated.

So right now it's not specifying 
so we are going to paste this inside our ennemi   for loop and make sure it's not post pasted inside 
the if condition it's pasted inside our loop. So   indentations matter and then we are going to send 
the value of i according with specifying which x&y   coordinates we want to be printed on the screen. 
So basically which enemy we are talking about.   So if we go up to our enemy function over here 
you can see we haven't specified the AI value so   we need to specify the value and also the which 
image enemy image do we want to draw? Obviously,   you will be thinking there's only one image but 
actually there are six enemy images because we   have created a list of enemy images too, 
as you can see over here.

Alright guys,   so this is looking pretty good. I think almost 
all of the code is done. So let me just play it   and then we will figure out what we have to recap 
and if there are any errors, we can solve them.   So let's play it and see if it works. Alright, 
so this is looking pretty good. We have created   six enemies and when we showed them so let's try 
and shoot one of them amateur bad player. Alright,   so when we are shooting them, our collision is 
also working. It's they are responding. Alright,   so this is looking pretty good. So how is 
this game going to end whenever one of these   Space Invaders come and hit the bottom of 
the spaceship or basically hit the 480 by   access then we are going to end the game so we 
just keep shooting and increase the score.

And   right now there is no place where we are 
displaying the scores. In the next video,   we are going to make sure that we display 
the score on the left hand side top corner.   All right, guys, welcome back. So in the 
last video, we created multiple enemies,   and our game is looking real, real good. So the 
score system is working, but the score is not   being currently displayed on our game window. 
So we'll fix that in this video, we will make   sure that the score appears on the top left 
corner of our screen. So how do you do that,   so that is simple, we use a font object that is 
inside pygame. So pygame is actually going to help   us create font or text on the screen. So the first 
thing we need to do is go to this word image. And   we are going to actually remove the score variable 
that we've created over here. So instead of that,   we are going to just press enter and write score 
so that we know we are creating score under this   statement.

And then right now we are going to 
create a variable known as core value, and we're   going to give it a value of zero. And obviously, 
you can see with this red symbol, there is some   error with say a score plus one, we are doing 
it over here. So we need to change this to score   value. And then we can remove the print statement 
because we don't need it down.

So let's just go up   now. And then we have to use the score object or 
the PI game font object. So that is pretty easy.   You just create a variable known as font. And 
obviously you probably know already, what font is,   font is just the type of text or the style of 
text that is displayed how much the weight of   the line often is, is actually dependent upon 
the font, what kind of font you use. So first,   we are going to define what kind of font we want. 
So how do you do that, we just use the pygame dot   font method that is inside pygame pygame dot font 
dot capital F font and inside this we are going   to give it two values. The first is which font Do 
we want. So inside pygame, there is one free font   which is known as free. cents bold. So right now 
we are just going to use this font and dot TTF is   the extension of the font. And then we are going 
to give it a size.

So we're just going to give it   a size of 32. And then after that we are going to 
give it the x and y coordinates of where we want   this text to appear. So we want it to appear 
in that top left corner somewhere, but not   just attached the screen a little bit away from 
the scheme. So we are going to give it a value of   text text the x coordinate of 10 pixels, and then 
text y of that is the y coordinate also of 10.

Now   just like we did with these player player enemies, 
we have to create a function that is going to show   this score value on the screen. So let's do that 
we are going to create a function which we are   going to call show score. Pretty easy stuff. And 
inside this function, we have to give it the X   and Y value just like we have done with everything 
else. And one difference is that for example, you   can see how we are plotting the image inside this 
def player. Instead of creating the player trying   the player on the screen, we are going to render 
the text on the screen.

So I'll just show you   what I mean by that. So we're going to create a 
variable of score. And inside this we are going to   write font dot render. And we're going to require 
some values inside it. So this is the what I mean   by instead of bleeding, we are going to render the 
text of show the text on the screen. So using this   font object we have created over here we are now 
right font on trend. And there is going to require   a couple of values the first value is what text Do 
you want. So we want our text to be first of all   score. And then we want the score value in front 
of the text. So we are going to write it actually   we have to convert it into a string. So right 
now, this score value is an integer, so we have   to use typecasting and inside this. So basically 
we are converting this integer value to a string   by writing str in front of it. This concept in 
Python is known as typecasting and actually, in   programming This concept is known as type casting. 
So inside this we are gonna write score value.

And   then after that the second value is required is 
true. So we can display it on the screen. And   then the third value requires is what is the color 
of the font that you want, you can show whatever   color you want. Obviously, we have to use the RGB 
values, which we have discussed before. But I'm   just going to use the white whether that is 255 
or eight 255 green, and then 255 blue. So this   is looking pretty good. Let me just format this 
properly.

And then we are going to show it on the   screen and how do you show it on the screen. 
So first, we are going to render the score   called render the text. And then we have to blit 
this text on the screen or draw this text on the   screen. That is why I said this is a little bit 
different. First you have to render then you have   to break it on the screen. So we are going to use 
the same concept we have over here. So actually,   let me just copy this from here and paste it and 
instead of image we are going to render our score.   So this time is not an image it's a font or a 
text and it requires X and Y value which we are   providing through this function. And now one 
last step. That we have to do is pretty easy,   we just have to go down and anything that you 
want to persist on our screen obviously has to   be called inside our while loop.

So I'm just gonna 
call our show score function and x, y is text x,   and text y. Alright guys, so this is looking 
pretty easy. So let me just run it and show you   that it works. And hopefully it will run without 
any errors. So our score is displayed on the top   left corner. And when we shoot someone, let me 
just show someone as you can see, our score is   increasing. So let me just shoot a couple of more 
enemies or space invaders.

Alright guys, so this   is looking pretty good. Our score is increasing 
and resolving respond and our game is being   created. So one last thing I want to tell you guys 
is that how do you add extra fonts. So right now,   if we go to our fonts, so for example, here is 
a font, this is the only font that is inside our   pilot. So let me just close this, how do you add 
other fonts inside this, so what you can do is   you can go to a website or something and download 
fonts. And they will give you a font that is of   extension dot TTF. And you can just download this, 
place it inside your project structure, and just   write the name of the font. So for example, what 
you can do is you can go to this website known as   d a font. And this gives a lot of fonts for free. 
So you can download just any any font that you   want.

And we're going to give you a zip file, just 
extract that zip file, and it's going to give you   a dot TTF file, then paste that TTF file inside 
the Space Invader project folder, and just write   the name over here. And then you can use that 
font inside your plugin. So this is pretty easy.   And this transfer the font size. So let me just 
increase for sign to something crazy 70 maybe it's   not that crazy. But as you can see the score has 
increased to 70 says, but let's keep it let's keep   it small 32 pixels.

Alright guys. So that's pretty 
much it. So let's just to recap a little bit,   first we create the score value, we added a font 
object, then we created the x and y coordinates   of the font where we want it to appear. And 
then inside a show score, we did two things,   we rendered the font and then we blurted it or 
drew it on the screen, and render we applied or   gave it three values, the score the true and the 
color of our text, so you can change it to green.   So let me just show it to you. Yes, RGB. So GB 
should be 255. And then we can make both of these   values are zero red and blue. And this should make 
it green. Let's play it. And as you can see, it's   green. But we want to invite color white, I think 
looks good on any game.

So let me just change it   to 255 again. Alright, let me just give a space 
over here. And then we do it on the screen. And   then the last thing we did was before changing the 
value of our scores, so after collision, we need   to make sure that the score value is increasing 
by one after we hit the enemy by a bullet. And   the second thing is we call the show on the score 
function that is pretty standard. Alright guys,   so in the next video, we are going to learn 
how to end the game. So right now the game   is not ending is just keep on going even if the 
enemy hit our spaceship. So one thing I noticed   is that the enemies are not moving very fast. 
So we'll also increase the speed of the enemy   a little bit in the next video. And we'll make 
these minor changes. So I'll see you over there.   Alright guys, welcome back. And hopefully 
you're having a great day. And today we are   going to learn about how to add sounds and music 
to our PI game.

And currently there are no sounds   inside our game. So it looks pretty simple. 
But what we are going to do is we are going   to add three types of sounds. The first sound 
is the background sound that's going to play   continuously in the background. The second is 
the shooting of the bullet sound. In this case,   I call it laser dot wave. And the third 
one is explosion dot wave that is going   to be produced when our laser bullet hits our 
enemy. And just to show you guys how it sounds,   I'm going to play this main dot Python file, 
which I have already changed the code off so that   you guys can see what's happening inside again. So 
I'm just gonna play it and you can see Alright, so   you must have seen there are three sounds first on 
continuously goes in the background.

Second is the   laser or the bullet sound. And the third is when 
our bullet hits our enemy. Now how can you get all   these three files? Let me actually make sure that 
the code is original and the last one that we have   used. And now how do you get these three dot WAV 
files. So what I want you to guys to do is I want   you to go to github.com arthropod Space Invaders 
by game and you will be able to get all the code   that I've written till now and along with it you 
will be able to get the.pe files that I have been   talking about after downloading these three files 
or maybe the whole code and you can download them   by clicking on this clone or download and done 
download zip. Make sure you add the sound files   to your project by going to Space Invader and just 
pasting them over there.

Now let's get started   with adding background music into our game. So 
first thing we need to do is import something   Known as a mixer from our pygame Library. And to 
do that we just right from pi game, import mixer,   import this mixer. And what does this mixer This 
is basically a class that helps us handle all   kinds of music inside our game, whether it can 
be repeating our music, loading, music, anything   that want.

So you have to look inside this class 
whenever you want to do anything with sounds or   music. And then just below this background, we 
are going to add a background sound. So let's   write our comments. so that you guys can know in 
future what we are talking about. And then we're   just going to use the mixer library by writing 
mixer dot music dot load pretty easy, because   we want to load the file and then we are going to 
play the file.

And inside this, we're just going   to write background dot WAV, which is the name of 
our file, as you can see on the left hand side,   and then we're just gonna play this sound by 
writing mixer dot music dot play pretty easy.   And now we want this file to play continuously. 
Because right now, if you don't add anything   inside this dot play, this file is going to play 
once and then just stop, but we want it to play   in a loop because this is a game and can go on for 
long. We don't want it to play just once. And how   do you do that inside this mixer class, you just 
add minus one and it's going to play on loop.

So   now let's just test it out and see whether it's 
working or not. As you can hear the background   music must be going on. But we haven't yet added 
the sound to the experience town so that must not   be there. So that's why we are going to be working 
on adding the bullets are now but one thing I want   you guys to notice is that currently we are using 
mixer dot music because we want this file to be   played continuously in the background. So this 
is kind of music. But as something is very short,   for example our bullet sound then we have to use 
mixer dot sound. So we are going to come below   where we have a bullet shooting. So how are we 
going to catch the moment when our bullet is being   released.

So we are going to do that inside our 
let's go to above let's go to this if bullet state   is ready. So over here we can release the sound 
of our bullet going out from our spaceship. So   because over here we are getting the x coordinate 
of the spaceship and then we are shooting the   bullet over here so we can somewhere over here at 
our bullet Stan. And how do you do that is also   very easy. Just below this we are going to write 
mixer dot sound. So in this case, it's not mixer   dot music, it's mixer adult sound. And we're 
gonna first create a variable let's create a   variable and call it bullet underscore sound just 
to make sure that we know where our sound is,   and makes a dot sound and inside this you have 
to give the file of the sound so and that's in   our case is laser dot WAV.

And then just like we 
did in the music case, we are going to play it so   we're just gonna write bullets sound, not state 
will it sound dot play, and we don't want it to   be played inside a loop. That's why we haven't 
added minus one. So now our bullets is making   a sound now we just need to add a sound to our 
collision. And where are we catching collision   let me just copy this first and we are going to 
go below I just want you to guess first where we   are going because this is pretty obvious we are 
going to this part where if collision we want a   sound p plate and that sound is off explosions. 
So we're just going to copy and paste this over   here because most of the things are going to 
be same instead of bullet we're going to write   explosion sound. And then I'm just going to copy 
and paste this just below this play and instead of   laser dot wave we are going to go with explosion 
dot wave.

So that's this is pretty much it. Let's   actually play our game one more time and see if 
everything is working properly. So let's play this   Alright guys, so everything is looking really 
good. So are all of the three sounds are playing   obviously Feel free to walk around and play 
around and add more sounds maybe remove and   add your own songs. That's going to be fun. In 
the next video we are going to learn about how to   make sure that our game gets over when our enemy 
hits our spaceship. So I'll see you over there.   In the last video, we learn how to add sounds 
to our game and in this video we are going to   show the game over a screen. So I removed all of 
the sounds for this video because it's going to   be difficult to explain what's going on if I add 
the sound.

So what we're going to do is when many   of these enemies come close to our spaceship 
maybe over here, we're going to remove all of   these enemies or maybe just get them out of the 
screen. And we are going to show a big test just   like we are shown over here the score zero we 
are going to show a big text of game over over   here in the middle of the screen. And when is this 
pixels gonna head without these enemies gonna come   close to the spaceship when they're gonna hit 
the y axis of 440 pixel. So if you remember at   the top at zero pixel at the bottom is 600 pixel 
and adjust at the starting of the spaceship it's   about 480 pixel, but just by experimenting, I 
found out that 440 is perfect.

So when I use   that 440 pixel As a limit, so when our enemies 
come over here, we are going to show game over   for our player. And the final score is going to 
be shown over here. So what we are going to do   is we are going to come to our enemies where we 
are moving our enemies basically. So we'll come   down and come to enemy movement. So enemy 
movement was over here. And then over here,   we are just going to add a text. So let's add 
a text and just call it Game Over, because we   are going to be writing the game over code just 
below this.

And what do you want is when whenever   an enemy lets enemy right, and whenever enemy 
Why have I so whenever one of the enemies and   doesn't need to be all of the enemies when one of 
the enemies come to for 40 pixels. And actually,   just to test it out, I don't want the enemies to 
come to the bottom. So I'm going to make it very,   very small, maybe 200 pixels. And just when we are 
ending the game and we are finalizing the game,   I'm going to change it again to 440 pixels.

So 
whenever one of the enemies come to 200 pixels,   then what we want to do, we want to move all 
the enemies, so we are on create another for   loop for j n. And then we just want to copy 
all of these, because we want to move all   the enemies out of the screen, that's how I'm 
going to create another for loop inside this   big for loop. And then under this and is going to 
change the axis of enemy y j equals to 2000. And   this should make sure that these enemies go below 
the screen to 2000 y pixel. And then after this,   I'm gonna just make sure that we display 
the game over text. So how do you do that,   I'm just going to create a function. And this 
function will be called underscore game over text.   And we are going to call this function and then we 
are going to break out of this loop.

So let's make   sure that we are not doing anything weird with the 
brackets and over here we are just going to write   break. And this looks pretty good. So what we are 
doing is whenever an enemy, it doesn't need to be   all the enemies when one of the enemies reaches 
is greater than 200 pixels in this case, but it's   actually going to be 440. And then we are going to 
collect all of the enemies inside this for loop.   And we want each of the enemies to be moved out of 
the screen.

And we are doing that by setting the   y axis to 2000. It is not going to be shown on the 
screen. And then we're calling this game over text   function which is going to display the game over 
text on the screen. And then we are breaking out   of this loop because we don't need this for i in 
range loop anymore. So now let's create this game   over underscore test functions. So we are going to 
go where we have added our score. So let's just go   over here. So you can see we have added our score 
over here. So we are going to do doing basically   the same thing. And we are going to write game 
over text over here. And then we're going to copy   the same thing that we have done over here. And 
instead of font we are going to just write game,   or we can write or underscore font, and we want 
the font to be bigger. So this is the size of the   font, we are going to make it 64 by 64 pixel The 
size is bigger.

And then we are going to create   our function. So just below this show underscore 
function, we are going to create our game over   next function. And we are going to do the same 
thing that we did previously with our show under   score function. And then over here, let's just 
copy and paste this line. So we are going to copy   this paste over here. And then instead of score, 
let's just call it over underscore text. And then   we don't need all of this stuff, we just need to 
be displayed game. And let's make it in capitals,   just to make sure it looks good. Game over. So 
this is looking good, then we just need to blurt   it all drawn on the screen, we're gonna copy and 
paste this over here, let's just press enter and   paste this over here. And then instead of score, 
we are going to write over underscore text. And   we are not because we are not going to use the 
x and y values, we can use it but because our   game worst takes is going to be displayed at one 
place.

So I'm going to remove this and instead   of that, I'm just gonna write 202 50 pixels. 
And this 200 comma 250 pixel is basically the   middle of the screen, you can try out different 
values and see what works for you. But basically,   I've divided the both of these values by two and 
made it a little bit less both the x and y axis.   And that's how I got to the center obviously, you 
to change the values a little bit so that it looks   good.

Anyway, so this is looking pretty good right 
now let's run our main.py file and see if it's   working. And you have to remember that we have 
made it 200 pixels. And you can see that again,   what else is being displayed, but it's not in the 
middle and it's not big. So why is that happening.   And this is because we have used the same font 
over here that we have created previously,   this font, we need to change this.

And because 
we have created a new font that is known as   the Oh font. So we're just going to copy this 
and paste this instead of font don't render we   are going to paste over underscore font, because 
this is our new font. And this font for used for   a score. That's why it's so small. let's reload 
it and hopefully this time it will work. So let's   wait for it to come to 200 y axis and after that 
is going to show the game or screen so now you   can't hit any of the enemies so the score is going 
to remain constant.

So let me just show it to you   again. Let me just hit A couple of enemies. And 
now we have hit our enemies. So let's wait for our   200 pixel to get over. And it's going to happen 
anytime soon. All right, it's your end game over.   And now because you can't hit any more enemies, 
your score is going to remain constant. Obviously,   you can add more buttons like play again and do 
stuff like that. But by now you already know how   to do it. So I'm not going to go into it again. 
So now finally, let's change is now that we know   that our code is working instead of 200.

Let's 
change it to 440 pixels. And make sure you add the   sounds again and make it a complete game. So guys, 
this is pretty much it. For this video series, we   created our space invader games from scratch. And 
if you were a beginner who didn't know anything   about pi game or creating games, now you have 
a basic understanding of how a game is created.   It has been wonderful hanging out with you guys. 
So thank you for watching and I'll see you around.