如何编写优雅的碰撞处理机制？

Question

我有点困惑：假设我正在制作一款简单的 2D、类似塞尔达传说的游戏。 当两个对象碰撞时，每个对象都应该产生一个结果动作。然而，当主角与某物碰撞时，他的反应仅取决于他碰撞的物体的类型。如果它是一个怪物，他应该反弹，如果它是一堵墙，什么都不会发生，如果它是一个带有丝带的神奇蓝色盒子，他应该治愈，等等（这些只是例子）。

我还应该注意到，这两件事都是碰撞的一部分，也就是说，碰撞事件应该同时发生在角色和怪物身上，而不仅仅是其中之一。

你会如何编写这样的代码？我可以想到许多令人难以置信的不优雅的方法，例如，在全局 WorldObject 类中使用虚拟函数来识别属性 - 例如，GetObjectType() 函数（返回 ints、char*s、任何将对象标识为 Monster 的东西） 、Box 或 Wall），那么在具有更多属性的类中，比如 Monster，可能会有更多的虚函数，比如 GetSpecies()。

然而，维护起来很烦人，并导致碰撞处理程序中出现大量级联 switch（或 If）语句。

MainCharacter::Handler(Object& obj)
{
   switch(obj.GetType())
   {
      case MONSTER:
         switch((*(Monster*)&obj)->GetSpecies())
         {
            case EVILSCARYDOG:
            ...
            ...
         }
      ...
   }

}

还有使用文件的选项，文件将具有以下内容：

Object=Monster
Species=EvilScaryDog
Subspecies=Boss

然后代码可以检索属性，而无需对虚拟函数的需求使一切变得混乱。然而，这并不能解决级联 If 问题。

然后可以选择为每种情况提供一个函数，例如 CollideWall()、CollideMonster()、CollideHealingThingy()。这是我个人最不喜欢的（尽管它们都远非讨人喜欢），因为它似乎维护起来最麻烦。

有人可以深入了解这个问题的更优雅的解决方案吗？ 感谢您的任何帮助！

Answer 1

我会反之亦然 - 因为如果角色与物体碰撞，物体也会与角色碰撞。因此，您可以拥有一个基类 Object，如下所示：

class Object  {
  virtual void collideWithCharacter(MainCharacter&) = 0;
};

class Monster : public Object  {
  virtual void collideWithCharacter(MainCharacter&) { /* Monster collision handler */ }
};

// etc. for each object

通常，在 OOP 设计中，虚拟函数是此类情况的唯一“正确”解决方案：

switch (obj.getType())  {
  case A: /* ... */ break;
  case B: /* ... */ break;
}

编辑：
澄清后，您将需要对上述内容进行一些调整。 MainCharacter 应该为它可以碰撞的每个对象提供重载方法：

class MainCharacter  {
  void collideWith(Monster&) { /* ... */ }
  void collideWith(EvilScaryDog&)  { /* ... */ }
  void collideWith(Boss&)  { /* ... */ }
  /* etc. for each object */
};

class Object  {
  virtual void collideWithCharacter(MainCharacter&) = 0;
};

class Monster : public Object  {
  virtual void collideWithCharacter(MainCharacter& c)
  {
    c.collideWith(*this);  // Tell the main character it collided with us
    /* ... */
  }
};

/* So on for each object */

这样您就可以通知主角有关碰撞的信息，并且它可以采取适当的操作。此外，如果您需要一个不应通知主角碰撞的对象，您可以删除该特定类中的通知调用。

这种方法称为双重调度。

我还会考虑将 MainCharacter 本身设为 Object，将重载移至 Object 并使用 collideWith 而不是 collideWithCharacter 。

Answer 2

从一个公共抽象类（我们称之为 Collidable）派生所有可碰撞对象怎么样？该类可以包含可通过碰撞和一个 HandleCollision 函数更改的所有属性。当两个对象发生碰撞时，您只需对每个对象调用 HandleCollision，并将另一个对象作为参数。每个对象都操纵另一个对象来处理碰撞。这两个对象都不需要知道它刚刚弹回的其他对象类型，并且您没有大的 switch 语句。

Answer 3

使所有可碰撞实体使用 collideWith(Collidable) 方法实现接口（假设为“Collidable”）。
然后，在碰撞检测算法中，如果检测到 A 与 B 碰撞，您将调用：

A->collideWith((Collidable)B);
B->collideWith((Collidable)A);

假设 A 是 MainCharacter，B 是怪物，并且两者都实现 Collidable 接口。

A->collideWith(B);

将调用以下内容：

MainCharacter::collideWith(Collidable& obj)
{
   //switch(obj.GetType()){
   //  case MONSTER:
   //    ...
   //instead of this switch you were doing, dispatch it to another function
   obj->collideWith(this); //Note that "this", in this context is evaluated to the
   //something of type MainCharacter.
}

这将依次调用 Monster::collideWith(MainCharacter) 方法，您可以在那里实现所有怪物角色行为：

Monster::CollideWith(MainCharacter mc){
  //take the life of character and make it bounce back
  mc->takeDamage(this.attackPower);
  mc->bounceBack(20/*e.g.*/);
}

更多信息：单次调度

希望有帮助。

Answer 4

你所说的“烦人的 switch 语句”我会称之为“一场伟大的游戏”，所以你走在正确的轨道上。

为每个交互/游戏规则提供一个函数正是我所建议的。它使查找、调试、更改和添加新功能变得容易：

void PlayerCollidesWithWall(player, wall) { 
  player.velocity = 0;
}

void PlayerCollidesWithHPPotion(player, hpPoition) { 
  player.hp = player.maxHp;
  Destroy(hpPoition);
}

...

所以问题实际上是如何检测每种情况。假设您有某种导致 X 和 Y 碰撞的碰撞检测（就像 N^2 重叠测试一样简单（嘿，它适用于植物与僵尸，而且发生了很多事情！）或者像扫描和修剪一样复杂+ gjk）

void DoCollision(x, y) {
  if (x.IsPlayer() && y.IsWall()) {   // need reverse too, y.IsPlayer, x.IsWall
     PlayerCollidesWithWall(x, y);    // unless you have somehow sorted them...
     return;
  }

  if (x.IsPlayer() && y.IsPotion() { ... }

  ...

这种风格虽然冗长，但

• 很容易调试，
• 易于添加案例
• ，当您有
  逻辑/设计不一致或
  省略“哦，如果 X 既是
  由于玩家和墙壁
  “PosessWall”能力，然后呢！？！”
  （然后让您只需添加案例
  来处理这些）

Spore 的细胞阶段正是使用这种风格，并且有大约 100 次检查，导致大约 70 种不同的结果（不包括参数反转）。这只是一个十分钟的游戏，整个阶段每 6 秒就有 1 个新的交互 - 这就是游戏价值！

Answer 5

如果我正确地理解了你的问题，我会喜欢

Class EventManager {
// some members/methods
handleCollisionEvent(ObjectType1 o1, ObjectType2 o2);
// and do overloading for every type of unique behavior with different type of objects.
// can have default behavior as well for unhandled object types
}