Python Jumpstart by Building 10 Apps Transcripts
Chapter: App 7: Wizard Battle App
Lecture: Exploring specialized (derived) classes

Login or purchase this course to watch this video and the rest of the course contents.
0:00 So we basically have a working game here, I guess one final thing to consider is what happens if there are no more creatures,
0:08 so we can come down here and add one more part after this section here and say if not creatures
0:15 and we'll leverage the implicit truthiness of collections, this is a list of creatures, if it's empty, it'll be false.
0:22 So then we'll say print, something like you defeated all the creatures, and then we'll just exit, like so, let's just test that super quick,
0:32 I'm not sure we'll be able to defeat the evil wizard of 1000 so let's just there is a theoretical chance but- it's not so high,
0:41 so let's go over here and just comment out the wizard for just a minute, so here we can attack all the creatures,
0:48 how many are left- oh, it looks like we defeated all the creatures, well done, game over, perfect.
0:53 So our game is working, but it's kind of blunt and basically the only factor we have to consider here in the entire game play is that number,
1:04 what is the level of our creature and what is the level of our wizard and then its randomness.
1:11 Do you feel like a fighting a toad should be equivalent of fighting the dragon
1:14 or fighting evil wizard should be the same as fighting a standard like bat, probably not, not only do they have different ways to fight
1:23 but the properties that you would take into consideration around how they would fight would be different,
1:30 maybe a toad's worthiness would have some sort of factor there and if a dragon had scales maybe you would consider like how thick his scales were
1:39 or if he was a fire breathing dragon or something like this. But if we just use our creature class let's go over to that
1:46 if we just use our creature class here, it doesn't model scales or worthiness or whether it breaths fire,
1:53 it simply is the most common denominator thing that models all creatures, right, they have names and levels.
2:01 And that's exactly what we want we want to have this sort of commonality so regardless the type of creature we are fighting, we can just use that, ok.
2:10 So let's add 1 more feature that will give us a little flexibility to this creature class and then we are going to look at
2:16 how we create other classes based off of creature and use inheritance and polymorphism in that kind of thing.
2:23 Let's add a method say def and we'll say get_defensive_roll() or something like that. Now up here we just had the creature do the roll directly here
2:38 but rather than do this let's comment this out, and let's say we'll go to the creature and we'll say get_defensive_roll(),
2:46 and it's up to the creature to take all of its attributes into account, if it's a dragon, let's think about its scaliness,
2:52 if it's a toad, it's worthiness or whatever, right, we can make our game behave exactly the same
2:59 if we just use sort of the same algorithm, we randomly compute our 1 to 12 number,
3:05 that's throwing a 12 sided dice and then we are going to multiply that by the level, and that's what the base creature does,
3:12 but maybe we'll do something different for a dragon, if we can invent this idea of a dragon and so on.
3:17 So let's just make sure we can still play the game, so we are going to look around and we see a level 1 toad so let's attack it, excellent,
3:25 toad rolls 2 let's look around again, now we see the evil wizard let's attack it just to see that it's throwing something high,
3:34 oh we've been defeated, it rolled 5000, of course we've been defeated. So now let's go back and think about our creatures here.
3:44 We want to categorize these different things, these different fighters into more specialized versions of creatures,
3:53 so maybe a toad and a bat maybe we would actually want to call these like small animals here, so let me just sort of sketch this out,
4:02 so maybe these would be something like small animals, and small animals let's see, small animals would have the same properties as the creatures
4:10 but maybe they would have some diminished sort of throw to save or as the tiger, maybe this is a predator, dragon maybe this would be a dragon
4:21 and maybe to the dragon we could say scaliness = 20 or whatever a scaliness factor is right and that might be considered when the dragon is fighting,
4:32 if it has more scales it's even harder to beat and then similarly maybe the wizard maybe it has some type of magic
4:38 and it somehow takes that into account as well, right, so maybe we put a wizard here, this isn't going to turn out really well for us, so far,
4:47 first of all we don't have small animals, right, these are not a thing we are modelling, and we don't have a dragon,
4:56 let me just comment those out for a minute, we do have a wizard,
5:00 now if I try to run this it's probably not going to work so well, a wizard has appeared,
5:04 let's attack it; oh bam, the wizard doesn't have this concept of a defensive roll, Hum? all the creatures in our game are supposed
5:15 to sort of have this commonality of everything that is a creature and then some specialization in them.
5:21 So let's take a moment and look at this core concept called inheritance that allows us
5:26 to sort of layer on this specialization and share attributes and behavior across these different types of creatures in our game
5:33 and then we'll come back and add it to our classes.

Talk Python's Mastodon Michael Kennedy's Mastodon