#100DaysOfCode in Python Transcripts
Chapter: Days 13-15: Text-based games (and classes)
Lecture: Demo: Building our classes
Login or
purchase this course
to watch this video and the rest of the course contents.
0:00
Okay, so here's our general program.
0:02
Let's put that aside for a minute,
0:03
and go work on the various creatures that we're going to model.
0:06
And I'll call this actors to kind of say,
0:08
here's where I'm going to put a creature,
0:09
the wizard, and so on.
0:11
So what we need to do is create what we talked about,
0:13
something called a class,
0:14
and this is going to be the blueprint of a creature.
0:17
So, the way you create a class in Python
0:19
is really straightforward. You say class, and then you say the name of it.
0:23
Okay, we're going to model everything at the lowest level
0:26
as a creature, and use a colon to define the block
0:29
that is the class, like you do
0:31
all the various blocks in Python.
0:33
Now, there's a couple of things which we can do
0:36
to get started, but, commonly, you want to store
0:39
pieces of data and behaviors with the creature.
0:42
So, for the data part we're going to use
0:44
what's called an initializer.
0:45
So we'll say def init, and there's this dunder init,
0:48
in fact if I say double underscore,
0:51
these methods are called dunder because it's
0:52
double underscores on both ends.
0:55
These are all part of what makes up classes,
0:58
and they all have special meaning.
0:59
The one that we care about is this init.
1:01
This is very common.
1:03
So down here, we might want to have a name for it.
1:06
Equals, let's call it, toad, and it might have a level.
1:10
And the level of the toad is 1, or something like that.
1:13
Now, this is not really helpful
1:15
because every creature is going to be a toad of level one.
1:19
So what we can do is, we can when we create them say,
1:21
this particular creature is a tiger,
1:23
this creature is a bat, and so on,
1:25
and so we could pass in the name here,
1:27
and we could pass in the level.
1:29
So we're going to go like this.
1:31
So, here we've defined this blueprint.
1:32
What is a creature?
1:33
A creature is anything that can be created
1:36
and given explicitly a name and a level.
1:38
We could go farther and give those types,
1:40
as you can in Python 3,
1:42
but we're not going to do that right now.
1:44
The other thing, this is the data part we have so far,
1:47
the other thing is going to be some kind of
1:51
behaviors around it.
1:52
So, a creature, can, let's suppose that one creature
1:56
can be defensive against some kind of attack.
2:00
So we could say it like this.
2:02
So the creature's going to roll a defensive roll.
2:05
And now, you might want this to be
2:07
somewhat based on the creature's level.
2:10
So let's create some sort of randomness.
2:13
Let's say roll equals,
2:15
well I'll go over here and we'll say random.
2:16
Now this comes from the standard library
2:18
so we have to import it here, put like that at the top.
2:22
Then we can say randint(), and you give a lower bound,
2:26
of let's say 1 to 12, and if you want to know whether this
2:31
goes from 1 to 12, 1 to 11, and things like that,
2:34
we can say view quick documentation.
2:37
And what does it say?
2:39
It returns a number such that A,
2:41
the number that comes back is
2:42
less than or equal to the upper and lower bound.
2:45
Perfect. So this is our, let's say, 12-sided die.
2:48
And then we'll return roll times self.level.
2:52
Anytime you want to refer to your own items,
2:55
your own values, you have to say self dot.
2:58
So to get back to this, we say self.level.
3:02
Alright, so this is going to be some kind of defense here.
3:05
Now let's go and create our various creatures in the game.
3:09
There's this little to do here.
3:11
We had a couple of things, we had a bat, we had a toad,
3:14
we had a tiger, we had a wizard, an evil one, and so on.
3:18
So we'll type creature and of course
3:20
we have to import that at the top here, just like any type.
3:25
We go like this and if I ask Python to
3:28
show me the parameters, you'll see it takes a name.
3:30
So let's call this a bat, and this is a level 5 bat.
3:34
I think we had a toad which is a level 1.
3:38
And we had a tiger which was level 12, let's say.
3:41
And we had a dragon, which is a level 50.
3:46
And for now, I'm going to put it this way,
3:48
evil wizard was a 1000.
3:51
I think that's what it said.
3:53
Okay, so if we just run this and
3:56
we could print out our creatures,
3:59
we need to make sure that we're running the main.
4:02
Remember, up here, at the very top, we wrote this,
4:04
but at the bottom we have to do our little main.
4:07
Like this, to say are we running this script as a program?
4:10
Or are we just importing it?
4:12
If this is true, we're running it
4:13
as a program, then we want to invoke our main method.
4:16
So let's go over here and say run,
4:19
and there's some stuff that
4:20
went a little bit crazy somewhere along the way
4:23
because we didn't finish it.
4:25
But here, you'll see that we've created
4:27
a creature object here, and a
4:28
creature object there, and so on.
4:32
Our little creature part worked,
4:33
but then the code that we sort of commented out below,
4:36
isn't quite done.
4:38
So this is close, but remember I said
4:40
you might want to have special features.
4:42
So let's just focus on the dragon for a minute.
4:45
You might want to have special features that
4:46
take into account the scaliness, the fire-breathingness,
4:49
have a different mechanism for defense, and so on.
4:52
So let's say we're going to have a class called dragon.
4:55
And the dragon also is going to have a defensive roll,
4:58
like this, and maybe the dragon also
5:01
wants to have this information.
5:03
Woops, copy that.
5:05
So the dragon is going to go like this,
5:06
and then it's going to copy it,
5:07
and this seems really, really tedious.
5:10
It is and I'll fix it in just a second.
5:12
You'll see that we can model this differently.
5:14
But when we create a dragon, it will have this.
5:16
And let's also say that it has
5:18
a scaliness factor and breathes fire.
5:26
Alright, so we want to store these here, so I'll say,
5:31
"self dot", that equals that.
5:34
In fact, in PyCharm you can hit alt enter
5:36
and it will even write that whole bit for you
5:38
because it knows that this is what you should do.
5:40
But you probably see a lot of duplication here, and here.
5:44
And if I want to change something about this,
5:46
like add a feature to all creatures,
5:48
well I'll have to go in and add it everywhere, like this.
5:51
So, we'll be able to something a little bit better here
5:53
in just a second.
5:54
But let's go ahead and write this.
5:56
Let's take that and let's say
6:00
we're going to multiply that times the self.scaliness,
6:06
let's go that equals that.
6:07
We'll say if self.breathes_fire,
6:11
then value equals value times 2.
6:14
So it's even worse, stronger if it breathes fire.
6:18
Okay, great, so there's that.
6:20
Now, this is not really super helpful.
6:25
Any change we make over here, we would kind of like
6:29
to copy them over there, and really, we would like
6:31
to treat the dragon as just a specialization of a creature.
6:34
Remember, this is a relationship.
6:37
So we can model that by saying this dragon is a creature,
6:42
like this, alright?
6:44
And when we say that, what it lets us do is
6:47
actually take on all the attributes here.
6:50
Notice this is giving us a little warning,
6:52
it says, "you need to say super dot",
6:55
and in pass the name and the level.
6:57
And this basically says we're going to run
6:59
this bit of code, and we don't actually need
7:01
this stuff here, we're just going to store
7:04
let it pass on through, then we're just going to store
7:06
the things that are special about the dragon.
7:09
Similarly, this right here, we could say the role
7:12
is actually whatever the regular creature does.
7:20
And then we could say, okay we're going to do
7:21
that same thing, and we're going to factor in
7:24
the scaliness and the firebreathing, here.
7:28
You can see right here that PyCharm is saying that
7:30
you're actually getting this detail here
7:33
from your creature class that you're driving from.
7:36
Okay, so this is all well and good.
7:39
Let's do one more thing.
7:40
Let's have a wizard.
7:47
Now the wizard is also going to be a creature,
7:49
and the wizard actually has no special items or a passing
7:53
to it, so we can just leave this init thing off.
7:55
We're just going to add one behavior
7:57
to the wizard, which is going to be attack.
7:59
So he's going to have a creature he's going to attack,
8:02
and it's going to return True or False.
8:04
So it'll go something like this.
8:09
Now notice, both the wizard can get this defensive role,
8:12
or offensively, but it's fine,
8:14
and the creature also knows how to get a defensive role.
8:16
And we'll just compare those, we'll say return,
8:19
my role is greater than or equal to their role.
8:25
Alright, so what we're going to do is have the wizard attack
8:28
another creature, and then if we roll something higher
8:31
than we win, otherwise we lose.
8:32
And we're indicating that by returning True or False.
8:35
Alright, so we were able to take on a lot of the features
8:39
and the blueprint of the creature to get this
8:43
defensive role, and all we're doing is adding
8:45
an attack mechanism.
8:46
Whereas the dragon, we said we're going to change the way
8:49
defense works for dragons as well as,
8:50
like, storing additional stuff.
8:53
So we're able to model these
8:55
various actors in our game, all the while
8:58
keeping a sort of common functionality so they can interact
9:00
with each other.
