如何防止我的python游戲重復執行，而是繼續進行？

Question

我使用pygame和livewires制作了一個簡單的游戲，其中精靈必須避免掉下蘑菇。 在特定時間掉落的蘑菇數量意味着隨着分數的增加而增加。 這是我的意思：

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()

該代碼是很容易解釋的，每當一個蘑菇等於開始時，就會創建一個新對象，從而意味着一個新的蘑菇進入。但是，發生的情況是該代碼第二次無法正常運行，而蘑菇卻無法正常工作。也不會更快地產生。 同樣，當游戲第一次開始時，第一個蘑菇到達底部的那一刻，它說級別1已清除，應該在兩個蘑菇之后。 精靈只是一個紅色的蘑菇，也是一個火柴人，如果要模擬，可以在g圖像上找到它。

所以我的問題是，如何使對象的STATS在出現另一個蘑菇時從中斷的地方繼續進行，並在正確的時間顯示消息

Answer 1

您的問題出在所有看起來像這樣的行中：

Mushroom().score_required+=50

這里有很多問題，所有這些問題加起來使它沒有任何用處：

• Mushroom（）創建一個新的Mushroom實例（此行完成后即消失）。
• 通過實例向屬性分配（包括更新分配）始終會創建或更新實例屬性，即使存在相同名稱的類屬性也是如此。
• + =運算符不會就地改變整數之類的不可變值（因為這是不可能的）； a += b實際上與a = a + b 。*

因此，當您將它們放在一起時，您正在做的是創建一個等於Mushroom.score_required + 50的新值，然后將該值分配給臨時實例的新實例屬性（該實例立即消失）。 這對class屬性或任何其他實例沒有影響。

您在類似的行中有一個相關但不同的問題：

x_position=random.randrange(640)

除非您希望所有蘑菇都具有相同的x_position ， x_position這不應是class屬性，而應是instance屬性，否則您將遇到各種奇怪的問題。

將游戲統計信息存儲為隨機類的類屬性是一件奇怪的事情。 您可以通過多種方法進行這項工作，但沒有充分的理由嘗試。 類屬性對於類的所有實例都可能共享的常量很有用，但它們不能代替全局變量。

更好的設計應該是這樣的：

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

---

*這不是完全正確的。 實際上， a = a + b等效於a = a.__add__(b) ，而a += b等效於a = a.__iadd__(b)如果存在），僅當不存在時才回落到__add__沒錯 對於像列表可變對象，這使得一個很大的區別，因為__iadd__可以改變self就地，然后返回它，這意味着你最終分配相同的對象回到a是已經在那里了。 但是對於不可變的對象，沒有區別。