How to Program a Game! (in Python)

00:00:00 what's up guys and girls in today's
00:00:01 video we are going to go over how to
00:00:03 program your first game in Python so in
00:00:07 this video we'll be programming in
00:00:08 Python 3 and then using sublime text 3
00:00:10 as our editor and by the end of this
00:00:12 video you'll have a game that looks like
00:00:15 this it's a very basic game where you're
00:00:19 controlling the red block and you're
00:00:21 trying to dodge these blue blocks that
00:00:23 are falling and as the score increases
00:00:25 the speed of the blocks increases as
00:00:28 well so as you can see now it's getting
00:00:30 a little faster getting a little harder
00:00:32 and if I do ever collide with a blue
00:00:35 block it says game over down here and
00:00:39 your score so this is what you'll have
00:00:41 completed by the end of this video and
00:00:43 you should have some programming
00:00:45 knowledge to do this video all the
00:00:48 knowledge you need for this is in the
00:00:50 first 5 Python tutorials I've posted on
00:00:52 my youtube channel so if you check the
00:00:54 description for those videos and watch
00:00:55 through them all
00:00:56 you'll be like more than prepared for
00:00:58 this video and also if you haven't set
00:01:00 up your development environment with
00:01:02 sublime text in Python 3 I'll also have
00:01:05 a link in the description to set up
00:01:06 everything so you're ready to get going
00:01:08 in this video alright in this video
00:01:11 we're going to be using the PI game
00:01:13 library of Python so if you don't have
00:01:15 this already installed open up a command
00:01:17 prompt if you're on Windows or a
00:01:19 terminal if you're on Mac and type in
00:01:21 the command pip install PI game and that
00:01:25 should it install it properly if the the
00:01:29 command pip isn't recognized you
00:01:31 probably didn't install python properly
00:01:33 so i recommend just rewatching my setup
00:01:35 video uninstalling whatever you have and
00:01:37 reinstalling and potentially if you're
00:01:40 on Mac you might have to instead of
00:01:42 typing pip install my game you'll have
00:01:44 to type pip 3 install PI game so if the
00:01:48 first command doesn't work for you try
00:01:50 typing pip 3 in salt PI game okay once
00:01:53 you have PI game installed open up a new
00:01:55 Python file I just called mine game py
00:01:57 and we'll go through the basic setup of
00:02:01 the PI gate like whenever you do a PI
00:02:04 game project the basic setup of that so
00:02:06 the first line we always need to write
00:02:07 is import PI game and we should run that
00:02:10 and make sure it doesn't give us
00:02:11 there if it did give you an error right
00:02:13 there with that import make sure you
00:02:14 install the PI game properly so maybe
00:02:17 run through those pip commands again and
00:02:19 make sure that they actually said PI
00:02:21 game was installed and if you're on Mac
00:02:23 remember you might have to do pip 3
00:02:25 instead of just pip install PI game ok
00:02:27 so we have pi game that the first line
00:02:30 we need to always do is initialize PI
00:02:32 game so we do PI game done it and when I
00:02:37 when I forget how to do this I usually
00:02:38 just look it up online so if you look up
00:02:40 like build a like building a PI game in
00:02:44 Python this these like the basic
00:02:47 commands you'll start your file out with
00:02:49 will be provided by someone else on the
00:02:52 internet so PI game dot an it run that
00:02:55 still nothing is happening so we want to
00:02:58 actually create a screen in PI game so
00:03:01 to do a screen we can do screen equals
00:03:04 PI game display dot set mode and then we
00:03:09 pass in a tuple of width and height so
00:03:12 the width would be like something like
00:03:13 800 and the height will say is something
00:03:16 like 600 and this is in pixels so if I
00:03:20 run that you should see a screen pop up
00:03:22 and then quickly close and don't worry
00:03:24 about it quickly closing we'll fix that
00:03:26 in a few minutes so we have a screen of
00:03:29 with 800 and height 600 pixels one thing
00:03:33 I recommend you do is instead of
00:03:36 directly passing in these numbers here
00:03:38 let's initialize two variables that hold
00:03:42 those values so we're gonna initialize a
00:03:44 width variable which is equal to 800 and
00:03:47 height variable which is equal to 600
00:03:51 and the reason we're doing this is
00:03:53 because we'll want to probably use our
00:03:55 width and height when we're building
00:03:56 this game so if we set variables to
00:03:59 equal the width and height then we can

00:04:01 easily access those things throughout
00:04:04 our game and also if we wanted to say
00:04:07 one day change our width to like a
00:04:09 thousand pixels if we have a variable it
00:04:13 makes everything else easier because we
00:04:15 don't have to switch every one of these
00:04:16 values in our code we just have to
00:04:19 switch it right here so let's say ok
00:04:22 we'll go back to 800 with the width
00:04:25 let's say we wanted the height 600 so
00:04:26 we'll just pass in hug it right here so
00:04:29 now if ever on that run you still the
00:04:35 same screen pops up and then just closes
00:04:37 because we haven't handled the closing
00:04:39 condition yet okay so the next thing we
00:04:42 want to do is develop our game loop so
00:04:46 basically what is gonna happen with PI
00:04:47 game is we're gonna have a loop that's
00:04:49 just running while our games not over so
00:04:51 we'll have like while not game over and
00:04:53 then we'll have PI game is an event
00:04:57 based programming library so we'll have
00:05:01 a for loop inside of this while loop
00:05:03 that will track all of our events so
00:05:05 it's gonna look like something like this
00:05:06 and as I said I'm whenever I'm making
00:05:12 this from scratch I'm usually looking up
00:05:14 that just kind of the basics online and
00:05:17 then just kind of importing them in so
00:05:18 don't worry about like having to
00:05:20 memorize this so we're gonna do our
00:05:22 instance a variable called game over is
00:05:24 initially equal to false and then we're
00:05:28 gonna have a loop that says while not
00:05:30 game over so that's going to keep
00:05:33 running until we hit the game over
00:05:35 condition and what we want to do is have
00:05:38 now a for loop which is going to get the
00:05:40 events in PI game so for event in PI
00:05:45 game dot event dot get and to start out
00:05:50 I'm just going to print event so if I
00:05:54 run this if you see down here at the
00:05:58 bottom of my screen it's tracking
00:06:02 everything I do on the screen and this
00:06:04 is super helpful for us because now we
00:06:07 can any action we do during our game we
00:06:11 track it with this events and we can use
00:06:14 it to help us program specific things to
00:06:17 happen based off of certain events so
00:06:19 this is super useful these events and
00:06:21 notice there's like a bunch of different
00:06:23 mouse motion mouse button up mouse
00:06:25 button down key presses key like down
00:06:29 key up let me think
00:06:32 like you can do escape all sorts of
00:06:35 different things you can do with
00:06:37 events and then I'll close out and
00:06:39 actually the closing out won't be
00:06:41 handled right now properly so if the
00:06:43 manually close it shoot I'll fix that in
00:06:47 one sec so I'm just gonna cancel build
00:06:48 up here so if you can't exit out just go
00:06:53 up to tools cancel build or do control +
00:06:55 break okay so the first event we have to
00:06:58 handle and this happens in I think every
00:07:01 PI game you're gonna make is we have to
00:07:04 do one event type that's called
00:07:08 the kind of quit event so if we do top
00:07:11 we do in this four that we're gonna do
00:07:13 if event dot type equals equals PI game
00:07:20 quit that happens then we want to do a
00:07:25 system exit so assist exit end will
00:07:29 actually have to import this system
00:07:30 library and that comes pre-installed on
00:07:34 every Python version so now if I run
00:07:36 this and I click this X right here it
00:07:41 lets me quit out properly
00:07:43 alright so that's our basic screen all
00:07:46 right so now that we have our screen
00:07:47 let's begin drawing shapes on our screen
00:07:50 that will eventually move around and
00:07:51 manipulate so whenever I need to know
00:07:55 how to do something either do a Google
00:07:57 search or I look up on this official PI
00:08:00 game 0 r slash Doc's so this has all the
00:08:03 different things you can do in PI game
00:08:05 so I want to right now I want to draw
00:08:08 something so I'm going to click on the
00:08:09 draw section of the docs and I just want
00:08:13 to begin by just drawing a rectangle
00:08:14 it's the simplest shape so we'll begin
00:08:16 with just drawing a rectangle so this
00:08:19 gives us the command to draw a rectangle
00:08:22 so I can do PI game rect to draw rect
00:08:26 then I need to pass in something like
00:08:29 this so this is how a rectangle is
00:08:31 defined so let's do that real quick so
00:08:36 let's we want to just draw a shape
00:08:39 somewhere on our screen so I'm going to
00:08:42 just do we want to do this outside of

00:08:44 the event loop
00:08:45 want to do it just at the same level as
00:08:48 this for loop so outside of that but
00:08:52 inside the wild not game over we want to
00:08:54 do PI game draw rect and then if I look
00:08:58 at the documentation one more time
00:08:59 it takes in a surface so the surface is
00:09:02 going to be our screen in this case the
00:09:05 color this is going to be an RGB color
00:09:07 value which RGB is just there's three
00:09:11 values that each each have 0 to 255 and
00:09:15 they together make a color so look into
00:09:18 RGB colors if you haven't heard of them
00:09:20 before it's pretty straightforward you
00:09:22 don't really need to know too much about
00:09:23 it and then the rectangle and the
00:09:26 rectangle is defined by I think X
00:09:29 location Y location width and height and
00:09:33 then with so to figure out the rectangle
00:09:36 real quick
00:09:37 I'll go to rect and ya left top width
00:09:43 height that's gonna be how we draw a
00:09:45 rectangle so let's do this so PI game
00:09:50 dot draw rect surfaces the screen next
00:09:53 we need to do the color so we'll just
00:09:55 say we want to draw a Red Square
00:09:58 so to do red in PI game we do to 5500
00:10:03 that's an RGB for red because red has
00:10:06 255 in the green and blue slots have
00:10:10 zeros which means no color so it's just
00:10:12 gonna be red now we get into our
00:10:14 rectangle and to define that we did left
00:10:17 position top position and then width and
00:10:21 height so we'll just do it somewhere in
00:10:23 the middle of the screen so I'm going to
00:10:24 say like 300 400 or actually live with
00:10:29 you over 400 300 and then width will be
00:10:32 like 50 and height would be like 50 and
00:10:35 then finally the last part of the
00:10:38 rectangle drawing the rectangle was the
00:10:44 width and that's an optional parameter
00:10:47 if it says equal to 0 that means
00:10:48 optional so this is just the outline of
00:10:50 our shape and I'm just not gonna bother
00:10:52 with it
00:10:52 so we'll just draw this ok so right now
00:10:58 I'm drawing a rectangle but we actually
00:10:59 don't see it on the screen and that's
00:11:01 because I'm PI again we need to do a
00:11:02 command we need to update our screen
00:11:04 every iteration so I can do something
00:11:07 like PI game dot display update and now
00:11:13 we have that Red Square drawn in the
00:11:16 center of our screen and a couple of
00:11:20 things to note for good practice is we
00:11:23 should instead of just defining these
00:11:26 things inside of this let's try to make
00:11:28 this a little neater and kind of allow
00:11:31 someone reading our code to understand
00:11:33 more what we're doing so for example
00:11:35 with this red let's delete this and go
00:11:40 up to the top of our screen and just
00:11:41 define it as a like constant variable so
00:11:44 red is equal to 255 0 0 and now when
00:11:48 we're drawing the rectangle we could
00:11:50 pass in red as opposed to that like a
00:11:52 number that might not mean as much to
00:11:54 people same thing for these 400 and 350
00:12:00 s instead of defining them just as
00:12:03 numbers inside of this draw function
00:12:06 let's give them variables that add
00:12:08 meaning to what they are
00:12:09 so we'll say we'll call a variable maybe
00:12:15 player position so this is the Red
00:12:19 Square is going to be our player and so
00:12:21 we're gonna find a tuple that is the
00:12:23 position of the player so that's going
00:12:26 to be something like well we'll find it
00:12:29 as a list that is 400 and 300 and we
00:12:35 could even go a step farther we call
00:12:37 this player act player Y but we'll just
00:12:39 do 400 300 so when I was drawing this I
00:12:45 could do player position index of 0 and
00:12:53 player position this is from the
00:12:56 indexing video the list video I have on
00:12:58 Python 1 to get these two values and
00:13:02 then that's also define a player size so
00:13:06 player size is going to be equal to 50
00:13:09 both width and height will do
00:13:10 make this a square for now so this
00:13:12 should be player size and this next
00:13:15 variable or this next value is going to
00:13:17 be player size as well and it still
00:13:25 works cool so we just made it neater so
00:13:27 now I can read this code we can read
00:13:30 this code easier than when it was just a
00:13:33 bunch of numbers floating all over the
00:13:35 place so what this is called in
00:13:38 programming is we had initially a bunch
00:13:40 of magic numbers floating around our

00:13:42 screen and basically they're called
00:13:44 magic numbers because someone reading
00:13:46 our code might not know have any idea of
00:13:48 where they come from but now that we
00:13:50 define some of these variables it's a
00:13:52 lot easier to read our code and
00:13:55 understand what's actually happening
00:13:56 here okay now let's get the movement
00:13:59 happening so when we press a key we can
00:14:02 move this block to the left and right so
00:14:04 to do this we're gonna have to track the
00:14:06 event that is mouse button down and
00:14:09 mouse or not mouse button down but a key
00:14:11 press down and key press up so we're
00:14:14 going to track a new event so below the
00:14:17 kwid event we're going to do another
00:14:20 event so this event is going to be if
00:14:22 event dot type equals equals and once
00:14:26 again I'm finding this this event type
00:14:28 from the PI game library so if I go to
00:14:31 events they have all sorts of event
00:14:37 types listed here so we're going to want
00:14:39 to do keydown and keyup so if the event
00:14:43 type equals equals pi game dot key down
00:14:51 then we're going to want to make some
00:14:53 movement so let's specify what a key it
00:14:56 is so we can do if event key equals
00:14:59 equals pi game dot then all the keys are
00:15:03 listed in this documentation stew
00:15:05 let's see where the key is event key
00:15:09 somewhere down here maybe it's actually
00:15:13 up here then there should be kiddie yet
00:15:16 key so all the keys are found here so in
00:15:19 key tab key clear all of it is located
00:15:22 here so I'm going to use the
00:15:24 left and right arrows so if I can find
00:15:26 left and right in here so we've left
00:15:28 arrow and right out right here so K
00:15:30 underscore right and caters for left so
00:15:32 if PI game event I key equals PI game
00:15:35 dot K left then we want to move it left
00:15:39 so I'm just going to pass for now we'll
00:15:41 fill that in a sec and then the other F
00:15:44 is else–if event key equals equals PI
00:15:50 game dot key right we want to do
00:15:55 something else and and the reason I use
00:16:07 an else–if as opposed to else is
00:16:09 because if we use else then it would
00:16:11 attract any other key to be the the
00:16:14 right movement we want it to be
00:16:16 specifically the right arrow so let's
00:16:18 fill in these functions these are these
00:16:20 if statements so if event.keycode equals
00:16:23 pi game you've got K left what do we
00:16:25 want to happen
00:16:26 well we're drawing this rectangle down
00:16:28 here using the player position so if we
00:16:33 can tweak the player position in this if
00:16:36 statement that's going to allow us to
00:16:38 move so take a second and try to do that
00:16:41 on your own and then unpause the video
00:16:43 when you want to see how I will go ahead
00:16:45 and do that okay to do this I'm going to
00:16:50 begin by decoupling this list in doing x
00:16:55 equals player position 0 and y equals
00:17:01 player position 1 so this is just taking
00:17:06 our position right here and just
00:17:09 grabbing the X&Y coordinate just so it's
00:17:11 easier for us to read so when wherever
00:17:13 we press the key down it will grab the x
00:17:15 and y coordinates and then what we want
00:17:18 to do is we want to if the key left is
00:17:21 pressed we want to shift the x value so
00:17:25 I'm going to do X minus equals 5 and if
00:17:31 we hit event key right I'm going to do X
00:17:34 plus equals 5 so it's basically just
00:17:37 changing whatever our x-coordinate is in
00:17:39 our position whenever we press these
00:17:42 keys and then finally whatever happens
00:17:45 after this I'm going to just set the new
00:17:47 position to equal the list of X comma Y
00:17:55 so the new values of x and y whatever
00:17:57 happen to them in these if statements
00:18:00 we're just going to reset it down here
00:18:02 and one thing to note is I took out this
00:18:05 Y just because in case you want to make
00:18:07 your player go up and down in the future
00:18:09 you'll be able to do that with this
00:18:11 right here so let's run this cool it's
00:18:17 kind of working I keep pressing the
00:18:20 value I don't know if you can see the
00:18:22 the block extending the the problem is
00:18:26 the block is moving but it's just
00:18:29 tracking the red with it it's not moving
00:18:32 probably how we want it to be moving and
00:18:36 so that the problem with that is it's
00:18:38 always drawing the rectangle but it's
00:18:41 never resetting the screen so when the
00:18:43 rectangle has move it's not refilling
00:18:45 the entire screen black so one thing we

00:18:48 can do to fix this is there's a function
00:18:51 called screen dot fill and that takes
00:18:54 into RGB value so just like we use the
00:18:56 RGB value red we can pass in the RGB
00:19:00 value black and if I run this now well
00:19:06 we got our we got our red block moving
00:19:09 around and there's no annoying trace of
00:19:12 where it's been but we're moving really
00:19:13 slowly so let's go ahead and make this
00:19:17 instead of maybe minus equals five and
00:19:19 plus equals five let's just move it one
00:19:23 whole block size so player size and
00:19:26 player size and so finally we were on
00:19:29 this and now it's jumping around our
00:19:32 screen nice and fast so that looks
00:19:34 really good and just for good practice
00:19:39 let's take out this zero zero zero
00:19:42 delete that and pass it up here so we're
00:19:45 gonna do background color
00:19:50 and we'll just pass that in here so you
00:19:53 can change this to whatever background
00:19:55 color you want we'll just stick with
00:19:56 black for now so screen fill background
00:19:59 color and now it's easier to read that
00:20:02 line as well cool look at that okay now
00:20:09 let's go ahead and get blocks starting
00:20:11 to drop from the sky
00:20:13 so we'll get blocks dropping from the
00:20:15 sky and actually real quick I think it
00:20:18 would be helpful to initialize our
00:20:19 position to a slightly different
00:20:20 location so let's do how about instead
00:20:25 of this initial location of 400 300
00:20:27 let's set it right in the middle so
00:20:30 we'll do with divided by 2 which
00:20:32 actually will still be 400 but it just
00:20:36 if we change this with now it'll stay in
00:20:38 the middle and the 300 instead of that
00:20:40 we'll do let's say height and if we did
00:20:45 the full height it's gonna be off the
00:20:47 screen so the in pygame
00:20:50 the zero zero spot stops that the starts
00:20:53 at the top left so if I went all the way
00:20:55 down on the height
00:20:56 I'd be down here and it's drawing it
00:20:58 then below the screen so what we'll do
00:21:01 instead is we'll do like height minus
00:21:04 two times player size oh shoot I think I
00:21:11 used the capital when I wasn't supposed
00:21:12 to so two times player size now we were
00:21:15 on that what happened
00:21:18 player size is not to find out I'll have
00:21:20 to do this right above this line save
00:21:25 run cool and now it's in a nice position
00:21:30 at the bottom of the screen so it's a
00:21:32 little bit more friendly now to having
00:21:34 blocks fall from this guy because it's
00:21:36 not right there in the middle okay let's
00:21:38 begin with just one block falling from
00:21:40 the sky so we'll define an enemy let's
00:21:43 say well we will call these blocks from
00:21:45 the sky enemies so we'll say enemy size
00:21:48 and to begin we can just set this to 50
00:21:51 I'm gonna set this the same size this
00:21:53 player is but you can play around with
00:21:55 this as you see fit and we'll say enemy
00:21:58 position equals we want it to be at the
00:22:02 top of the
00:22:03 screen so we'll say something like I
00:22:06 don't know we'll do some random value
00:22:09 here now for begin with 100 and then we
00:22:13 want it to be around the top of the
00:22:15 screen and so I'm going to just say like
00:22:16 100 0 and I'm going to print this out
00:22:21 right before we print out the the the
00:22:29 player so screen let's this declare the
00:22:33 enemy at blue so blue and RGB is you
00:22:38 mean it's RGB so 0 0 red and green are
00:22:42 zeros and then the blue value is the 255
00:22:45 in this case and we run that oh shoot I
00:22:50 didn't actually finish this line so
00:22:53 screen blue now and then we want to do
00:22:57 enemy position so it's the same exact
00:23:00 line except now we're switching in enemy
00:23:02 position as opposed to player position
00:23:05 so enemy position 1 so this is the X&Y
00:23:08 of enemy and then we'll make them square
00:23:10 so with your enemy sized enemy size so
00:23:13 the width and the height is the same for
00:23:15 the enemy run that and now we have this
00:23:19 enemy at the top of the screen and it's
00:23:22 set to 100 right now so we should
00:23:24 probably set it to a different value so
00:23:29 ideally what we want to do is set it to
00:23:31 a random value so maybe take a second
00:23:33 right now and see if you can figure out
00:23:35 how to set this initial enemy position
00:23:37 to a random value on the screen and
00:23:39 unpause the video when you're ready for
00:23:41 me to show you how to do that okay to do

00:23:47 a random value on the screen we need to
00:23:50 use this random library that I have
00:23:52 mentioned in the first video I did in
00:23:55 the tutorial series on Python and that
00:23:57 was in the math and variables video and
00:23:59 there's actually this library called
00:24:00 random so we can use random to do the
00:24:05 following in do enemy position equals
00:24:08 random dot random in so we'll get just
00:24:12 an integer between 0 and our width
00:24:16 so that will put us right in the middle
00:24:18 of the screen as we want just some
00:24:20 random spot at the top of the screen on
00:24:22 the x-axis we do that and as you can see
00:24:28 it's in the kind of right side the first
00:24:31 time I run it if I run it again it will
00:24:32 be in a different spot so see it's now
00:24:34 on the left and there's actually got a
00:24:38 small error with this line as is and
00:24:43 that is that this could actually have a
00:24:46 value of width so if I instead made this
00:24:49 width real quick you can't actually see
00:24:54 the block because width is right here at
00:24:57 the very edge and then it draws it to
00:24:59 the right so we actually need to do is
00:25:03 do random int zero – with – enemy size
00:25:10 enemy size save that and now that will
00:25:15 make sure it's in between the width of
00:25:18 our screen okay cool okay now let's get
00:25:26 the actual enemy to start following
00:25:28 downwards so to do that we can do the
00:25:33 following so right now this is the Y
00:25:37 location of the enemy and it's never
00:25:39 changing so to get it to start falling
00:25:41 we need to on each iteration have this
00:25:44 value change so that it actually goes
00:25:48 down on the screen so we can do that
00:25:52 pretty simply so we'll do something like
00:25:56 let's say if enemy enemy position
00:26:11 one is greater than zero or greater than
00:26:16 or equal to 0 and let enemy position 1
00:26:22 so enemy position 1 remember is the Y
00:26:24 position of the enemy is less than the
00:26:28 height then we want to get it to fall
00:26:33 downwards so we can do enemy position 1
00:26:39 minus equals like 20 we'll say and then
00:26:45 else will do enemy position will want to
00:26:50 reset it the else condition in this case
00:26:52 means it's off the screen so we'll want
00:26:54 to set it to back to 0 equals 1 and one
00:27:01 nice thing about using lists is I can
00:27:03 directly modify the enemy position in
00:27:06 place so I actually don't have to reset
00:27:08 it like I did here like I could have
00:27:11 just modified player position 0 directly
00:27:15 and not reset it like I did here
00:27:17 so like this is another way to do what
00:27:19 we did up here equals 0 now let's see
00:27:24 what happens ok it's like freaking out
00:27:29 why is it freaking out and the reason
00:27:32 it's freaking out is because as I
00:27:34 mentioned before the top of the screen
00:27:35 is actually 0 0 right here so when we
00:27:38 decrease the height we're actually going
00:27:40 upwards so what we actually have to do
00:27:42 is add 22 enemy position plus it equals
00:27:45 20 see what happens now oh my gosh it is
00:27:49 flying and one thing we can do to kind
00:27:54 of tame how fast it's going is we can
00:27:59 set up frames per second rate a frame
00:28:03 rate to our game and to do that we
00:28:05 define a clock so we'll define our clock
00:28:07 outside the while loop clock equals PI
00:28:10 game time clock and let's just set our
00:28:16 hour speed of our game to go that say
00:28:19 like 30 frames per second I think that
00:28:21 seems fair so in the wild loop now we
00:28:24 need to do clock dot tick and we'll do
00:28:29 pass in 30 for 30 seconds and this
00:28:32 should slow it down a bit yeah so now it
00:28:34 falls nice and smooth it's actually
00:28:37 still going pretty fast I might slow it
00:28:38 down a bit more we'll make this like
00:28:41 plus equals 10 now let's see what
00:28:45 happens that's like a nice fall and as
00:28:48 you can see right when I get to the
00:28:50 bottom it goes back to the top and falls
00:28:53 again so now we have a falling block
00:28:56 couple changes will make to make this a
00:28:58 little bit better is first off the block
00:29:00 is falling from the same spot every time
00:29:02 so we should reset the the exposition of
00:29:08 the anime so enemy position 0 which is
00:29:11 the x position we want to reset that to
00:29:14 another random value so we can do random
00:29:16 Rand int again 0 – width – enemy size so
00:29:23 let's see what that looks like yeah it's
00:29:28 going different spots every time left
00:29:32 and right side way – right side cool but
00:29:39 we're still not gonna have any

00:29:40 collisions right now like right now it
00:29:42 just runs right through it so we need to
00:29:44 do collision still and also one thing I
00:29:46 think is nice to do is instead of doing
00:29:48 10 here this is a magic value we don't
00:29:50 really know what that 10 means let's
00:29:52 define a variable called speed up top so
00:29:57 we'll say speed equals 10 and now we can
00:30:03 just do plus equals speed here so now if
00:30:06 we change that speed variable so if I
00:30:08 change the speed variable like 1 it's
00:30:11 gonna move really slowly and if you lose
00:30:16 in this game I come on you gotta ain't
00:30:18 gotta be better than that but that's
00:30:20 really slowly and we can change it to
00:30:22 like 50 to make it move really fast
00:30:25 oh so as you can see that's one way we
00:30:29 can play around with like the level of
00:30:31 our game
00:30:34 we already set it to ten so we have a
00:30:38 falling block now okay so the next thing
00:30:41 we're gonna do is go ahead and detect
00:30:43 collisions so first off I'm just gonna
00:30:45 write a comedy right here that makes
00:30:47 that just lets us know that this is
00:30:49 updating the position of enemy but let's
00:30:54 detect collisions between the enemy
00:30:56 position in the player position so to do
00:30:59 this we're gonna define a function and
00:31:01 we're probably to go by the end of this
00:31:02 video we're gonna kind of move all this
00:31:04 stuff in here into their own function
00:31:06 because it just makes the code neater
00:31:08 but we'll begin the first function will
00:31:12 write today is the function that detects
00:31:15 collisions so we're gonna do detect
00:31:19 collision and that's going to take in
00:31:22 the player position and the enemy
00:31:26 position and we'll just begin by doing
00:31:31 like player X so this is the player's
00:31:36 x-coordinate just to make this neater
00:31:38 player actually equals player position
00:31:40 zero and then player y equals player
00:31:45 position one then we can do the same
00:31:49 thing with enemy enemy x position equals
00:31:51 enemy position zero and that's the index
00:31:55 of 0th index and enemy y equals the
00:31:59 enemy position first index so now we
00:32:05 have their positions and now we need to
00:32:07 figure out if they overlap to help us do
00:32:10 this I created a little visual so we
00:32:11 could see what happens when overlaps
00:32:13 occur so here we have the player block
00:32:15 down below so and we have the enemy
00:32:18 block falling from above so collisions
00:32:22 could happen like this they could happen
00:32:25 like this
00:32:26 and if the player moved into the enemy
00:32:28 they could also happen like this and
00:32:31 then like this let's focus on what
00:32:35 happens to the x coordinates of these
00:32:37 blocks first and then we'll focus on the
00:32:40 y coordinate so if a collision happens
00:32:42 and also we know about the enemy
00:32:44 we know about the player we know their
00:32:46 top left position so the players top
00:32:48 left position is piece of X piece of Y
00:32:50 and the enemy's top left position is e
00:32:52 sub x e sub y so if a collision happened
00:32:57 like this we know that this e sub X this
00:33:01 left side of the enemy has to be between
00:33:06 P sub X and then if the player has size
00:33:12 piece of X plus player size or the size
00:33:15 is player size the coordinate over here
00:33:17 would be piece of X plus player size so
00:33:21 one condition we can write down that we
00:33:24 know will have to be included in our
00:33:25 collision is if Y sub X is greater than
00:33:34 piece of X and E sub X is less than less
00:33:45 than or equal to I guess we could do
00:33:46 greater than or equal to and less than
00:33:47 or equal to greater than or equal to and
00:33:51 I guess this side of each strictly less
00:33:53 than e sub X is less than P sub X I mean
00:33:59 it won't really matter because this is
00:34:02 just a pixel difference but piece of X
00:34:06 plus player size so that's one
00:34:09 conditional off that include and then we
00:34:13 can also think about the reverse of that
00:34:15 so the reverse of that would look like
00:34:17 this would be if instead of the player
00:34:24 being the farthest to the left we have
00:34:26 the enemy actually to the farthest to
00:34:28 the left and if that was the case then
00:34:31 we can ignore this right side for now
00:34:34 but we know that piece of X now right
00:34:37 here has to fall in between east of X
00:34:42 and then east of X plus enemy size so
00:34:46 the other condition we can write here is
00:34:52 we also need so this is an or condition

00:34:55 so Oh
00:34:56 and this is we're just looking at the x
00:34:58 coordinate or piece of X is greater than
00:35:04 or equal to e sub X so this is the
00:35:10 reverse and piece of X is less than E
00:35:17 sub X plus enemy enemy Wow sorry
00:35:24 sighs let's type that up in our sublime
00:35:29 text window we said if a sub X so I'm
00:35:35 going to just go back real quick and
00:35:36 look at what it said each of X is
00:35:38 greater than equal to piece of X oh my
00:35:43 god piece of X is greater than or equal
00:35:45 to piece of X and E sub X is less than
00:35:52 piece of X plus player size so this is
00:35:56 the coordinates
00:35:58 that's one condition and X can overlap
00:36:01 and there be a collision or the other
00:36:04 condition was piece of X just the
00:36:06 reverse is greater than equal to e sub X
00:36:09 and piece of X is less than E sub X plus
00:36:18 enemy size and I'll put this in
00:36:23 parentheses just to be careful and just
00:36:28 so that this stuff evaluates in the
00:36:29 proper way I'm going to surround this
00:36:31 with parentheses don't know if it really
00:36:35 matters but just I guess good to be safe
00:36:38 in this in parentheses or here so these
00:36:42 are the two ways the x coordinate could
00:36:44 overlap so let's do the same thing for
00:36:49 the y coordinate so I'm gonna erase the
00:36:51 screen here give me one sec it just
00:36:55 raised off the enemy again so we've
00:36:58 taken care of whether or not the ex this
00:37:01 is overlap now we need to make sure that
00:37:03 the Y's when you check to see if the Y's
00:37:06 overlap so I'm gonna hide this
00:37:09 so if the wives overlap then we're gonna
00:37:11 have something looking like this so we
00:37:14 have let's say this is the overlap
00:37:17 position we have a piece of X piece of Y
00:37:19 and he sub XC sub y and if the wiser to
00:37:23 overlap then we would have something
00:37:26 that looks like this so we need a sub y
00:37:32 to be between piece of Y and piece of y
00:37:37 plus player size so it's the same exact
00:37:38 thing so we either need that to happen
00:37:41 or the reverse of that is if this enemy
00:37:45 is the top lock
00:37:46 we need piece of Y to be between UI and
00:37:50 E sub y plus enemy size so I don't know
00:37:54 if you can see that so in if both of
00:37:57 those conditions happen so if the X
00:37:58 condition happens and then either one of
00:38:01 the y conditions happens then we know we
00:38:03 both have a X intersect and a Y
00:38:05 intersect so we know that there's a
00:38:08 collision so to write the Y condition
00:38:10 will basically just mirror the X
00:38:13 condition and I will do if each of Y is
00:38:17 greater than or equal to piece of Y and
00:38:22 E sub y is less than piece of y plus
00:38:27 player size and we'll have two
00:38:32 parentheses here or this is just the
00:38:37 mirror of the other one piece of Y is
00:38:39 greater than equal to e sub y and piece
00:38:45 of Y is less than E sub y plus enemy
00:38:50 size so this is going to be for the Y
00:38:53 condition and if you know we either have
00:38:56 an X the first condition up here checks
00:38:59 to see if there's an X overlap and then
00:39:02 once we check if there's an extra
00:39:04 overlap if there's also a Y overlap with
00:39:06 one of these corners then we know there
00:39:12 is going to be a collision so we want to
00:39:15 return true here and if it doesn't enter
00:39:19 these
00:39:20 then outside here we want to return
00:39:23 false and if it does enter once you
00:39:26 return false it exits out of the the
00:39:29 function and would never run this so
00:39:30 this only runs if you this doesn't pass
00:39:33 for this line doesn't pass okay let's
00:39:36 check to see if that works so to do this
00:39:39 we'll go back to our game loop and
00:39:42 basically we'll just do if so we've
00:39:46 updated the enemy position at this point
00:39:48 so if detects collision of let's see how
00:39:52 we wrote the function player position
00:39:53 enemy position so if detect collision of
00:39:56 player position enemy position so if
00:40:00 that returns true then the game should
00:40:02 be over right game over
00:40:05 equals true and we don't really need to
00:40:09 worry about the else condition because
00:40:11 the else condition would just allow the
00:40:14 game to keep running so let's see if
00:40:16 that works
00:40:22 ok I'll let this one pass okay second
00:40:25 one will it it yay it looked like it
00:40:28 worked and it might look better if we

00:40:31 actually break out of the loop right
00:40:33 here because if we break out of the loop
00:40:36 then we don't draw the rectangles one
00:40:39 additional time so I'm going to just
00:40:40 check this it might not look any better
00:40:42 but I just want to see what I think of
00:40:44 this run so now if we collide all at the
00:40:48 next block it it's more there's less
00:40:53 overlap in the collision it kind of
00:40:54 stops it right when they touch and so I
00:40:58 guess it's kind of a personal preference
00:41:00 there what you think looks better so if
00:41:02 you do want it to just break up
00:41:04 immediately use the break command if not
00:41:06 just you can get rid of it doesn't
00:41:08 really matter
00:41:12 okay now that way you've done collisions
00:41:15 let's go ahead and actually draw
00:41:18 multiple enemies so right now we only
00:41:19 have a single enemy falling let's change
00:41:21 our code up so that we can actually have
00:41:23 many different enemies following
00:41:25 following to do this we're going to do a
00:41:29 couple things so I guess we need a
00:41:32 function that controls how many
00:41:34 enemies should be on the screen at a
00:41:36 certain time so that will be one
00:41:39 function and then another function will
00:41:42 probably the modified detect collision
00:41:44 or do some sort of update positions
00:41:46 function for all the enemies so that we
00:41:49 can you know control each enemy updating
00:41:54 instead of just doing this right here so
00:41:56 we'll do a drop drop enemy function to
00:41:59 also do an update enemy position
00:42:02 function I think and we'll see if we
00:42:03 need to do anything more than that so
00:42:05 let's begin with the drop enemy function
00:42:08 so what we're gonna do is that instead
00:42:11 of having just an enemy position here
00:42:14 I'm going to define a enemy list as well
00:42:21 and that will equal be empty at first or
00:42:24 I guess we could keep our original enemy
00:42:26 and I could just pass in any position to
00:42:29 start so it just has a single enemy in
00:42:31 it right now and so the function we're
00:42:34 going to call drop enemy or drop enemies
00:42:38 will look at this enemy list and to
00:42:43 begin let's say we want to keep adding
00:42:46 enemies until we have ten total in our
00:42:49 list so to do this we're going to do if
00:42:56 length enemy list is less than 10 then
00:43:03 we want to I guess generate a random
00:43:06 enemy so we'll do X position equals
00:43:10 random dot R and int so this is just
00:43:13 random spot on the width of the screen
00:43:15 zero to width minus enemy size and
00:43:18 you've seen this before and then in Y
00:43:20 position will be zero it'll be the top
00:43:24 of the screen you can make this a little
00:43:25 indented if you want to but we'll just
00:43:27 start with the top of the screen and
00:43:29 then we'll have to append this new XY
00:43:33 coordinates to our aim or our enemy list
00:43:36 and we list dot append a list of
00:43:42 x-position y-position
00:43:47 so that will be our drop enemy's
00:43:50 function and then we'll have to have I
00:43:53 guess a draw enemies function and a
00:43:57 update positions function and we might
00:44:01 let's say so we'll do a draw enemies
00:44:05 first draw enemies and this could be put
00:44:09 right into the loop but I'm gonna just
00:44:11 bring it out because it's easier to read
00:44:13 that way so a lot to do for this is for
00:44:17 enemy in enemy list we'll just want to
00:44:22 copy whatever we're doing down here to
00:44:25 draw the enemy so just copy this line
00:44:28 I'm going to take it out of here and
00:44:31 paste it in here and so this is no
00:44:38 longer enemy position this is now called
00:44:40 enemies or I guess I could change it to
00:44:42 enemy position in enemy list draw the
00:44:48 rectangle for that enemy so now it
00:44:50 iterates through multiple enemies cool
00:44:52 it what else do we have to change down
00:44:54 here
00:44:55 well we'll actually have to call that
00:44:59 draw enemies function of enemy list and
00:45:05 also have to call that function we just
00:45:08 wrote called drop enemies and that takes
00:45:11 in the enemy list as well I think we
00:45:13 could probably we're gonna have to
00:45:16 comment out this stuff here because this
00:45:18 would no longer be relevant but I think
00:45:20 we can probably run this as is and see
00:45:22 what happens
00:45:23 oh my god well you have a bunch of
00:45:26 things at the top of the screen so I
00:45:28 guess that's a good thing so let's see

00:45:32 what we can do to fix this so first off
00:45:35 I guess this we just commented out the
00:45:38 update code so that's a problem that's
00:45:41 why they weren't following falling so
00:45:45 that's this write a function called I
00:45:48 guess update enemy positions
00:45:52 so find a function called Def update
00:45:57 enemy positions and that will take in
00:46:03 the enemy list and let's say do we need
00:46:06 a stake in anything else I don't think
00:46:10 so so it takes in the enemy list and
00:46:18 what we'll wants to do with that is that
00:46:21 will basically just copy this code right
00:46:25 here so copy this code and paste it into
00:46:32 this list and now we need to uncomment
00:46:36 it so update enemy positions and now
00:46:42 we're gonna also have to do if for do a
00:46:44 for loop for enemy position and enemy
00:46:48 list and okay so we have this so that's
00:47:00 going to update each individual one and
00:47:03 instead of resetting this will actually
00:47:04 pop it off our list so that our drop
00:47:08 enemy's function can take care of it now
00:47:10 so this updates the position and we'll
00:47:12 want to have a else statement which
00:47:14 basically says so this is saying it's on
00:47:17 the screen the else condition would be
00:47:23 it has gotten off the screen and if it
00:47:25 gets off the screen we'll just pop that
00:47:28 specific enemy off the list so one thing
00:47:35 we can do to figure out what the index
00:47:38 of it is in the enemy list is we can do
00:47:40 this is from the for and while loops
00:47:43 tutorial I have so you numerate enemy
00:47:46 list and then we can do enemy position
00:47:51 and also get the index so index and
00:47:53 enemy position and we want to pop off
00:47:55 this index and then basically the drop
00:48:00 enemies function will handle this again
00:48:02 so let's see we have draw enemies update
00:48:09 enemy positions drop enemies and we'll
00:48:11 play I have to change this detect
00:48:13 collision or we'll make a new function
00:48:16 called like collision check or something
00:48:24 like that and they'll take in the enemy
00:48:25 list and this will return true
00:48:29 this will cause a game to end if any of
00:48:32 this collision check ever returns true
00:48:34 so so for enemy position in enemy list
00:48:41 I'm doing a lot of functions right now
00:48:44 so hopefully this all is making sense if
00:48:47 you have any questions about a specific
00:48:48 function I'm writing here make sure to
00:48:50 just leave a comment I'll help you guys
00:48:52 out so enemy position in enemy
00:48:55 we can do the following we just need to
00:48:58 use our detect collision function here
00:49:00 so we can guess maybe it will also pass
00:49:03 in the current player position
00:49:08 so if detect collision is true here for
00:49:17 the enemy position player position then
00:49:22 we want to return it true and then if we
00:49:25 get through that for loop successfully
00:49:26 with no returns of true we want to
00:49:29 return false all right we have a bunch
00:49:33 of things now we just need to add them
00:49:34 to our loop so we have drop enemy's draw
00:49:37 enemy's update enemy positions collision
00:49:39 check so let's see drop enemies DRI
00:49:44 enemies I need to do update enemy
00:49:47 positions that will take in the enemy
00:49:52 list and I guess we want to update the
00:49:54 positions before we draw them probably
00:50:01 no no update I just copied blank space I
00:50:08 didn't let me just copy that line in
00:50:10 enemy lists and finally we'll want to do
00:50:13 a collision collision check on our enemy
00:50:19 list using the player position and do we
00:50:28 update yeah
00:50:29 the player position will be updating
00:50:31 from this code up here so we'll do if
00:50:39 collision check game over equals true
00:50:49 then we'll break so this is exactly what
00:50:52 we were doing up up here but now
00:50:54 collision check uses detect collision
00:50:57 inside of it but it loops over the
00:50:59 entire list of enemies so let's see what
00:51:02 happens now whoa we got an arrow enemy
00:51:08 collision check is not defined I must
00:51:13 have spelled it wrong up here collision
00:51:15 check that looks right how did I spill
00:51:17 it down here collision God name enemy
00:51:22 list is not defined what the heck oh and
00:51:25 then me oh I can't spell it anymore
00:51:29 it's getting hard as we get to the end
00:51:30 of this video come on oh my god oh my
00:51:35 god yes we got it we got it working
00:51:42 pretty well oh my god but they fall so
00:51:45 fast at the start so one thing you could
00:51:52 do if you want it to stagger a little

00:51:55 bit because right now they're all
00:51:55 following it around the same time is a
00:51:59 little bit of a hack and it looks like
00:52:03 this so right now in our drop enemy's
00:52:08 right we have if length mu list is 10 we
00:52:11 automatically add the new enemy so that
00:52:15 means we're adding them all at the same
00:52:16 time what we could do is is add a little
00:52:19 bit of a pseudo delay and how we would
00:52:22 do this maybe try to think of your own
00:52:25 way to do this at first to just delay
00:52:27 this function work like a pending so
00:52:30 like only certain times does it actually
00:52:32 append it's like every like 10 times it
00:52:35 appends one of these when it could be
00:52:37 appending all of them at the same time
00:52:41 so what I would do is I would do a just
00:52:47 gonna write at a variable called delay
00:52:49 and that equals
00:52:56 random dot R and random random dot
00:53:01 random and what random dot random does
00:53:03 if you don't know is it generates a
00:53:05 random decimal or a random float value
00:53:07 between 0 and 1 and any of those values
00:53:11 between 0 & 1 are equally likely so this
00:53:13 is a good way for us to get some sort of
00:53:15 probabilistic do something based on a
00:53:18 probability so we can now add a line
00:53:21 that says and delay is less than like
00:53:26 let's say 0.5 so only half the time does
00:53:29 it actually append to this list and that
00:53:31 will allow us to like stagger the blocks
00:53:33 a little bit and we might have to tune
00:53:35 this value so if that is the case then
00:53:38 only append to the list let's see what
00:53:42 happens down okay it looks like it's
00:53:45 staggering a little bit more but it's
00:53:47 still they're all falling pretty much at
00:53:49 the same time so we'll make this even
00:53:51 smaller will they make it point 1 and
00:53:54 look at that so now the blocks are
00:53:58 following a much more staggered rate
00:54:09 alright to end this video let's add a
00:54:12 score let's add you know increase in
00:54:17 difficulty as we progress in score then
00:54:20 also maybe like changing up the
00:54:21 background color or like changing the
00:54:23 the block sizes so we'll do some
00:54:26 additional features right now so first
00:54:28 off let's do score so to do score what
00:54:31 we need to see is that if I run the game
00:54:36 run game run game oh maybe the game is
00:54:39 already running oops so if I was to run
00:54:42 this game right basically we want our
00:54:48 score to increase as we successfully
00:54:50 dodged each block so what we really need
00:54:52 to do is just a pet or add one to our
00:54:54 score each time one of these blocks on
00:54:56 the screen that you can see with my
00:54:58 mouse falls all the way under the screen
00:55:01 and so this is going to be pretty
00:55:03 straightforward so outside of our loop
00:55:06 at the top of our screen
00:55:07 we'll just define a score right and our
00:55:11 score is going to start out at zero so
00:55:16 now we have a score at zero and each
00:55:18 time these blocks fall and get to the
00:55:21 ground will increase our score by one so
00:55:25 let's see how do we do this so it's
00:55:30 gonna happen in this update enemy
00:55:32 position so the first if statement here
00:55:37 get checks up the enemies in the screen
00:55:40 this else would check to see if they
00:55:42 fell off the screen so here's where we
00:55:44 want to increase our score so we'll do
00:55:46 score plus equals one here and see what
00:55:53 happens
00:55:55 local variable score reference before
00:55:58 assignment so basically what happened
00:56:00 here is we actually need to up to pass
00:56:05 in our score because it doesn't know
00:56:08 where the score variable is in this
00:56:11 function name because I guess yeah sure
00:56:19 yeah it doesn't doesn't recognize this
00:56:22 score because we never passed it in so
00:56:28 if I do this now now we actually have to
00:56:31 change up how we call our function so we
00:56:34 can do score plus equals one where is it
00:56:38 we're sort of where's the update enemy
00:56:39 positions I'll delete this room quick so
00:56:43 update any positions and we want to pass
00:56:44 in our score now to see what happens now
00:56:51 okay so our score should be increasing
00:56:53 and to check that how would we print out
00:56:56 our score right below update enemy
00:56:59 position so print score and we should be
00:57:01 able to see this at the bottom of the
00:57:03 screen over here when we run it again so
00:57:07 zero zero zero should be one now it
00:57:09 should be one okay it's not one what did

00:57:11 we do wrong and what we did wrong here
00:57:15 is that score is a integer and integers
00:57:18 are a immutable type so it can
00:57:21 just directly increase the score by
00:57:24 doing plus equals one we actually have
00:57:26 to reset score to point to the new value
00:57:29 so what we can do is a pretty simple
00:57:32 change and that will just be in the
00:57:35 update enemy positions function will
00:57:40 return to score when it finishes and
00:57:43 we'll just reset our score so now we'll
00:57:45 do a score equals update enemy positions
00:57:49 so this will do the update and also just
00:57:51 return a value so this is totally fine
00:57:53 for us to do okay Oh am I still printing
00:57:58 score I guess I'm not printing score
00:58:00 anymore so we'll print score again so
00:58:04 now the score should increase as the
00:58:06 blocks fall off the screen come on yes
00:58:09 yes five six seven so it's down here on
00:58:13 the side wow I just dodged a bunch one I
00:58:15 was late trying to show you that the
00:58:16 numbers right over here okay so that's
00:58:21 the score and it looks pretty good it's
00:58:23 going up like we want it to and so let's
00:58:28 actually get that score to print to the
00:58:30 screen so to do this in PI game we can
00:58:33 at the top of our screen we're gonna
00:58:34 need to define a font so I'll just do
00:58:37 this below the clock it doesn't really
00:58:39 matter where we do this so I'm just
00:58:40 going to save my font equals and I'm
00:58:43 looking this this is a command that I
00:58:44 would look up online to remember I
00:58:46 forget this off the top of my head we
00:58:48 can do PI game font dot sis font and
00:58:52 what I did in my example that I showed
00:58:54 you guys at the start of this video so I
00:58:56 use some font called mono space but
00:59:00 there's a bunch of options I think if
00:59:01 you look at the PI game website you can
00:59:03 find all the options
00:59:04 Samanta space of 35 pixels and then to
00:59:08 actually print out the score what I want
00:59:10 to do is is down here in the game loop
00:59:15 so maybe after I update the score I'll
00:59:19 actually draw it and I can do that by
00:59:20 doing text equals score plus so we can
00:59:28 use plus when we're appending two
00:59:30 strings together so I'm
00:59:31 to score and then we'll do label equals
00:59:37 my font render text and then we need to
00:59:41 do the position so the position will
00:59:45 just say actually I don't remember
00:59:50 exactly what this my font on render does
00:59:52 but just follow me on how I do this so
00:59:54 forget what exactly this one is here I
00:59:57 think this might be the direction is
00:59:59 going so the one means horizontally I
01:00:00 think if I change this to a zero it
01:00:02 would be vertical text then I want to
01:00:05 use a color for it so the color will
01:00:08 define will define yellow so yellow is
01:00:11 255 255 0 and I'm actually going to copy
01:00:16 this out and do what I did with yellow
01:00:18 and blue or in red blue and I'm gonna do
01:00:22 yellow up here so yellow equals to 3 5
01:00:25 255 0 and so Fassett yellow here the
01:00:34 last thing we need to do is actually
01:00:36 attach our label to the screen to do
01:00:39 that we can do this function called
01:00:40 screen bullet it label and then wouldn t
01:00:45 we need to select a position so the
01:00:48 position I'm going to select is this is
01:00:49 just something I played around with
01:00:51 before and it worked so I'm gonna do
01:00:53 with minus 200 and then height minus 40
01:00:58 so if you know we know our font size is
01:01:01 35 that we chose
01:01:02 so height minus 40 gives us a little
01:01:04 more space than what our font size is
01:01:08 and this offsets it to the left a little
01:01:10 bit so let's see if that worked
01:01:16 yeah must be strained not in so the
01:01:20 problem here is we're trying to add a
01:01:21 number to the string so we actually have
01:01:24 to do is we can typecast values so if I
01:01:28 have a number that I want to make not
01:01:31 the number but actually a string that
01:01:33 represents the number I could surround
01:01:35 it with STR of score look at that come
01:01:42 on increase yes yes
01:01:44 I don't know if you saw that but it was
01:01:46 increasing over there on the right side
01:01:49 and that gives us a little bit of extra
01:01:52 space so that if we get to like hundreds
01:01:54 the numbers of the hundreds still will
01:01:56 work properly but you can play around
01:01:59 with that how you see fit
01:02:01 cool we have our score all right what

01:02:05 else should we do we want to do a level
01:02:07 based on the score so how do we define a
01:02:09 function that's called like set level so
01:02:14 I'll do this up here so the fine set
01:02:17 level so that's gonna need to take in
01:02:20 the score and basically we'll change our
01:02:25 speed variable so we have this speed
01:02:27 variable here based on the score so
01:02:29 maybe it's right in our speed is 10
01:02:31 maybe we start out really easily so if
01:02:36 our score is less than 20 maybe our
01:02:38 speed is just me you know three so if
01:02:42 score less than twenty speed equals
01:02:49 three hell if score less than forty
01:02:55 speed equals four and we can keep doing
01:03:00 this
01:03:01 l if score is less than 60 speed equals
01:03:08 five and then L if score I will do else
01:03:19 so once you get over sixty we'll we'll
01:03:21 make it really hard so speed equals
01:03:24 fifteen and so if we remember speed was
01:03:31 being added here so we'll probably have
01:03:34 to let's see what if this works
01:03:52 I don't know it was it I don't I don't
01:03:55 think it was updating at all so speedo
01:03:57 is set to 10th here these values here is
01:03:59 not going to reset the speed it's just
01:04:01 gonna call some variable some new
01:04:03 variable called speed inside of this
01:04:05 function 3 so we'll actually have to do
01:04:07 is pass in our speed variable and then
01:04:11 at the end of this function will return
01:04:14 the speed so our set level function will
01:04:20 happen down here maybe right after we
01:04:23 update our score so where do we update
01:04:25 our score so the score is updated here
01:04:28 so we can set the level right after that
01:04:31 score and then speed and we're gonna
01:04:34 have to say speed equals set level score
01:04:39 speed so now it should go slow
01:04:41 yay we got it we got it oh my god this
01:04:46 is gonna take forever for me to actually
01:04:47 see if it speeds up maybe I'll change
01:04:50 these values around a bit yeah I'll
01:04:56 change these values a bit so you don't
01:04:58 have to wait all day just to see me
01:04:59 playing around with that level
01:05:01 all right speed set level score speed so
01:05:05 instead of the value as I said initially
01:05:08 let's make this 5 let's make this 8
01:05:12 let's make this 12 and see if that
01:05:16 worked so it should never guess we get
01:05:19 faster so we got this this is the first
01:05:21 10 blocks and now after I'd passed the
01:05:26 second 10 blocks we should see a
01:05:27 substantial increase in speed so oh look
01:05:31 at that yep at 20 they started going
01:05:32 faster and we should get another
01:05:34 increase at 40 let's see if it happens
01:05:37 yep I definitely see an increase and our
01:05:40 final increase will be at 60 and yeah
01:05:44 it's definitely moving faster
01:05:52 and in addition in the set level
01:05:55 function you can really play around with
01:05:56 this as you see fit
01:05:58 you could also maybe change the amount
01:06:01 of you could make this like a variable
01:06:04 like enemy number of enemies and as the
01:06:09 level increased you can also make this
01:06:12 value right here and drop enemies
01:06:13 increase so you maybe have 50 blocks
01:06:16 dropping at the same time you can also
01:06:18 make speed proportional to the score so
01:06:21 you could do something like I'll show
01:06:25 you I'll just comment this out real
01:06:26 quick you could do something like speed
01:06:32 equals score divided by 5 so at the
01:06:36 start of the game it would be I guess
01:06:38 you'd have to do like score divided by 5
01:06:42 plus like 1 or something just so it
01:06:44 actually has some motion when the score
01:06:46 is at 0 but like this now if you got to
01:06:50 50 you would be at speed 11 if you got
01:06:52 to 100 you'd be at speed 100 divided by
01:06:55 5 which is 20 so 21 so this would be a
01:07:00 proportional to the score this way and I
01:07:04 guess you'd still have to return speed
01:07:06 so that's just another thing you could
01:07:08 do you make this set level proportional
01:07:11 to speed if we drew this draw this out
01:07:14 and we like I'll leave this as an
01:07:17 exercise if you want to make more
01:07:18 enemies drop or if you can't figure out
01:07:20 how to get more enemies to drop I just
01:07:22 leave me a comment and I'll tell you in
01:07:23 the comments but there's a bunch of
01:07:25 different ways we can play around with
01:07:27 this so I'm gonna just leave my function
01:07:31 how I had it so I'm gonna comment this
01:07:35 comment this out and just reset it to be

01:07:38 this there the last thing I'll do in
01:07:41 this video is just play around with our
01:07:43 background colors a little bit so we got
01:07:47 the game working if we wanted to change
01:07:52 the colors like we can make our
01:07:54 background color like you know some you
01:07:57 know we could to do this we could do
01:07:59 good drawing use a website so there's a
01:08:03 bunch of like
01:08:05 RGB color sight when just look that up
01:08:09 online RGB color wheel so I could take
01:08:13 any value I want it so maybe I wanted a
01:08:15 light blue background so like something
01:08:17 like this so I know it has 11 for our
01:08:21 238 for green and 207 for blue and I'm
01:08:25 on a site called color spy right now so
01:08:27 I'm gonna copy that 11 238 11 238 and
01:08:33 then what was the last color I forget
01:08:36 207 so this will give us a nice light
01:08:39 blue so now if I run this we have a
01:08:43 different color game and this makes the
01:08:45 score a little bit hard to see but you
01:08:47 can see that the screen color did change
01:08:50 and you could do the same thing you
01:08:53 could play around with clutters here so
01:08:55 if I wanted to say I wanted like a
01:08:57 tannish color for a player they're gonna
01:09:00 go into like the oranges and you know
01:09:04 this is kind of a tannish color – 29 –
01:09:07 OH – 137 so I changed this red or I'll
01:09:11 leave it as red just because I don't
01:09:13 want to change the other name so – 29 –
01:09:15 a – 137 – 29 so oh my god it's so hard
01:09:20 for me for this number of all talking –
01:09:22 OH – 137 – OH – and then 137 we'd run
01:09:28 this you know now we have different
01:09:31 colors so play around and have fun with
01:09:33 these colors that's another feature you
01:09:36 can change
01:09:38 alright that's all we're gonna cover in
01:09:39 this video we went from having a blank
01:09:41 screen to having a fully functional
01:09:43 animated game so that's pretty cool if
01:09:46 you enjoyed this video and learn
01:09:48 something if you huge of you throw a big
01:09:50 thumbs up and also it'd mean a lot to me
01:09:52 if you subscribe to my channel I'm
01:09:54 trying to get to a thousand subscribers
01:09:55 as fast as possible thank you guys for
01:09:59 watching and peace out

You may also like