Struct bevy_ecs_tilemap::prelude::MapQuery

pub struct MapQuery<'a> { /* fields omitted */ }

MapQuery is a useful bevy system param that provides a standard API for interacting with tiles. It’s not required that you use this, but it does provide a convenience. Note: MapQuery doesn’t directly change tile components. This is meant as a feature as you may have your own tile data attached to each tile and a standard tile query wouldn’t pull that data in.

Implementations

impl<'a> MapQuery<'a>

pub fn build_layer(
    &mut self,
    commands: &mut Commands<'_>,
    layer_builder: LayerBuilder<impl TileBundleTrait>,
    material_handle: Handle<ColorMaterial>
) -> Entity

Builds the tile map layer and returns the layer’s entity.

pub fn set_tile<T: Into<u16> + Copy>(
    &mut self,
    commands: &mut Commands<'_>,
    tile_pos: UVec2,
    tile: Tile,
    map_id: T,
    layer_id: T
) -> Result<Entity, MapTileError>

Adds or sets a new tile for a given layer. Returns an error if the tile is out of bounds. It’s important to know that the new tile wont exist until bevy flushes the commands during a hard sync point(between stages). A better option for updating existing tiles would be the following:

...
mut my_tile_query: Query<&mut Tile>,
mut map_query: MapQuery,
...

let tile_entity = map_query.get_tile_entity(tile_position, 0); // Zero represents layer_id.
if let Ok(mut tile) = my_tile_query.get_mut(tile_entity) {
  tile.texture_index = 10;
}

pub fn get_layer<I: Into<u16>>(
    &self,
    map_id: I,
    layer_id: I
) -> Option<(Entity, &Layer)>

pub fn get_tile_entity<T: Into<u16>>(
    &self,
    tile_pos: UVec2,
    map_id: T,
    layer_id: T
) -> Result<Entity, MapTileError>

Gets a tile entity for the given position and layer_id returns an error if OOB or the tile doesn’t exist.

pub fn despawn_tile<T: Into<u16>>(
    &mut self,
    commands: &mut Commands<'_>,
    tile_pos: UVec2,
    map_id: T,
    layer_id: T
) -> Result<(), MapTileError>

Despawns the tile entity and removes it from the layer/chunk cache.

pub fn despawn_layer_tiles<T: Into<u16>>(
    &mut self,
    commands: &mut Commands<'_>,
    map_id: T,
    layer_id: T
)

Depsawns all of the tiles in a layer. Note: Doesn’t despawn the layer.

pub fn depsawn_layer<T: Into<u16>>(
    &mut self,
    commands: &mut Commands<'_>,
    map_id: T,
    layer_id: T
)

Despawns a layer completely including all tiles.

pub fn depsawn_map<T: Into<u16>>(
    &mut self,
    commands: &mut Commands<'_>,
    map_id: T
)

pub fn get_tile_neighbors<T: Into<u16>>(
    &self,
    tile_pos: UVec2,
    map_id: T,
    layer_id: T
) -> [(IVec2, Option<Entity>); 8]

Retrieves a list of neighbor entities in the following order: N, S, W, E, NW, NE, SW, SE.

The returned neighbors are tuples that have an tilemap coordinate and an Option.

A value of None will be returned for tiles that don’t exist.

Example

let neighbors = map.get_tile_neighbors(UVec2::new(0, 0));
assert!(neighbors[1].1.is_none()); // Outside of tile bounds.
assert!(neighbors[0].1.is_none()); // Entity returned inside bounds.

pub fn notify_chunk(&mut self, chunk_entity: Entity)

Let’s the internal systems know to “remesh” the chunk.

pub fn notify_chunk_for_tile<T: Into<u16>>(
    &mut self,
    tile_pos: UVec2,
    map_id: T,
    layer_id: T
)

Let’s the internal systems know to remesh the chunk for a given tile pos and layer_id.

Trait Implementations

impl<'a> SystemParam for MapQuery<'a>

type Fetch = MapQueryState<(<QuerySet<(Query<'a, (Entity, &'static mut Chunk)>, Query<'a, (Entity, &'static Chunk)>)> as SystemParam>::Fetch, <QuerySet<(Query<'a, (Entity, &'static mut Layer)>, Query<'a, (Entity, &'static Layer)>)> as SystemParam>::Fetch, <QuerySet<(Query<'a, (Entity, &'static mut Map)>, Query<'a, (Entity, &'static Map)>)> as SystemParam>::Fetch, <ResMut<'a, Assets<Mesh>> as SystemParam>::Fetch)>