Crash with dispatcher update

[rudiHammad]

Hello,
I followed the crash course regarding events. Here is what I am trying to do, it is quite simple. I have a CollisionSystem that enqueues to the game dispatcher a CollisionEvent. Here is the code with some comments to be specific (Sorry for the long code but I think it will be faster and easier to see what is happening)

/////////////
// events.h   
/////////////

struct CollisionEvent
{
public:
    entt::entity entA;
    entt::entity entB;
    CollisionEvent(entt::entity entA, entt::entity entB) : entA(entA), entB(entB) {}
};

/////////////
// systems.h
/////////////
struct CollisionSystem
{
public:

    CollisionSystem() = default;

    void update(entt::registry& registry, std::unique_ptr<entt::dispatcher>& enttDispatcher)
    {   
        auto view = registry.view<SpriteComponent>();
        for (auto i = view.begin(); i != view.end(); i++)
        {
            auto spriteCmpA = view[*i];
            for (auto j = i; j != view.end(); j++)
            {
                auto spriteCmpB = view[*j];

                if (*i == *j)
                    continue;

                if (spriteCmpA.sprite->getBoundingBox().intersectsRect(spriteCmpB.sprite->getBoundingBox()))
                {
                    enttDispatcher->enqueue<CollisionEvent>(*i, *j);  // <<<< Here I am enqueueying the CollisionEvent
                }
            }
        }
    }
};


struct DamageSystem
{
public:

    entt::registry* registry;
    DamageSystem(entt::registry* registry) { registry = registry; }     

    void subscribeToEvents(std::unique_ptr<entt::dispatcher>& dispatcher) {   
        dispatcher->sink<CollisionEvent>().connect<&DamageSystem::onCollision>(this);
        ax::log(">> Subscribed to collision events <<");
    }

  
    void onCollision(CollisionEvent& event)
    {
        ax::log(">> The damage system received an event collision between entities <<");
        registry->emplace<DeadTag>(event.entA);     // <<<<<<<<<<<<<<<<<<<<<<<<<<<<< AT THIS LINE IT CRASHES WITH THE ERROR BELOW:
                                                    //>> Subscribed to collision events <<
                                                    //>> The damage system received an event collision between entities <<
                                                    // Exception thrown: read access violation.
                                                    // **_My_data** was 0xFFFFFFFFFFFFFFF7.
                                                    //*/
        registry->emplace<DeadTag>(event.entB);

    }

};

As you can see I pointed that it crashes with registry->emplace<DeadTag>(event.entA); . I will show next the gamescene code that has the update loop. So far, I enqueued CollsionEvent when two sprites collide. And with dispatcher->sink<CollisionEvent>().connect<&DamageSystem::onCollision>(this); I am calling the member function that will tag the enties as DeadTag. Those entities are to be distroyed at the end of the game loop. Here is the code of the gamescene.cpp

/////////////
// gamescene.cpp
/////////////

void GameScene::loadLevel()
{
    //... 
    // Skipped the code to keep it simple. At this point a couple on entities are creted with components, etc...and bellow I set the systems
    //...
    registry.ctx().emplace<MovementSystem>();
    registry.ctx().emplace<RenderSystem>(registry);
    registry.ctx().emplace<AnimationSystem>();
    registry.ctx().emplace<CollisionSystem>();
    
    registry.ctx().emplace<DamageSystem>(&registry);
    registry.ctx().get<DamageSystem>().subscribeToEvents(enttDispatcher);   // << here i am calling once only, the DamageSystem
                                                                            // method to subscribeToEvents...(is that right??? i am not sure)
        

}


void GameScene::updateEntitiesToBeKilled()
{
    auto view = registry.view<DeadTag>();
    for (auto entity : view)
    { 
        registry.destroy(entity);
    }
}


void GameScene::update(float delta)
{
    enttDispatcher->update<CollisionEvent>();       // << HERE I RUN THE ENQUEUE EVENTS THAT CAUSE THE CRASH WHEN
                                                    // THAT I MENTIONED IN systems.h

    registry.ctx().get<MovementSystem>().update(delta, registry);
    registry.ctx().get<RenderSystem>().update(registry);          
    registry.ctx().get<AnimationSystem>().update(registry);
    registry.ctx().get<CollisionSystem>().update(registry, enttDispatcher);


    // Checks which entities were taged to be killed with DeadTag and kills them (reminder: we can kill while iterating the loop)
    updateEntitiesToBeKilled();
}

Let me put here again the output when it crashes

>> Subscribed to collision events <<
axmol: QuadCommand: resizing index size from [-1] to [2560]
>> The damage system received an event collision between entities <<
Exception thrown: read access violation.
**_My_data** was 0xFFFFFFFFFFFFFFF7.

As you can see it printed out >> Subscribed to collision events << so void subscribeToEvents(std::unique_ptrentt::dispatcher& dispatcher) was called properly, and also it printed out after >> The damage system received an event collision between entities <<
so it is connecting right?
I have been looking at this for 2 days now and can't figure out why it crashes. Sorry again for the long code, I hope it was clear to understand.

Thanks,
R

[rudiHammad]

hello again,
I am still stuck on this. But let me rephrase the issue in a simpler way because maybe my previous post was a bit convoluted and most likely wrong.

So, my GameScene class has the member entt::registry resistry that I pass to my systems update() methods by reference.
The CollisionSystem update method enqueues a CollisionEvent between 2 entites when a collision happens using enttDispatcher->enqueue( (CollisionEvent{ entA, entB}) ); At this point all is working.

Now the challenge I am facing that is crashing is: I have a DamageSystem that has to listen that event that happened in the CollisionSystem, to tag those to entities with DeadTag.

In other words, an event happening in a SystemA between two entities, has to be listened in a SystemB and set those entities with a DeadTag (because at the end of the game loop all entities with the DeadTag are destroyed). I am sure this must be very simple, but I am a bit lost.

Thanks

[skypjack]

Are you able to pack a small, reproducible example? I can't easily figure out what's going on here and cannot invest a whole day to reproduce it, I'm sorry.

[rudiHammad]

hmm... I am using axmol framework, so I can't really pack an example that doesn't force you install axmol. I'll see if I can figure out a more software agnostic way to reproduce the problem. No worries.

[rudiHammad]

I am trying to think how to make a pack fast and easy to debug, but I am not sure how. Do you have any preferred github repository that I can download with a basic game loop structure to try to reproduce what I am doing?

edit: never mind, I think I figured out of to post a working pack to test very easily. I'll post it later

[skypjack]

I don't think that you need a proper loop nor anything similar. You can even drop a link to an example on godbolt.
The problem is that I can barely get what you're doing and therefore it's hard to help you. I can only guess what the problem is.

[rudiHammad]

I'll try to explain again in case the issue is my approach (and I'll drop an example a soon as I can).

I want to create an event when a collision happens between two entities in a CollisionSystem. When this happens, I want my DamageSystem to be notified, so the damage system puts a tag (DeadTag) in those entities that collided. And finally, my gameloop, in the last line check which entities have the DeadTad to destroy them.

It is simple but I agree with you that my code doesn't help help understand the problem. So I'll try to simplify it.

[rudiHammad]

Hello again.
I finally manage to make an example that reproduces exactly the error. It is as easy as creating an empty project and copy this unique one file so it won't take much of your time. I also added console output to help see what is happening.
In summary, as I said previously, when a collision happens in the CollisionSystem I enqueue an event that is listened by the DamageSystem. And it is the DamageSystem that is in charge of killing the entity when he is notified of that event, by tagging them as DeadTag.
The way entities are killed is by running updateEntitiesToBeKilled(); , at the end of the game loop. Basically it checks which entites are tagged with DeagTag, which what the damage system did.

Anyway, here is a the complete code that will reproduce the error.

#include "entt.hpp"
#include <iostream>
#include <chrono>
#include <thread>
#include <memory>

/////////////////////////////////////////////////////////////////////////////////////////
//	Events
/////////////////////////////////////////////////////////////////////////////////////////

struct CollisionEvent
{
public:
    entt::entity entA;
    entt::entity entB;
    CollisionEvent(entt::entity entA, entt::entity entB) : entA(entA), entB(entB) {}
};


/////////////////////////////////////////////////////////////////////////////////////////
//	Components
/////////////////////////////////////////////////////////////////////////////////////////

struct TransformComponent
{
public:
    std::vector<int> position;

    TransformComponent(std::vector<int> position)
    {
        this->position = position;
        
    }
};


struct RigidBodyComponent
{
public:
    std::vector<int> velocity;

    RigidBodyComponent(std::vector<int> velocity)
    {
        this->velocity = velocity;
    }
};


struct DeadTag {};


/////////////////////////////////////////////////////////////////////////////////////////
//	Systems
/////////////////////////////////////////////////////////////////////////////////////////
struct MovementSystem
{
public:

    MovementSystem() = default;

    void update(entt::registry& registry)
    {
        auto view = registry.view<TransformComponent, RigidBodyComponent>();
        
        for (auto entity : view)
        {
            auto& transform = view.get<TransformComponent>(entity);
            const auto rigidBody = view.get<RigidBodyComponent>(entity);

            transform.position[0] += rigidBody.velocity[0];
            transform.position[1] += rigidBody.velocity[1];

            std::cout << transform.position[0] << std::endl;  // check output
        }
        std::cout << "---------" << std::endl;
    }
};



struct CollisionSystem
{
public:

    CollisionSystem() = default;

    void update(entt::registry& registry, std::unique_ptr<entt::dispatcher>& enttDispatcher)
    {

        auto view = registry.view<TransformComponent>();
        for (auto i = view.begin(); i != view.end(); i++)
        {
            auto tranfCmpA = view[*i];
            for (auto j = i; j != view.end(); j++)
            {
                auto tranfCmpB = view[*j];
                // Bypass if we are trying to test same entity
                if (*i == *j)
                    continue;
                if (tranfCmpA.position[0] == tranfCmpB.position[0]) {
                    std::cout << "Entities collided. Proceding to enqueeing CollisionEvent to dispatcher..." << std::endl;
                    enttDispatcher->enqueue((CollisionEvent{ *i, *j }));
                }

            }
        }
    }
};




struct DamageSystem
{
public:

    entt::registry* registry;
    DamageSystem(entt::registry* registry) { registry = registry; }

    void subscribeToEvents(std::unique_ptr<entt::dispatcher>& dispatcher) {
        dispatcher->sink<CollisionEvent>().connect<&DamageSystem::onCollision>(this);
        std::cout << ">> Subscribed to collision events <<" << std::endl;
    }


    void onCollision(CollisionEvent& event)
    {
        std::cout << ">> The damage system received an event collision between entities <<";
        registry->emplace<DeadTag>(event.entA);
        registry->emplace<DeadTag>(event.entB);
    }

};


/////////////////////////////////////////////////////////////////////////////////////////
//	GameScene
/////////////////////////////////////////////////////////////////////////////////////////

class GameScene
{
public:
    GameScene();
    void run();
    void update(entt::registry registry);
    void updateEntitiesToBeKilled();

private:
    entt::registry registry;
    std::unique_ptr<entt::dispatcher> enttDispatcher;
};


GameScene::GameScene()
{
    enttDispatcher = std::make_unique<entt::dispatcher>();

    // Create entities
    auto playerEntity = registry.create();
    auto asteroidEntity = registry.create();

    // Add components to entity
    registry.emplace<TransformComponent>(playerEntity, std::vector{0, 0});
    registry.emplace<RigidBodyComponent>(playerEntity, std::vector{1, 0});
    registry.emplace<TransformComponent>(asteroidEntity, std::vector{6, 0});
    registry.emplace<RigidBodyComponent>(asteroidEntity, std::vector{-1, 0});


    // Add systems (after the components since RenderSystem constructor requieres the registry to have the sprites)
    registry.ctx().emplace<MovementSystem>();
    registry.ctx().emplace<CollisionSystem>();
    registry.ctx().emplace<DamageSystem>(&registry);
    
    // Run once
    registry.ctx().get<DamageSystem>().subscribeToEvents(enttDispatcher);


}


void GameScene::updateEntitiesToBeKilled()
{
    auto view = registry.view<DeadTag>();

    for (auto entity : view) {
        registry.destroy(entity);
    }
}



void GameScene::run()
{   
    enttDispatcher->update<CollisionEvent>();


    // Game logic
    registry.ctx().get<MovementSystem>().update(registry);
    registry.ctx().get<CollisionSystem>().update(registry, enttDispatcher);
    registry.ctx().emplace<DamageSystem>(&registry);

    // Kill entities at the end if tagged with DeadTag
    updateEntitiesToBeKilled();
}





/////////////////////////////////////////////////////////////////////////////////////////
//	Game "Engine"
/////////////////////////////////////////////////////////////////////////////////////////

int main()
{
    GameScene gamescene;

    bool isRunning = true;
    auto previousTime = std::chrono::steady_clock::now();

    while (isRunning)
    {
        auto currentTime = std::chrono::steady_clock::now();
        auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - previousTime).count() / 1000.0;
        previousTime = currentTime;

        gamescene.run();

        std::this_thread::sleep_for(std::chrono::milliseconds(1000) - (currentTime - previousTime));
    }
 
}

This errors with **_My_data** was 0xFFFFFFFFFFFFFFF7. when this line is executed registry->emplace<DeadTag>(event.entA);

Thanks

[skypjack]

Well, in this specific example you have a trivial error actually. Just replace this:

    DamageSystem(entt::registry *registry) {
        registry = registry;
    }

With the following:

    DamageSystem(entt::registry *registry)
        : registry{registry}
    {}

In the first case, you aren't initializing the registry data member and this explains the crash.
No idea if it's also the same error as in you real world code. 🤷‍♂️

[rudiHammad]

Oh my god...I new I was doing some silly mistake. I though I was initializing the variable but I forgot this->registry = registry.
That's all it was...Weeelll... that was quite embarrassing. You can delete this entire post if you want XD.
Thank you.

[skypjack]

Ahahah, no worries at all. I suggest you to enable warnings though. That's how I found it in a blink. 😉

[rudiHammad]

Yes, from now on I will.
One last question before closing this discussion. I have seen games where the subscription to events is done and cleared every frame.
Following the last example, it would be something like this:

void GameScene::run()
{   
    registry.ctx().get<DamageSystem>().subscribeToEvents(enttDispatcher);   // this line was before in the constructor
    enttDispatcher->update<CollisionEvent>();  // update
    enttDispatcher->clear();   // clear all 

    // Game logic
    registry.ctx().get<MovementSystem>().update(registry);
    registry.ctx().get<CollisionSystem>().update(registry, enttDispatcher);
    registry.ctx().emplace<DamageSystem>(&registry);

    // Kill entities at the end if tagged with DeadTag
    updateEntitiesToBeKilled();
}

This doesn't look very efficient right? or is it normal in game developement to subscribe and clear events everyframe?

[skypjack]

It really depends on the use case and your design. It could make sense for some uses but it's definitely silly for many others.