• 04/03/14 12:36 PM
    Sign in to follow this  

    A Critique of the Entity Component Model

    General and Gameplay Programming

    rioki
    • Posted By rioki

    The entity component model is all the rage for the last decade. But if you look at the design it opens more issues than it solves.

    Broadly speaking the entity component model can be summarized as the following: An entity is composed of components who each serve a unique purpose. The entity does not contain any logic of its own but is empowered by said components. ecm-intro.png

    But what does the entity component model try to solve? Each and every illustration of the entity component model starts with a classic Object-Oriented conundrum: a deep inheritance hierarchy with orthogonal proposes.

    For example, you have a Goblin class. You form two specializations of the Goblin class, the FylingGoblin who can fly and the MagicGoblin who uses magic spells. The problem is that it is hard to create the FylingMagicGoblin.

    dreaded-diamond.png

    Even with C++ and its multiple inheritance, you are not in the clear as you still have the dreaded diamond and virtual inheritance to solve. But most languages simply do not support a concise way to implement it. When solving the issue with components, the components GroundMovement, FlyingMovment, MeleeAttack and MagicAttack are created and the different types of goblins are composed of these.

    flying-magic-goblin.png

    Good job, now we went from one anti-pattern (deep inheritance hierarchy) to a different anti-pattern (wide inheritance hierarchy). The central issue is that the inheritance hierarchy tries to incorporate orthogonal concepts and that is never a good idea. Why not have two object hierarchies, one for attack modes and one for movement modes?

    goblin-sanity.png

    As you can see from an object oriented standpoint the entity component model fares quite poorly. But that is not the only problem the entity component model tries to solve. In many cases, you see the concept of a data driven engine. The idea is that you can cut down on development time by moving the object composition out of the code and into some form of data. This allows game designers to "build" new objects by writing some XML or using a fancy editor. Although the underlying motivation is valid, it does not need to use an entity component model, as a few counter examples show quite well. Putting the structural criticism aside, a naive implementation of the entity component model can in no way be efficient. In most cases the components are not such high concepts as moving or attacking, they are more along the lines of rendering and collision detection. But unless you have additional management structures, you need to look at each and every entity and check if it has components that are relevant for the rendering process.

    inefficient.png

    The simplest way to resolve the issue, without altering the design too radically, is the introduction of systems. In this case the actual implementation is within the systems and the components are just indicating the desired behaviour. The result is that a system has all the relevant data in a very concise and compact format and as a result can operate quite efficiently.

    better-graphics.png

    But if you look closely you can see that we have all these useless components. What if you removed the components and just used properties on the components and the systems just look for appropriately named properties? Now you have duck typing.

    duck-typing.png

    Duck typing is a concept that is used a lot in weakly typed languages, like for example JavaScript or Python. The main idea here is that the actual type is irrelevant, but specific properties and function are expected on a given object within a specific context. For example it is irrelevant if it is a file stream, a memory stream or a network socket - if it has the write function it can be used to serialize objects to. The problem with duck typing is that is does not lend itself easily to native languages. You can cook up some solution using some varying type but in no way is this an elegant solution. Chances are you already have a scripting system, in this case the solution is quite straight forward, you implement the core game logic in scripts and underlying systems look at this definition and implement any heavy lifting in native code. The idea of alternating hard and soft layers is nothing new and should be considered where flexibility and performance is needed. You may think that implementing the game logic in scripts is an inefficient way to do it. In cases where you are building a simulation-oriented game this may be quite true. In these cases is makes sense to extract your logic and reduce it to its core concepts, a simulaiton if you will. Then implement the presentation layer and control layers externally directly against the simulation layer.

    totally-not-mvc.png

    The nice thing about this design is that you can split the presentation layer and simulation so far that you can put one of them on one computer and the other on a different one.

    mvc-network.png

    Wait, did you just describe MVC? Um... No... Stop changing the subject. When looking into scalability you get interesting requirements. One very clever implementation of the entity component system was to make it scale in an MMO setting. The idea here is that entities and components do not exist in code, but are entries in a database. The systems are distributed over multiple computers and each work at their own pace and read and write to the database as required.

    mmo-ecm.png

    This design addresses the need of a distributed system and reminds me of the High Level Architecture][10] used by NASA and NATO to hook up multiple real-time simulations together. Yes this design approach even has its own standard, the IEEE 1516. Ok, oh wise one, what should we do? If you read about these issues you are either building a game engine or a game. Each and every game has different requirements and game engines try to satisfy a subset of these different requirements. Remember what you are developing and the scope of your requirements. If your current design sucks, you do not need to go overboard with your design, because chances are you aren't gonna need it. Try to make the smallest step that will solve the problem you are facing. It pays out to be creative and look at what others have done.



      Report Article
    Sign in to follow this  


    User Feedback

    Create an account or sign in to leave a review

    You need to be a member in order to leave a review

    Create an account

    Sign up for a new account in our community. It's easy!

    Register a new account

    Sign in

    Already have an account? Sign in here.

    Sign In Now


    Sacaldur

    Report ·

      

    Share this review


    Link to review
    Ectara

    Report ·

      

    Share this review


    Link to review
    3Ddreamer

    Report ·

      

    Share this review


    Link to review
    DrakeFG

    Report ·

      

    Share this review


    Link to review
    ballmar

    Report ·

      

    Share this review


    Link to review
    tnovelli

    Report ·

      

    Share this review


    Link to review
    l0calh05t

    Report ·

      

    Share this review


    Link to review
    traghera

    Report ·

      

    Share this review


    Link to review
    mikegeig

    Report ·

      

    Share this review


    Link to review
    Bleys

    Report ·

      

    Share this review


    Link to review
    Wrathnut

    Report ·

      

    Share this review


    Link to review
    Tesshu

    Report ·

      

    Share this review


    Link to review
    Satharis

    Report ·

      

    Share this review


    Link to review
    KamilKZ

    Report ·

      

    Share this review


    Link to review
    AC9786

    Report ·

      

    Share this review


    Link to review
    Bacterius

    Report ·

      

    Share this review


    Link to review