Question

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

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

例如，世界有一个表，而表是 Deck 卡。我希望能够将 Deck 标记为检查器。

此外，我希望套牌中的每张卡的套装（str）和等级（整数）也被督察选中。 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 被实例化时，会给他们一个Observer，稍后会为他们提供值。

当 NeuralNet 触发时，每个Neuron都会向Observer询问当前的世界状态，该状态可以方便地存储在缓冲区中。

赞成

我们不会将 PlayerObserver 紧密耦合到播放器， MatchObserver 与匹配紧密耦合等等
我们可以在将数据输入 InputNeurons 之前对我们收到的数据做出明智的选择。例如，我们可以检查其他玩家是否正在面朝上玩，如果是，则使用该数据;否则，提供空值。
我们稍后可以轻松添加新的可观察类型，只需实施 organize_data（）功能。

缺点

我们需要记住在我们采取的每个动作之后调用notify_observers（）来改变游戏状态。这可能会导致错误。
需要做更多工作。

以下是一些示例代码，以便开始工作：

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（）的调用。

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

1 个答案:

赞成

缺点