在Python中标记对象/标量以供以后检查

Question

我有一个世界类，它是游戏模拟的根源。所有其他类都直接从World的方法或从World中实例化的对象实例化。我想生成一个特定对象和标量的列表，供以后使用。

在运行时，我有另一个类检查器，一旦游戏世界初始化，它将运行一次。的工作是查找所有标记的对象或标量，并返回引用列表，以供以后提取值。这一工作的必要性源于必须将各种游戏状态作为输入输入到AI的神经网络中。AI不关心它们的名称，只要它们在每次运行时以相同的顺序返回。

例如，World有一个Table，在这个Table上有一个Deck的卡片。我希望能把这个甲板标记出来，由检查官接上来。

另外，我希望甲板上的每个卡的西服(str)和等级(int)也能被检查官取走。AI不关心Deck；它关心每一张卡的个人套装/等级。

当前的python代码如下所示：

class Inspector:
  @staticmethod
  def inspect(obj):
    found = []

    # search through each class member
    for entity in vars(obj):
      if is_marked(entity):
        # the neural net only cares about ints/chars
        if isinstance(entity, int) or isinstance(entity, str):
          found.append(entity)
        else:
          # let's explore deeper
          found.append(inspect(entity))

    return found

  @staticmethod
  def is_marked(entity):
    if ???:
      return true
    else:
      return false

我设想使用这段代码运行游戏并构建标记对象的列表：

def main():
  world = World()
  ai = AI()
  world.init()
  marked = Inspector(world).inspect()
  ai.init(marked)

  simulate(world, ai)      

我正在研究is_marked()的内部工作。如何标记一个对象或标量以供以后检查，特别是当您无法创建对标量的第二个引用时？

编辑:我不理智地害怕使用Singleton和手动添加的东西。假装这是一件很好的事情，我该如何处理无秒参照标量因素呢？

Answer 1

这个问题是Observer/Observable模式的主要候选问题。

将有几类观察者: TableObserver，PlayerObserver等。

我们将手动将数据推送到观察者中的缓冲区中。

在实例化InputNeurons时，将为它们提供一个观察者，该观察者稍后将为它们提供值。

当NeuralNet触发时，每个神经元向它的观察者询问当前的世界状态，这个状态很方便地存储在它的缓冲区中。

优点

1. 我们不会将PlayerObserver紧密耦合到Player，将MatchObserver紧密耦合到Match，等等。
2. 在将数据输入InputNeurons.之前，我们可以对接收的数据做出明智的选择。例如，我们可以检查另一个玩家是否正面对着他的手，如果是的话，使用这些数据；否则，提供空值。
3. 我们可以在以后添加新的可观察到的organize_data()类型，只需很小的努力就可以实现一个函数。

缺点

1. 在每次改变游戏状态的动作之后，我们需要记住调用notify_observers()。这可能会导致道路上的虫子。
2. 还有更多的工作要做。

下面是一些开始工作的示例代码：

class Observable(object):
    def __init__(self):
        self._observers = []

    def register_observer(self, obj):
        if obj not in self._observers:
            self._observers.append(obj)

    def notify_observers(self):
        for observer in self._observers:
            observer.observe(self.wrapped.organize_data())


class Observer(object):
    def __init__(self, obj):
        self._observed = obj
        self.buffer = None
        self.register(obj)

    # called by observed object. provides the observer with a list of integers
    def observe(self, int_list):
        raise NotImplementedError("must implement observe")

    def register(self, obj):
        obj.register_observer(self)


class PlayerObserver(Observer):
    def __init__(self, player):
        super(PlayerObserver, self).__init__(player)

    # store a copy of the integer list passed our way
    def observe(self, int_list):
        self.buffer = list(int_list)

这里有一个Python观察者模式的例子：Observer Observable classes in python

不幸的是，通过创建包装类来实现观察者模式的"pythonic“方法包含了在调用包装类方法之前通知观察者的致命缺陷。在调用方法之后，我们最感兴趣的是了解对象的状态，因此该方法不起作用。最好在游戏的关键点手动触发对notify_observers()的调用。