29 years old, from Leipzig (germany), student of computer science (master degree), hobby gamedev, chaotic, curious, hungry for knowledge, analytical ... but a really nice guy (at least my friends think ^^)

Latest Media

We're sorry, but no images, videos or audio files have been added to this gallery.

If you would like to share media with the community, sign up and you can.

Blog RSS Feed Report abuse Latest Blog: Artemis Entity Framework - Introduction

0 comments by Aron_dc on May 7th, 2013

As I can’t show you any code of Gliese yet, I will show you an interesting library I stumbled upon while I took part in Ludum Dare. It’s called “Artemis Entity Framework” and is very useful if you make a entity based game (most games are entity based I think ;) ) and don’t want to write a own entity management system.

For the beginning there are three basic classes you need to know:

  • World
  • Systems
  • Component

Components are the most simple objects Artemis does his magic on. They are simple data holding objects derived from com.artemis.Component and are used to store and change different aspects your entities could have. Just have a look at an example of a Position Component.

java code:
import com.artemis.Component;

public class Position extends Component {
  private float x,y;
  public Position(float x, float y){
    this.x = x;
    this.y = y;
  public Position(){
    this.x = 0f;
    this.y = 0f;
  // I've hidden all getters and setters as they are trivial.
  // You could also chose to make the attributes public

As you can see there is no magic in this code. So let's investigate Artemis further and look what Components are effectively used for.

Components normally don't have any logical code, as described above they're simple data holders. So where do we modify our entities. Let's imagine you have some entities with different components that give them information about their position (look at the code above) and speed (imagine a class almost identically to the Position-class but with speed vectors). To actually move them according to their speed we need Systems (typically derived from com.artemis.EntitySystem or its subclasses).

Systems use ComponentMappers to retrieve the different Components (called Aspects in this context) from entities and use them to process some logical code (e.g. rendering, moving etc.).

I'll show you a simple EntityProcessingSystem, called MovementSystem, that is used to transform an entitys position according to their speed.

java code:
import com.artemis.Aspect;
import com.artemis.ComponentMapper;
import com.artemis.Entity;
import com.artemis.annotations.Mapper;
import com.artemis.systems.EntityProcessingSystem;
import com.me.mygdxgame.components.Position;
import com.me.mygdxgame.components.Velocity;

public class MovementSystem extends EntityProcessingSystem {
  ComponentMapper<Position> pm;
  ComponentMapper<Velocity> vm;

  public MovementSystem() {
    super(Aspect.getAspectForAll(Position.class, Velocity.class));

  protected void process(Entity e) {

    Position position = pm.get(e);
    Velocity velocity = vm.get(e);

    position.setX(position.getX() + velocity.getVx() * world.delta);
    position.setY(position.getY() + velocity.getVy() * world.delta);



So what do we have here...

First you'll notice the two ComponentMappers, annotated with @Mapper, that are later used to retrieve the Components for Position and Velocity of an entity.

Then we use the super-constructor to tell our EntityProcessingSystem what components the entity we want it to process should have. In this example we need the Position and Velocity so we tell it through giving the super-constructor the according class information.

The logic is processed in the process-Method that gets an entity to handle with. In there you'll see that we get the references to the two components we need through the ComponentMappers (pm.get(e) retrieves the Position-Component from the processed entity). Then we change the current Position with the help of the Velocity-Component of the entity (world.delta is simply the time that elapsed since the last processing run).

You can use these EntityProcessingSystems to make almost anything you need to do with your entities, from translation, rotation, assigning textures, rendering ... everything is encapsuled in an own EntityProcessingSystem.

The world (com.artemis.World) is the class that creates and handles your entities and systems. To show you how the World-class is used let me show you some snippets:

java code:
world = new World();
world.setManager(new EntityManager());  // sets how Entities are managed within our world. Different managers are available
world.setSystem(new MovementSystem());
world.initialize(); //final world initialisaition. Never forget to call this!

I only added one System but you can add as many Systems as you like. You can also exclude Systems from the automatic processing (but you have to call "process" manually then) through adding another parameter to the setSystem method that sets this System to "passive"-processing. This is useful if you want to split your gamelogic (typically processed automatically) and your rendering (that you better invoke manually to maintain a correct rendering order (e.g. background-foreground-hud).

Our world is initialized now, but how do we add entities? That's nearly as simple as writing a Component. First we retrieve a new entitiy from our world, then we add all components we think it needs and last we call addToWorld() at this entity.

java code:
Entity e = world.createEntity();
e.addComponent(new Position(20, 20));

The last thing we need to know is how to start the processing of our entities. To do that we first need to calculate a delta time (a time that passed since the last call of our main game-loop). As I use libgdxs Game class I already get that value from libgdxs internal behaviour.

java code:
//this belongs into you main game-loop
world.setDelta(delta); // pass delta time to Artemis
// here you could also call process at any System, you have excluded from automatical processing (e.g. rendering)

First we give our delta time to the world object, so it knows how much time passed. We then call process at our world object, that invokes every non-passive System in the same order we added it to our world. If you have passive Systems you'll need to invoke their process() method manually.

Conclusion / tl;dr
Using data classes (Component) and classes that implement the processing logic (System), Artemis makes it easy to hold your entities logic independent of the entity description and keeping them physically separated. The approach of adding needed components to an entity makes the whole system very flexible and helps keeping them slim and easy to understand. Thus making the whole implementation of different entities really fast and slim.

Post a Comment
click to sign in

You are not logged in, your comment will be anonymous unless you join the community today (totally free - or sign in with your social account on the right) which we encourage all contributors to do.

2000 characters limit; HTML formatting and smileys are not supported - text only

Offline Since
Nov 13, 2014
Germany Germany
Member Watch
Track this member
Activity Points
59,961 of 478,990
0 members
Time Online
1 second
Site Visits
Profile Visitors
2,417 (3 today)
Private Message
Send Now
Members Only

Latest tweets from @aron_dc

RT @gavanw: video update T.co

19hours 29mins ago

@fsinfLeipzig Da könnt ihr vermutlich aber nix für wenn der Stura Uni-Halle das pflegt

19hours 36mins ago

@fsinfLeipzig Wobei ich grad sehe, dass der Link zu "Her mit der Kohle" auch auf einen Fehler beim Aufbau der DB Verbindung führt.

19hours 36mins ago

@fsinfLeipzig Hier läuft auch Chrome Version 39.0.2171.65 m Wie gesagt das betrifft nur den Link auf T.co

19hours 37mins ago

@fsinfLeipzig Beim ersten Link zur Bekanntmachung der Vorschläge

Nov 22 2014, 5:57am

@fsinfLeipzig requested URL /news/2014/11/22/2014-11-wahlen/images/tmp/bekanntmachung-wahlvorschläge-2014.pdf was not found on this server.

Nov 22 2014, 5:56am

RT @MikehlJohnson: Need royalty-free sound effects libraries? Check out -> T.co - #gamedev #gameaudio #gamedesign #indied

Nov 21 2014, 8:46am

Viele Kinder wissen heutzutage gar nicht mehr, wie ein Binärbaum eigentlich aussieht ;-)

Nov 21 2014, 5:55am

Feststellung des gestrigen Abends: Wenn Leute in Internetdiskussionen auf Eloquenz und Argumente/Beweise treffen sind sie oft verwirrt.

Nov 21 2014, 4:55am

Ok mein 2. Monitor macht doch langsam schlapp... da werd ich in 10 Tagen wohl einen neuen kaufen müssen...

Nov 20 2014, 8:50pm

Baldurius friends since May 2, 2013
Silberschweif friends since Mar 24, 2012