transcript for app 7

Author: redeemefy

transcripts/txt/07_app/1.txt

@@ -5,12 +5,12 @@
 0:12 Well, it's going to be a text based game 
 0:14 and here you can see a standard ground of game play. 
 0:16 Of course, like all of our apps we start with a little header that says what the app is, 
-0:19 and then right off we have our hero in the game, the wizard Gandolf. 
-0:23 And he sees an Evil Wizard,
-0:25 it turn out that one is super strong 
-0:27 and so he is like I am not going to battle this, he could attack it, 
-0:30 he could look around, but he is just going to run away as quick as he can, 
-0:33 so he does, and then next he finds a Bat, and decides 
+0:19 and then right off bat we have our hero in the game, the wizard Gandolf. 
+0:23 And he sees an Evil Wizard.
+0:25 It turn out that one is super strong 
+0:27 and so he is like... I am not going to battle this, he could attack it, 
+0:30 he could look around, but he is just going to run away as quick as he can. 
+0:33 So he does, and then next he finds a Bat, and decides 
 0:37 hey, I can probably attack and kill this Bat, so he does, 
 0:40 but just barely he roles a 22, the bat roles at 22 
 0:44 and I guess because the element of surprise 
@@ -37,16 +37,16 @@
 1:39 we have to chain those initializers through the inheritance tree, 
 1:41 so we are going to talk about initializer chaining. 
 1:44 Speaking of inheritance, that lets us model our concepts
-1:47 in our program with different levels of specialization, 
-1:51 so we can model all of the actors, the dragon, the toad, the wizard 
+1:47 in our program with different levels of specialization. 
+1:51 So we can model all of the actors, the dragon, the toad, the wizard 
 1:55 as something maybe we'll call the creature in the game 
 1:58 and then we have a specialized version of the creature 
 2:00 that has other data and other features called the wizard 
 2:03 and it knows how to battle creatures 
 2:05 and then we can also have different types of creatures 
 2:07 that may themselves have special features 
-2:09 like a dragon that has a special attack or something like that,
-2:12 so this is called inheritance and it's a very powerful feature, when use judiciously. 
+2:09 like a dragon that has a special attack or something like that.
+2:12 So this is called inheritance and it's a very powerful feature, when use judiciously. 
 2:16 When we talk about inheritance, 
 2:18 we are also going to talk about polymorphism and duck typing. 
 2:21 Some languages have very strict rules 
@@ -57,5 +57,4 @@
 2:34 Python doesn't have compiling or this concept of strong typing
 2:37 instead we are going to use something called duck typing
 2:40 we'll talk about that near the end of our app.
-2:43 Let's get onto build a super fun dungeons and dragon style wizard game. 
-
+2:43 Let's get onto build a super fun dungeons and dragon style wizard game.

transcripts/txt/07_app/10.txt

@@ -2,7 +2,7 @@
 0:02 we kind of would like to use the wizard specialization, 
 0:06 the wizard class as any other fighter in our game. 
 0:10 And the commonality that we need for any kind of fighter
-0:13 is of course that it is a creature.
+0:13 is of course that it is a creature, right?.
 0:18 And we just saw that we can use inheritance up here like so 
 0:22 and say this wizard is a creature. 
 0:25 Now, this is little annoying, 
@@ -21,7 +21,7 @@
 1:03 one way we could just say we are going to have this init method here 
 1:08 and we could say super and this will give us access to 
 1:11 the direct methods on creature, 
-1:14 we could say dunder init and we can say name and level, 
+1:14 we could say __init__() and we can say name and level, 
 1:18 and now the warning will go away, right, 
 1:20 and we are actually passing this off, 
 1:22 so when you call this method, by creating a wizard 
@@ -69,15 +69,15 @@
 3:54 We could use that for something, but we don't really in this game. 
 3:57 I guess the thing we can do to make this small animals special is 
 4:00 maybe it's a little extra weak, so down here we can change this get defensive roll, 
-4:06 in the creature class, it has a get defensive roll and it just does this, 
+4:06 in the creature class, it has a get_defensive_roll() and it just does this, 
 4:10 let me copy the whole thing, and we can actually change how this works ok,
 4:16 so we can come over here and say the small animal has 
 4:19 all the behaviors and everything from the creature 
-4:21 except it's going to have its own version of get defensive roll. 
+4:21 except it's going to have its own version of get _defensive_roll(). 
 4:24 Now, some programming languages when you are doing inheritance 
 4:28 you have to have special words like override or virtual or these sorts of things, 
 4:31 Python doesn't have that, we just have one method 
-4:35 it's called get defensive roll, 
+4:35 it's called get_defensive_roll(), 
 4:36 if we just say it in the other classes something replaces it. 
 4:39 If we leave it this way, things should just still work again
 4:42 other than the wizard is not what we are looking for, but the bat is, perfect.
@@ -91,9 +91,9 @@
 5:14 so I got 6 so then we cut that down to 3.0. 
 5:17 So now we specialize our small creature to be 
 5:20 a little easier to defeat than the others, well quite a bit really. 
-5:23 However, this part of code, is literally this base get defensive roll. 
+5:23 However, this part of code, is literally this base get_defensive_roll(). 
 5:32 Ok, so we can actually change this, we can say you know what, 
-5:36 it could be the super, go to the creature class and we can call it it get defensive roll, 
+5:36 it could be the super, go to the creature class and we can call it it ge_ defensive_roll(), 
 5:40 and that way as this evolves over time 
 5:43 maybe we decide to switch to a 15 sided dice or something like that 
 5:48 we don't have to maintain the small animal, 
@@ -115,13 +115,13 @@
 6:46 basically the setup in the data that the wizard and the small animal use
 6:52 is the same as the creature, but the dragon, I am going to change this,
 6:54 I want the dragon to have a scaliness and an indicator whether it breaths fire or not. 
-7:00 So what we are going to do is we are going to define a dunder init
+7:00 So what we are going to do is we are going to define a __init__()
 7:03 and it's going to have to take all the data 
 7:06 or at least somehow supply the data that the creature is going to need, 
-7:10 so name and level, and then I am going to have a scaliness and a breaths fire, 
+7:10 so name and level, and then I am going to have a scaliness and a breaths_fire, 
 7:16 this will be a boolean to say it does or does not breath fire. 
 7:19 and then the first thing that we should do is 
-7:21 we should set up the creature feature so we'll say super.dunder init, 
+7:21 we should set up the creature feature so we'll say super.__init__(), 
 7:27 name and level, and then we need to assign to the dragon 
 7:32 whether or not his scaliness and whether or not it breaths fire. 
 7:35 So we can just say add this parameter here 
@@ -139,27 +139,27 @@
 8:15 maybe we'll have a factor of 5 or something, 
 8:18 I mean that's a pretty serious defensive measure that it literally can breath fire. 
 8:22 I could write this, let me say none and I'll say 
-8:26 if self.breaths fire, the fire modifier = 5 maybe this could just be 1 
+8:26 if self.breaths_fire, the fire_modifier = 5 maybe this could just be 1 
 8:36 but let me put it this way just an else statement, 
-8:38 so it's a little more clear, so else fire modifier = 1, 
+8:38 so it's a little more clear, so else fire_modifier = 1, 
 8:43 now this bit right here, we are using all these lines of code to do this,
 8:46 we could actually write this in a much nicer way, 
-8:49 we'll say fire modifier = and I can put this 
+8:49 we'll say fire_modifier = and I can put this 
 8:53 all in one line in this condensed if statement the Python supports, 
 8:56 let me just sketch out the placeholder 
 8:59 so value if true say if some test else value if false, right, 
 9:08 so if we use this the value if- let's do the test first, 
-9:11 so the test is going to be if breaths fire, self breaths fire, 
+9:11 so the test is going to be if breaths_fire, self breaths_fire, 
 9:18 so if it does breath fire, I would like the modifier to be 5, 
-9:21 but if it does not breath fire, I would like the modifier to be 1,
+9:21 but if it does not breath_fire, I would like the modifier to be 1,
 9:25 ok, so let me put this like so,
 9:27 so now this will actually let us in one nice little condensed line, 
 9:31 specify the fire modifier, the other thing is the scaliness factor, 
 9:36 let's say this i s a number between 1 and 100, 
 9:40 and it has like a 10% effect on here, so we'll have something like this, 
-9:44 scale, modifier = scaliness self.scaliness, divided by 10, right, 
+9:44 scale_modifier = scaliness self.scaliness, divided by 10, right, 
 9:55 so if it's a 100 it multiply it by 10, if it 1 it actually takes it down a little bit, 
-9:59 so then we are going to return base roll times fire modifier times scale modifier. 
+9:59 so then we are going to return base_roll times fire_modifier times scale_modifier. 
 10:07 Ok, now let's go back to our program here 
 10:10 and let me just put this back for a minute, 
 10:13 that's how it was before we started to talk about these dragons, 
@@ -168,11 +168,11 @@
 10:21 that's because I again forgot to import it, 
 10:24 it's kind of why I like the name spaces you don't have to keep doing this, 
 10:26 but it's all good. 
-10:29 So now we have our dragon, but notice PyCharm is already telling us not so good, 
+10:29 So now we have our dragon, but notice PyCharm is already telling us hummm? not so good, 
 10:32 but it won't run it will say you are missing
-10:34 this parameter of scaliness and breaths fire right there, 
+10:34 this parameter of scaliness and breaths_fire right there, 
 10:37 so let's say that this dragon has a scaliness of 50, no let's say 75, 
-10:45 that's a pretty serious scaliness and it does breath fire, 
+10:45 that's a pretty serious scaliness and it does breath_fire, 
 10:49 so this dragon is now a much harder thing to fight, all right,
 10:52 so let's look around, so we see- let's run away
 10:58 until we see something that is a dragon. 
@@ -194,8 +194,8 @@
 11:59 it takes all that into account during this battle 
 12:02 but the wizard doesn't have to know it's a dragon, it can still treat it like a creature. 
 12:07 And yet it behaves differently, finally the wizard can also behave 
-12:11 like just another creature in the game because it derives from creature, 
-12:15 we do this derivation by just defining the creature class 
+12:11 like just another creature in the game because it derives from creature. 
+12:15 We do this derivation by just defining the creature class 
 12:18 and then we say the wizard is a creature, here we have an additional method 
 12:23 that's not in the creature class called attack, 
 12:26 PyCharm we can collapse those, and then the small animal 
@@ -210,5 +210,4 @@
 12:55 like the scale modifier which apparently I misspelled. 
 13:00 So this just gives you a little taste of object oriented programming 
 13:03 but the types of applications that you can build are seriously powerful 
-13:06 and it's a lot of fun to think about solving problems this way. 
-
+13:06 and it's a lot of fun to think about solving problems this way.

transcripts/txt/07_app/11.txt

@@ -1,7 +1,7 @@
 
0:00 Let's look at the final core concept 
 0:02 in this object oriented wizard game called polymorphism. 
 0:06 Now you can see that we have a list of diverse creatures,
-0:09  we have small animals, creatures, dragons, wizards and so on, 
+0:09 we have small animals, creatures, dragons, wizards and so on, 
 0:13 and as you saw on a previous examples 
 0:15 and you can see in the note on the left here, 
 0:17 all of these objects all of these classes, small animal, dragon and wizard, 
@@ -21,23 +21,23 @@
 1:03 and that's fantastic, that lets us as we evolve our application 
 1:07 create more specialization other types of objects, 
 1:10 later in the game we want to add some kind of like water monster
-1:13  to attack the wizard when he is out in the ocean or something 
+1:13 to attack the wizard when he is out in the ocean or something 
 1:17 as long as that thing derives from creature, 
 1:20 we potentially don't have to rewrite the code 
 1:22 that handles wizard's battling water monsters
 1:25 it's just using this base class. 
-1:27 So that's a really powerful feature, 
-1:29 one other concept closely related to this is something called duck typing, 
-1:32 in statically typed compiled languages like CSharp, Java, C++ and so on, 
+1:27 So that's a really powerful feature. 
+1:29 One other concept closely related to this is something called duck typing, 
+1:32 in statically typed compiled languages like C#, Java, C++ and so on, 
 1:38 you absolutely must have these objects derived from creature 
 1:43 or trying to pass them to the attack method 
-1:46 which assumes it takes a creature literally not compile. 
+1:46 which assumes it takes a creature or literally not compile, your code won't run ever. 
 1:49 In Python it's not like that, Python uses something called duck typing 
 1:55 and as long as the shape of the pieces of the creature class
-1:59  that the attack method assumes are there, get defensive roll, name,
-2:04  as long as the types you pass match that, 
+1:59 that the attack method assumes are there, get defensive roll, name,
+2:04 as long as the types you pass match that, 
 2:07 you technically can use it here, and that is called duck typing, 
 2:09 it's like if it acts like a creature, if it looks like a creature, it is a creature, 
 2:13 but I still encourage you to create these object hierarchies 
 2:16 as it helps reduce code duplication, it helps with maintenance 
-2:18 and it's generally just the right thing to do. 
+2:18 and it's generally just the right thing to do.

transcripts/txt/07_app/2.txt

@@ -3,16 +3,15 @@
 0:07 or probably refine it and add some enhancements, 
 0:09 but let's just get started in kind of the same way we have with other apps. 
 0:14 So, again, we are going to add our program.py file 
-0:18 and we are going to have our main method, we'll have our print header, as always
-0:26 and in this one we are going to have what we are going to call a game loop. 
-0:30 And then in our main let's just go and say print header 
-0:32 and then we'll just run the game loop. 
-0:35 And finally, let's use our PyCharm live template to call the main
+0:18 and we are going to have our main() method, we'll have our print_header(), as always
+0:26 and in this one we are going to have what we are going to call a game_loop(). 
+0:30 And then in our main let's just go and say print_header() 
+0:32 and then we'll just run the game_loop(). 
+0:35 And finally, let's use our PyCharm live template to call the main()
 0:41 only if it's actually being executed rather than imported. 
 0:45 So header is pretty standard as always so let's just do this, 
-0:48 
-0:55 ok, standard header now let's focus in on this game loop we have here. 
-1:00 So the concept of our game loop is we just want to go around and around 
+0:55 ok, standard header now let's focus in on this game_loop() we have here. 
+1:00 So the concept of our game_loop() is we just want to go around and around 
 1:03 getting input from the user until the game ends
 1:07 so let's just start really simple with the concept of going around and around, 
 1:11 and so we'll just say while true and we are going to do some work here. 
@@ -25,15 +24,14 @@
 1:38 one could be they actually said they want to attack 
 1:41 and let's just print out some things we can kind of test a little loop here, 
 1:45 then we'll rewrite the behaviors. 
-1:47 So if they say a we'll say attack, elif if it's run away we'll just print run away,
-1:54 
-1:59 if they are going to look around we are going to print look around, and finally, 
+1:47 So if they say a we'll say attack, elif if it's run away we'll just print('run away'),
+1:59 if they are going to look around we are going to print('look around'), and finally, 
 2:04 if they hit something else and we don't know what it is we'll just say
 2:07 all right, you must want to exit the game, 
 2:09 like if we just hit enter with no command that means you are gone, 
 2:12 so we'll just say something like this, ok, exiting game. Bye. 
 2:17 So, let's go ahead and run our app just to make sure everything is hanging together. 
-2:22 
+2:22 Now, no run configuration, so we kow how to get that going.
 2:26 All right, so down here we can attack, we can look around, 
 2:30 we can run away, or we can say enter and we should exit. 
 2:33 Now, oops, we didn't really exit we just printed exit, right, 
@@ -43,5 +41,4 @@
 2:46 run the next line which is empty and we're done. 
 2:47 So look around, enter, exit, perfect. 
 2:51 So our little loop is running, it's time to build up the data structures
-2:55 with classes and objects it's going to be great. 
-
+2:55 with classes and objects it's going to be great.