C++游戏引擎中的组合、组件和实体

Question

我正在开发一个学校项目的游戏。我们使用一个由其中一个团队制作的引擎。引擎的构建对我来说不清楚，似乎是一种反模式。然而，似乎没有人能够向我清晰地解释设计选择。该引擎应该使用“组件化”设计，但我看不到它在使用。下面是组件、复合和实体类的代码。我的问题简而言之就是：这段代码是否使用了有效的设计模式，还是过于复杂只是为了“实现设计模式”，从而导致反模式？

Component.cpp:

#include "Engine\Component.h"
#include "Engine\Composite.h"

Component::Component(Composite* parent)

{
    this->parent = parent;
}

Component::~Component()
{
}

Entity.cpp

#include "Engine\Entity.h"
#include "Engine\Game.h"


Entity::Entity(Composite* parent):Composite(parent)
{
    this->mass = 1;
    node = NULL;
}

void Entity::update()
{
    Composite::update();

    this->angularVelocity += this->angularAccelaration;
    this->orientation += this->angularVelocity;

    this->accelaration = (1 / this->mass) * this->force;
    this->velocity += this->accelaration;
    this->position += this->velocity;
    if (node != NULL)
    {
        this->node->setPosition(this->position);
        this->node->setRotation(this->orientation);
    }
}

void Entity::draw()
{
    Composite::draw();

    if (node == NULL) return;
    if (!this->visible)
    {
        this->node->setVisible(false);
        return;
    }
    this->node->setVisible(true);

    this->node->render();
}

void Entity::createNode(std::string modelPath)
{
    // Get the mesh
    irr::scene::IAnimatedMesh* mesh = Game::getSceneManager()->getMesh(modelPath.c_str());

    // Create model entity
    this->node =  Game::getSceneManager()->addMeshSceneNode( mesh );
    this->node->setMaterialFlag(EMF_FOG_ENABLE, true);
}

Entity::~Entity()
{
    Composite::~Composite();
    if (node != NULL)
    {
        node->drop();
    }
}

Composite.cpp

#include "Engine\Composite.h"

Composite::Composite(Composite* parent):Component(parent)
{
}


Composite::~Composite()
{
    for (std::list<Component*>::iterator i = components.begin(); i != components.end(); ++i)
    {
        delete (*i);
    }
    components.clear();
}

void Composite::handleMessage(unsigned int message, void* data)
{
    for (std::list<Component*>::iterator i = components.begin(); i != components.end(); ++i)
    {
        (*i)->handleMessage(message, data);
    }
}

void Composite::update()
{
    for (std::list<Component*>::iterator i = components.begin(); i != components.end(); ++i)
    {
        (*i)->update();
    }
}

void Composite::draw()
{
    for (std::list<Component*>::iterator i = components.begin(); i != components.end(); ++i)
    {
        (*i)->draw();
    }
}

void Composite::addComponent(Component* component)
{
    components.push_back(component);
}

void Composite::removeComponent(Component* component)
{
    components.remove(component);
    delete component;
}

下面这段代码是Player.cpp，它使用了组合和实体作为一种混合类型的对象（我真的不理解其逻辑）。

Player.cpp

#include "Player.h"
#include "Messages.h"
#include <iostream>

Player::Player(Composite* parent) : Entity(parent)
{
    createNode("../assets/sydney.md2");
    //i = 0;
    //v3f = vector3df(0,0,0);
    /*networker = new NetworkComponent();
    addComponent(networker);
    networker->registerVar(&i);
    networker->registerVar(&v3f);*/
}

void Player::update() {
    Composite::update();
    //std::cout<<i<<std::endl;
    //std::cout<<"vectorx="<<v3f.X<<"\n";
}

void Player::handleMessage(unsigned int message, void* data) {
    switch(message) {
        case DAMAGE: /* Do something */;
    }
    delete data;
}

Player::~Player()
{
    Entity::~Entity();
}

我不相信这是基于组件的设计。应该删除实体(Entity)，只使用组合(Composite)和组件(Component)。组件基类应该为空，永远不直接使用。例如一个名为'Rigidbody'的组件，保存刚体数据结构和一些函数，覆盖完全虚拟的组件基类。

- RB-Develop

---

感谢 Nathaniel Ford 的编辑，这应该会使它更加简单明了 :) - RB-Develop

我不明白游戏组件设计和组合模式有什么相同之处。在组合模式中，Player也应该是一个组件吗？ - yngccc

@yngum 我原以为这两个是完全不同的。这段代码是两种设计模式的混合吗？如果“Player”是一个组件，那么会有哪些继承它呢？难道组件不应该像“Controllable”这样，由“Player”继承吗？至少我现在对组合模式的理解是这样的。 - RB-Develop

Answer 1

发布的代码是组合模式的变体。这个设计模式是一种结构型模式，用于允许客户端以统一的方式处理单个对象和复杂对象(例如由多个对象组成的对象)。例如，渲染循环可以迭代一个对象集合，在每个对象上调用draw()方法。由于这是一种结构模式，很难主观地回答这是否是过度工程的实例，因为这需要检查更多的类层次结构和架构。

然而，无论是Component和Composite的类命名约定，还是复合设计模式的使用都并不意味着这是一个“基于组件”的设计。我之前不熟悉游戏编程组件模式，但它似乎本质上就是将策略模式与状态耦合在算法类中，从而简化了strategy和context之间的接口。无论哪种情况，这两种模式都是实现可交换和封装算法的行为型模式。因此，发布的代码并没有实现“基于组件”的设计，因为Component、Composite、Entity或Player类都没有提供一种以可互换的方式封装算法的方法。例如，Entity::update()总是以相同的方式计算位置。这种耦合要求扩展Entity类层次结构，如果Entity需要使用不同的物理模型（考虑到Entity跃迁到具有不同物理模型的星球的情况），而不是委托给封装算法的Physics类层次结构。

- Tanner Sansbury

---

我明白你的意思，感谢你的见解。那么我想问设计是否有效。我以为组合和实体是一回事：它们都是将组件集合以抽象的方式添加到对象中来增加功能的。 - RB-Develop

@RB-Develop：我已根据原问题的更改更新了我的答案。实际问题相当主观，但希望答案提供一些澄清，让您自己做出决定。 - Tanner Sansbury

谢谢你的更新，这让我更清楚了。原来他们采用了“组件化实体系统”，只使用了组件和实体（看起来像是一种有着花哨名字的策略模式）。后来一位老师提到复合模式可能是个好主意，所以他们就加了它。我不认为这是过度设计，我认为这只是一个有缺陷的设计。 - RB-Develop