Question

我在 update()类中有一个函数 Character ，这样每次创建一个类角色的实例时，{{需要在主循环中调用方法，例如：

update

这很好，但如果我有很多troll = Character() monster = Character() while True: troll.update() monster.update()类的实例，那就不干净了。

我知道可以使用Character完成此操作。但我不想这样做，还有其他方法吗？

有什么建议吗？

Answer 1

利用在课堂上存储数据。

class Character():
    instances = []

    def __init__(self):
        Character.instances.append(self)
        self.x = 0

    def class_update(self):
        for x in self.instances:
            x.instance_update()

    def instance_update(self):
        self.x += 1

A = Character()
B = Character()

A.class_update()
B.class_update()

C = Character()

C.class_update()

print Character.instances
print A, B, C
print A.x, B.x, C.x

输出 -

[<__main__.Character instance at 0x10a8523f8>, <__main__.Character instance at 0x10a852440>, <__main__.Character instance at 0x10a852488>]
<__main__.Character instance at 0x10a8523f8> <__main__.Character instance at 0x10a852440> <__main__.Character instance at 0x10a852488>
3 3 1

我不知道这种方法的缺陷，却不知道你需要完成什么。

Answer 2

您可以将所有Character个对象保留在dict：

中

characters = {}
characters["troll"] = Character()
characters["monster"] = Character()

然后更新所有角色很简单：

for character in characters.values():
    character.update()

Answer 3

这里不能使用类方法，因为类方法不适用于实例，而是适用于所有sprite共享的类的某些部分。

假设你的角色有一个移动精灵的更新方法。所以它看起来像这样：

def update(self):
    self.pos = (self.pos[0] + self.v[0], self.pos[1] + self.v[1])

如果你在哪里使它成为一个类方法，第一个参数将是一个类，而不是一个实例，所以没有办法从类方法改变一个实例，除非该类本身有一个实例列表。 / p>

你应该采取的方法应该取决于游戏的大小。

对于初学者，只需将它们放在一个列表中，然后迭代调用每个实例更新方法。

另一种方法是在类中包含一个字符列表，正如RyPeck建议的那样。我认为将列表存储在主程序中会更好，因为类不需要知道任何实例的存在。

Answer 4

我认为你要找的是composite pattern。您创建一个包含所有Character实例的CompositeCharacter类。然后，您可以在CompositeCharacter对象中调用update方法，该方法将迭代地在其所有子项（您的Character对象集合）上调用update方法。

您可以像这样定义复合类，或者这个的一些变体。关键是你的实例化CompositeCharacter对象将有一个内部列表，并提供操作该列表的方法。

class CompositeCharacter():
    children = []

    def update(self):
        for c in self.children:
            c.update()

    def add(self, char):
        self.children.append(char)

在代码的开头，将复合字符对象实例化为一些变量引用...比如compCharacters。

compCharacters = CompositeCharacter()

或者您可以基于某些分组字符类

实例化许多CompositeCharacters

trollCharacters = CompositeCharacter()
monsterCharacters = CompositeCharacter()
humanCharacters = CompositeCharacter()

然后，当您实例化单个Character（）时，将它们添加到相应的CompositeCharacter对象。

troll = Character()
compCharacters.add(troll)    OR trollCharacters.add(troll)
monster = Character()
compCharacters.add(monster)  OR monsterCharacters.add(monster)

如果您已将它们添加到常规复合对象（compCharacters），那么您只需在该对象上调用更新

compCharacters.update()

或者，如果您使用了专门的分组，则可以在要更新的任何组中调用更新。

trollCharacters.update()

OR

monsterCharacters.update()

OR

humanCharacters.update()

您还可以将所有专用复合对象保留在父复合对象中。然后，如果您愿意，可以调用全局更新或调用专用更新。

compCharacters = CompositeCharacter()

trollCharacters = CompositeCharacter()
compCharacters.add(trollCharacters)

monsterCharacters = CompositeCharacter()
compCharacters.add(monsterCharacters)

humanCharacters = CompositeCharacter()
compCharacters.add(humanCharacters)

然后调用全局更新只需调用comp

compCharacters.update()

对许多实例的单个方法调用

4 个答案: