Question

我在C ++中编写类似流氓的游戏，并且在双重调度方面存在问题。

   class MapObject {
        virtual void collide(MapObject& that) {};
        virtual void collide(Player& that) {};
        virtual void collide(Wall& that) {};
        virtual void collide(Monster& that) {};
    };

然后在派生类中：

void Wall::collide(Player &that) {
    that.collide(*this);
}

void Player::collide(Wall &that) {
    if (that.get_position() == this->get_position()){
        this->move_back();
    }
}

然后我尝试使用代码：

vector<vector<vector<shared_ptr<MapObject>>>> &cells = ...

其中创建单元格如下：

objs.push_back(make_shared<Monster>(pnt{x, y}, hp, damage)); //and other derived types
...
cells[pos.y][pos.x].push_back(objs[i]);

当我试图碰撞玩家和墙壁时：

cells[i][j][z]->collide(*cells[i][j][z+1]);

玩家与基类发生碰撞，但不与墙碰撞。我做错了什么？

Answer 1

您的基类应该是：

class MapObject {
public:
    virtual ~MapObject () = default;
    virtual void collide(MapObject& that) = 0; // Dispatcher

    virtual void collide(Player& that) = 0;  // Both types known
    virtual void collide(Wall& that) = 0;    // Both types known
    virtual void collide(Monster& that) = 0; // Both types known
};

你的Player类应该是这样的：

class Player {
public:
    void collide(MapObject& that) override { that.collide(*this); } // dispatch done,
                                                        // call true virtual collision code

    // Real collision code, both types are known
    void collide(Player& that) override  { PlayerPlayerCollision(*this, that);}
    void collide(Wall& that) override    { PlayerWallCollision(*this, that);}
    void collide(Monster& that) override { MonterPlayerCollision(that, this);}
};

如果您的基类不是抽象的并且意味着有自己的碰撞，那么你必须重命名以区分调度程序与真正的碰撞代码：

class MapObject {
public:
    virtual ~MapObject () = default;
    virtual void collide_dispatcher(MapObject& that) { that.collide(*this); }

    // Real collision code, both types are known
    virtual void collide(MapObject& that) { MapObjectMapObjectCollision(*this, that);}
    virtual void collide(Player& that)    { MapObjectPlayerCollision(*this, that);}
    virtual void collide(Wall& that)      { MapObjectWallCollision(*this, that); }
    virtual void collide(Monster& that)   { MapObjectMonsterCollision(*this, that); }
};

你的Player类应该是这样的：

class Player {
public:
    virtual void collide_dispatcher(MapObject& that) { that.collide(*this); }

    // Real collision code, both types are known
    void collide(MapObject& that) override { MapObjectPlayerCollision(that, *this);}
    void collide(Player& that) override    { PlayerPlayerCollision(*this, that);}
    void collide(Wall& that) override      { PlayerWallCollision(*this, that);}
    void collide(Monster& that) override   { MonterPlayerCollision(that, this);}
};

Answer 2

这比解决问题更复杂。您正在进行手动双重调度，并且您有错误。我们可以修复你的错误。

但是你遇到的问题不是你的错误，而是你在进行手动双重调度。

手动双重调度容易出错。

每次添加新类型时，都必须编写O（N）个新代码，其中N是现有类型的数量。这段代码是基于复制粘贴的，如果你犯了错误，他们会默默地继续错误地发送一些极端情况。

如果您继续进行手动双重调度，只要您或其他任何人修改代码，您就会继续遇到错误。

C ++没有提供自己的双调度机制。但是使用c++17我们可以自动编写它

这是一个需要线性工作来管理双重调度的系统，以及每次碰撞的工作。

对于双重调度中的每种类型，您都要向pMapType添加一个类型。就是这样，发送的其余部分是为您自动编写的。然后从X继承您的新地图类型collide_dispatcher<X>。

如果您希望两种类型具有冲突代码，请编写自由函数 do_collide(A&,B&)。 pMapType变体中更容易的应该是A。必须先定义此函数，然后才能为调度工作定义A和B。

如果a.collide(b)或b.collide(a)运行，A和B是a和b的动态类型，则会运行该代码分别。

你也可以让do_collide成为一种或另一种朋友。

没有进一步的麻烦：

struct Player;
struct Wall;
struct Monster;

using pMapType = std::variant<Player*, Wall*, Monster*>;

namespace helper {
  template<std::size_t I, class T, class V>
  constexpr std::size_t index_in_variant() {
    if constexpr (std::is_same<T, std::variant_alternative_t<I, V>>{})
      return I;
    else
      return index_in_variant<I+1, T, V>();
  }
}
template<class T, class V>
constexpr std::size_t index_in_variant() {
  return helper::index_in_variant<0, T, V>();
}

template<class Lhs, class Rhs>
constexpr bool type_order() {
  return index_in_variant<Lhs*, pMapType>() < index_in_variant<Rhs*, pMapType>();
}

template<class Lhs, class Rhs>
void do_collide( Lhs&, Rhs& ) {
  std::cout << "Nothing happens\n";
}

struct MapObject;
template<class D, class Base=MapObject>
struct collide_dispatcher;

struct MapObject {
  virtual void collide( MapObject& ) = 0;

protected:
  template<class D, class Base>
  friend struct collide_dispatcher;
  virtual void collide_from( pMapType ) = 0;

  virtual ~MapObject() {}
};

template<class D, class Base>
struct collide_dispatcher:Base {
  D* self() { return static_cast<D*>(this); }
  virtual void collide( MapObject& o ) final override {
    o.collide_from( self() );
  }
  virtual void collide_from( std::variant<Player*, Wall*, Monster*> o_var ) final override {
    std::visit( [&](auto* o){
      using O = std::decay_t< decltype(*o) >;
      if constexpr( type_order<D,O>() ) {
        do_collide( *self(), *o );
      } else {
        do_collide( *o, *self() );
      }
    }, o_var );
  }
};

void do_collide( Player& lhs, Wall& rhs );
void do_collide( Player& lhs, Monster& rhs );
struct Player : collide_dispatcher<Player> {
  friend void do_collide( Player& lhs, Wall& rhs ) {
    std::cout << "Player hit a Wall\n";
  }
  friend void do_collide( Player& lhs, Monster& rhs ) {
    std::cout << "Player fought a Monster\n";
  }
};

void do_collide( Wall& lhs, Monster& rhs );
struct Wall : collide_dispatcher<Wall> {
  friend void do_collide( Wall& lhs, Monster& rhs ) {
    std::cout << "Wall blocked a Monster\n";
  }
};
void do_collide( Monster& lhs, Monster& rhs );
struct Monster : collide_dispatcher<Monster> {
  friend void do_collide( Monster& lhs, Monster& rhs ) {
    std::cout << "Monster Match!\n";
  }
};

Live example

虽然这里的管道很复杂，但它确实意味着您不会手动进行任何双重调度。你只是在写端点。这减少了你可以收到角落拼写错误的地方数量。

测试代码：

int main() {
  MapObject* pPlayer = new Player();
  MapObject* pWall = new Wall();
  MapObject* pMonster = new Monster();

  std::cout << "Player:\n";
  pPlayer->collide(*pPlayer);
  pPlayer->collide(*pWall);
  pPlayer->collide(*pMonster);

  std::cout << "Wall:\n";
  pWall->collide(*pPlayer);
  pWall->collide(*pWall);
  pWall->collide(*pMonster);

  std::cout << "Monster:\n";
  pMonster->collide(*pPlayer);
  pMonster->collide(*pWall);
  pMonster->collide(*pMonster);
}

输出是：

Player:
Nothing happens
Player hit a Wall
Player fought a Monster

Wall:
Player hit a Wall
Nothing happens
Wall blocked a Monster

Monster:
Player fought a Monster
Wall blocked a Monster
Monster Match!

您还可以为std::variant<Player*, Wall*, Monster*>创建一个中央typedef，并让map_type_index使用该中心typedef来确定其排序，从而减少向双调度系统添加新类型以添加类型的工作量单个位置，实现新类型，并转发声明应该执行某些操作的冲突代码。

此外，这个双重调度代码可以使继承友好;来自Wall的派生类型可以调度到Wall重载。如果您需要此功能，则必须使collide_dispatcher方法重载非final，允许SpecialWall重新加载它们。

这是c++17，但每个主要编译器的当前版本现在都支持它所需要的。一切都可以在c++14甚至c++11内完成，但它会变得更加冗长，可能需要boost。

虽然需要使用线性数量的代码来定义发生的情况，但编译器将生成二次数量的代码或静态表数据来实现双重调度。因此，在双重调度表中有10,000多种类型之前要小心。

如果您希望MapObject具体，请从其中拆分界面并从调度程序中删除final并将MapObject添加到pMapType

struct Player;
struct Wall;
struct Monster;
struct MapObject;

using pMapType = std::variant<MapObject*, Player*, Wall*, Monster*>;

namespace helper {
  template<std::size_t I, class T, class V>
  constexpr std::size_t index_in_variant() {
    if constexpr (std::is_same<T, std::variant_alternative_t<I, V>>{})
      return I;
    else
      return index_in_variant<I+1, T, V>();
  }
}
template<class T, class V>
constexpr std::size_t index_in_variant() {
  return helper::index_in_variant<0, T, V>();
}

template<class Lhs, class Rhs>
constexpr bool type_order() {
  return index_in_variant<Lhs*, pMapType>() < index_in_variant<Rhs*, pMapType>();
}

template<class Lhs, class Rhs>
void do_collide( Lhs&, Rhs& ) {
  std::cout << "Nothing happens\n";
}

struct collide_interface;
template<class D, class Base=collide_interface>
struct collide_dispatcher;

struct collide_interface {
  virtual void collide( collide_interface& ) = 0;

protected:
  template<class D, class Base>
  friend struct collide_dispatcher;
  virtual void collide_from( pMapType ) = 0;

  virtual ~collide_interface() {}
};

template<class D, class Base>
struct collide_dispatcher:Base {
  D* self() { return static_cast<D*>(this); }
  virtual void collide( collide_interface& o ) override {
    o.collide_from( self() );
  }
  virtual void collide_from( pMapType o_var ) override {
    std::visit( [&](auto* o){
      using O = std::decay_t< decltype(*o) >;
      if constexpr( type_order<D,O>() ) {
        do_collide( *self(), *o );
      } else {
        do_collide( *o, *self() );
      }
    }, o_var );
  }
};

struct MapObject:collide_dispatcher<MapObject>
{
    /* nothing */
};

live example

您希望Player从MapObject下降，您必须使用Base的{{1}}参数：

collide_dispatcher

Answer 3

看起来很小的错误。

if (that.get_position() == this->get_position())

这绝不是真的。更重要的是我认为你不需要它，但这不是一个问题。我想你需要改变这一行

cells[i][j][z]->collide(*cells[i][j][z+1]);

到

player[i][j][z+1]->collide(*cells[i][j][z+1]);

玩家将会碰壁。

C ++中的双重调度无法正常工作

3 个答案: