如何防止我的python游戏重复执行，而是继续进行？

Question

I've made a simple game using pygame and livewires, where a sprite has to avoid falling mushrooms. The number of mushrooms falling at a certain time is meant to increase as the score increases. Here is what I mean:

from livewires import games,color
import random

games.init(screen_width=633,screen_height=479,fps=50)

class Stick_Man(games.Sprite):
 def update(self):
  self.x=games.mouse.x
  if self.left<0:
      self.left=0

  if self.right>games.screen.width:
      self.right=games.screen.width
  self.check_collision()

 def check_collision(self):
  if self.overlapping_sprites:
   self.over_message()

 def over_message(self):
  b=games.Message(value="Game Over", size=100, color=color.red,x=games.screen.width/2,y=games.screen.height/2,lifetime=250,after_death=games.screen.quit)
  games.screen.add(b)


class Mushroom(games.Sprite):
 score=0
 start=200
 score_required=100
 level=1
 total_score=0
 speed=1
 mushroom=games.load_image("mushroom.jpg")
 x_position=random.randrange(640)

 @staticmethod
 def next_level():
    indicate='Level  ', + Mushroom.level, ' cleared'

    message=games.Message(value=indicate,size=50,color=color.red,x=games.screen.width/2,y=games.screen.height/2, lifetime=150)
    games.screen.add(message)
    Mushroom().score_required+=50

    Mushroom().score-=Mushroom.score_required
    Mushroom().start-=150
    Mushroom().speed+=5
    Mushroom().level+=1

    if Mushroom().start==20:
     Mushroom().start+=10 

 def __init__(self):
   super(Mushroom,self).__init__(image=Mushroom.mushroom,x=games.mouse.x,y=0)

 def update(self):
  self.dy=Mushroom.speed
  self.check()
  self.check2()

 def check(self):
  if self.bottom==games.screen.height:
     self.destroy()
     Mushroom.score+=50
     Mushroom.total_score+=Mushroom.score
  if Mushroom().score==Mushroom.score_required:
     self.next_level()

 def check2(self):   
  if self.top==Mushroom.start:
   self.duplicate()

 def duplicate(self):
      new_mush=Mushroom()
      games.screen.add(new_mush)

background_image=games.load_image("background.jpg",  transparent=False)
games.screen.background=background_image

stickman_image=games.load_image("stickman.png", transparent=True)

stickman=Stick_Man(image=stickman_image,left=1,bottom=480)

games.screen.add(stickman)

games.mouse.is_visible=False

b=Mushroom()
c=Mushroom()
a=Mushroom()
games.screen.add(b)
games.screen.add(a)
games.screen.add(c)
games.screen.event_brab=True

games.screen.mainloop()

The code is pretty self explanatory and whenever one of the mushrooms is equal to start, then a new object is created thus meaning a new mushroom comes in. However, what happens is that code doesn't function properly a second time and the mushrooms don't get faster spawn much faster either. Also, when the game first starts, the minute the first mushroom hits the bottom it says level one cleared, when it should be after two mushrooms. The sprite is just a red mushroom and also a stickman which can be found on g images if you want to simulate.

So my question is how do i make the object's STATS carry on from where it left off whenever another mushroom appears and also display the message at the right time

Answer 1

Your problem is in all of the lines that look like this:

Mushroom().score_required+=50

There are a number of problems here, which all together add up to make this have no useful effect:

• Mushroom() creates a new Mushroom instance (which goes away as soon as this line is done).
• Assigning (including update-assigning) to an attribute through an instance always creates or updates an instance attribute, even if there was a class attribute of the same name.
• The += operator doesn't mutate immutable values like integers in-place (because that would be impossible); a += b is effectively the same as a = a + b .*

So, when you put that together, what you're doing is creating a new value equal to Mushroom.score_required + 50 , then assigning that value to a new instance attribute of a temporary instance (which immediately goes away). This has no effect on the class attribute, or on any of the other instances.

You have a related, but different, problem in the lines like this:

x_position=random.randrange(640)

Unless you want all of the mushrooms to have the same x_position , this should not be a class attribute, but an instance attribute, and you're going to run into all kinds of strange problems.

Storing game stats as class attributes of a random class is a strange thing to do. There are ways you could make that work, but there's no good reason to even try. Class attributes are useful for constants that all instances of the class might as well share, but they're not useful as a substitute for global variables.

A better design would be something like this:

class Game(object):
    def __init__(self):
        self.score = 0
        self.start = 200
        self.score_required = 100
        self.level = 1
        self.total_score = 0
    def next_level(self):
        indicate = 'Level  ', + Mushroom.level, ' cleared'
        message =  games.Message(value=indicate, size=50, color=color.red,
                                 x=games.screen.width/2, y=games.screen.height/2,
                                 lifetime=150)
        games.screen.add(message)
        self.score_required += 50
        self.score -= self.score_required
        self.start -= 150
        self.speed += 5
        self.level += 1
        if self.start == 20:
            self.start += 10
     def update_score(self, n):
        game.score += n
        game.total_score += game.score
        if self.score == self.score_required:
            self.next_level()

class Mushroom(games.Sprite):
    mushroom=games.load_image("mushroom.jpg")
    def __init__(self, game):
        self.x_position=random.randrange(640)
        self.game = game
        super(Mushroom,self).__init__(image=Mushroom.mushroom,x=games.mouse.x,y=0)
    def update(self):
        self.dy=Mushroom.speed
        self.check()
        self.check2()
    def check(self):
        if self.bottom == games.screen.height:
            self.destroy()
        game.update_score(50)
    def check2(self):   
        if self.top == Mushroom.start:
            self.duplicate()   
    def duplicate(self):
        games.screen.add(Mushroom(self.game))

game = Game()
games.screen.add(Mushroom(game))
games.screen.add(Mushroom(game))
games.screen.add(Mushroom(game))
games.screen.event_brab=True

---

* That's not completely true. In fact, a = a + b is equivalent to a = a.__add__(b) , while a += b is equivalent to a = a.__iadd__(b) if such a method exists, falling back to __add__ only if it doesn't. For mutable objects like lists, this makes a big difference, because __iadd__ can change self in-place and then return it, meaning you end up assigning the same object back to a that was already there. But for immutable objects, there's no difference.