AFAIK, Adding an entity to the world involves adding its components to their respective systems. If an entity is only an id, constructing it is absolutely useless unless components or something else contain a reference to it.

Now, when an entity is to be destroyed, we’re going to remove it’s components from the systems, right? So we have the entity, but we have no idea which components it contains, or which systems they belong to.

Since the entity contains nothing, we know nothing. Maybe I’m missing something crucial here.

(it’s “good enough” for prototyping – I’ve had it running 100′s of game entities at 30 FPS on old Android phones)

Anyway, thanks again!

In theory, it ought to work well. The problem is that I haven’t written any C++ in a long time, and I’m very rusty. In practice, when I struggled and went looking for 2nd opinions, most of the hardcore C++ people I know haven’t adopted ES’s yet and won’t focus on the problem – they instead try to sell me on other, “more C++ style” solutions. Which is usually missing the point, sadly. In practice, C++ coding with the current free IDE’s I have access to makes my head hurt (Eclipse C++ support is (to put it nicely) “weak”, and let’s not even mention Xcode). I actually find it easier to write C++ on paper and then b*tch-slap the IDE into accepting it, than to write it with the IDE’s ‘help’ :(.

So … sorry!

I suggest you try tweeting at some well known tech / games people who tweet about C++ programming – there are interesting problems here, and they might find it fun to have a go with.

You mention that if you were working in C++ you would use templates. And for the life of me I can’t figure out what that would actually look like. I know enough about templates to see the benefit, but I’m just not seeing how an ES would work like that. Do you have any examples of an ES implemented in C++? The Entity Manager is where I’m having the real problem, but anything would be greatly appreciated.

And great job on the articles! I just wish there was more information on Entity-Component design in general (everything I’ve found either redirects here, or has a not-quite-right ES design).

ADOBE FIX THIS SERIOUS ISSUE!

What is the ‘right’ way to do this?

Re: gravity, I’d be inclined to apply a gravity vector every tick, and allow your Collision system to decide whether to act on it. That way, you have a more general solution. Only reason I’d do it differently is if you had too many things doing CD, and you had a performance problem there.

I don’t really understand how you would have a CD system that does *not* have logic for handling all the different types of collision?

When the player attempts to jump I need to determine if they are standing on ‘the ground’. In the existing game logic this is done using ugly, oddly specific code (we were in the final 72 hours of the project – code readability tends to go out the window at about that point :). I’ll also need to deal with ‘gravity’ for some entities (including the player), which causes them to fall when they are NOT standing on the ground. What would be the best way to do this in an entity system?

I considered adding some additional information to the Collides Component to store what entities it collided with this frame, but that just seems like the wrong way to do it. I could also have the CollisionSystem itself check for contact with the ground and react accordingly, but this would lead to bundling a lot of logic handling reactions between colliding components (damage, power ups, health packs, falling, etc) into that system. Again, this seems wrong.

Still getting dozens of bug reports that *are already fixed* in the main fork, but no-one can see that, because the original author has disappeared :(

A project I contribute to is actively missing out on programmers and users BECAUSE THE ORIGINAL AUTHOR WON’T DO ANYTHING (he ignores twitter @messages, he ignores emails, he ignores the project).

Forks on GitHub *are not allowed* to have:

– Documentation
– Issue Tracker

…so the whole project is gradually going FUBAR, because of GitHub’s top-down, command-and-control approach to projects :(.

We *cannot fix* items in the tracker, and we *are not allowed* to have our own tracker. WTF is a project supposed to do?

I’ve been considering how to retrofit a more sophisticated implementation of ES into my main project — a multiplayer game with shared physics, already using a “client belief” system to minimize network updates — so I’ll be following your thoughts here very closely. I was sold on the value of GUIDs (even for client-server) long before my Ludum Dare experiment, so I expect the transition to be less painful than otherwise.

I have some vague notions of the need for a versionable identity. In my testing, a simple incremented version or timestamp scheme breaks down; it develops conflicts, the same way source control systems with incremental revisions have conflicts. The best I can manage at the moment is a sort of patch component, which is workable for deltas but not so well for other types of conflicts. When this issue comes up again, my next thought was to look at modern revision control systems like Git to see if there are any ideas that will transfer.

But I’m really looking forward to whenever you have the time to describe SuperEntities. Can’t wait.

Thanks again.

While the display is ON, USB is running

While the lid is open by even just 5 millimetres, USB is running, until approx 10 seconds after the display sleeps

While the lid is closed, USB remains running for approx 10 seconds

Indeed.. I certainly came across a bit zealous on extensible enums. Though it certainly has been the solution for me in storing unrelated entity state and general enum / state sharing between code projects / modules reducing dependencies on concrete enum types between modules. Like Josh Bloch mentions in item 34 that extensible enums seem only useful for opcodes; it turns out that encoding unrelated entity state is a very similar problem. The benefit of a statically typed enum over strings and bit fields and being able to load and manipulate states via reflection and the various Class methods of Java are awesome. IE Class.getEnumConstants();

The benefit of ExtEnumSet is that you can pack it with entity state enums that are unrelated to each other, but maintain one location for storing all entity state instead of separate location / data components. All systems just need access to the single ExtEnumSet stored in the entity. Otherwise if you store state for each subsystem area specifically in it’s own component (say an animation data component) then every system that acts on those states also has to depend on all of the data components storing the various state. This can quickly void the benefit from a dependency angle of a component architecture for more complex games. There is also no way to enumerate over all these states in mass with state stored in separate components.

Also check out the item 32 & 33 of Effective Java and the EnumSet / EnumMap discussion. The phase change example can be extended / modified to encode and retrieve say animation transition states.

Now instead of polling with if conditional statements each frame consider storing additional helper systems (or just a callback interface / class type) in an EnumMap (or ExtEnumMap). IE an animation system component can store additional callbacks by transition state or perhaps just the normal entity states (run left, etc.) stored will also trigger callbacks when the EnumSet storing state is enumerated against the EnumMap storing the callbacks. I’m sure a little code example will make this clearer, but this seems like something to explore to complete an agnostic mechanism that can be loaded up in a data driven manner avoiding hard coded if conditional polling. This is at least how I will first approach a generic animation system. This basic mechanism should work for both 2D sprite sheets and bones or other 3D animation systems.

Granted if your game is simple and everything is known in advance and you don’t mind hard coding the if / conditional / polling then that certainly will be the quickest. In my efforts I’m building generic subsystems such as animation that are entirely data driven.

I don’t have an official blog yet, but will be launching one officially for my efforts at the TyphonRT link. I do post tech pontifications on G+ – https://plus.google.com/u/0/117904596907381647757/posts

Without a big corporate employer to pay travel costs, merely speaking at a USA conference costs me a minimum of $1,500 – and some local UK devs recently agreed that e.g. attending Apple’s WWDC conf costs around $3,000-$4,500.

So … not trying to go to conferences at the moment. Focussing on making stuff instead :) which a much better thing to do anyway!

I don’t see the difficulty here, can you say what the specific problem is?

If you’ve got something that plays an animation, then you already have some notion of gradually moving through an anim.

To add transitions, all you have to do is duplicate those items in your animation component, and prefix them something like “transitionTo…”, and add a 3rd framecounter, which is the “percentageOfTransitionCompleted”

On each frame, if you detect there’s a transition in progress, you take the frame in the old anim, and the frame in the new anim, and then you use the percentageOfTransition.. to morph between them (and update the percentageOfTransition… counter too).

Depending on how your anims work, you MIGHT need to keep updating the framecounters for the two anims too – e.g. if someone is “running’, and then hits “jump”, then you probably want to keep the legs moving in the source anim while you transition it to the other anim. (this works fine in 3D, where you can tween the individual bones of the legs. If you’re using 2D sprites with no bone info … it probably looks very strange / wrong)

Don’t sweat it too much. Things are still seemingly in the early adoption phase, so there isn’t any one codified approach so to speak yet. There are small to large differences between most ES implementations.

>How should the states be saved? As a string in the a special component? Or as different components?

If you are using Java I am a huge fan of extensible enums. Josh Bloch’s book Effective Java item 34 is a good place to start (http://tinyurl.com/73xvzo7). You’ll notice though that even in Bloch’s description of extensible enums he stops short and mentions that they are not usable with an EnumSet (item 32) which is a fast implementation of a Set for enums.

To overcome this I’ve made an extensible EnumSet (ExtEnumSet) that allows one or more extensible enums to be packed into a bit set. One of the only things in my ES efforts that defines an Entity vs just a standard component manager is that the Entity is guaranteed to have at least one ExtEnumSet to store state. An entity if necessary can have more than one, but due to the extensible nature of the set usually one is just fine. The really cool thing is that you can correlate combinations of state between unrelated extensible enums or even just retrieve the combinations of state stored for one extensible enum.

>Where would a current animation state be stored? How would the absence / presence of a component play a role here?

Buried in the “goliath ES post” I even discuss how it’s possible to create an extensible enum component that conforms to the general ES mechanism.

I much prefer extensible enums in my work as they provide a strongly typed way to store unrelated state and this definitely cuts out mistakes with a collection of Strings or the plain old bit fields.

An animation system can then retrieve one or more enum sets from ExtEnumSet to determine currents state and say which sprite sheet to draw. Quite conceivably if there are parallel animations on the same entity 2 or more animation systems could run in parallel each frame.

If there is complex transition state that can’t be represented by on / off or a combination of state I suppose one could even create an “in between” extensible enum that stores a third state for a more complex action. This transition enum would be time varying somehow where a system would control it’s state and not the user directly.. IE user presses a button state 1 is on; user lets go button and state one is off and then a system detects this and sets the in between state; x seconds later the system turns off the in between state.

The nice thing about the ExtEnumSet is that it provides one data component that can generically store any number of different state enums. IE you don’t have to make a custom component for each different type of state you want to store as it all can be packed into one ExtEnumSet. Various animation systems also just need to access the single ExtEnumSet. This also allows state to be programmatically set or say input oriented systems to directly store state in this ExtEnumSet and the animation systems don’t have to know anything about the various input systems.

Unfortunately there is not a whole lot of folks out there who have written on using extensible enums or creating an extensible EnumSet. As far as I know with some Googling I haven’t found anyone else mention the above. It’s been a huge boon in my efforts thought it’s also not easy to create this additional EnumSet variation and I can see why work stopped at EnumSet in regard to the Java SDK and the general case. Definitely more error prone for a custom collection and my implementation is only 75% complete today, but brings great functionality already.

I swear by extensible enums really… They are also a key way to share state between wholly distinct modules (usually an IDE project) greatly aiding reduction of dependencies for state between modules.

I have one more question about systems and components. Currently I’m working with animations and how to handle them. I created an animation component to work with a rendering component. A generic “Animate” system simply updates the frame count in the animation component and passes rendering information to the rendering component (more specific: which rectangle on the sheet to draw).

However my question is about how to handle transitions between animations / animation states. Where would you put that logic? In one system that checks animation states and events to change a state, or diffuse over all systems? How should the states be saved? As a string in the a special component? Or as different components?

Undoubtedly my lack of experience puts me in a position where I’m not sure how to handle this while making sure to respect the Entity System Philosophy.

I noticed some one asked a similar question on one of your previous articles in the series, Adam. Oh, I just can’t seem to find it at the moment. On gamedev.stackexchange there was a similar question though. I wondered what you’d think about the answer, especially when you told us not to trust advice from that site :). http://gamedev.stackexchange.com/questions/25686/abstracting-entity- system-animation-states

You also mentioned in part 2: “The Animation system constantly looks out for anything that would trigger a new animation, or cause an existing animation to change (e.g. player changes direction mid-step), and updates the data of each affected Entity (of course, only those that actually have the Animatable Component, i.e. are animations).”

Could you help me out here and elaborate a bit on how that would work exactly? How does it “look out” for those triggers? A bunch of if-statements where we check keyboard input (while running, for example)? Where would a current animation state be stored? How would the absence / presence of a component play a role here?

Anyway, thanks for the advice you guys gave me and hopefully you’ll find the time to help me out again. It’s a learning process and I hope I’m not bothering you with boring details, I’m just trying to fit the pieces together.

My general approach is to use multiple languages. So called scripting languages have come a long way. I’ve done some pretty amazing stuff with jruby for instance, because I can leverage the jvm and choose when to use pure java or do it in ruby. And I’ll sometimes drop out to C using extensions.

For network servers, messaging systems, etc.., you are better off using java or C. Anything that has to handle thousands of operations a second, is going to benefit from a faster language. But the key here is that with distributed computing and scaling horizontally, there are fewer places in your code that have to handle that kind of volume, so it opens the door to doing a lot more with more productive languages. The big failure of the game industry has been to stick with vertical scaling. You don’t need to handle thousands of requests per second on a single server, although I’d say around a thousand is a good number for an intel box.

I haven’t worked that much on physics engines in particular, but I’ve spent many years on client/server architectures, and I work with live games where we are using distributed systems and message passing to a good degree of success. I’ve seen first hand the source code for several commercial engines, and how can I say it nicely, they are antiquated. They can only scale vertically, they still have an rdbms as a central bottleneck. Very little use of tools like redis, mongodb, zeromq, etc.. If you are still scaling vertically and your only option is to squeeze as much as you can out of a single server, you are doing it wrong.

Another major lesson I’ve learned is that the performance of the language does not equal the performance of the system. The main reason now days to choose languages like C or Java is the tools, that’s where dynamic languages are still pretty far behind. Things like thread/heap dumps, good memory management, profiling tools, that’s what you miss the most.

http://blog.gemserk.com/2012/01/03/reusing-artemis-entities-by-enabling-disabling-and-storing-them/

Pretty much any 3rd party library one has to be mindful of how data/system components aggregate OOP bound objects including say the Android SDK which has provided its many “bundles of joy” to untangle. IMHO the majority of the Android SDK is hastily created, already shows the general failures of OOP, and real trouble spots w/ some underlying Harmony implementation _still_ plagues Android 3.5+ years on even w/ ICS – Google is more interested in adding new features _still_ instead of shoring up the bases and reducing technical debt instead of piling it on… (uh oh did I just go on another Android rant; love it). If you are lucky the objects are not just bound by DI or constructor injection; IE they are more POJO in nature and / or have getters / setters so that when an aggregate component is recycled these explicitly composed objects can be set with fresh data.

The Gemserk folks sort of cheat by simply disabling unused entities in their aggregated state and enabling them again when they are needed. This certainly works, but unfortunately is not much of an improvement over a heavyweight object pool.

Regarding methods in data components. From my perspective this is certainly fine especially if the setter methods do some sort of error or bound correction as any externalization of this is kind of silly. Also the use of interfaces for components even data components one must have getter / setter accessors.

@JS – “cannot contain methods. However sometimes it seems to be logical for a component to hold a class object”

Explicit composition / has a relationships are fine IMHO. In my efforts Since any component can also be a component manager it’s possible to create a data component that supports implicit composition so one can dynamically aggregate and access additional child components. In my efforts generally where speed or data oriented concerns aren’t in play the implicit composition form is preferred. In particular if one is combining a 3rd party OOP framework it’s necessary to embed. One has to be careful though in this approach of embedding OOP frameworks in a component framework when it comes to recycling components especially if the contained OOP objects are only initialized via constructors.

An example of folks running into this type of problem are Gemserk folks who are customizing Artemis combined with libgdx which is an OOP framework. Recycling components becomes a problem when your core framework integration is OOP. Nice blog to follow on folks using entity systems: http://blog.gemserk.com/

In my efforts I provide essential parity in features compared to libgdx, but all APIs are component oriented thus recycling custom components that integrate graphics API components don’t get gunked up with deeply embedding an OOP framework. Might I say though that it’s taken me significantly longer to get my efforts publicly available due to the additional up front architecture complexity.

Methods live inside your System, not on your Compononents. Put the method inside your CD system – which is where it should be! It has nothing to do with anything except collision!

If you’re desperate to keep it in separate methods-per-type, use Function Overloading, and have multiple static methods / instance methods on your System (or on a helper class for your system – which is probably the cleanest way to do it)

You can’t.

You shouldn’t.

I’d like to seperate my collision code from the entity system. My “CollisionSystem” (or process in my implementation) should take data from the entity system, give it to a separate physics / collision engine, pull out results and create CollisionReaction components accordingly or update the data within the entity system.

What I want to avoid is to implement a set of collision algorithms that are dependent on a specific entity system component. How can I achieve this encapsulation of collision code so it doesn’t have to know the entity system or what components are?

RotMG could be much faster if they switch to Flash 11 / Stage3D. It’s a 3d engine doing software rendering using Flash’s 2d API. That port is probably more practical than a port to Unity :)

re: Shape – sounds to me like you should have a PolygonCollidable component, a CircleCollidable component, etc. Why on earth would you have a “Shape”? I’ve done it this way in a few games – then I can swap in/out new CD algorithms, e.g. algorithms that don’t support circles, or only support 2D collision not 3D collision – and everything works fine because the algorithms only access the data that they understand.

Obviously, if there are entities that the algo doesnt understand, they dont participate in CD – but that’s much better than any alternatives.

re: vector – If you’re going to create new basic datatypes – e.g. Vector – then your choices depend on language. The purest approach is to make the new type IDENTICAL TO a fixed-size array of basic datatypes (i.e. a struct in C), and (if your language supports it) read/write to/from the raw basic datatypes – even if you use a flyweight / facade on the front to make it “look like” a basic datatype (in the form of an object). Creating new methods for the new type – that live outside the ES and outside your code – is OK. But a lot of people find it difficult to stop at that point; a lot of people are then tempted to add methods to their components themselves.

In general, though, I advise against adding new datatypes until you’re 100% sure and comfortable with the ES. It’s so easy to screw up at that point.

re: “process” – yes, “System” is too generic a name really, I’m open to better names, but they’re all too generic. e.g. Process is already defined to mean “a kind of thread” or “an application” in many programming languages :(.

I know components can only hold data e.g. “int”, “String”, … and cannot contain methods. However sometimes it seems to be logical for a component to hold a class object.

I have a very concrete example. My collision detection class has static methods for calculating if polygons and circles overlap. Therefor I have 3 important classes: Polygon, Circle, Vector. Those classes hold a bit of data [ Vector.x and Vector.y for example ] and a few simple methods to do math [ Vector.add(Vector v) ]. They clearly do not contain game logic.

It seems logical to create a “Physical” component with field “shape” which holds e.g. a Polygon object.

The other way to do this I see right now is to give a “PhysicalPoly” component a list of x values and a list of y values and a center and when I run the CollisionSystem create new Polygon objects based on the data in the PhysicalPoly components I need to check and destroy them in the end. However this seems quite intensive to do each game tick.

What am I overlooking here?

On a side note: I named my (sub)systems differently by the name of “Process”. Every process has one public method “Process.run()”. The way I understand your concept of an ES that seemed like a better naming to me. E.g. I have a component “Position” and a process “Move”. So I call Move.run() on every Position component I want to move.

Another thing I did is create simple groups of entities. Instead of letting my Move process on all entities with a specific component (like a ‘Move’ component) I would let it process all entities who subscribed to the “Movable” group. So on entity creation I would add all components I want it to have and register the entity to all groups I want it to be processed in.

Here is an example of entity creation (I thought you might be interested):

// Create player
Integer player = em.createEntity();

// Add player to groups
em.addEntityToGroup(player, “PLAYER”); // Add player to group
em.addEntityToGroup(player, “MOVABLE”); // Add player to group
em.addEntityToGroup(player, “ACCEL”); // Add player to group
em.addEntityToGroup(player, “RENDERABLE”); // Add player to group

// Add components to player
Position pos = new Position(0, 0); // Create component
em.addComponent(player, pos); // Add component
Velocity vel = new Velocity();
em.addComponent(player, vel);
Accel acc = new Accel(30);
em.addComponent(player, acc);
Rendering ren = new Rendering(0);
em.addComponent(player, ren);

Thanks for the extra info!

re: TCP/UDP – doh, I’d heard rumours that Flash supported UDP by now, but looking into it, I see that’s not quite true (yet). That’s a huge blow for fast MP games like RotMG :(.

I know a lot of indie game devs are switching to Unity now, due to frustration with Adobe. There’s still a plugin to install, but I know a lot of Flash sites lose a lot of users when they move to newest Flash, and find many users don’t want to / can’t / can’t be bothered to upgrade Flash.

Hmm … RotMG ported to Unity … that could be interesting….

My main complaint is that Apple’s Dev Forum doesn’t restore properly, but I’m willing to put part of the blame for that on how I think the Dev Forum is implement.