What's the best way to organize my data?

[Yoric]

I've been teaching myself Bevy by writing a small Minesweeper. I have the basic features working, but I feel that I'm doing something wrong.

If we limit to the grid (aka the Model), I have

• a struct Grid that derives Resource, containing a Vec<Tile>;
• a struct Tile that contains the precomputed number of neighbouring bombs and a few booleans to determine whether there is a bomb, the tile has been visited, etc.;
• a bunch of ButtonBundle with TextBundle as children (to be replaced with images once I have the time to do so);
• a struct TileMarker that derives Component, which I spawn along with the ButtonBundle to be able to determine the index in Grid of the tile I've just clicked.

This works. However, for instance, when I'm discovering an entire region after clicking on a tile with 0 neighbouring bombs, the algorithm is a bit odd:

1. from my on_interact System, compute the set of tiles that need to become visible;
2. send a message with this set of tiles;
3. use the following to change the visible state of tiles:

fn on_discovered(
   mut ev: EventReader<RegionDiscoveredEvent>,
   mut tiles_query: Query<(&mut BackgroundColor, &mut Children, &TileMarker)>, // Used to iterate through *all* tiles? Surely I can do better
   mut text: Query<&mut Text>, // Used to `get` the text I have as children of my `ButtonBundle`
) {
   // Iterate through all tiles in `tiles_query`, checking if they're mentioned as part of my `RegionDiscoveredEvent`
     // If that's the case, iterate through all children 
       // Look for the children in `text`
          // Display the number of neighbours with bombs.
}

What am I doing wrong? Should I somehow get rid of Grid as a data structure and make it one Entity with plenty of Component tiles? If so, how can I organize the logic so that I can easily access the neighbours of a tile?

I feel that the question is more generic than Minesweeper so perhaps I'm simply missing a source "how to think in ECS" :)

[nicopap]

Your architecture is very close to what I would come up with, the general idea is sound. However, on_discovered can be drastically improved.

The key piece you are missing is Query::get. It is a method to query directly by Entity a set of components, it has a O(1) time complexity.

Think of Entity as a unique identifier, or primary key. In your Tile struct, consider adding an Entity field. When you "discover" a tile, you can add the Entity in question to the RegionDiscoveredEvent you are emitting. This way, when you query for tile components, you can directly query for the specific uncovered tile, rather than iterate over all of them and checking if they are part of RegionDiscoveredEvent.

Regarding the text, right now, dynamic text in bevy is kind of super awful to work with, and you already are updating the text the best way it can be done…

With this, you could tweak slightly your algo: Now, instead of iterating over all tiles, you only iterate through the tiles mentioned in the event.

In short, the algorithm would now look as follow:

struct RegionDiscoveredEvent {
    entity: Entity,
}

fn on_discovered(
    mut ev: EventReader<RegionDiscoveredEvent>,
    mut tiles_query: Query<(&mut BackgroundColor, &Children, &TileMarker)>,
    mut text: Query<&mut Text>, // Used to `get` the text I have as children of my `ButtonBundle`
) {
    for ev in ev.read() {
        let Ok((mut bg, children, tile)) = tiles_query.get_mut(ev.entity) else {
            continue;
        };
        let Some(mut text) = children.iter().find_map(|e| text.get_mut(e).ok()) else {
            continue;
        };
        *text = …;
        *bg = …;
    }
}