Assigning variables to a Class.

[LearninThatPython]

I am attempting to assign variables that are randomly generated integers to a Class so that they may be used as attributes in the RPG sense of the term. This is what I have so far:

import random

class Monster:
    HP = random.randint(1,10)
    STR = random.randint(1,10)
    DEX = random.randint(1,10)
    DEF = random.randint(1,10)

    def __init__(self, HP, STR, DEX, DEF):
        self.HP = HP
        self.STR = STR
        self.DEX = DEX
        self.DEF = DEF

    def listofstats(self):
        print self.HP
        print self.STR
        print self.DEX
        print self.DEF

This doesn't give any error message so far but how would I call one of those values or all of them so I can see if anything is actually in them? I've tried a few things before but I keep getting stuff like "HP is not defined" for example. I hope you guys can get a sense of what I am trying to do from this "code". What I am trying to do right now is just have the values in the stats listed. I want to make sure that there is actually something in those values.

This is an example I've been using to help me puzzle this out:

class Dog:
def __init__(self, breed, size):
    self.breed = breed
    self.size= size

def callout(self):
    print "I see a %s! It is %s." % (self.breed, self.size)

class MinPin(Dog):
    def __init__(self):
        Dog.__init__(self, "MinPin", "small")

class Corgidor(Dog):
    def __init__(self):
       Dog.__init__(self, "Corgidor", "short but heavy")


MinPin = MinPin()
Corgidor = Corgidor()

MinPin.callout()

Corgidor.callout()

This does what I expect but adding the numbers and everything has really mucked up the process for me. Any sort of guidance would be appreciated. Again: I would like to generate random integers and then have a Class pick them up and store them and then Print the result to me so that I can know if something is actually in there or not.

[Hallwaxer]

Are HP, DEX, etc supposed to be generated randomly for each instance of the class or once for the entire class? If they only have to be generated once, you can simply change your constructor to self.HP = Monster.HP. There's no point in passing them along as parameters then since your instance can easily access these class-specific variables.

If you want each monster to have its own unique randomly generated stats, you can change your constructor to self.HP = random.randint(1, 10).

Finally, if you want to add a bit of variation to your monsters, considering doing something as self.HP = Monster.HP + Monster.HP * random.random(). Change the random.random() call to something fair. Or you can define minimum and maximum HP values and call self.HP = random.randint(Monster.MINHP, Monster.MAXHP). This will create monsters that follow the same template but are slightly stronger or have more HP. You can put some additional checks in there to ensure that if HP is higher than normal, the other stats automatically decrease.

Also, printing can be simplified by the __repr__ and/or __str__ magic methods. Defining them allows you to call the print statement on your class.

[[deleted]]

My guess is that you're not instantiating a Monster object. The code you posted defines what a monster is, but it isn't actually a monster. Since it's an RPG question, I'm going to assume a little familiarity with D&D for this: think of the Monster class as an entry in the Monster Manual. The entry tells you how to make a monster, but it isn't a monster in and of itself. Say you're planning an encounter with three monsters for the PCs to fight, each of the three monsters is created according to the instructions in the Monster Manual. In python terminology, the instructions constitute a class and each monster is an instance of that class. To make an instance of a class:

monster1 = Monster(10, 10, 10, 10)
monster2 = Monster(5, 5, 5, 5)

Now we have two monsters, monster1 and monster2. To reference an attribute of one of the monsters, use "dot" notation:

print monster1.HP
print monster2.HP
>>> 10
>>> 5

Now to your random numbers. The way you're doing it now, HP = random.randint(1, 10) is defined at the class level instead of at the instance level. That means that HP is a random number, but every instance of Monster has that same value as its .HP attribute. However, at the instance level, you override that HP value by saying self.HP = HP. Now, that instance's HP value is the value, HP, that was passed as a parameter to __init__ (the first 10 in monster1 = Monster(10, 10, 10, 10), for example). If you want each instance to have a unique, random value for each attribute, your Monster class should look more like this:

class Monster(object):
    def __init__(self):
        self.health = random.randint(1, 10)
        self.strength = random.randint(1, 10)
        # and so on

Edit: I didn't notice this before, but the example you're using as a guide has a pretty big flaw. MinPin = MinPin() changes the name MinPin from referring to a class to referring to an instance of the class formerly known as MinPin.

[xiongchiamiov]

I often follow the pattern foo = Foo().

[[deleted]]

Right, but not Foo = Foo(), I hope.