3

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

组件.cpp：

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

Component::Component(Composite* parent)

{
    this->parent = parent;
}

Component::~Component()
{
}

实体.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();
    }
}

复合材料.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，它使用复合和实体作为混合类型的对象（我真的不明白逻辑）。

播放器.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();
}

我根本不相信这是基于组件的设计。不应该删除实体，只使用复合和组件。组件基类不应该是空的，从不直接使用吗？就像一个名为“Rigidbody”的组件，它拥有一个用于刚体数据的数据结构和一些覆盖完全虚拟组件基类的函数？

4

1 回答 1

2

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

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

于 2013-04-08T22:30:56.737 回答