Struct jumpy::core::editor::MapManager

pub struct MapManager<'a> {
    pub commands: Commands<'a>,
    pub entities: ResMutInit<'a, Entities>,
    pub spawned_map_meta: ResMutInit<'a, SpawnedMapMeta>,
    pub element_handles: CompMut<'a, ElementHandle>,
    pub transforms: CompMut<'a, Transform>,
    pub spawned_map_layer_metas: CompMut<'a, SpawnedMapLayerMeta>,
    pub tile_layers: CompMut<'a, TileLayer>,
    pub tiles: CompMut<'a, Tile>,
    pub tile_collisions: CompMut<'a, TileCollisionKind>,
    pub map: Res<'a, LoadedMap>,
    pub element_kill_callbacks: Comp<'a, ElementKillCallback>,
    pub spawner_manager: SpawnerManager<'a>,
}

A system parameter for editing the map.

MapManager provides an interface for editing the map contents easily while the match is running. This can be used both for manual map editing, and by algorithms for generating or randomizing maps.

Map generators implement the MapConstructor trait, which is given a MapManager to make its changes with.

Fields

commands: Commands<'a>

entities: ResMutInit<'a, Entities>

spawned_map_meta: ResMutInit<'a, SpawnedMapMeta>

element_handles: CompMut<'a, ElementHandle>

transforms: CompMut<'a, Transform>

spawned_map_layer_metas: CompMut<'a, SpawnedMapLayerMeta>

tile_layers: CompMut<'a, TileLayer>

tiles: CompMut<'a, Tile>

tile_collisions: CompMut<'a, TileCollisionKind>

map: Res<'a, LoadedMap>

element_kill_callbacks: Comp<'a, ElementKillCallback>

spawner_manager: SpawnerManager<'a>

Implementations

impl<'a> MapManager<'a>

pub fn create_element( &mut self, element_meta_handle: &Handle<ElementMeta>, translation: &Vec2, layer_index: u32, )

Create a new map element at the given location on the given layer.

pub fn create_layer(&mut self, name: Ustr)

Create a new layer with the given name.

pub fn delete_layer(&mut self, layer_index: u32)

Delete the layer with the given index.

pub fn rename_layer(&mut self, layer_index: u32, name: &str)

Rename the layer with the given index.

pub fn move_element(&mut self, entity: Entity, position: &Vec2)

Move an element to a new position on the map.

pub fn delete_element(&mut self, entity: Entity)

Delete an element off of the map.

pub fn set_layer_tilemap( &mut self, layer_index: u32, tilemap: &Option<Handle<Atlas>>, )

Set the tilemap for the given layer.

pub fn set_tile( &mut self, layer_index: u32, position: UVec2, tilemap_tile_index: &Option<u32>, tile_collision_kind: TileCollisionKind, )

Set the tile index of a tile on the given layer.

pub fn swap_layer(&mut self, layer_index: u32, is_downward: bool)

Swap the position of two layers.

pub fn rename_map(&mut self, name: &str)

Rename the map.

pub fn get_size(&self) -> UVec2

Get the size of the map.

pub fn get_layers_total(&self) -> usize

The the number of layers.

pub fn clear_tiles(&mut self)

Clear all the tiles on the map.

pub fn clear_elements(&mut self)

Clear all of the elements on the map.

Trait Implementations

impl<'a> SystemParam for MapManager<'a>

type State = (<Commands<'a> as SystemParam>::State, <ResMutInit<'a, Entities> as SystemParam>::State, <ResMutInit<'a, SpawnedMapMeta> as SystemParam>::State, <RefMut<'a, ComponentStore<ElementHandle>> as SystemParam>::State, <RefMut<'a, ComponentStore<Transform>> as SystemParam>::State, <RefMut<'a, ComponentStore<SpawnedMapLayerMeta>> as SystemParam>::State, <RefMut<'a, ComponentStore<TileLayer>> as SystemParam>::State, <RefMut<'a, ComponentStore<Tile>> as SystemParam>::State, <RefMut<'a, ComponentStore<TileCollisionKind>> as SystemParam>::State, <Res<'a, LoadedMap> as SystemParam>::State, <Ref<'a, ComponentStore<ElementKillCallback>> as SystemParam>::State, <SpawnerManager<'a> as SystemParam>::State)

The intermediate state for the parameter, that may be extracted from the world.

type Param<'p> = MapManager<'p>

The type of the parameter, ranging over the lifetime of the intermediate state.

fn get_state(world: &World) -> Self::State

This is called to produce the intermediate state of the system parameter.

fn borrow<'s>(world: &'s World, state: &'s mut Self::State) -> Self::Param<'s>

This is used create an instance of the system parame, possibly borrowed from the intermediate parameter state.