如何防止我的 python 游戏重复并继续进行？答案

【问题标题】：How can I prevent my python game from reiterating and instead carry on?如何防止我的 python 游戏重复并继续进行？
【发布时间】：2013-08-23 20:50:28
【问题描述】：

我使用 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()

代码很容易解释，只要其中一个蘑菇等于开始，就会创建一个新对象，因此意味着一个新蘑菇进来。但是，发生的情况是代码第二次无法正常运行，并且蘑菇也不会变得更快产卵更快。此外，当游戏第一次开始时，第一个蘑菇落到底部的那一刻，它说一级已通关，而应该是在两个蘑菇之后。精灵只是一个红色蘑菇，也是一个火柴人，如果你想模拟，可以在 g 图像上找到。

所以我的问题是，当另一个蘑菇出现时，我如何让对象的 STATS 从停止的地方继续，并在正确的时间显示消息

【问题讨论】：

为什么你的类有一堆类属性和静态方法？这在 Python 中通常不是一个好主意，并且通常表明您正在尝试用 Python 编写 Java 代码。反复执行Mushroom().foo 的静态方法中的代码特别奇怪，因为它每次都在创建一个新实例（每个实例都可能立即消失，或者如果Sprite.__init__ 执行某些操作，它可能会被其他对象保留花哨）。
同时，“对象的 STATS”是什么意思？您的代码中没有任何名为“STATS”（任何大小写）的内容；您显示的唯一对象没有任何实例属性……
最后，如果你想创建新的蘑菇，你不应该将每个蘑菇存储在一个单独的变量中，你应该有一个列表或其他集合，你可以@ 987654324@到。
啊，是的，我所说的统计数据只是指我设置的所有这些类属性，也许游戏数据会是一个更好的放置方式。是的，这不是创造新蘑菇的问题，它已经做到了。问题是它在该 duplicate() 函数中重新启动，而我真的希望它携带当前游戏数据，例如分数、级别等 - 所有类属性。这就是我所坚持的，我看不出附加任何东西会有什么帮助
newmush=Mushroom() 不可能重置 Mushroom 中的类属性——如果这样做了，您代码中的十几个其他地方您调用 Mushroom() 只创建一个新实例立即释放它会产生相同的效果。

标签： python python-3.x pygame

【解决方案1】：

您的问题出现在所有如下所示的行中：

Mushroom().score_required+=50

这里有很多问题，加起来就没有什么有用的效果：

Mushroom() 会创建一个新的 Mushroom 实例（此行完成后它就会消失）。
通过实例分配（包括更新分配）属性总是会创建或更新实例属性，即使存在同名的类属性。
+= 运算符不会就地改变整数等不可变值（因为那是不可能的）； a += b 实际上与 a = a + b 相同。*

因此，当您将它们放在一起时，您所做的是创建一个等于Mushroom.score_required + 50 的新值，然后将该值分配给临时实例的新实例属性（立即消失）。这对类属性或任何其他实例都没有影响。

您有一个相关但不同的问题，如下所示：

x_position=random.randrange(640)

除非你想让所有的蘑菇都有相同的x_position，否则这不应该是一个类属性，而是一个实例属性，你会遇到各种奇怪的问题。

将游戏统计数据存储为随机类的类属性是一件奇怪的事情。有一些方法可以使这项工作发挥作用，但没有充分的理由去尝试。类属性对于类的所有实例可能共享的常量很有用，但它们不能用作全局变量的替代品。

更好的设计应该是这样的：

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。但对于不可变对象，则没有区别。

【讨论】：