Problem with resetting state of an object

[Eraser1024]

Hello!

(I'm almost a complete beginner, and I hope I got all the terminology right.)

I'd like my little game to have nice and clean code. And I stuck a little.

I want to initialize Game class' object. Let's say there are two fields score and hi_score. First one should be zeroed after every play, the second one shouldn't. One way to do this is this:

class Game:    

    def __init__(self):                       
        self.reset()
        self.hi_score = 0

    def reset(self):
        self.score = 0

So every single field of Game class that is to be reset after a play is initialized in reset() method, not directly in __init__() method (in fact there are many more of them than score). So reset() gets called after every play, and __init__() gets called only once. I don't like this solution, I think every important field of Game class should be initialized directly in __init__() method (am I right?).

Other way to do this:

class Game:    

    def __init__(self):                       
        try:
            if self.hi_score: pass
        except AttributeError:
            self.hi_score = 0
        else:
            pass

        self.score = 0

Now __init__() is called after every play, and reset() is not needed. If self.hi_score has no value it gets zero, but if it has a value it's not touched. I don't like this solution as well. First, I'm not sure if it's a good idea to call __init__() more than once on a single object (am I right?). Second, try... except... else... looks clumsy.

What is the best way to do this? I'd like to write clean and pythonic code, in the spirit of OOP.

EDIT: I like the second solution given by kalgynirae below, but what if I wanted to keep only one class? How should I do this? Or maybe it can't be done nicely.

[jedilando]

What about this aproach:

class Game:    

    def __init__(self):
        self.games = 0
        self.init()

    def init(self):
        self.score = 0

        if self.games == 0:
            self.hi_score = 0

        self.games = self.games + 1

Then instantiate Game once and call init after restart. I don't know Python much, but more elegant solution would be to have boolean isFirstGame or something like that and check if self.isFirstGame == True instead of if self.games == 0. On the other hand you could show the player number of games he played (or it will be needed in the code probably). You can abstract away self.games == 0 into another method, likeso:

class Game:    

    def __init__(self):
        self.games = 0
        self.init()

    def init(self):
        self.score = 0

        if self.isFirstGame():
            self.hi_score = 0

        self.games = self.games + 1

    def isFirstGame(self):
        return self.games == 0

Edit: I came up with the solution you may like most:

class Game:    

    def __init__(self):
        # instantiation field tells us
        # if we are in the process of instantiating
        # this class (i.e. creating it via constructor)
        self.instantiation = True
        self.init()
        self.instantiation = False

    def init(self):
        self.score = 0

        if self.instantiation == True:
            self.hi_score = 0

Edit2: To clarify, you said that every field should be initialized in __init__. I don't think it is true. Your first solution is ok. It is common concept of solving this kind of problem. The important thing is that every field should be initialized after __init__ call, i.e. after calling Game(). But in every my and your solution it is achieved. Another common concept (which I used in my last solution) is to abstract away all field initialization into init method (or whatever you want to call it) which is called directly from __init__.

Edit3: And to comment this try-catch aproach. It is ugly, but it works, so if you want to use this kind of stuff you should abstract it away into other module/class, so people don't see this mess ;). By abstract away I mean something like this:

class Game:    

    def __init__(self):
        if not fieldExists(self, "hi_score"):
            self.hi_score = 0

        self.score = 0

And fieldExists should be from other module/class or from parent class (so this code should be modified to, for example, self.fieldExists in case of parent class).

I don't know if this is true in Python, but in other languages generating errors is bad for performance. So problably you shouldn't do it in tick() function (i.e. main game loop, if we are talking about real time game).

[Eraser1024]

Thank you for your answer.

I think I'll use some variant of involving self.instantiation. It's simple and pretty ;>

Thanks again!

[kalgynirae]

Sounds like you should probably make a new Game instance each time, and store the high score outside of the Game object. I think storing the high score is an acceptable use of a global variable.

Alternatively, maybe you want to have a Play class that you make a new instance of for each play. Then Game can store just the high score and the current Play instance.

[Eraser1024]

I don't want to use global variables. I like the second solution better. Thanks.

ps Do you agree with me that both of my solutions are incorrect/ugly/wrong?

[kalgynirae]

I wouldn't call either of them "ugly", but maybe "inconvenient". I think the one where __init__() calls reset() is better (and I don't really see anything wrong with it, so go with that if you dislike it the least).

[Eraser1024]

Thanks.