- 00:00:01 hi great to have you aboard of this
- 00:00:03 video do you want to learn – then why
- 00:00:06 don't you learn it by creating something
- 00:00:08 entertaining and funny a game for
- 00:00:10 example this is exactly what we will do
- 00:00:13 in this video we will build a game in
- 00:00:16 Python from scratch no prior Python
- 00:00:19 knowledge is required the game will run
- 00:00:21 in the terminal and in this game we as
- 00:00:24 the player will fight against the
- 00:00:26 monster we will be able to create a
- 00:00:29 player name we can attack the monster we
- 00:00:31 can heal ourselves we can't even display
- 00:00:34 high scores from previous rounds and
- 00:00:36 more cool things so if you want to learn
- 00:00:39 – right now this is your chance to do so
- 00:00:43 [Music]
- 00:00:45 so before we dive into Python let's have
- 00:00:49 a look at the actual game that we want
- 00:00:51 to build the game will actually consist
- 00:00:53 of a player as basically and a monster
- 00:00:56 the player has certain attributes you
- 00:01:00 could say for example the player name
- 00:01:02 the player could have an attack so an
- 00:01:04 attack which allows us to well harm the
- 00:01:07 monster
- 00:01:08 we could have something like a heal
- 00:01:09 feature which allows us to increase our
- 00:01:12 health level and we also need a health
- 00:01:14 indicator and health status bar which
- 00:01:17 shows us if you are still alive or if we
- 00:01:19 are both dead the same thing is true for
- 00:01:21 the monster the monster also could have
- 00:01:24 some attributes like name and the health
- 00:01:27 indicator and also the attack picture
- 00:01:29 let's say that the monster shouldn't be
- 00:01:31 allowed to heal itself though so the
- 00:01:33 monster basically only can attack
- 00:01:35 ourselves now to control this entire
- 00:01:38 game flow we need something like a user
- 00:01:40 interface which allows us to select an
- 00:01:42 action we are always working from the
- 00:01:45 player perspective of course this means
- 00:01:47 an action we can select is basically
- 00:01:49 only attack or heal so let's say we want
- 00:01:52 to attack the monster right here if we
- 00:01:54 do so we will have an impact on to the
- 00:01:56 health of the monster and decrease the
- 00:01:59 monsters well health status after this
- 00:02:02 attack we have to check if the monster
- 00:02:04 is still alive so if the health level is
- 00:02:06 smaller than or equal to zero if this is
- 00:02:10 the case so if we say yes the monster is
- 00:02:12 basically not
- 00:02:14 anymore then we have to make sure that
- 00:02:16 the player wins and that a new round of
- 00:02:19 the game starts or a new game starts in
- 00:02:21 general in case the monster is still
- 00:02:23 alive though
- 00:02:24 well the monster will attack back
- 00:02:25 automatically with that the monster bill
- 00:02:28 of course affect our health negatively
- 00:02:30 then we have to implement the same check
- 00:02:32 we had before we have to check if our
- 00:02:35 health level is below or equal to zero
- 00:02:38 if that's the case well then
- 00:02:40 unfortunately the monster won the game
- 00:02:42 and we have to start a new one if this
- 00:02:44 is not the case so if you are still
- 00:02:46 alive well then we go back to our user
- 00:02:48 interface and we can start the next
- 00:02:50 round
- 00:02:50 by selecting another action in our case
- 00:02:53 this would be attack or heal so that's
- 00:02:55 the game we want to build in a nutshell
- 00:02:57 as I said we will build this all from
- 00:03:00 scratch with Python and for that we need
- 00:03:03 to use and understand some core Python
- 00:03:05 features so what will we learn in here
- 00:03:07 regarding – we will have a look at
- 00:03:11 variables variables allow us to store
- 00:03:14 information in our code and to access it
- 00:03:16 whenever we need it we will also have a
- 00:03:19 look at user input this means we will
- 00:03:21 learn how we can make sure that the user
- 00:03:23 can enter data and that we can react to
- 00:03:26 the input the user made will also have a
- 00:03:29 look at operators operators allow us to
- 00:03:32 subtract or add different items or also
- 00:03:35 to check whether an item is smaller or
- 00:03:38 bigger than another item for example
- 00:03:39 besides that we'll have a look at lists
- 00:03:42 and dictionaries
- 00:03:44 dictionaries are special ways you could
- 00:03:47 say to store information in Python and
- 00:03:50 also one of the key concepts we will
- 00:03:52 cover in this video we'll also have a
- 00:03:54 look at functions in pythons so we will
- 00:03:56 learn how we can create functions what
- 00:03:58 functions are and why we need them to
- 00:04:00 create reusable code definitely one of
- 00:04:03 the core features of every programming
- 00:04:06 language basically we'll also have a
- 00:04:08 look at control structures these are
- 00:04:10 things like if statements for example
- 00:04:11 you might have heard about that
- 00:04:13 this means we execute code if a certain
- 00:04:16 condition is true well or not and
- 00:04:18 finally we'll have a look at f strings
- 00:04:20 so-called formatted string literals
- 00:04:23 these are things which allow us to
- 00:04:25 dynamically inject in
- 00:04:27 from outside into a so-called string
- 00:04:29 this is a bit more advanced right here
- 00:04:32 but we will come to a point in the video
- 00:04:34 where this makes perfect sense to you
- 00:04:36 now with that we can leave this
- 00:04:39 theoretical planning part and jump
- 00:04:40 directly into our code and to get
- 00:04:44 started you need an IDE in my case I
- 00:04:46 will use Visual Studio code and you need
- 00:04:49 – free installed on your machine
- 00:04:52 installation guidelines for both of
- 00:04:54 these can be found in the video
- 00:04:56 description now once you created a new
- 00:04:59 project in your IDE we can create a
- 00:05:02 Python file right here we click on to
- 00:05:05 this button and now we can give this
- 00:05:07 file any name we want in my case I will
- 00:05:09 name it game the important thing is that
- 00:05:11 we add dot py to this file this will
- 00:05:15 turn it into a file – can read them and
- 00:05:19 in this file we can now get started and
- 00:05:21 as I said we need a player and the
- 00:05:24 monster these are the core components of
- 00:05:26 our game you could say and the player
- 00:05:29 and the monster have certain attributes
- 00:05:31 so if we think about the player we could
- 00:05:33 say that our player should have a name
- 00:05:35 and a name could be manual in this case
- 00:05:38 for example my name now if we save that
- 00:05:41 you see that we get an error immediately
- 00:05:43 if we hover over it you can see that we
- 00:05:45 created an undefined variable manual and
- 00:05:49 that's the first important concept we
- 00:05:51 will cover here writing text like this
- 00:05:53 in our code won't work here we have to
- 00:05:56 put this information this specific
- 00:05:58 information into a so-called variable
- 00:06:01 variable simply allow us to store
- 00:06:04 information in our code and to access
- 00:06:06 this information later now to make this
- 00:06:09 a bit more precise right here we could
- 00:06:11 say that actually manual should just be
- 00:06:14 the value or the information that you
- 00:06:16 want to store right here and this
- 00:06:18 information should be stored in a
- 00:06:20 variable which could be named player
- 00:06:23 underscore name for example that's the
- 00:06:26 naming convention in Python for
- 00:06:27 variables we type the name with small
- 00:06:30 letters and if we have a combination of
- 00:06:33 different names like player name in here
- 00:06:35 we connect these different names with an
- 00:06:37 underscore then we add a space and set
- 00:06:40 the variable
- 00:06:41 equal to the information that should be
- 00:06:44 stored in this variable in that case the
- 00:06:46 name manual now if we save it now we can
- 00:06:49 see that the error regarding the
- 00:06:50 variable right here is gone because we
- 00:06:52 basically declared that variable so we
- 00:06:55 assigned a value to this variable manual
- 00:06:58 in this case but if I hover over manual
- 00:07:00 right here you can see that this is
- 00:07:02 still an undefined variable now the
- 00:07:03 problem is that the information in a
- 00:07:06 variable has to have a specific data
- 00:07:09 type data types in Python are numbers so
- 00:07:12 integers in this case as you can see if
- 00:07:14 I save this now we don't have an error
- 00:07:16 these are floats like 1 or 2 for example
- 00:07:19 this is also working
- 00:07:21 we have boolean x' a boolean would be
- 00:07:25 true like that written with a capital
- 00:07:27 letter at the beginning or false
- 00:07:30 written like that or as we have in our
- 00:07:34 case strings strings should be wrapped
- 00:07:37 in quotation marks this can be double
- 00:07:39 quotation marks like this or single
- 00:07:41 rotation marks generally you can use
- 00:07:44 whichever you want the important thing
- 00:07:46 is to be consistent though I will stick
- 00:07:48 to single quotation marks in this
- 00:07:49 project here now we can add the player
- 00:07:53 name right here in the petition marks
- 00:07:55 manual and with that you can see that we
- 00:07:58 now don't get an error and that manual
- 00:08:00 now is a string so summarize that we now
- 00:08:03 declared a variable named player name
- 00:08:06 and this variable contains information
- 00:08:09 in this case the string manual that's
- 00:08:12 basically our first variable now we can
- 00:08:15 of course create additional variables
- 00:08:16 here another one could be player attack
- 00:08:20 for example we talked about that already
- 00:08:22 and this could have an integer now let's
- 00:08:25 say 10 we could also add player he'll
- 00:08:29 for example that we can heal our player
- 00:08:31 which could be a value of 16 we might
- 00:08:34 have to work on these values later and
- 00:08:36 we could add health for example right
- 00:08:38 here as the last variable which could
- 00:08:40 have a value of 100 so with that we
- 00:08:43 basically defined our player right here
- 00:08:45 this doesn't do a lot on if we now
- 00:08:48 execute the code that we wrote in this
- 00:08:51 file we will see that nothing is
- 00:08:53 displayed down here in our terminal
- 00:08:55 this is what I talked about at the
- 00:08:56 beginning of this video that our user
- 00:08:59 interface will be this part right here
- 00:09:01 this terminal by the way if you don't
- 00:09:03 see this terminal you can always make it
- 00:09:05 appear right here if you go to view and
- 00:09:07 then click right here on to terminal
- 00:09:10 this will make it appear down here
- 00:09:12 however if we now execute this file by
- 00:09:15 entering – and now the file name so game
- 00:09:18 dot py like this and it enter you can
- 00:09:23 see that we don't get an error or
- 00:09:24 something like that but that nothing is
- 00:09:26 printed or displayed down here now by
- 00:09:29 saying printed I already gave you a hint
- 00:09:31 what we can do next because in Python we
- 00:09:34 can print or display the output of our
- 00:09:38 code so to say by adding so-called print
- 00:09:41 statements now a print statement is
- 00:09:43 written like that you type print then
- 00:09:46 you open the quotation marks right here
- 00:09:48 and then you enter well basically what
- 00:09:50 you want to print right here this could
- 00:09:52 be a string for example like Hello if I
- 00:09:55 now repeat the command right here like
- 00:09:57 this you can see that we printed hello
- 00:09:59 down there now in our case we don't want
- 00:10:02 to print any random string we might want
- 00:10:05 to print the information that we stored
- 00:10:08 in a variable for example right here in
- 00:10:10 our player name for that we remove the
- 00:10:14 content here and now add player name
- 00:10:16 right here as you can see we already get
- 00:10:18 these suggestions in the IDE right here
- 00:10:20 so this makes it easier to select the
- 00:10:22 variable we want to refer to him in that
- 00:10:24 case I will use player name and hit tab
- 00:10:26 and if we now save that and run the code
- 00:10:29 again you can see that manual down here
- 00:10:32 is printed in our console so these are
- 00:10:36 two important things we learn already we
- 00:10:39 can use variables and we can print the
- 00:10:42 output of our code in the terminal by
- 00:10:45 using such a print statement now the
- 00:10:47 problem is that actually using for
- 00:10:50 variables for our player is not really
- 00:10:53 the most logical approach actually
- 00:10:56 wouldn't it be better to basically have
- 00:10:59 one variable player for example and if
- 00:11:02 we would then have an option to access a
- 00:11:04 specific information of that variable
- 00:11:06 for example the attack right
- 00:11:09 because if I want to do this now I have
- 00:11:11 to change player name to player attack
- 00:11:13 right here and then we run the code and
- 00:11:16 this will return the value for the
- 00:11:17 attack but as you can see that's not
- 00:11:20 really convenient and also not a really
- 00:11:21 nice coding style right here
- 00:11:23 therefore we need an option to basically
- 00:11:26 combine all this information in such a
- 00:11:29 single variable for that let's maybe
- 00:11:31 create another variable and let's call
- 00:11:33 it player this time and now set it equal
- 00:11:35 to well to what and – we have different
- 00:11:39 options to add multiple information to
- 00:11:42 such a variable a very common one is a
- 00:11:45 so called
- 00:11:46 list a list is always written like that
- 00:11:49 so you use the square brackets right
- 00:11:51 here and then you enter content into
- 00:11:54 your list in our case our list could
- 00:11:57 have four different types of content it
- 00:11:59 could have D string Manual which will be
- 00:12:02 the name and the four at the free
- 00:12:04 integers 10 16 and 100 so I could now
- 00:12:08 type manual right here then I could type
- 00:12:11 10 16 100 that would be possible and if
- 00:12:17 I now comment out this code right here
- 00:12:19 this is shift command + 7 right here as
- 00:12:24 a shortcut that I can use and as you can
- 00:12:27 see by that we automatically add the
- 00:12:29 hash tags right here but at the
- 00:12:32 beginning so this means this code is now
- 00:12:34 not used you could say so this code will
- 00:12:36 not be executed basically it's just
- 00:12:38 there as kind of notes for us or we can
- 00:12:40 keep the code right here and maybe reuse
- 00:12:42 it later but it's not used at the moment
- 00:12:44 and here we get an error now because of
- 00:12:47 that because as you can see the variable
- 00:12:48 is no longer defined because we
- 00:12:50 commented it out but if I now change the
- 00:12:54 player attack to player right here
- 00:12:56 save the file always important otherwise
- 00:12:59 it won't work and now run Python game
- 00:13:01 again you can see that the content of
- 00:13:03 our list right here is printed we can
- 00:13:06 also check the type of the content we
- 00:13:09 have right here because I'm referring to
- 00:13:10 this list all the time and if you add
- 00:13:12 type right here in front of the variable
- 00:13:15 that you want to print and now add the
- 00:13:18 the renfa's is right here and if you're
- 00:13:21 now safe to file and run the code again
- 00:13:22 you can see that we created a list right
- 00:13:25 here that's also an important concept
- 00:13:27 you can always check the type of the
- 00:13:29 information you stored right here for
- 00:13:31 example in your variable by using this
- 00:13:33 type method right here however we don't
- 00:13:37 need that here we only need to print it
- 00:13:39 and the problem is also that we don't
- 00:13:41 want you access the entire content as
- 00:13:44 before we might want to access the name
- 00:13:46 only right here we can do this with
- 00:13:49 lists for that we simply add the square
- 00:13:53 brackets again right here and now we can
- 00:13:56 basically select a specific item in our
- 00:14:00 list by using a so called
- 00:14:02 index the index always starts with zero
- 00:14:05 in such a list what does this mean this
- 00:14:08 basically so the first item has an index
- 00:14:11 of zero the second item ten right here
- 00:14:15 has an index of 1 and the third item has
- 00:14:19 an index of two before if item has an
- 00:14:21 index of 3 and so on
- 00:14:22 so this means if I now simply add 0
- 00:14:25 right here so the index of 0 right there
- 00:14:28 and now run our code once again you can
- 00:14:31 see that manual is printed right here in
- 00:14:34 our console if you change it to 2 for
- 00:14:37 example then what is printed well I hope
- 00:14:39 you guessed it it's 16 now because we
- 00:14:42 have the index to sew deferred item in
- 00:14:44 our list right here so with that we now
- 00:14:47 achieved a lot already we are now able
- 00:14:49 to store all the information that is
- 00:14:51 related to our player in such a list and
- 00:14:54 we can access it by simply using this
- 00:14:56 player variable and then using the index
- 00:14:58 to print a specific item in that list
- 00:15:01 now besides accessing it we can also
- 00:15:04 change the value that we have in such a
- 00:15:06 list we can do this by simply typing
- 00:15:08 player then again the square brackets
- 00:15:11 and now again the index that you might
- 00:15:13 want to change let's say we are not
- 00:15:15 happy with our value for the attack
- 00:15:18 right here let's say we want to set it
- 00:15:19 equal to 12 for example for that we
- 00:15:22 access our current list item with the
- 00:15:25 index 1 and now set it equal to 11 maybe
- 00:15:29 like that if I now print there
- 00:15:32 right here so we print the item with two
- 00:15:36 index one again
- 00:15:37 and if we not execute that code you can
- 00:15:39 see that we change the content of this
- 00:15:41 list item to 11 however let's say we are
- 00:15:45 happy with that and we don't want to
- 00:15:46 change the value because there is
- 00:15:49 another problem right here although we
- 00:15:52 stored the information in our list we
- 00:15:54 don't actually see what the actual well
- 00:15:57 value is I mean it's obvious for us that
- 00:15:59 this is a name but how should we know
- 00:16:01 that 10 right here refers to an attack
- 00:16:03 right here this refers to the amount we
- 00:16:06 can heal ourselves and that this is our
- 00:16:09 health bar that's not totally clear
- 00:16:11 right here therefore a list is not the
- 00:16:14 perfect solution in this case so let's
- 00:16:16 also comment out this year because
- 00:16:19 besides lists we also have another
- 00:16:21 really common option to store data right
- 00:16:24 here in Python these are so-called
- 00:16:27 dictionaries a dictionary works like
- 00:16:30 this you type player and now set it
- 00:16:33 equal to content in curly braces between
- 00:16:36 these curly braces you now don't add the
- 00:16:38 items as before so with like manual
- 00:16:41 right here then a comma and then the
- 00:16:43 next item it doesn't work like that
- 00:16:45 because dictionaries always work with
- 00:16:48 so-called key value pairs that what's a
- 00:16:51 key what's a value well in our case we
- 00:16:54 store the name as a value so our key
- 00:16:56 would be the name it's type name right
- 00:16:59 here it's important in the quotation
- 00:17:01 marks it is important but then we don't
- 00:17:04 add a comma or something like that
- 00:17:06 we add a colon right here and then we
- 00:17:08 add the value that belongs to that key
- 00:17:11 in our case this is manual so the name
- 00:17:14 like that then we add a comma and then
- 00:17:18 we add the second key in our case this
- 00:17:20 would be attack like that then we had a
- 00:17:24 colon and then we add the value for our
- 00:17:26 attack this is 10 in our case no
- 00:17:29 quotation marks are required of course
- 00:17:31 because we have an integer here after
- 00:17:34 that we have a heal key this one right
- 00:17:38 here so quotation marks colon and the
- 00:17:42 value and finally we have our health
- 00:17:45 at there : and 100 so this is now a
- 00:17:50 so-called dictionary as you saw
- 00:17:52 dictionaries work different than lists
- 00:17:54 and this also refers to the way we can
- 00:17:57 access our items in the dictionary if we
- 00:18:00 for example run our code once again then
- 00:18:04 you see that we get a key error right
- 00:18:06 here so we basically can't access our
- 00:18:09 dictionary with this index right here
- 00:18:12 this doesn't work the reason for that is
- 00:18:14 that we need to access the values that
- 00:18:17 we stored in our dictionary by the key
- 00:18:19 so in our case we can simply say that if
- 00:18:22 we want to access the player name right
- 00:18:24 here and they finna run the code like
- 00:18:27 this you can see that we print the name
- 00:18:29 manual right here once again we can also
- 00:18:33 access different values of course by
- 00:18:35 simply changing the key this could be
- 00:18:36 something like attack ready for example
- 00:18:38 if we now run the code we can access the
- 00:18:41 value of 10 now such a dictionary is of
- 00:18:44 course a very better approach to access
- 00:18:46 the information we have in the
- 00:18:47 dictionary because throughout the game
- 00:18:49 we will have to access our attack we
- 00:18:51 will then have to access the impact that
- 00:18:53 the attack has on the health of the
- 00:18:54 monster and so on so with this
- 00:18:57 dictionary we actually got a nice way of
- 00:18:59 storing our player and monster related
- 00:19:02 information now because of that we can
- 00:19:05 delete all that out commented code right
- 00:19:07 here like that and now we can also add
- 00:19:11 our monster right here it follows the
- 00:19:14 same logic actually so basically our
- 00:19:16 monster is equal to a dictionary and the
- 00:19:19 monster will also have a name key like
- 00:19:23 that and let's give it a name of maybe
- 00:19:25 max for example
- 00:19:27 then we have an attack also for the
- 00:19:30 monster which could have a value of
- 00:19:32 maybe let's say it's a bit stronger 12
- 00:19:35 we might have to adjust these values
- 00:19:37 later so let's use these as dummy values
- 00:19:39 for the moment then we have well we
- 00:19:42 don't have a heal option because it's a
- 00:19:44 the monster can only attack the player
- 00:19:46 and can't heal itself and this means we
- 00:19:49 only need the health right here at the
- 00:19:51 end with a value starting value of 100
- 00:19:54 also now we got the information we need
- 00:19:57 for the monster and the player but so
- 00:19:59 far the user doesn't see anything right
- 00:20:01 here on the screen you can see the
- 00:20:03 different values depending on the key we
- 00:20:05 access but actually that's not
- 00:20:07 information that we want to display when
- 00:20:09 the game started what we actually would
- 00:20:11 like to have is some kind of user
- 00:20:13 interface which guides the user to
- 00:20:15 select a specific option in the case of
- 00:20:18 the player this can only be attack or
- 00:20:20 heal these are the two options we have
- 00:20:22 but we can use the print statements we
- 00:20:24 learn already – well create such a user
- 00:20:27 interface let's say we first want to
- 00:20:29 print something like please select
- 00:20:31 action we learned that we can refer to
- 00:20:34 variables and to print the information
- 00:20:36 stored in the variables already but of
- 00:20:39 course if we add a single quotation mark
- 00:20:40 as I showed you some minutes ago and add
- 00:20:42 a string right here then we can also
- 00:20:44 print this information so as I said we
- 00:20:46 can say please select action like that
- 00:20:50 and then we can add two more print
- 00:20:53 statements with the first one saying
- 00:20:58 something like attack right and the
- 00:21:02 second option would be to heal player or
- 00:21:08 just heal maybe like that if we save
- 00:21:11 that and run our code once again
- 00:21:12 then you can see that these statements
- 00:21:14 are printed right here in our terminal
- 00:21:17 and this should now be the starting
- 00:21:19 screen the player sees when he starts
- 00:21:21 the game the problem now is that well we
- 00:21:23 basically can't interact with that as
- 00:21:25 you can see we don't have any options to
- 00:21:27 we'll add information right here or
- 00:21:28 something like that so we basically only
- 00:21:30 have these print statements therefore we
- 00:21:33 need to allow our player to add some
- 00:21:35 input to our game right here and this
- 00:21:38 brings us to another default method pipe
- 00:21:41 with the input method the input method
- 00:21:44 is simply well written like that input
- 00:21:46 and now by adding the parentheses right
- 00:21:48 here and that's it already with that if
- 00:21:51 we save that now run the code again you
- 00:21:55 can see down here that we now have the
- 00:21:57 option to enter some well information
- 00:21:59 material to add some input this could be
- 00:22:01 1 2 3 whatever in our case we should
- 00:22:04 only be able to select 1 or 2 also
- 00:22:06 something we'll work on later but if I
- 00:22:08 now add 1 right here at the input and
- 00:22:10 then we exit the game already
- 00:22:12 now this exiting problem is something we
- 00:22:14 will also have a look at in a few
- 00:22:15 minutes for the moment let's make sure
- 00:22:17 that something happens after the player
- 00:22:20 selected a specific input for that we
- 00:22:24 need a so called control structure in
- 00:22:26 Python control structures are for loops
- 00:22:30 while loops or that's one we need right
- 00:22:33 here if statements an if statement
- 00:22:35 simply allows you to execute a specific
- 00:22:38 code that you define of course if a
- 00:22:41 certain condition or multiple conditions
- 00:22:43 are true now let's create such an if
- 00:22:45 statement to see how this works in our
- 00:22:46 case to create an if statement you
- 00:22:49 simply type if and now you add the
- 00:22:52 condition that should be true to make
- 00:22:54 sure that the code you then define is
- 00:22:56 running in our case the input right here
- 00:22:59 so basically the information we returned
- 00:23:02 right here should be equal to 1 right so
- 00:23:04 if the player entered run in this should
- 00:23:07 then lead to an attack against them
- 00:23:09 against the monster we are gonna need to
- 00:23:11 declare a variable right here and this
- 00:23:14 variable now could be player choice for
- 00:23:17 example
- 00:23:19 like that with that we can now refer to
- 00:23:22 our player choice right here and if this
- 00:23:26 player choice is equal now important not
- 00:23:29 with a single equal sign because this
- 00:23:31 will basically set the variable equal to
- 00:23:34 well something in our case we don't want
- 00:23:37 to change the information stored in the
- 00:23:39 variable we only want to check if the
- 00:23:42 information stored in the variable is
- 00:23:43 equal to something this means we have to
- 00:23:46 add a second equal sign and now say if
- 00:23:48 our player choice is equal to one then
- 00:23:52 we have to add a colon and then if you
- 00:23:54 would enter you can see that we get this
- 00:23:56 automatic indentation right here this is
- 00:23:58 important in Python we basically use
- 00:24:02 indentation to specify where our code
- 00:24:06 belongs to in our case this means that
- 00:24:08 this code right here which for example
- 00:24:10 could be a print statement saying attack
- 00:24:13 right here only gets executed if this
- 00:24:18 condition is true so if this is true
- 00:24:20 execute the code this indented code
- 00:24:22 right here if we run our code now you
- 00:24:25 can see if we get one attack well we
- 00:24:29 don't get the print statement right here
- 00:24:31 right so this doesn't work here we only
- 00:24:34 get one this was our input but nothing
- 00:24:36 is displayed and actually our player
- 00:24:38 choice was equal to one but this is not
- 00:24:40 working the problem here is that input
- 00:24:44 right here always returns a string and
- 00:24:47 this means we compare player choice
- 00:24:50 right here to an integer now player
- 00:24:53 choice is not equal to this integer to
- 00:24:56 you to one therefore this code right
- 00:24:58 here is not executed again you can also
- 00:25:01 check this by adding type um player
- 00:25:05 choice like that and if you now say that
- 00:25:08 you print this statement first right
- 00:25:11 here then you can see if you had one
- 00:25:13 that will return a string right here
- 00:25:15 that's what I was referring to
- 00:25:17 therefore this check doesn't work at the
- 00:25:19 moment now let's get rid of that code
- 00:25:22 and let's now simply turn this one right
- 00:25:25 here into a string by adding single
- 00:25:27 quotation marks like that if we do this
- 00:25:30 and vulnera once again
- 00:25:32 add it attack then you can see that
- 00:25:35 attack is printed right here and with
- 00:25:38 that we now wrote our first successful
- 00:25:40 if statement right here now with the new
- 00:25:43 knowledge we can of course also add the
- 00:25:45 second condition we have right here if
- 00:25:46 the player selects you we want to heal
- 00:25:49 our player for that we simply enter
- 00:25:52 additional code but now important not
- 00:25:55 indented because as I said the indented
- 00:25:58 code will run if this condition right
- 00:26:00 here this one is true therefore we have
- 00:26:03 to start right here and now add a
- 00:26:06 so-called Elif statement Elif simply
- 00:26:10 stands for else if so basically if this
- 00:26:13 condition is true do this else so Elif
- 00:26:18 another condition is true then well
- 00:26:21 execute another code now this other
- 00:26:23 condition right here is pretty
- 00:26:24 straightforward for us of course we
- 00:26:26 simply have to check if our player
- 00:26:28 choice is equal important single
- 00:26:30 quotation mark to and if this is true
- 00:26:33 then we want to print let's say he'll
- 00:26:35 player like that and we could also say
- 00:26:39 that if our user enters any different
- 00:26:42 input so not one or two then something
- 00:26:45 like invalid input should be printed to
- 00:26:47 our console to our terminal down here so
- 00:26:50 with that again not indented we add else
- 00:26:53 right here this time else is different
- 00:26:56 from Elif as else doesn't require any
- 00:26:59 additional condition it simply says well
- 00:27:01 if this is not true and well if that is
- 00:27:04 not true well then in all other cases
- 00:27:06 simply execute a different code in our
- 00:27:09 case this could be as I said print
- 00:27:11 invalid oops
- 00:27:13 invalid input right here like that let's
- 00:27:18 now run this code so again so if we
- 00:27:20 enter one we can see that we print
- 00:27:23 attack if you run the code again and two
- 00:27:26 we run he'll player and if we enter
- 00:27:29 anything else like five for example we
- 00:27:31 get the output invalid input here now
- 00:27:35 with that we got our first logic in here
- 00:27:37 let's now focus on to our first
- 00:27:40 condition right here so if the player
- 00:27:41 shows is equal to one because these
- 00:27:43 print statements are nice but actually
- 00:27:46 that's not
- 00:27:47 what should happen here because if the
- 00:27:49 player choice was one then we want to
- 00:27:51 attack the monster this means we want to
- 00:27:54 access the attack key right here in our
- 00:27:56 player with the value 10 and after that
- 00:27:59 we want to access our health key right
- 00:28:02 here in our monster variable and
- 00:28:05 decrease the monster health by this 10
- 00:28:08 right here or whatever value we use for
- 00:28:11 our attack right here now how can we do
- 00:28:13 this well let's maybe space here and
- 00:28:17 let's now delete that print statement
- 00:28:20 because we learned everything we need to
- 00:28:22 achieve this the first thing we need to
- 00:28:24 do is we need to access our monster
- 00:28:27 health because that should change in the
- 00:28:28 end for that we can again refer to this
- 00:28:31 monster variable right here and now add
- 00:28:34 the square brackets right here and
- 00:28:37 access our health key we learned that
- 00:28:40 already so we simply type health right
- 00:28:42 here this health should now be equal to
- 00:28:45 something else this means we don't want
- 00:28:48 to compare it to anything we want to set
- 00:28:50 it equal to something so we want to
- 00:28:51 change the information stored in that
- 00:28:54 health key for that we use a single
- 00:28:56 equal sign and now say that again the
- 00:28:59 monster health right here so important
- 00:29:03 I'm not referring to the initial status
- 00:29:06 of the monster health so this 100 right
- 00:29:09 here so this initial value for the
- 00:29:12 monster health should decrease by well
- 00:29:15 by what well minus the player right our
- 00:29:19 player variable again the square
- 00:29:21 brackets and now attack so basically by
- 00:29:25 the value that is stored in our attack
- 00:29:28 key now after that let's say we want to
- 00:29:31 print our monster health once again to
- 00:29:35 see if this operation was successful for
- 00:29:39 that we run the game once again we now
- 00:29:41 attack the monster and as you can see
- 00:29:44 apparently it worked because now the
- 00:29:46 monster health decreased to 90 so this
- 00:29:50 is pretty cool but actually the monster
- 00:29:52 is not the only party which can be
- 00:29:54 attacked right here the player can also
- 00:29:56 be attacked now we can use the same
- 00:29:59 logic actually we have right here
- 00:30:00 let's maybe add the space down here and
- 00:30:03 let's now say that after the monster was
- 00:30:05 attacked by the player well the monster
- 00:30:06 will fight back so also the player
- 00:30:08 health will decrease now for that we can
- 00:30:11 use the exact same logic we can simply
- 00:30:14 say that our player health right here is
- 00:30:17 equal to our player health so the
- 00:30:20 initial value we have for the player
- 00:30:22 health
- 00:30:23 – our well monster attack right here
- 00:30:28 like that and let's know maybe also add
- 00:30:32 the player health to our terminal down
- 00:30:36 there to see if it was successful and
- 00:30:40 let's then check what happens so if we
- 00:30:42 run the game once again the player
- 00:30:45 attacks the monster and the monster
- 00:30:47 fights back this means after this round
- 00:30:51 the monster health is at 90 which makes
- 00:30:54 sense we had an attack of 10 against
- 00:30:56 this health of 100 and the player health
- 00:30:59 is at 88 because the monster attack of
- 00:31:01 12 well had an impact to our initial
- 00:31:03 health level of 100 so if you run the
- 00:31:06 game once again and attack again well we
- 00:31:10 can see that we got the same value and
- 00:31:12 the reason for that is that we always
- 00:31:14 exit our game after the first attack was
- 00:31:18 done or the first two attacks one for
- 00:31:20 the player one but a monster we're done
- 00:31:21 because what – at the moment does is it
- 00:31:24 basically scans our code from top to
- 00:31:26 bottom
- 00:31:27 Sisu k we have a player variable we have
- 00:31:29 a month's variable we print this code
- 00:31:31 right here then we have an input and
- 00:31:34 then we have this if statement right
- 00:31:37 here so if we select one Python symbol
- 00:31:40 you see is okay we selected one so I
- 00:31:42 will run this code I will print monster
- 00:31:44 and player and then I will stop
- 00:31:47 executing the code because we are done
- 00:31:49 there is nothing to tell – please repeat
- 00:31:52 the code or anything like that now this
- 00:31:54 brings us to the next control structure
- 00:31:57 we need right here we need a way to tell
- 00:32:00 python that it shouldn't exit the game
- 00:32:03 after first attack was done but it
- 00:32:05 should continue the game until a certain
- 00:32:07 exit condition that we define and exit
- 00:32:10 condition if you remember back the slide
- 00:32:11 would be something like the health of
- 00:32:14 either the monster or the player is
- 00:32:16 equal to or smaller than zero this is
- 00:32:19 something we'll implement in a few
- 00:32:20 minutes let's focus on to this logic to
- 00:32:22 stay in the game or to keep executing
- 00:32:25 the code until we tell – that we are
- 00:32:27 done and that we want to exit the game
- 00:32:29 now we learned about the if statement
- 00:32:31 already which allows us to create this
- 00:32:33 structure right here another control
- 00:32:35 structure is a so called Y loop a code
- 00:32:38 running inside of such a while loop is
- 00:32:41 executed as long as a condition that we
- 00:32:44 define is true now this sounds kind of
- 00:32:47 abstract so let's create this Y loop now
- 00:32:50 and then see why this is exactly what we
- 00:32:53 might need right here for that we will
- 00:32:55 add the new code up here because when we
- 00:32:58 initialize our game this information is
- 00:33:00 important for – it has to know the
- 00:33:03 initial values for all variables but
- 00:33:05 once this initialization was done we
- 00:33:07 only want to execute code that is
- 00:33:10 running inside of our while loop as long
- 00:33:12 as this while loop is true our game is
- 00:33:13 running if we exit the while loop well
- 00:33:15 the game is no longer running so we
- 00:33:18 create a while loop by simply typing
- 00:33:20 while right here and now we have to
- 00:33:22 define a condition and in our case the
- 00:33:26 condition could actually be something
- 00:33:27 like well while our game is running well
- 00:33:31 execute that code as soon as our game is
- 00:33:34 no longer running well then don't
- 00:33:36 execute this code again this means we
- 00:33:39 can actually declare another variable up
- 00:33:42 here before we create a while loop and
- 00:33:45 this could be something like game
- 00:33:47 running equals well true now what is
- 00:33:51 true now true is a so-called boolean
- 00:33:54 boolean x' can be either true or false
- 00:33:57 I showed you that in the beginning
- 00:33:58 already these allow us to easily control
- 00:34:01 while loops for example because if we
- 00:34:04 say that the initial value for game
- 00:34:06 running is true well we can simply add
- 00:34:09 this logic right here to say game
- 00:34:10 running equals true so basically as long
- 00:34:14 as you don't change the value right here
- 00:34:15 so it's true here well please keep it
- 00:34:17 running but if we want to exit this loop
- 00:34:20 now we only have to change game running
- 00:34:22 from true to false and with that this
- 00:34:25 condition is no longer met and we exit
- 00:34:27 our while loop
- 00:34:28 immediately important though to be able
- 00:34:31 to tell Pyfrom that our code should only
- 00:34:33 be executed inside our while loop or
- 00:34:36 that the code belongs to this while loop
- 00:34:37 basically we have to indent the code
- 00:34:40 this means we can select everything
- 00:34:42 right here so all the code we wrote so
- 00:34:44 far and now it tap to basically indent
- 00:34:46 it now if you now save this we shouldn't
- 00:34:49 get an error and as you can see if we
- 00:34:52 now run the code – game attack attack we
- 00:34:56 stay inside our loop and important the
- 00:34:59 health values also decrease as you can
- 00:35:02 see the monster has help of 18 and the
- 00:35:03 player of 76 which makes sense after two
- 00:35:06 rounds because the monster received two
- 00:35:09 attacks 10 each from player and the
- 00:35:12 player received two attacks from the
- 00:35:14 monster with 12 each so 99 – sorry 80
- 00:35:20 versus 76 and if you continue attacking
- 00:35:22 this decreases more and more we can also
- 00:35:25 get to health levels below zero as I
- 00:35:28 said this is something we'll address
- 00:35:30 soon the problem is that we don't exit
- 00:35:33 our loop till now for that as I said we
- 00:35:35 only need to refine a case where this
- 00:35:37 true changes to false for that we could
- 00:35:40 add another if statement so after these
- 00:35:43 statements right here if our player
- 00:35:49 health right here is smaller than or
- 00:35:55 equal to zero well then we simply say
- 00:35:58 that game running should be set to false
- 00:36:02 like that if we now exit our game we can
- 00:36:08 do this by hitting ctrl + Z right here
- 00:36:10 no here this may be and now run the code
- 00:36:12 once again we can attack attack again
- 00:36:15 again again again again again
- 00:36:18 oops sorry invalid input so again again
- 00:36:22 and let's see yep now we can see that we
- 00:36:26 reached a health level of -8 for our
- 00:36:29 player and because of that we exited our
- 00:36:32 game why did this happen just repeat
- 00:36:34 that we said that the game running
- 00:36:37 variable is set to false as soon as our
- 00:36:40 player is that basically
- 00:36:42 this is the sign for our while loop to
- 00:36:44 stop being executed and with that we're
- 00:36:47 basically outside of our loop well and
- 00:36:50 with that we basically are outside of
- 00:36:52 our code because there is no more code
- 00:36:54 to run at the moment for Python now by
- 00:36:58 the way we used this double equal sign
- 00:37:01 right here right these two we also used
- 00:37:03 this right here this smaller than or
- 00:37:05 equal sign these are so-called
- 00:37:07 comparison operators in Python we saw
- 00:37:10 two of these already we also have more
- 00:37:13 we also have something like smaller than
- 00:37:15 larger than larger than or equal to and
- 00:37:18 we also got this this one right here
- 00:37:21 which basically means not equal to so
- 00:37:25 these are operators we can use to
- 00:37:27 basically check if a specific value is
- 00:37:31 equal to another value so as you can see
- 00:37:34 right here these are really helpful
- 00:37:35 besides these comparison operators let
- 00:37:39 me change the back to smaller than and
- 00:37:40 equal to we also have another really
- 00:37:43 helpful operator type in – these so
- 00:37:47 called logical operators and these can
- 00:37:49 be helpful right now because at the
- 00:37:51 moment we only check if our player
- 00:37:53 health is smaller than or equal to zero
- 00:37:55 but actually if our months is that we
- 00:37:57 also want to stop executing our code and
- 00:38:00 geological operators are simply and so
- 00:38:04 this means it would check if the player
- 00:38:06 is that and if our monster health right
- 00:38:12 here it's also smaller than or equal to
- 00:38:16 zero but that's basically not what you
- 00:38:18 want right here because you basically
- 00:38:19 want to exit the game if either of the
- 00:38:22 two is dead and not a faux fur that we
- 00:38:24 could also use not right here which
- 00:38:27 would simply check if the player health
- 00:38:30 if the player is dead and if the monster
- 00:38:32 is not that so if the monster is still
- 00:38:34 alive also not 51 right here
- 00:38:36 and we can also use or another logical
- 00:38:40 operator which simply says check if
- 00:38:43 either this condition right here this
- 00:38:45 one or that condition is true and if
- 00:38:48 that's the case please execute the code
- 00:38:50 right here now if we quickly change our
- 00:38:53 player attack right here to allow
- 00:38:55 above the one from the monster 213 for
- 00:38:58 example and run the code once again you
- 00:39:01 can see that D monster health the first
- 00:39:04 one right here it's at 87 and so on this
- 00:39:06 and like this and like that and now as
- 00:39:09 you can see our monster is dead appear
- 00:39:12 and we stop our code execution so the
- 00:39:15 logical operator right here also pretty
- 00:39:17 helpful if you have situations like that
- 00:39:19 or you want to run a code depending on
- 00:39:22 whether one of multiple conditions is
- 00:39:25 met however our current code has a
- 00:39:29 logical issue because we do check if the
- 00:39:32 player or the monster is that down here
- 00:39:34 but wouldn't it make more sense to
- 00:39:37 actually check this after each attack
- 00:39:39 because let's assume that our monster
- 00:39:42 health decreased below zero after the
- 00:39:44 first attack our player made this can
- 00:39:46 happen right here right so it is
- 00:39:47 possible that this code runs then the
- 00:39:49 monster has a health level below zero
- 00:39:51 but what will happen then is that the
- 00:39:53 player can still be attacked by the
- 00:39:55 monster we don't have any logic to check
- 00:39:57 if the monster is able to make his
- 00:40:01 attack because well it's only checked
- 00:40:03 after this if condition was one so after
- 00:40:06 we entered the command we make our two
- 00:40:08 attacks one by the player one more
- 00:40:10 monster and then we check if the game
- 00:40:12 can continue running and this doesn't
- 00:40:15 make a lot of sense actually so adding
- 00:40:17 the check actually well right here after
- 00:40:20 the monster attack and right there after
- 00:40:23 the player attack is what we should do
- 00:40:24 next
- 00:40:25 for that we can use our new knowledge
- 00:40:27 that we gained regarding boolean's right
- 00:40:29 here because why don't we use something
- 00:40:32 like a player one boolean and a monster
- 00:40:35 one boolean and then we add an if
- 00:40:37 condition right here to check if the
- 00:40:39 monster is still alive so basically we
- 00:40:41 do something like if monster health
- 00:40:48 right here is smaller than or equal to
- 00:40:51 zero then we have to do something we
- 00:40:53 basically have to end the game we'll
- 00:40:55 implement that code soon but for a
- 00:40:57 moment let's simply create this
- 00:40:58 placeholder and to do this we can use
- 00:41:00 pass right here
- 00:41:02 so what pass simply does is it basically
- 00:41:05 shows Python okay
- 00:41:07 there is some code required right here
- 00:41:09 at the stage I did not create that code
- 00:41:11 at the moment so Python simply sees okay
- 00:41:13 we need some code right here but it
- 00:41:15 doesn't throw an error it basically
- 00:41:17 understands that we have a placeholder
- 00:41:18 right here you could say and therefore
- 00:41:20 it keeps executing the following code
- 00:41:22 without an error because if you would
- 00:41:24 not add this right here you would get an
- 00:41:26 error and if that is not true so if the
- 00:41:32 monster is alive well then the monster
- 00:41:34 can attack back so we can add else right
- 00:41:36 here
- 00:41:36 no Elif statement required because we
- 00:41:39 basically need to say only okay the
- 00:41:41 monster is alive so let's attack the
- 00:41:42 player so else we say the player health
- 00:41:45 should decrease and afterwards we of
- 00:41:49 course also have to check if the player
- 00:41:53 health right here is smaller than or
- 00:41:58 equal to zero like that and we can also
- 00:42:01 add pass for the moment because we will
- 00:42:03 add the code in a few seconds these
- 00:42:06 print statements can stay here for the
- 00:42:08 moment we'll also put them to a
- 00:42:10 different position later now these are
- 00:42:13 the if checks I talked about but I also
- 00:42:15 mentioned something like player 1 or
- 00:42:17 monster 1 these follow the same logic we
- 00:42:22 have appear for game running the only
- 00:42:24 difference is of course that we will
- 00:42:26 basically declare that variable inside
- 00:42:29 our game because we don't need to add
- 00:42:31 these right here because the information
- 00:42:33 if the player 1 or not is not required
- 00:42:35 outside our actual game logic right here
- 00:42:38 but it's part of the actual game so
- 00:42:40 let's say as long as the game is running
- 00:42:42 the initial value for player 1 should be
- 00:42:46 equal to false because when the game
- 00:42:48 starts or as long as the game is running
- 00:42:49 nobody won
- 00:42:51 and the same thing is true for our
- 00:42:52 monster 1 variable right here this
- 00:42:55 should also be set to false like that
- 00:42:57 now with these two variables defined we
- 00:43:01 can
- 00:43:01 our quadrant here and say that if our
- 00:43:04 monster is dead
- 00:43:05 well then player one right here should
- 00:43:09 be set to true because well the monster
- 00:43:13 died player one and the same logic also
- 00:43:16 applies right here if the player is dead
- 00:43:18 if the player is that then our monster
- 00:43:21 one should be set to true also right
- 00:43:24 because then we can use this logic right
- 00:43:28 here and go down to this if check and
- 00:43:32 basically change this logic to simply
- 00:43:35 player
- 00:43:38 one equals true or monster one equals
- 00:43:46 true right like that well then the game
- 00:43:49 ends so let's see if this works still
- 00:43:53 let's run the code that's tak it's
- 00:43:56 attack let's attack or attack like that
- 00:44:01 and now if we hit one once again we can
- 00:44:05 see that the game was accident because
- 00:44:07 our player won the game as you can see
- 00:44:09 right here the monster only has a health
- 00:44:11 of minus 4 so it's basically that so
- 00:44:14 with that we refactored our code we now
- 00:44:17 have these checks at the right position
- 00:44:18 another thing that I don't like though
- 00:44:20 is that we basically exit the game as
- 00:44:23 soon as the player or the monster won
- 00:44:25 basically it's correct that's what we
- 00:44:27 wanted to implement so I wanted to kind
- 00:44:30 of escape this while loop right here
- 00:44:32 because we say that the game stops as
- 00:44:34 soon as somebody won but actually it
- 00:44:36 shouldn't be the entire game that stops
- 00:44:38 after somebody won it should actually be
- 00:44:41 only the current round that is stopped
- 00:44:43 because what we actually need is we need
- 00:44:45 to make sure that as soon as the player
- 00:44:47 or the monster won the default values
- 00:44:50 for the health so 100 for the monster
- 00:44:52 and the player are set again and with
- 00:44:55 that we should be able to start the next
- 00:44:56 round immediately and not exiting the
- 00:44:58 entire game and then having to enter
- 00:45:00 pipe from game py again to start the
- 00:45:02 game that's not what we want but we can
- 00:45:05 implement that easily now with our
- 00:45:07 knowledge that we gained so far because
- 00:45:09 why don't we just add a second while
- 00:45:12 loop which is something like new round
- 00:45:15 so as long as new round is true we keep
- 00:45:18 running our current game as soon as new
- 00:45:22 round is false so as soon as the monster
- 00:45:25 or the player won we exit the current
- 00:45:27 round and start a new game now let's
- 00:45:30 have a look at how we could implement
- 00:45:32 that because we could say right here
- 00:45:36 after our first while loop we add this
- 00:45:38 while loop so let's say while new round
- 00:45:41 is equal to true right this should
- 00:45:45 happen so let's maybe indent our code
- 00:45:48 right here once again like that and we
- 00:45:51 can define the new round right here
- 00:45:53 inside our first while loop so new round
- 00:45:56 should be equal to true at the beginning
- 00:45:59 now with that we can say that as long as
- 00:46:02 scheme running is set to true which we
- 00:46:04 defined right here new round is also set
- 00:46:07 true and as long as new round is set to
- 00:46:09 true this code should be executed this
- 00:46:13 means if we simply change down here our
- 00:46:15 game running right to new round right
- 00:46:20 here we should be able to exit our round
- 00:46:24 as soon as the monster or the player won
- 00:46:26 and then we will go back to our game and
- 00:46:29 this means the logic that we exit the
- 00:46:31 entire game as soon as somebody one
- 00:46:33 should now be fixed now let's see if you
- 00:46:35 run Python game and click attack
- 00:46:38 multiple times
- 00:46:41 hmmm this is not working the code keeps
- 00:46:46 getting executed and we don't have any
- 00:46:48 kind of hint that we actually exit this
- 00:46:50 second loop right here the problem here
- 00:46:53 is this part right here our variables
- 00:46:56 because we never leave this first while
- 00:46:59 loop we basically set game running to
- 00:47:02 true then as long as this is true we say
- 00:47:05 that neuron to be true then we say as
- 00:47:07 long as this is the case please execute
- 00:47:09 this code then we set new round to false
- 00:47:12 and what happens then is we go back to
- 00:47:14 this first right loop this is nice but
- 00:47:17 what is missing here is the resetting of
- 00:47:19 the values so we basically continue
- 00:47:22 using the values the changed values
- 00:47:24 already and that's why the health level
- 00:47:27 right here keeps decreasing as you can
- 00:47:29 see up here besides that we also have to
- 00:47:33 issue that only the monster health keeps
- 00:47:37 decreasing
- 00:47:38 that's simply due to the fact that we
- 00:47:40 never get to execute this code right
- 00:47:42 here because what's basically happening
- 00:47:43 is at the moment that we have the
- 00:47:46 situation that the monster health is
- 00:47:48 smaller than or equal to zero well and
- 00:47:50 this means the code rodriram is no
- 00:47:53 longer executed so we've each round we
- 00:47:54 start again our while loop then we come
- 00:47:56 right here to if monster health is
- 00:47:58 smaller than or equal to zero well this
- 00:48:00 is the case
- 00:48:01 therefore we go down here to if player
- 00:48:03 one is true or monster one is true in
- 00:48:05 our case the player has won something
- 00:48:07 you run this false and so on so we
- 00:48:09 basically skip this second else block
- 00:48:12 right here this will be automatically
- 00:48:14 fixed if we implement the logic
- 00:48:16 correctly now now as I said the problem
- 00:48:19 is that we don't reset the values and to
- 00:48:21 easily fix that we can simply take this
- 00:48:23 code right here and put it into our
- 00:48:27 first while loop right here with the
- 00:48:29 correct indentation of course with that
- 00:48:32 we make sure that as soon as we leave
- 00:48:34 our while loop right here we go back to
- 00:48:37 the game running and initialize our
- 00:48:39 variables with these default values now
- 00:48:42 let's see if this works now if we now
- 00:48:45 run the code hit attack multiple times
- 00:48:48 to see that the monster should be dead
- 00:48:51 now now it is not it's attack
- 00:48:54 and as you can see now the monster is
- 00:48:57 back at 87 after first round
- 00:49:00 this means the player made one attack if
- 00:49:02 I continue doing this you can see now
- 00:49:04 the monster is dead – for now we have
- 00:49:08 another round and the values are reset
- 00:49:10 it like that and the monster again has
- 00:49:12 only a health of 87 so with the new
- 00:49:16 structure we basically control the
- 00:49:19 entire game logic only with these two
- 00:49:22 while loops so this one right here and
- 00:49:23 this one right there the only problem we
- 00:49:26 have now is that we are not able to exit
- 00:49:28 the game but this should be an easy fix
- 00:49:30 now right because we can simply add a
- 00:49:32 third print statement right here
- 00:49:35 so print free exit game like that and
- 00:49:41 now we can simply add another Elif
- 00:49:44 statement right here so Elif player
- 00:49:48 choice is equal to 3 then we say oops
- 00:49:53 not like that at the rotation mark right
- 00:49:56 here then we can say that well what
- 00:50:00 should happen well game running right
- 00:50:03 here should be set to false with that we
- 00:50:06 will also exit this value so let's say
- 00:50:09 game running should be equal to false
- 00:50:11 right here now let's check that let's
- 00:50:13 leave the game clear it and run the code
- 00:50:17 so attack it's working and if I hit free
- 00:50:19 now and exit the game hmm this is not
- 00:50:22 working do you know why
- 00:50:25 well of course we are setting game
- 00:50:27 running two folds but we are still right
- 00:50:29 here in our new round loop so we of
- 00:50:32 course also have to change our new round
- 00:50:36 to false with that if we run our code
- 00:50:40 once again oops
- 00:50:42 like that like that attack works exit
- 00:50:47 game works now we are out of our game is
- 00:50:50 it again we can start it and exit it so
- 00:50:53 this is also working fine now we are
- 00:50:56 making a good progress with the game in
- 00:50:58 general I would say I would like to work
- 00:51:01 on two things now though the first thing
- 00:51:03 is I would like to add another input
- 00:51:05 field because at the
- 00:51:08 moment we have a fixed value for the
- 00:51:10 name key for player and I think it would
- 00:51:13 be nicer if we can add our name
- 00:51:15 individually right here we could also
- 00:51:17 change this for the monster but I think
- 00:51:19 the fixed monster name is fine right
- 00:51:21 here as a second step I would like to
- 00:51:23 make our game a bit more beautiful
- 00:51:25 so maybe add some a print statements and
- 00:51:27 yeah maybe make it better display the
- 00:51:29 health information more often things
- 00:51:32 like that but let's start with that
- 00:51:34 additional input right here because when
- 00:51:37 we start the game I would like to be
- 00:51:39 able to enter the player name now to do
- 00:51:43 that we can simply arm add another print
- 00:51:47 method right here print function and
- 00:51:49 this could be something like enter
- 00:51:51 player name right here now with that we
- 00:51:53 print that but of course we also want to
- 00:51:55 be able to change the player name
- 00:51:58 according to our input now for that we
- 00:52:01 need to access the name key once again
- 00:52:04 and change the value so why don't we
- 00:52:05 just set player name right here equal to
- 00:52:11 not sure what and input once again
- 00:52:14 because the player should be able to
- 00:52:15 enter the name on his own right here
- 00:52:17 with that if we start our game once
- 00:52:20 again we can see that we can enter the
- 00:52:23 player name let's say menu right here
- 00:52:24 and then the game starts and as we can
- 00:52:27 see it arounds continue like that and as
- 00:52:30 soon as the game ends yeah we can enter
- 00:52:32 the player name once again so this is
- 00:52:35 working fine I would like to have some
- 00:52:37 more visual improvements now as I said a
- 00:52:40 few seconds ago the first thing we could
- 00:52:42 do right here is we could add an
- 00:52:44 additional print statement on top of our
- 00:52:46 enter player name and this print
- 00:52:48 statement should should just be some
- 00:52:50 dotted line you could say which
- 00:52:52 separates the content a bit makes it
- 00:52:54 easier to read in the end for that we
- 00:52:57 can simply print and now we enter two
- 00:53:00 quotation marks and now we simply add
- 00:53:02 three lines like that so free – is
- 00:53:05 basically now we can use another
- 00:53:08 arithmetic operator right here this one
- 00:53:10 right here to start to multiply these by
- 00:53:13 a number of our choice let's maybe say 7
- 00:53:16 or something like that this simply means
- 00:53:18 we want to print 21 of these dashes
- 00:53:22 um before the enter player name text is
- 00:53:26 printed so let's look at that if we exit
- 00:53:28 the game like this you can see this is
- 00:53:31 this nice line right here and I think
- 00:53:33 this improves the look of our game a bit
- 00:53:35 we could also add such a well separator
- 00:53:39 you could say right here before we can
- 00:53:42 select the actual action this is just
- 00:53:45 some cosmetic improvement of course
- 00:53:46 nothing that is really required but I
- 00:53:48 think it's nice to freshen up the game a
- 00:53:50 bit with these things feel free to add
- 00:53:52 this add additional positions I'm happy
- 00:53:55 with that at the moment what I'm not
- 00:53:57 happy about this is the fact that we
- 00:54:00 don't CD health at the beginning of the
- 00:54:02 game and also at the end of the game
- 00:54:04 because if I select the action now you
- 00:54:06 can see that we see the health right we
- 00:54:09 see it right here
- 00:54:10 but we don't have any kind of
- 00:54:12 information regarding while the player
- 00:54:13 health is this value and the monster
- 00:54:16 health is that value right here so let's
- 00:54:18 first add the health information at the
- 00:54:21 beginning of a game and then improve the
- 00:54:23 way the health status is displayed
- 00:54:25 throughout the game now at the beginning
- 00:54:27 of the game means that we have to go up
- 00:54:30 here so once the game is started up so
- 00:54:33 we can say that after the player entered
- 00:54:37 his name we want to print right here our
- 00:54:40 player name right here and now we want
- 00:54:44 you at the information about something
- 00:54:46 like the player so manual or whatever
- 00:54:49 name we gave him has a 100 health like
- 00:54:53 that but 100 health should be retrieved
- 00:54:56 from the dictionary right here from the
- 00:55:00 player and 100 health for the monster
- 00:55:03 should be retrieved from this dictionary
- 00:55:04 because we could also change our health
- 00:55:06 to 200 or something like that when the
- 00:55:08 game starts so I want to make sure that
- 00:55:10 this is displayed at the beginning and
- 00:55:11 that the player has the information
- 00:55:12 about the health amounts at the
- 00:55:14 beginning of the game for that we have
- 00:55:17 to combine different types of
- 00:55:19 information right here the first thing
- 00:55:21 is right here the value from the
- 00:55:23 dictionary this will return a string so
- 00:55:26 this should be fine right here but if we
- 00:55:27 now add a plus sign like that we can
- 00:55:30 combine a second information that should
- 00:55:33 be printed right here now as I said if a
- 00:55:35 to print the player name has a specific
- 00:55:38 amount of health then we could add
- 00:55:40 something like has right here so an
- 00:55:42 ordinary string we can also add space at
- 00:55:45 the beginning and at the end because
- 00:55:46 this will make sure that the player name
- 00:55:48 and has it's not connected directly but
- 00:55:50 that we have some space in between these
- 00:55:53 two values that should be displayed
- 00:55:55 right here after that we can add another
- 00:55:57 + to add our player health right we
- 00:56:01 learn how this works so the player
- 00:56:03 health should be displayed like that so
- 00:56:05 with that we can now access the health
- 00:56:07 value of the health key with the
- 00:56:10 corresponding value of 100 right here
- 00:56:11 the problem though is that if we would
- 00:56:14 execute it like this we will get an
- 00:56:16 error let me show you this if I start
- 00:56:18 the game once again and the name then
- 00:56:21 you can see that we get an error that we
- 00:56:23 can only concatenate strings not
- 00:56:25 integers the issue is that player name
- 00:56:28 right here now print statement is a
- 00:56:30 string it's manual right here or if we
- 00:56:32 change it it's the input that the player
- 00:56:34 gave us so menu in this case has isn't
- 00:56:37 is a string we can see it right here but
- 00:56:39 player health is an integer and this
- 00:56:42 causes a problem here because well as we
- 00:56:44 said we cannot concatenate strings and
- 00:56:46 integers there is one easy solution for
- 00:56:49 that issue though we can simply use the
- 00:56:51 so called string method in Python to
- 00:56:53 turn our value right here into a string
- 00:56:57 now how does this work we simply add STR
- 00:57:00 in front of the value that should be
- 00:57:03 kind of converted to a string you could
- 00:57:05 say now we open the brackets right here
- 00:57:08 and we are done because as you can see
- 00:57:11 right here now we basically well kind of
- 00:57:14 wrapped our player health into this
- 00:57:19 string method and with that it should be
- 00:57:21 turned into a string we'll see in a few
- 00:57:23 seconds if this works let's just add one
- 00:57:25 last item right here to our print
- 00:57:29 statement and this simply is well
- 00:57:31 another string with a space at the
- 00:57:32 beginning health because like that
- 00:57:35 health because I just want to print
- 00:57:36 player name so whatever name we give the
- 00:57:38 player has 100 so this value health
- 00:57:41 let's see if this works let's save it
- 00:57:43 and let's run the code once again let's
- 00:57:45 enter menu and as you can see we print
- 00:57:48 menu
- 00:57:49 has 100 health right here on top now
- 00:57:52 this works fine so let's also do the
- 00:57:54 same thing for our monster right here
- 00:57:56 here we simply have to change the
- 00:57:59 monster name right here like this and
- 00:58:03 this should be the monster health
- 00:58:06 important to keep in mind player name
- 00:58:09 right here refers to the variable right
- 00:58:11 there because we gave the variable a
- 00:58:13 different information right here so we
- 00:58:15 said that the player name is equal to
- 00:58:17 our input the monster name right here is
- 00:58:20 still equal to the value we have for the
- 00:58:22 name key on top right here in all
- 00:58:24 monster variable with that if we quickly
- 00:58:27 exit our game run it once again and the
- 00:58:31 name we see that we have menu with 100
- 00:58:36 health and Max with 100 health too we
- 00:58:39 could also add to make it a bit more
- 00:58:41 readable the print statement right here
- 00:58:44 again so that we have the separation so
- 00:58:47 if that we made the startup a lot more
- 00:58:49 beautiful let's not have a look at the
- 00:58:51 content we print throughout the actual
- 00:58:54 round while it's running because right
- 00:58:56 here ice is something that I don't like
- 00:58:58 these to print methods right here
- 00:59:00 because our if statement right here
- 00:59:02 should actually just contain the logic
- 00:59:04 to see how much health impact the player
- 00:59:07 attack has and then to see if the
- 00:59:09 counterparty saw the monster or a player
- 00:59:11 right here is still alive of course we
- 00:59:13 also want to make sure that we kind of
- 00:59:15 show the impact of the monster attack
- 00:59:17 but these to print methods no I don't
- 00:59:20 think this should be placed right here
- 00:59:21 so let's delete it and let's not think
- 00:59:24 about a better location for these
- 00:59:25 methods well I think about a location
- 00:59:28 would be down here because here we have
- 00:59:31 the actual selections but after these
- 00:59:33 selections are checked so after we know
- 00:59:36 which choice the player made then we can
- 00:59:38 add these statements and for that we
- 00:59:40 should refactor this if statement right
- 00:59:43 here – because what is actually
- 00:59:44 happening
- 00:59:45 well if player 1 right here is equal to
- 00:59:52 false and now we use the end logical
- 00:59:57 operator and if monster 1
- 01:00:01 right here is also false so basically
- 01:00:04 this means both the player and the
- 01:00:06 monster are still alive then please
- 01:00:08 print something like player name has
- 01:00:16 player health – same logic we used above
- 01:00:21 already left but what do we have to do
- 01:00:25 right here we have to put the left into
- 01:00:27 quotation marks and data space and we
- 01:00:30 have to combine these different values
- 01:00:32 we want to output with a plus right here
- 01:00:34 and right there
- 01:00:36 the same thing could be printed for our
- 01:00:38 monster of course so we could say the
- 01:00:42 monster right here also has a specific
- 01:00:45 amount of health left by the way
- 01:00:48 selecting these two items at once simply
- 01:00:51 works by pressing command D on the Mac
- 01:00:53 right here here we have an issue still
- 01:00:55 because I overlooked this has so we
- 01:00:57 should select both of these and now put
- 01:00:59 it into sink rotation marks and add a
- 01:01:02 space at the beginning and at the end of
- 01:01:04 it now this looks better and we should
- 01:01:07 add the plus right here of course like
- 01:01:08 this and like that now we don't have an
- 01:01:11 error here anymore but we should also be
- 01:01:13 factored this code down here now because
- 01:01:15 if nobody won well then this code will
- 01:01:18 run but L if so else if the player won
- 01:01:26 by the way we can also get rid of this
- 01:01:29 truth statement right here because if
- 01:01:31 you just write like player 1 then this
- 01:01:33 automatically means that if player 1 is
- 01:01:35 true so basically writing this player 1
- 01:01:40 equals 2 is the same thing as writing if
- 01:01:43 player 1 so if player 1 we could say we
- 01:01:47 also print something like um player name
- 01:01:53 plus 1 and of course new round is set to
- 01:01:59 false then that is to correct and
- 01:02:02 another Elif right here if the monster 1
- 01:02:07 like that new round is also set to false
- 01:02:11 and we should print right here oh maybe
- 01:02:15 not
- 01:02:16 refer to the player to monster name we
- 01:02:18 could simply type something like the
- 01:02:21 monster one like this right here now if
- 01:02:27 that we refactor our code a bit we are
- 01:02:29 now able to print different statements
- 01:02:32 depending on whether the player has one
- 01:02:34 or the monster has one and we also print
- 01:02:37 the current health statues if nobody won
- 01:02:40 so if the round basically continues one
- 01:02:42 thing we have to change your dough is we
- 01:02:44 have to turn our health right here into
- 01:02:47 a string again that's also the same
- 01:02:49 issue we had above but we also edit the
- 01:02:51 print statement so let's add a string
- 01:02:53 method right here and right there like
- 01:02:57 this so if we now restart the game it
- 01:03:02 here enter the name attack we can see
- 01:03:05 maybe let's crease a little bit we can
- 01:03:09 see man us 88 left so it decreases it
- 01:03:13 keeps decreasing and now we see that
- 01:03:15 menu 1 because the game was over as we
- 01:03:18 can see the monster so max only had 9
- 01:03:21 left and we see that I won the game in
- 01:03:24 this case so this is working final so
- 01:03:27 and with that we improved the structure
- 01:03:29 of our game a lot as I would say a good
- 01:03:31 next step now would be to also work on
- 01:03:34 the other if statements specifically I
- 01:03:37 would like to work on the heal option
- 01:03:38 right here because at the moment we can
- 01:03:40 basically just attack or exit the game
- 01:03:43 but heal player still is simply not just
- 01:03:46 a print statement so let's work on that
- 01:03:48 now if our player says that he just
- 01:03:51 wants to heal himself and not attack the
- 01:03:53 monster then the logic is a bit
- 01:03:55 different because what will happen then
- 01:03:57 well we can simply say that if the
- 01:03:59 player wants to heal himself then player
- 01:04:02 health right here so we again access the
- 01:04:05 health key of our player is a quote you
- 01:04:08 well the player health that he currently
- 01:04:11 has but now not minus something because
- 01:04:15 we don't want to subtract something we
- 01:04:18 want to add right here the heal amount
- 01:04:21 we defined for our player just to bring
- 01:04:23 that back to your mind the heal amount
- 01:04:25 is this key right here so we have a heal
- 01:04:27 key with a value of 16
- 01:04:29 so let's add this now so we can say that
- 01:04:32 playerhealth is equal to the current
- 01:04:34 playerhealth plus the player heel that
- 01:04:38 we have right here what we don't need
- 01:04:41 here is now we don't need to check
- 01:04:43 whether our player is still alive
- 01:04:45 because well if we survived if the
- 01:04:47 previous round then you will be able to
- 01:04:48 heal himself because of that the health
- 01:04:50 will increase but after the player
- 01:04:54 healed himself well the monster will
- 01:04:56 still be able to attack the player so we
- 01:04:59 have to add this monster attack now to
- 01:05:02 do that we can simply say that player
- 01:05:04 health now but this is now the updated
- 01:05:06 player health so this one right here so
- 01:05:08 player health is equal to well the
- 01:05:14 player health again so the current value
- 01:05:16 for the player health – the monster
- 01:05:21 attack that we have so basically it's
- 01:05:25 the same logic that we had right here
- 01:05:28 however after this attack we have to
- 01:05:30 check whether our players still alive so
- 01:05:33 we can again copy that code right here
- 01:05:35 so if the player health is below 0 or
- 01:05:38 equal to 0 then well unfortunately our
- 01:05:41 player has lost the game and the monster
- 01:05:44 has won so this would be the logic for
- 01:05:46 our second choice right here for our
- 01:05:49 second option let's quickly check if
- 01:05:51 this works let me enter name and exit
- 01:05:53 the game so let's now we start the game
- 01:05:56 and enter name once again and let's
- 01:06:00 attack yeah we have 88 life left so
- 01:06:03 let's see if we kill ourselves
- 01:06:04 we got 92 left which basically makes
- 01:06:06 sense because we got an attack from the
- 01:06:09 monster of 12 but we had a heal level of
- 01:06:13 16 so we increased our health by 4 so
- 01:06:16 this is also working fine now with that
- 01:06:19 code added I think it's time to think
- 01:06:21 about the core game logic once again
- 01:06:24 because at the moment we have a pretty
- 01:06:26 well let's say easy to predict game
- 01:06:31 result because we only have two attack
- 01:06:33 options for the player and monster so
- 01:06:36 it's 13 for player and 12 for the
- 01:06:38 monster so basically if the player
- 01:06:40 always attacks well he will win the game
- 01:06:43 that's pretty boring so I think we
- 01:06:44 should make this a bit more dynamic and
- 01:06:46 I actually don't want to change the
- 01:06:48 player values right here I think these
- 01:06:51 are okay but I'm not happy with the
- 01:06:53 monster right here because wouldn't it
- 01:06:55 be great if we could make this a bit
- 01:06:56 more dynamic if we define a minimum
- 01:06:59 value for the monster attack and a
- 01:07:02 maximum value and then kind of create
- 01:07:04 something which allows us to dynamically
- 01:07:06 select the value in between this minimum
- 01:07:09 and maximum with that we have a random
- 01:07:11 element in our game and this would make
- 01:07:13 it a lot more exciting now how can we
- 01:07:16 achieve that well the first thing is we
- 01:07:18 should get rid of that single key right
- 01:07:22 here and add two keys instead of this
- 01:07:24 one one could be attack min right here
- 01:07:28 for the minimum attack value which could
- 01:07:31 be equal to let's say 12 and then we add
- 01:07:34 another value or another key and value
- 01:07:36 which could be attack max right here
- 01:07:40 which could have a value of well let's
- 01:07:44 say 20 maybe even this can make it a
- 01:07:46 little bit more exciting let's maybe
- 01:07:47 decrease this a bit to 10 let's say
- 01:07:49 something like that with that we now
- 01:07:52 have these two options the problem is
- 01:07:55 that we now need a way to well kind of
- 01:07:56 choose a value in between 10 and 20
- 01:07:58 randomly for each round for that purpose
- 01:08:02 we need to import a so called module
- 01:08:04 chip – now what is a module generally we
- 01:08:08 could write everything from scratch
- 01:08:10 right here in Python this is generally
- 01:08:12 possible but isn't really convenient and
- 01:08:14 it would mean that we have to write a
- 01:08:15 lot of code and a lot of logic just for
- 01:08:18 things like while creating such a random
- 01:08:20 number in the end because of that –
- 01:08:22 comes with a lot of different modules
- 01:08:25 which can be imported to your project
- 01:08:27 and which come with these features
- 01:08:29 implemented by default but the important
- 01:08:32 thing is that you can use different
- 01:08:33 features of this module in a very very
- 01:08:37 convenient way now let's see how this
- 01:08:39 works now because I think then it will
- 01:08:41 become a lot clearer you basically
- 01:08:43 import a module to – by simply going to
- 01:08:46 the top of your code right here and then
- 01:08:49 import the module of your choice in our
- 01:08:51 case we need to import from the
- 01:08:54 so-called random
- 01:08:56 jool more about modules can be found in
- 01:08:59 the link in the video description by the
- 01:09:01 way and from this random module we want
- 01:09:04 to import a specific feature you could
- 01:09:06 say in our case we want to import the
- 01:09:09 rant int feature this one right here the
- 01:09:12 rant in feature simply allows us to
- 01:09:15 return a random integer between a bottom
- 01:09:18 and a top corridor you could say so in
- 01:09:22 our case between the minimum attack and
- 01:09:24 the maximum attack and the cool thing
- 01:09:26 about this module now is that we can
- 01:09:28 simply use this feature without writing
- 01:09:30 any additional code we only have to use
- 01:09:32 a specific method as I said methods and
- 01:09:35 functions or something we'll cover in a
- 01:09:37 few seconds and then we will get back a
- 01:09:39 random number now a lot of talking how
- 01:09:42 does this work now well basically we
- 01:09:45 want to have our monster attack down
- 01:09:47 here so this basically this monster
- 01:09:49 attack is now no longer a fixed value
- 01:09:51 but this should be a random value for
- 01:09:54 that we can simply define a variable
- 01:09:57 let's say monster attack really
- 01:10:01 important this now is a variable you can
- 01:10:04 see this with the underscore right here
- 01:10:06 and I don't refer to the monster attack
- 01:10:08 key right here right that's important so
- 01:10:11 I'm not referring to any kind of attack
- 01:10:13 key which by the way is also not
- 01:10:15 existing any longer and I want to store
- 01:10:17 an information a specific information in
- 01:10:20 it variable and this information L is
- 01:10:23 something that is only available because
- 01:10:25 we imported this random module I will
- 01:10:29 now use a so called function or a method
- 01:10:31 and we will dive deeper into functions
- 01:10:34 in a few minutes so just to give you a
- 01:10:35 big picture a function is simply some
- 01:10:39 code that can be executed whenever we
- 01:10:42 call this function so whenever we tell
- 01:10:44 Python to well refer to that function
- 01:10:47 you could say then this code will be
- 01:10:49 executed and the Rand int is a function
- 01:10:52 which is available due to the random
- 01:10:54 module be imported so we don't see the
- 01:10:56 actual code inside that function right
- 01:10:58 here but we have this function or method
- 01:11:01 available now as we use this random
- 01:11:04 module a function is called by typing
- 01:11:07 the function name and adding the
- 01:11:09 parentheses right here
- 01:11:10 so adding the parentheses simply means
- 01:11:12 that you call the function we have two
- 01:11:14 types of functions though all to
- 01:11:16 something we'll have a look at later by
- 01:11:17 the way we have functions with empty bar
- 01:11:19 and parentheses this would be something
- 01:11:21 like this or in the case of the rent in
- 01:11:23 function we have a function which
- 01:11:25 requires so-called parameters or
- 01:11:28 arguments if a function requires such
- 01:11:32 arguments this simply means that we have
- 01:11:34 to pass some additional information from
- 01:11:37 outside to this function to make sure
- 01:11:40 the code inside the functions can be
- 01:11:43 executed correctly and the information
- 01:11:45 we pass to this function our so-called
- 01:11:47 arguments we will have a look at
- 01:11:48 parameters and arguments also later in
- 01:11:50 more detail so the important thing right
- 01:11:52 here is we have this rent in function so
- 01:11:55 this predefined code we can execute
- 01:11:58 whenever we need it and we have to add
- 01:12:00 additional information to this function
- 01:12:02 to make sure the code can be executed
- 01:12:04 correctly now as we want to calculate a
- 01:12:07 random integer we need to add two
- 01:12:09 arguments here the first one is the
- 01:12:12 minimum value for our attack so we need
- 01:12:14 monster attack min right here and the
- 01:12:17 second argument is the monster attack
- 01:12:19 max that's the second argument and with
- 01:12:21 that we are now able to call this
- 01:12:24 function inside our variable and with
- 01:12:26 that to retrieve the calculated random
- 01:12:29 number for the monster attack with these
- 01:12:32 two arguments added we now made sure
- 01:12:34 that if we refer to the monster attack
- 01:12:36 variable this function is called and
- 01:12:38 executed and therefore we only have to
- 01:12:40 change our monster attack right here
- 01:12:43 with D monster
- 01:12:44 underscore attack variable because if we
- 01:12:46 now subtract this monster attack
- 01:12:48 variable we will subtract the result of
- 01:12:51 the Rand int function and this will be
- 01:12:53 this random attack value calculated due
- 01:12:57 to our random module so this was a lot
- 01:12:59 of talking let's now see if this works
- 01:13:01 so let's exit the game and start it once
- 01:13:03 again and player name and let's attack
- 01:13:07 the monster so we see menu has 83 left
- 01:13:11 now so we kind of deducted 17 let's try
- 01:13:15 it another time now we have 65 left so
- 01:13:18 83 minus 1818 is 65 so another random
- 01:13:22 number
- 01:13:23 now we have 50 left so 15 so basically
- 01:13:27 this seems to work now if this random
- 01:13:29 module right here we are able to create
- 01:13:31 this random integer now we simply have
- 01:13:33 to also copy that code from here to down
- 01:13:37 there to our second choice if we decide
- 01:13:39 to heal ourselves and let's make sure
- 01:13:42 the indentation is correct right here
- 01:13:46 like this and like that so this is not
- 01:13:51 working fine but we just saw something
- 01:13:53 that you should avoid no matter if
- 01:13:55 you're writing Python code or any other
- 01:13:57 code we just copy and paste it well
- 01:14:01 basically the same code right that's not
- 01:14:04 always a totally bad thing but
- 01:14:05 especially if we have things like this
- 01:14:07 monster attack right here so this line
- 01:14:09 right here and right there this is not
- 01:14:12 really a good
- 01:14:13 well code structure I would say because
- 01:14:16 what is actually happening right here is
- 01:14:17 we only need this code to get this
- 01:14:20 random integer now wouldn't it be better
- 01:14:23 to kind of outsource this code and to
- 01:14:26 kind of to be able to refer to the
- 01:14:27 result of this calculation right here in
- 01:14:30 monster attack at the moment this is not
- 01:14:32 possible because we first have to define
- 01:14:34 or declare the variable to get back this
- 01:14:37 value situations like that are the
- 01:14:40 perfect area or application area for
- 01:14:43 so-called functions now what are
- 01:14:45 functions functions basically allow us
- 01:14:48 to run a specific predefined code
- 01:14:52 whenever we call such a function calling
- 01:14:55 a function simply means that we tell the
- 01:14:58 function that it should be executed now
- 01:15:00 now how do we write such functions let's
- 01:15:03 go down to the code and create such a
- 01:15:05 function a function in Python is created
- 01:15:07 by simply typing the death keyword right
- 01:15:10 here now we have to give the function a
- 01:15:12 name and the name should basically
- 01:15:14 describe what is well basically done
- 01:15:17 inside the function so in our case what
- 01:15:19 are we calculating and this could be
- 01:15:21 something like monster attack maybe like
- 01:15:25 this the problem is that we have monster
- 01:15:27 attack already right here for our
- 01:15:29 variable and this is something you
- 01:15:31 should avoid you should not name
- 01:15:33 variables and functions equal that's
- 01:15:35 something you should not do they have
- 01:15:37 or we will just change the name here to
- 01:15:39 monster attack or maybe let's call it
- 01:15:45 calculate armed monster attack like that
- 01:15:49 with that we have a different naming
- 01:15:51 right here then we add parentheses right
- 01:15:53 there
- 01:15:53 and then we add a colon and here we now
- 01:15:55 have a function which doesn't require
- 01:15:57 any arguments you remember when we used
- 01:16:00 to rent in function before we had to add
- 01:16:02 the attack min and attack maximum as
- 01:16:04 arguments otherwise the function
- 01:16:06 wouldn't work correctly in this case we
- 01:16:09 don't need that arguments because the
- 01:16:11 function doesn't require any additional
- 01:16:13 information from outside and with that
- 01:16:16 we're basically back to our already
- 01:16:17 known Python programming syntax because
- 01:16:20 now we hit enter and now the indented
- 01:16:23 code right here will only be executed if
- 01:16:25 we call so if we basically execute the
- 01:16:29 function right here now what you want to
- 01:16:31 do is if we refer to this function we
- 01:16:34 just want to have this random integer so
- 01:16:37 we can just refer to this code right
- 01:16:38 here copy it and paste it right there
- 01:16:42 into our function so let's now see what
- 01:16:45 happens if we save that right here we
- 01:16:47 can see it we get no errors so this
- 01:16:50 seems to work ok so let's exit the game
- 01:16:52 and let's now start the game once again
- 01:16:55 and rename attack well this works fine
- 01:16:59 of course but the problem is that we
- 01:17:01 basically don't use the function right
- 01:17:03 now because as I said before we have to
- 01:17:06 call a function to really execute the
- 01:17:09 code that we saved right here what does
- 01:17:11 this mean for us well we basically
- 01:17:13 should get rid right here in our first
- 01:17:16 if statement of the monster attack a
- 01:17:20 variable we don't need this variable
- 01:17:22 anymore because the only purpose of this
- 01:17:24 variable was to basically calculate this
- 01:17:26 random number this is now done by our
- 01:17:28 function and we can instead of that now
- 01:17:32 say that we just refer to the calculate
- 01:17:38 monster attack function and important to
- 01:17:41 call a function in Python we have to add
- 01:17:44 the parentheses right here let's now
- 01:17:46 save this and let's now see what is
- 01:17:48 happening so if we know X
- 01:17:51 the game and her name menu like that say
- 01:17:57 attack then we get an error it says that
- 01:18:02 the calculate monster attack right here
- 01:18:04 this name is not defined but that's
- 01:18:07 strange right
- 01:18:08 because actually we defined it down
- 01:18:10 there but somehow puffin doesn't know
- 01:18:13 that this function exists and therefore
- 01:18:15 has no idea what it should do right
- 01:18:17 there now this is also very important to
- 01:18:20 understand the code right here in Python
- 01:18:23 and generally in programming actually is
- 01:18:25 always read or parsed from top to bottom
- 01:18:28 this means if we think about what is pi
- 01:18:31 for doing right here it starts reading
- 01:18:33 the code up there scans the code scans
- 01:18:36 the code scans the code and then it sees
- 01:18:38 okay we want to execute or call a
- 01:18:41 function right here but the problem is
- 01:18:43 that Python has no idea that this
- 01:18:45 function is defined down there because
- 01:18:47 as I said the code is parsed from top to
- 01:18:49 bottom
- 01:18:50 therefore how should it know that
- 01:18:52 therefore we will take this function l
- 01:18:54 scroll to the top of our code and add it
- 01:18:57 right here ahead of our first Y loop
- 01:19:00 with that pipe now understands that we
- 01:19:03 have a function named calculate monster
- 01:19:05 attack and that this function will be
- 01:19:08 called right here now let's see what
- 01:19:10 happens now if you run the game once
- 01:19:11 again enter the player name menu right
- 01:19:14 here and attack now we have another
- 01:19:17 problem
- 01:19:17 Python is aware of our function but we
- 01:19:20 basically have something like an
- 01:19:22 unsupported operand type the coughing
- 01:19:26 right here is this non type because our
- 01:19:29 function is not returning anything at
- 01:19:32 the moment because we basically told our
- 01:19:34 function up here that it should
- 01:19:36 calculate the random integer but the
- 01:19:38 problem is we didn't tell the function
- 01:19:39 what it should do then so it calculates
- 01:19:41 that integer but well then that's it
- 01:19:44 therefore we have to add another
- 01:19:46 important statement to this function
- 01:19:48 right here this so-called return
- 01:19:50 statement like this return simply tells
- 01:19:54 python that it should well return the
- 01:19:57 result of this operation and the result
- 01:19:59 of this operation is the calculated
- 01:20:01 value for our attack so if we save that
- 01:20:04 now
- 01:20:05 and run the code once again enter the
- 01:20:07 player name and attack then you can see
- 01:20:10 that this is working now because now
- 01:20:13 basically what happens is we say that we
- 01:20:17 call the function right here we
- 01:20:19 calculate the value for our monster
- 01:20:22 attack and we return that value and with
- 01:20:25 that we insert the value right here in
- 01:20:27 our function and therefore T
- 01:20:29 playerhealth is recalculated what we can
- 01:20:32 do now of course is we can also take
- 01:20:34 that code
- 01:20:35 so this playerhealth we just created and
- 01:20:37 also replace it for our second if case
- 01:20:40 right here important make sure to do the
- 01:20:44 indentation indentation correctly too so
- 01:20:48 besides the fact that we now refactor
- 01:20:51 our code again made it a bit leaner
- 01:20:53 which is always good we also had a first
- 01:20:56 look at functions and to be more precise
- 01:20:59 we actually solve two types of functions
- 01:21:01 already let's scroll up a bit to the
- 01:21:04 functions we use because we have our
- 01:21:06 calculate monster attack function and we
- 01:21:08 have our rent in red here so the
- 01:21:10 function we use from our random module
- 01:21:12 that we imported and if you look at the
- 01:21:15 parenthesis at the end of these two
- 01:21:16 functions we see a big difference the
- 01:21:19 first function right here
- 01:21:20 has empty parentheses this means this
- 01:21:23 function doesn't require any arguments
- 01:21:26 or parameters the rent in function on
- 01:21:29 the other hand requires two arguments in
- 01:21:31 our case monster attack min and monster
- 01:21:33 attack max what's the difference here
- 01:21:35 well the calculate monster attack
- 01:21:37 function doesn't need any kind of
- 01:21:40 external information to run correctly
- 01:21:42 because if we call that function we
- 01:21:45 simply execute this code right here and
- 01:21:46 this code comes with all the information
- 01:21:49 needed well to run the function this
- 01:21:51 means we don't need any parameters right
- 01:21:53 here we don't have to pass any arguments
- 01:21:56 to that function so any external
- 01:21:58 information you could say this is
- 01:22:00 different for our random integer
- 01:22:02 function right here we need to calculate
- 01:22:04 a random integer between a minimum and a
- 01:22:06 maximum value in this minimum and
- 01:22:09 maximum value in our case is some
- 01:22:12 external information and to pass this
- 01:22:14 external information into our function
- 01:22:17 we use a so called
- 01:22:19 argument in our case we have two
- 01:22:20 arguments we have the minimum attack and
- 01:22:22 de maximum attack we don't have to use
- 01:22:25 these external information as arguments
- 01:22:28 here by the way we could also use fixed
- 01:22:30 values for example 10 as the first
- 01:22:32 argument and for the max value as the
- 01:22:34 second argument we could use 20 that
- 01:22:36 would also be possible 20 like that this
- 01:22:39 would also be possible but this would
- 01:22:41 make our code a lot less dynamic because
- 01:22:45 actually the monster variable right here
- 01:22:48 and the corresponing dictionary contains
- 01:22:50 information about the minimum and
- 01:22:51 maximum attack so instead of using fixed
- 01:22:54 values as arguments right here we can
- 01:22:57 simply pass attack min and attack max as
- 01:23:00 arguments for the first parameter so
- 01:23:03 this is monster attack min and the
- 01:23:10 second parameter receives the monster
- 01:23:14 attack max as an argument so that's the
- 01:23:18 core idea behind functions parameters
- 01:23:21 and arguments parameters simply allow us
- 01:23:24 to add additional information to
- 01:23:27 functions to make sure the code inside
- 01:23:29 the function works correctly and the
- 01:23:31 information we pass to these parameters
- 01:23:33 are our so called arguments so attackman
- 01:23:36 and attack max in our case however using
- 01:23:40 the function like this is working fine
- 01:23:41 in this case but this is not a perfect
- 01:23:45 solution to be honest because at the
- 01:23:48 moment we declare our variable some
- 01:23:50 monster right here and we refer to this
- 01:23:52 variable inside our function and after
- 01:23:55 we declare the variable we call the
- 01:23:57 function down here calculate monster
- 01:23:59 attack but there can be situations where
- 01:24:03 this can cause problems because what if
- 01:24:05 we want to call our function before we
- 01:24:09 declare the actual variable for example
- 01:24:11 we could print our calculate monster
- 01:24:13 attack function right here if we run our
- 01:24:16 code now we get an error because the
- 01:24:19 named monster is not defined because
- 01:24:22 what's happening is that well
- 01:24:24 – parses the code it reads the code and
- 01:24:27 finds the function then goes into our
- 01:24:29 while loop and then we want to print the
- 01:24:32 function
- 01:24:32 and then we have a problem because – is
- 01:24:36 no idea that this monster variable
- 01:24:38 exists because we use it in the function
- 01:24:40 but we declare it after we call the
- 01:24:43 function therefore this approach is not
- 01:24:46 perfect here we can stick to it for the
- 01:24:48 moment though but actually we should
- 01:24:50 improve that code to make sure we avoid
- 01:24:52 errors like that
- 01:24:54 however we will work on that as soon as
- 01:24:56 we were diving deeper into parameters
- 01:24:58 and arguments because an argument might
- 01:25:00 be helpful here nevertheless if we
- 01:25:03 delete it right here and run the code
- 01:25:04 again we can see this still works fine
- 01:25:07 so we'll stick to that solution for the
- 01:25:09 moment now why don't we practice that a
- 01:25:12 bit and create another function which
- 01:25:14 also requires an argument well for that
- 01:25:17 we can scroll down and here in our game
- 01:25:20 ending or around ending situations where
- 01:25:23 either the player one or the monster one
- 01:25:25 I think it would be a nice place to add
- 01:25:26 such a function because we could
- 01:25:28 actually create a function that might be
- 01:25:31 called something like arm game ends
- 01:25:33 something like this which gets called if
- 01:25:37 the player or the monster one so we can
- 01:25:40 actually delete this print statement
- 01:25:42 right here and also write there and add
- 01:25:48 game ends right here like this as you
- 01:25:51 can see our 30 parentheses so like this
- 01:25:53 we call this function and we don't pass
- 01:25:56 any argument we of course also have to
- 01:25:59 define the function trait the function
- 01:26:01 so let's go up here again now we'll
- 01:26:04 create the game and function without any
- 01:26:07 arguments and say that this should print
- 01:26:09 something like maybe um player one like
- 01:26:16 this if we do that and run the code
- 01:26:20 let's enter player name attack attack
- 01:26:23 attack attack attack it seems that we
- 01:26:27 might lose let's see ah we made it
- 01:26:29 though we actually won the game but the
- 01:26:32 problem still is that even if the
- 01:26:33 monster would have won the game we would
- 01:26:35 always print the player one because we
- 01:26:37 always call this game and function in
- 01:26:38 this game and function well it simply
- 01:26:40 prints the player one so wouldn't it be
- 01:26:42 better if we would be able to pass an
- 01:26:45 hour
- 01:26:46 human to this function which basically
- 01:26:48 simply is the player name in case the
- 01:26:51 player won right here or something like
- 01:26:53 the monster in case the monster won for
- 01:26:56 that we need to add a parameter to our
- 01:26:58 function this can be done up here in the
- 01:27:02 parenthesis and now we can specify a
- 01:27:04 name for this parameter in our case this
- 01:27:07 could be like the winner's name for
- 01:27:10 example like this so we now have this
- 01:27:13 function with this parameter and now we
- 01:27:15 need an argument that gets passed to
- 01:27:17 that function to be able to use it
- 01:27:19 inside our function at the moment we
- 01:27:21 don't use it but we will add that in a
- 01:27:23 few seconds for that we can go back
- 01:27:25 right here and now simply add the
- 01:27:28 argument so the argument that gets
- 01:27:30 passed to this parameter inside the
- 01:27:32 parentheses right here now what is the
- 01:27:34 argument we need in case the player won
- 01:27:36 well it's of course the player name
- 01:27:40 right here like that and for the monster
- 01:27:43 well I think that's quite obvious it's
- 01:27:45 the monster name of course this and like
- 01:27:48 that so in case the player wins the game
- 01:27:51 we call the game and function and we
- 01:27:55 pass the player name as an argument this
- 01:27:58 argument now gets passed to this
- 01:28:01 function right here as the spinner name
- 01:28:03 parameter important as you can see the
- 01:28:06 naming of the argument right here and
- 01:28:10 the parameter right there doesn't have
- 01:28:13 to be equal can be but it doesn't have
- 01:28:15 to but important if you want to use the
- 01:28:18 argument then inside your function then
- 01:28:21 you have to name it identically for
- 01:28:24 example if you want to print the
- 01:28:25 winner's name we have to add winner's
- 01:28:27 name right here like this with that if
- 01:28:32 we exit our game clear it and run it
- 01:28:37 once again and the name menu
- 01:28:40 and attack attack attack attack attack
- 01:28:43 attack attack we can see max right here
- 01:28:46 so this means the monster because this
- 01:28:48 is the name of the monster won the game
- 01:28:50 so this is working we now pass the
- 01:28:53 argument to our function and can
- 01:28:55 dynamically output the winner name the
- 01:28:58 problem is that I might also want to
- 01:29:00 have something like a little bit of a
- 01:29:02 sentence right here because just
- 01:29:03 printing the name like this
- 01:29:04 it's not really nice as I would say for
- 01:29:07 that something like using a string as we
- 01:29:09 had it before
- 01:29:10 for example player won the game like
- 01:29:15 that would be good but player should
- 01:29:19 actually not be the player it should be
- 01:29:21 either to player name or if the player
- 01:29:23 won or the monster name if the monster
- 01:29:26 won and we have to use it dynamically
- 01:29:28 well based on the argument we have right
- 01:29:31 here to do this we have a really nice
- 01:29:33 feature in – also it's called formatted
- 01:29:37 string literals or f strings and these
- 01:29:40 allow us to dynamically inject content
- 01:29:42 into strings so exactly what we want to
- 01:29:45 achieve right here to create such an F
- 01:29:47 string you simply add well an F in front
- 01:29:51 of your string so this is the string
- 01:29:52 that we are using right here and you
- 01:29:55 simply wrap the content that you want to
- 01:29:57 dynamically inject into your string with
- 01:29:59 curly braces so like this and like that
- 01:30:02 this would be the player then being
- 01:30:04 injected dynamically but as I said this
- 01:30:07 is not working at the moment because the
- 01:30:09 name of the argument right here and
- 01:30:11 right there inside our function so where
- 01:30:14 we want to use that argument has to be
- 01:30:15 equal so with that we can simply add
- 01:30:18 winner name right here so what is
- 01:30:20 happening now is that if the player for
- 01:30:22 example wins the game we pass the player
- 01:30:24 name to our function and then we use
- 01:30:27 this argument right here inside our f
- 01:30:30 string if the monster wins the same
- 01:30:34 thing happens but the winner name will
- 01:30:35 be the monster name and not the player
- 01:30:37 name now let's see if this works
- 01:30:39 so let's escape our game clear it run it
- 01:30:43 once again enter name attack attack
- 01:30:46 attack attack attack attack and
- 01:30:49 Tech max won the game so this is working
- 01:30:52 fine let's not also see if we can win
- 01:30:55 the game this so let's maybe start
- 01:30:58 repealing ourselves healing again
- 01:31:00 attacking the monster healing ourselves
- 01:31:01 ah this doesn't work good healing can we
- 01:31:05 win the game we might have to readjust
- 01:31:06 the gaming logic a little bit I think we
- 01:31:10 will lose again yeah now we won the game
- 01:31:14 we did it so as you can see now we won
- 01:31:16 the game and this is also printed now
- 01:31:18 dynamically because now menu so the
- 01:31:20 player name is used in our function
- 01:31:23 let's move away from functions now and
- 01:31:25 let's work again on the user experience
- 01:31:27 because we have this output right here
- 01:31:29 so monster or player on the game this is
- 01:31:33 nice but actually I would like to add
- 01:31:35 some more information on the player
- 01:31:37 after a round or a game ended because
- 01:31:40 let's say that the monster won then we
- 01:31:43 would have max won the game right here
- 01:31:44 but then I would also like to print the
- 01:31:46 player info like the player named the
- 01:31:49 player healthy had and also maybe
- 01:31:52 something like how many rounds it took a
- 01:31:54 single game to end so to either make
- 01:31:56 sure to play a one or the monster one
- 01:32:00 so for that we need to print this
- 01:32:02 information and we need to add a counter
- 01:32:04 let's work on it step by step and let's
- 01:32:06 print the information first for that I
- 01:32:09 will go down right here to our game
- 01:32:13 ending conditions so either the player
- 01:32:15 or the monster run we have our game and
- 01:32:17 function and after that I would like to
- 01:32:20 create a new variable this variable
- 01:32:22 could be something like round result
- 01:32:25 right here and the round result should
- 01:32:28 contain the following information it
- 01:32:30 should contain the name right so the
- 01:32:34 name of our player and because of that
- 01:32:36 you have to refer to our player name
- 01:32:39 right here and it should contain the
- 01:32:42 health level of our player as soon as
- 01:32:45 the round ended and the health level is
- 01:32:48 of course our player health right here
- 01:32:51 now we add a print statement right here
- 01:32:54 to print our round result and then we
- 01:32:59 copy this information down here to our
- 01:33:02 monster like that if you remember back I
- 01:33:05 said that copying and pasting code is
- 01:33:07 not always a best practice for this
- 01:33:10 purpose here I will copy paste the code
- 01:33:12 though because in a few minutes we will
- 01:33:14 basically save our results and for that
- 01:33:17 I prefer this approach I come back to
- 01:33:20 that in a few minutes though so let's
- 01:33:21 keep it this way for the moment if we
- 01:33:24 now restart our game enter the name and
- 01:33:28 attack attack attack attack attack
- 01:33:29 attack
- 01:33:31 you can see that menu won the game so
- 01:33:34 basically play up on the game and then
- 01:33:35 we save to player stats or the name and
- 01:33:37 the health this can be helpful in case
- 01:33:39 we have different players then each
- 01:33:41 player can see his name and the health
- 01:33:44 level he had now besides that I also
- 01:33:47 wanted to add a counter so that you can
- 01:33:50 see how many rounds it took until the
- 01:33:51 game ended for that we simply have to
- 01:33:54 define such a counter first and where
- 01:33:57 should we do that well right here in our
- 01:33:59 first while loop in our game running
- 01:34:03 while loop because as soon as we start a
- 01:34:05 new game not a new round a new game the
- 01:34:08 counter has to be reset well and what
- 01:34:11 should be the value for a counter
- 01:34:13 nationally
- 01:34:13 initially well it should be zero so we
- 01:34:15 can say the counter is zero right here
- 01:34:18 at the start of the game now whenever we
- 01:34:23 start a new round the counter should
- 01:34:25 increase by one because we start a new
- 01:34:27 round the counter goes up the round
- 01:34:28 ended the next round starts and the
- 01:34:30 counter increases because of that we can
- 01:34:33 simply add the counter right here in our
- 01:34:35 second while loop so the new round while
- 01:34:37 loop and we can again refer to our
- 01:34:39 counter variable and say that the
- 01:34:41 counter should be the initial value of
- 01:34:43 the counter this one plus one because we
- 01:34:47 increase the counter by one and as long
- 01:34:49 as we stay inside our round the counter
- 01:34:52 will be one when we start the round then
- 01:34:55 we go for our while loop we stay around
- 01:34:57 the second round starts sort of counter
- 01:35:00 increases to do if the round ends we go
- 01:35:02 back to our first while loop right here
- 01:35:04 and set the counter back to zero so that
- 01:35:07 should be the logic
- 01:35:08 let's now also print this counter right
- 01:35:11 here in our round result and for that we
- 01:35:14 can simply add it as another key right
- 01:35:17 here so this could be the round key
- 01:35:20 right here and while the value for
- 01:35:23 rounds is simply our counter variable
- 01:35:25 let's also add this down here um for our
- 01:35:32 monster one case now let's see if this
- 01:35:35 works let's end the game and restart it
- 01:35:40 enter a name tag attack attack attack
- 01:35:43 attack attack and yeah as we can see max
- 01:35:47 won the game so the monster won the game
- 01:35:48 the player was menu the health level was
- 01:35:51 minus seven so we were beaten and it
- 01:35:54 took the monster seven rounds to win
- 01:35:56 against us so if that we also
- 01:35:58 implemented such a counter functionality
- 01:36:00 to our game right here let's now also
- 01:36:03 try another player name so let's say the
- 01:36:05 other players Tony so another player
- 01:36:08 Tony attacks attacks attacks attacks
- 01:36:11 attacks attacks and again max won the
- 01:36:14 game but the problem is that now Tony is
- 01:36:17 only displayed right here but actually
- 01:36:19 in the previous round I was playing
- 01:36:21 against a monster but my stats were not
- 01:36:23 safe now keep in mind that we didn't
- 01:36:26 exit the game so we
- 01:36:27 actually stayed inside our game but
- 01:36:29 somehow our results were not saved this
- 01:36:33 could be the next film we work on how
- 01:36:35 can we save the data of a single round
- 01:36:37 right here in our code to make sure we
- 01:36:40 get kind of a while results list in the
- 01:36:42 end to see how different players
- 01:36:43 performed against the monster we
- 01:36:47 actually learned almost everything we
- 01:36:49 need for that already in this video
- 01:36:51 because if you remember back the
- 01:36:53 beginning of this video we talked about
- 01:36:55 lists and lists allowed us to store well
- 01:36:58 different items and actually this right
- 01:37:01 here so this dictionary is a single item
- 01:37:04 in the next round if another player
- 01:37:06 plays against the monster the result
- 01:37:08 would also be a dictionary which could
- 01:37:10 be the next list item and so on so what
- 01:37:13 we actually only meet is an empty list
- 01:37:16 at the beginning of the game and to this
- 01:37:18 empty list we then simply add the
- 01:37:21 dictionary so this one right here every
- 01:37:23 time a game was finished so every time
- 01:37:26 either the monster or the player won for
- 01:37:29 that we will first create this empty
- 01:37:32 list and let's create that list appear
- 01:37:34 outside of our while loop because
- 01:37:36 basically that's the initial thing that
- 01:37:38 should be created as soon as we run our
- 01:37:41 Python file right here so let's maybe
- 01:37:44 call this armed game results and they
- 01:37:48 should be simply an empty list so with
- 01:37:50 these square brackets right here and
- 01:37:51 well this empty list won't help us a lot
- 01:37:54 but if you now scroll down again right
- 01:37:56 here
- 01:37:59 to our well game ending condition as I
- 01:38:02 was referring to him then actually this
- 01:38:05 round result variable is everything we
- 01:38:07 need right here we have this round
- 01:38:09 result variable which contains the
- 01:38:11 dictionary I was referring to so if we
- 01:38:13 could just add this dictionary to our
- 01:38:16 list we are done already and this can be
- 01:38:19 done with a default method available for
- 01:38:21 lists so let's get rid of our print
- 01:38:23 statement right here and let's now refer
- 01:38:25 to our list so we call it game results
- 01:38:27 and now we use a special method by
- 01:38:30 adding a dots this shows us all the
- 01:38:32 methods or functions available for lists
- 01:38:35 and the method I'm referring to right
- 01:38:37 here is the one on top
- 01:38:38 it is append because it simply allows us
- 01:38:41 to append an item to an existing list
- 01:38:43 and what do we want to append right here
- 01:38:46 well we want to append our round results
- 01:38:49 of course like that not round results
- 01:38:52 the round result sorry for that like
- 01:38:54 this and we can of course also use this
- 01:38:57 right here for our monster one case like
- 01:38:59 that so with that we should be able to
- 01:39:03 store the result of a round in our list
- 01:39:06 then to start a new round with a
- 01:39:08 different player name for example and as
- 01:39:11 soon as this round ends we should also
- 01:39:13 be able to add this result now so this
- 01:39:15 new dictionary as the next list item to
- 01:39:18 our list just to be sure we understand
- 01:39:20 the code so let's have a look we start
- 01:39:23 with this empty list right here as soon
- 01:39:25 as we run our app – file then we start
- 01:39:28 our game with our while loop right here
- 01:39:29 and then we start our round
- 01:39:33 we go through all our rounds so just as
- 01:39:37 we did it before we know the code and as
- 01:39:39 soon as either the player or the monster
- 01:39:41 win the game we append the dictionary
- 01:39:44 with the player results so in this case
- 01:39:46 this dictionary or the dictionary down
- 01:39:48 here to this existing empty list
- 01:39:50 if this round was ended then we go back
- 01:39:53 to our game while loop so this one right
- 01:39:56 here but we don't declare this variable
- 01:39:59 once again because we declared the game
- 01:40:02 results right here outside of our while
- 01:40:03 loops this means we use our current
- 01:40:06 lists of the game results list
- 01:40:08 containing one item for the next round
- 01:40:10 then the code starts again as soon as
- 01:40:12 the round ends we add the new result to
- 01:40:14 this list and so on what will not work
- 01:40:17 here is if we really end the game so if
- 01:40:20 we use our exit game option right here
- 01:40:21 then our list will not be stored so if
- 01:40:24 you run the game once again then the
- 01:40:26 result will be gone we could also change
- 01:40:28 that by saving the result to a file but
- 01:40:32 this is something we won't have a look
- 01:40:33 at in this tutorial so let's see if this
- 01:40:36 logic I was referring to is working now
- 01:40:38 before we do that though we have to make
- 01:40:40 sure we arm print our result also so
- 01:40:44 let's print our game results right here
- 01:40:49 and right there otherwise well we can't
- 01:40:52 see a lot listen like that
- 01:40:54 so let's now run the game let's enter a
- 01:40:57 name for the player let's attack he'll
- 01:41:00 he'll attack attack he'll so I'll play
- 01:41:02 around a bit
- 01:41:03 that looks good maybe we win this time
- 01:41:05 yeah we can see that menu on the game we
- 01:41:08 can see the health and the rounds let's
- 01:41:10 now add another player maybe Tony and
- 01:41:13 let's attack attack attack attack attack
- 01:41:15 yeah and now we can see that we added
- 01:41:18 the second dictionary also to our list
- 01:41:21 so this is the second stat and we can
- 01:41:23 also do this with another player let's
- 01:41:26 say Sam quickly played a game and we can
- 01:41:29 see Sam is also added right here to our
- 01:41:32 list as you can see we have free list
- 01:41:34 items and each list item right here is a
- 01:41:38 dictionary so dictionary one or item one
- 01:41:40 with the first dictionary item two with
- 01:41:42 the second one and item free with the
- 01:41:44 third dictionary and this is working
- 01:41:47 nice
- 01:41:47 but I'm not happy with two things now
- 01:41:50 the first thing is that the result is
- 01:41:53 printed automatically right here I think
- 01:41:56 it would be better if the results or the
- 01:41:58 printing of the results would be another
- 01:42:01 option so another player choice so we
- 01:42:03 could have a fourth player choice
- 01:42:05 something like right here print for our
- 01:42:10 show results something like that and in
- 01:42:17 addition to that I don't want to show
- 01:42:19 the results like this so inside this
- 01:42:21 list and also one after another I would
- 01:42:24 like to have them below each other so we
- 01:42:26 have the first dictionary right here
- 01:42:27 then in the second line we have the
- 01:42:29 second pictionary and so on so let's
- 01:42:33 first implement this fourth choice now
- 01:42:35 and lets them work on the way the
- 01:42:37 information is displayed now as we know
- 01:42:39 the logic already we know what we have
- 01:42:41 to do right here we have to create
- 01:42:43 another Elif statement right here there
- 01:42:46 the player choice is for well what
- 01:42:49 should happen then well basically we
- 01:42:52 only want to print our game results so
- 01:42:54 we can delete this print statement right
- 01:42:57 here from our player one and maybe cut
- 01:43:00 this one from our monster and now simply
- 01:43:02 add this right here as the fourth choice
- 01:43:04 like that
- 01:43:05 that's it already so let's exit the game
- 01:43:08 and it started its player name if you
- 01:43:13 know it for we should see nothing let's
- 01:43:16 grab a bit yeah
- 01:43:17 here is our empty list so this is
- 01:43:18 working fine let's now attack and see
- 01:43:21 what is happening then yeah now we see
- 01:43:24 max won the game now we have to enter
- 01:43:26 the player name for the next round so
- 01:43:27 let's say Tony wants to start and Tony
- 01:43:30 wants to see what the results from the
- 01:43:32 previous players were so we can hit for
- 01:43:34 now two shorter results and if we scroll
- 01:43:37 up yeah we can see that the result of
- 01:43:39 the last round is printed right here so
- 01:43:41 this is working fine this was the first
- 01:43:43 step the second step now is to well
- 01:43:46 change the way the results are shown as
- 01:43:48 I said I would like to show the results
- 01:43:50 not inside the list but dictionary by
- 01:43:52 dictionary line-by-line for that we need
- 01:43:56 to have a look at the third control
- 01:43:57 structure that is really important in –
- 01:44:00 we had a look at
- 01:44:02 if statements already we had a look at
- 01:44:04 while loops which basically could
- 01:44:05 basically control our entire application
- 01:44:07 and now we have a look at for loops a
- 01:44:11 for loop basically allows us to iterate
- 01:44:14 well over a sequence a sequence is
- 01:44:17 something like well a list or a
- 01:44:19 dictionary in our case and to give back
- 01:44:22 a result for each of these iterations
- 01:44:24 now this sounds totally abstract of
- 01:44:26 course therefore I would like to
- 01:44:28 implement the for loop now step by step
- 01:44:30 then see how it works and then also
- 01:44:33 compare it to the while loop we created
- 01:44:34 so far now where do we create such a for
- 01:44:37 loop well right here in our fourth
- 01:44:39 choice because what do I want to achieve
- 01:44:41 right here as I said I would like to
- 01:44:44 have the look at the content of our
- 01:44:46 lists of our game results list right
- 01:44:49 here and then I would like to basically
- 01:44:52 print or display each single item off
- 01:44:55 this list separately so if we have three
- 01:44:58 items inside our list I don't want to
- 01:45:00 print the entire list
- 01:45:02 I would like to go for the first item
- 01:45:04 print that I would like to go to the
- 01:45:06 second item print it and then I would
- 01:45:08 like to go to the third item print it
- 01:45:10 and so on this is what I meant with
- 01:45:12 iterating over a sequence over a list in
- 01:45:15 that case so basically what I want to
- 01:45:17 tell Python is have a look at this list
- 01:45:19 iterate through each item this list
- 01:45:22 contains and printed separately that's
- 01:45:25 what I would like to achieve right here
- 01:45:26 and for that we can use the for loop I
- 01:45:29 was referring to you the for loop is
- 01:45:31 written like this we add four and now we
- 01:45:34 can add a name of your choice because
- 01:45:36 what you're now saying Python is
- 01:45:38 basically for each item inside a list do
- 01:45:42 something and for each item you can
- 01:45:45 specify a name of your choice so for
- 01:45:47 example you could say for item in game
- 01:45:53 results like that so you say for each
- 01:45:56 item you find in the game results list
- 01:45:58 please do something at the moment we
- 01:46:01 will just delete that and say we don't
- 01:46:02 do anything we just pass right here
- 01:46:06 important item doesn't have to be named
- 01:46:09 item right here you could also name this
- 01:46:10 for score in game results
- 01:46:15 or player stat in game results whatever
- 01:46:20 this is simply what you name each single
- 01:46:23 list item in your list so your can name
- 01:46:25 this as you prefer the important thing
- 01:46:27 here is that you say that for each item
- 01:46:30 in this is also important you have to
- 01:46:32 put this right here in the list in our
- 01:46:34 case so in this game results variable
- 01:46:36 please do something what you could do
- 01:46:39 now is for example you can simply say
- 01:46:41 that for each item you find inside our
- 01:46:44 list please print and now important this
- 01:46:47 item here the naming is important you
- 01:46:49 have to name this right here equal to
- 01:46:53 the name you gave to each item inside
- 01:46:55 your list just repeat that what you're
- 01:46:57 not doing right here is we say please go
- 01:46:59 for the list so the list saved in our
- 01:47:02 game results variable right here and for
- 01:47:04 each item which we named players that
- 01:47:07 right here in this for loop please print
- 01:47:09 me the corresponding item now let's see
- 01:47:11 if this works now so we can clear this
- 01:47:14 now we can run the code once again and a
- 01:47:17 name menu attack attack attack attack
- 01:47:20 attack as always then we add Tony as the
- 01:47:23 second player we also attack all the
- 01:47:25 time
- 01:47:25 maybe he'll it once or twice like that
- 01:47:27 and now we enter a third player maybe
- 01:47:31 Sam once again and now we show the
- 01:47:33 results if we scroll up a bit you can
- 01:47:36 see that now we have two changes
- 01:47:39 compared to the previous print statement
- 01:47:41 we had without the for loop the first
- 01:47:43 thing is that the items are no longer
- 01:47:46 stored in a list before we had the
- 01:47:48 square brackets around the dictionaries
- 01:47:50 because well the dictionaries purchased
- 01:47:52 single list items additionally we also
- 01:47:55 print the items line by line now because
- 01:47:58 these are now single dictionaries
- 01:48:00 because we simply access the
- 01:48:02 dictionaries inside our lists what
- 01:48:04 basically took them out of the list
- 01:48:06 right here and printed them line by line
- 01:48:08 so players dead right here so for
- 01:48:11 players that is simply this dictionary
- 01:48:13 right here and that dictionary right
- 01:48:15 there so that's the for loop and what's
- 01:48:19 the difference now to the while loop
- 01:48:20 that we previously made well here we
- 01:48:22 iterate over the items inside our list
- 01:48:25 as soon as the race is over
- 01:48:26 well the for loop
- 01:48:28 ends our Y loop simply keeps running as
- 01:48:31 long as a certain condition is true so
- 01:48:34 if we never change the new round to
- 01:48:36 false the new round will continue
- 01:48:38 infinitely so we will never finish or
- 01:48:41 exit this while loop this continues
- 01:48:43 forever basically until the condition
- 01:48:45 you define right here ends for the for
- 01:48:47 loop this is different because the for
- 01:48:49 loop will simply end as soon as the
- 01:48:51 iteration already lists items in our
- 01:48:53 case ends so as soon as the for loop
- 01:48:55 looped through all the items well the
- 01:48:57 for loop automatically ends in our case
- 01:48:59 so that's basically difference if you
- 01:49:01 want to iterate few items use a for loop
- 01:49:03 if you want to keep executing a code
- 01:49:06 until a certain condition is no longer
- 01:49:07 true then use a while loop so with that
- 01:49:11 we are actually done with our game right
- 01:49:12 here but now it's the time to have a
- 01:49:15 look at our code once again and see if
- 01:49:17 we have some issues or if we can improve
- 01:49:19 some things here specifically I want to
- 01:49:21 work on one little problem you could say
- 01:49:24 that we have right here I showed you
- 01:49:26 that earlier in the video when I called
- 01:49:29 the calculate monster attack function
- 01:49:31 right here before we actually declare
- 01:49:33 the monster variable if you remember
- 01:49:36 back what we learned about parameters
- 01:49:37 and arguments then this is exactly what
- 01:49:39 can be helpful here not what they mean
- 01:49:41 by that why don't we just say that we
- 01:49:43 add two parameters right here to our
- 01:49:46 calculate monster attack function for
- 01:49:48 example attack min as the first
- 01:49:50 parameter and attack max as the second
- 01:49:53 parameter now we can copy them and paste
- 01:49:55 them right here to our rent in function
- 01:49:58 to be able to use them and now we only
- 01:50:00 have to go down to our calculate monster
- 01:50:05 attack function so these two functions
- 01:50:07 right here and we can see the error
- 01:50:09 already we didn't add any arguments to
- 01:50:12 the function we can change that quickly
- 01:50:14 because the first argument should be the
- 01:50:16 monster attack min right so referring to
- 01:50:20 our monster variable and the second one
- 01:50:24 would be monster attack next like that
- 01:50:30 let's quickly
- 01:50:33 copy these down here to the second
- 01:50:36 monster attack so this is working now so
- 01:50:39 we shouldn't have an issue but now if I
- 01:50:43 again want to print our function before
- 01:50:48 we declare the monster variable so
- 01:50:51 calculate monster attack right here then
- 01:50:56 we can add monster attack min and
- 01:51:01 monster attack next once again so if we
- 01:51:09 save that we get an error now right here
- 01:51:12 because as you can see we are using our
- 01:51:15 variable monster before we are actually
- 01:51:17 assigning it this means if I cut the
- 01:51:20 print statement now and put it below our
- 01:51:23 variable we can see this error is gone
- 01:51:26 and with that we improved our code a lot
- 01:51:28 because now we can immediately see that
- 01:51:31 if we want to call the function to
- 01:51:33 earlier well that we get this error and
- 01:51:35 that we first have to declare the
- 01:51:36 variable so with that this approach
- 01:51:38 right here is the one to prefer because
- 01:51:41 it makes sure that our code runs
- 01:51:42 correctly and it helps us avoiding
- 01:51:44 errors like that let's delete the print
- 01:51:46 statement though and let's also get rid
- 01:51:49 of that empty line and let's now finally
- 01:51:52 see if it's the wroking so we run the
- 01:51:53 game and for a name tag he'll maybe
- 01:51:58 crease it up a bit right here attack yep
- 01:52:01 this is working let's say Tony wants to
- 01:52:03 play again play yeah this works also
- 01:52:08 let's not say Sam wants to see the
- 01:52:11 results
- 01:52:14 yep this works fine and now we want to
- 01:52:16 exit the game so with that we refactor
- 01:52:19 our app and also finished our app for
- 01:52:22 this video I hope you got a good
- 01:52:25 understanding now of the core basics of
- 01:52:28 Python and especially how you can apply
- 01:52:30 them in practice because learning to
- 01:52:32 code in theory is nice but I think
- 01:52:35 applying the knowledge and learning it
- 01:52:37 by really practicing it in a practical
- 01:52:39 project like this is a lot more helpful
- 01:52:41 at least in my opinion so with that I
- 01:52:43 wish you all the best for your Pyfrom
- 01:52:45 projects dive deeper into Python it's an
- 01:52:48 awesome language it's a lot of fun to
- 01:52:50 work with and also make sure to have a
- 01:52:52 look at academy.com
- 01:52:53 there you can also find more Python
- 01:52:55 content and also a lot more content
- 01:52:58 mainly related to programming and web
- 01:53:00 development and with that well thanks a
- 01:53:02 lot for watching and bye