So I'm working on a game with Anax. I'm using finite state machines to model the change in game state (i.e. main menu vs. in-game vs. splash screen, etc.). I don't wanna publish the source code yet, because it's not properly tested or polished, but here's the gist of it;

• The WorldStateMachine, of course, maintains a pointer to the World in question (just a raw pointer, though).
• Rather than directly passing in a new state (e.g. wsm.changeState(TITLE_SCREEN)), I'm writing it with more traditional transitions in mind (e.g. wsm.transition(EXIT)). The states are nouns of some kind (title screen, in-game, etc.), and the transitions are verbs (exit, advance, pause, etc.). Whenever you transition, the WorldStateMachine takes the input and the current state, and looks at the transition table (a std::map) to decide where to go next. If no transition is defined, an exception is thrown.
• The WorldState itself consists of just three function objects; one called on state exit, one called on state entry, and one called every frame.
• Systems are not explicitly added to WorldStates; that's what onEnter() is for (though that could be up for debate)
• WorldState favors composition over inheritance (you're not subclassing it, you're passing functions into it), though I don't see why I couldn't allow both with abstract base classes or something.
• All states in a WorldStateMachine are referenced by some key
• There are three template parameters for WorldStateMachine; one is the state type (which is ideally an enum), another is transition type (also an enum, preferably), the third is a parameter pack of arbitrary arguments (e.g. a std::vector<sf::Event>; I know you use SFML). For a WorldStateMachine to be compatible with a WorldState, it must share the last parameter type.
  • This part of the design I'm a bit iffy about. Subject to change.

I'm writing this for my game, but if I were to polish it up and write unit tests, would you want it in Anax?

Calling entity.removeComponent(), when any System uses that Component causes crash and/or 'onEntityRemoved' does NOT get called. However, outright killing the Entity does trigger the onEntityRemoved System callback.

Error: "Assertion failed: entity.isValid() && hasComponent(entity, componentTypeId) && "Entity is not valid or does not contain component", file C:\anax\detail\EntityComponentStorage.cpp, line 75"

I'm looking for a Component-Entity-System library, and I found these two. The faq lists EntityX as an inspiration. I find the two very similar in goals and implementation as well. Is there a killer advantage to choose either?

Hi Miguel Martin, first I would like to say I'm impressed that you are building this kind of tools at your age, it usually take some years of coding to get the knowledge and confidence to code this things.

My questions is about the licensing of the library. I'm building a simple game engine and I'm currently using Artemis-Cpp for the Entity-Component System, but your implementation catched my attention and I would like to give it a try and see how it performs (I'm more interested in code readability rather than raw performance TBH) but the copyright is holding me off at this point. My game engine will have a MIT license and I don't know if that conflicts with your copyright licensing.

Will it be sufficient to include a Copyright note stating that I use anax, which is implemented and copyrighted by Miguel Martin?

Just noticed this, I'm guessing it will just require some sort of 'hasEntity()' interface in the System class? This worked for me:

// if the entity passes the filter the system has
if(i.second->getComponentFilter().doesPassFilter(m_entityAttributes.componentStorage.getComponentTypeList(entity)))
{
    if(!i.second->hasEntity(entity))
    {
        i.second->add(entity); // add it to the system
        detail::EnsureCapacity(attribute.systems, systemIndex); 
                        attribute.systems[systemIndex] = true;
    }
}

Fixed Entity::Id's being re-cycled incorrectly. Fixed issue where re-activating Entities caused them to be re-added to their Systems. Added the ability for an empty Entity handle to check its validity without asserting.

I just read an interesting article on Tuts+ about spaces, which are analogous to layers on Photoshop or similar; a game object (an Entity, in Anax's case) occupies a space, and interacts only with other objects on that space. My question is this; do you think it's a good idea to use Worlds as spaces by having multiple Worlds exist at a time, each with their own Entitys, Components, and Systems? Or might that break something?

Sorry for writing it here, I think I am abusing the functionality of GitHub's issues again, but there is no forum or chat.

In this example the systesm are first declared

SpriteRenderingSystem m_spriteRenderingSystem;
AnimationSystem m_animationSystem;
MovementSystem m_movementSystem;
PlayerInputSystem m_playerInputSystem;
CollisionSystem m_collisionSystem;

then added to the world

m_world.addSystem(m_spriteRenderingSystem);
m_world.addSystem(m_animationSystem);
m_world.addSystem(m_playerInputSystem);
m_world.addSystem(m_movementSystem);	
m_world.addSystem(m_collisionSystem);

and then their update method is called every frame

m_collisionSystem.update(deltaTime);	
m_animationSystem.update(deltaTime);
m_playerInputSystem.update(deltaTime);
m_movementSystem.update(deltaTime);

And this is just from a simple example.

I thought about having a container (like std::vector), which would cut down on the latter two snippets, which could be replaced with a for-loop, but the data types are different for all of them. I haven't worked with this yet, but maybe std::any or having them be pointers of a base type that all systems inherit from?

What's your input?

Basic collision tutorial - I still need to clean it up, fix the member variable prefixes (i used mVar instead of m_Var XD), remove some debug lines, and document a little more. There's one problem that I can't figure out - for some reason, the sprites are getting rendered half of their width to the right; but their bounding boxes are at the correct position. If you don't see anything right away, don't worry about it - I'll probably be able to get down to the bottom of it within a couple of days.

Anyway, tell me if you see anything glaringly wrong in the Game.cpp - I followed your convention layed out in the Movement tutorial, and made Game inherit from CollisionSystem::Listener and overrode the CollisionSystem::Listener function. In the original source, you didn't have the onCollisionOccured function an absolute virtual - I made it so; is there a reason you didn't?

When executing make if you are using g++ 4.8.1 you get the error "c++: error: unrecognized command line option ‘-stdlib=libc++’" This fixes that.

LNK2019 unresolved external symbol "public: void __thiscall anax::World::SystemDeleter::operator()(class anax::detail::BaseSystem *)const " (??RSystemDeleter@World@anax@@QBEXPAVBaseSystem@detail@2@@Z) referenced in function "public: __thiscall std::unique_ptr<class anax::detail::BaseSystem,struct anax::World::SystemDeleter>::~unique_ptr<class anax::detail::BaseSystem,struct anax::World::SystemDeleter>(void)" (??1?$unique_ptr@VBaseSystem@detail@anax@@USystemDeleter@World@3@@std@@QAE@XZ)

Getting this whenever using anax::World. I've used both Visual Studio and mingw32-make and get the same results. I get the DLL and put it in the .exe directory. I feel like there should be a .lib file but I don't get any?

Hi frend! I can not understand the error with the library box2d. If I get the entity of the userdata http://www.iforce2d.net/b2dtut/user-data You could help me? I already suffering a few days with this problem ._.

#include <anax/anax.hpp>
#include "Box2D/Box2D.h"
#include "iostream"

anax::World anax_world;
b2World * b2world  = new b2World(b2Vec2 {0, 9.8});// standart physic init

struct Player : anax::Component {
    Player() {}
};
struct Physic : anax::Component {
    Physic() {}
    b2Body * b2body;
};
struct TestSystem : anax::System<anax::Requires<Physic>>
{
    void init()
    {
        auto entities = getEntities();
        for (auto entity : entities) {

            auto & b2body = entity.getComponent<Physic>().b2body;
            b2BodyDef bodyDef;
            bodyDef.position.Set(0,0);
            bodyDef.type = b2_dynamicBody;
            b2body = b2world->CreateBody(&bodyDef);
            b2PolygonShape shape;
            shape.SetAsBox(1,1);// create simple box for test
            b2body->SetUserData(&entity);// add this entity to userdata
            b2body->CreateFixture(&shape,1.0);
        }
    }

    void update()
    {
        auto entities = getEntities();
        for (auto entity : entities) {

            auto & b2body = entity.getComponent<Physic>().b2body;
            anax::Entity * entity_from_data =
                    (anax::Entity*)b2body->GetUserData();// get entity from userdata

            if(entity_from_data)// if != NULL
            if(entity_from_data->hasComponent<Player>())// FIXME here is error!!!
                std::cout << "has Player"<< std::endl;
            else
               std::cout << "no Player"<< std::endl;
        }
    }

};
    int main()
    {
        TestSystem testSystem;
        // add system
        anax_world.addSystem(testSystem);

        // add entity
        anax::Entity player;
        player = anax_world.createEntity();
        player.addComponent<Physic>();
        player.addComponent<Player>();
        player.activate();

        // initialization
        anax_world.refresh();
        testSystem.init();
        int i;
        while (++i < 10)// Main  loop
        {
            anax_world.refresh(); // ECS update
            testSystem.update();

            b2world->Step(1.0f/30.0f, 6, 4);//physic update
        }
        // De-Initialization
        anax_world.clear();
        delete b2world;
        std::cout << "test end" << std::endl;
    }

I had to add a lot of my own asserts to the various Id and entity add/remove functions before I finally determined I was killing entities multiple times before calling refresh and that this isn't valid. It is reasonable that it isn't valid, but not obvious enough to not even be asserted for I would argue (almost nothing that is possible to do incorrectly is)!

Given that the kill commands are queued and then processed during refresh one might assume (as I did without even realising it) that duplicate kill operations would naturally be collapsed. Or that the container that contains the entities would be a unique set rather than a vector upon which multiple copies of the same entity could be pushed.

Adding this in World::killEntity finally caught my error:

ANAX_ASSERT(isValid(entity), "invalid entity tried to kill");
ANAX_ASSERT(std::find(std::cbegin(m_entityCache.killed), std::cend(m_entityCache.killed), entity) == std::cend(m_entityCache.killed), "entity tried to kill multiple times");

Hello, when testing the library today I have noticed that under Visual Studio 2015 when configuring with BUILD_SHARED_LIBS no lib is generated. This happens when the project does not have any kind of dllexport in the code.

I use a cross-platform way to do exports in one of my projects (link). I am going to work on this in the following days and submit a PR. But I do not know which are the things that should be exported from this lib.

Found this problem while wanting to remove a component of an entity, when that entity was added to a new system.

Here's my understanding of the problem: a. |onEntityAdded| is called while iterating over |m_entityCache.activated|. b. Calling activate() leads to adding an entry to |m_entityCache.activated|. Unfortunately, iterating on a vector that you modify doesn't work.

Possible fix: Copy (or swap pointers/std::move) all the arrays over which you iterate at the beginning of World::refresh(), clear them, and only then iterate over them:

void World::refresh() {
  auto copyActivated = m_entityCache.activated;
  auto copyDeactivated = m_entityCache.deactivated;
  auto copyKilled = m_entityCache.killed;
  m_entityCache.clearTemp();
  for (auto& entity : copyActivated) {

Hi Miguel, I noticed that you implemented creating Component with addComponent() and passing initializer list as arguments, but that doesn't work on my compiler as Component that I'm creating has BaseClass and I haven't seen you use it in any example. Is this just future feature? I read that this should be working on C++17 compilers.

example: struct A : Component { int i; float f; }

Entity e = world.createEntity(); e.addComponent(1, 0.2f);