Struct rust_rpg_toolkit::map::Map

pub struct Map {
    pub background_color: Color,
    pub world_offset: Vec2,
    pub grid_size: UVec2,
    pub tile_size: Vec2,
    pub layers: HashMap<String, MapLayer>,
    pub tilesets: HashMap<String, MapTileset>,
    pub draw_order: Vec<String>,
    pub properties: HashMap<String, MapProperty>,
    pub player_spawn_point: Option<Vec2>,
}

Fields

background_color: Color

world_offset: Vec2

grid_size: UVec2

tile_size: Vec2

layers: HashMap<String, MapLayer>

tilesets: HashMap<String, MapTileset>

draw_order: Vec<String>

properties: HashMap<String, MapProperty>

player_spawn_point: Option<Vec2>

Implementations

impl Map

pub const PLAYER_SPAWN_POINT_NAME: &'static str

pub async fn load<P: AsRef<Path>>(path: P) -> Result<Self>

pub async fn load_tiled<P: AsRef<Path>>(
    path: P,
    export_path: Option<P>
) -> Result<Self>

pub fn to_grid(&self, rect: Rect) -> URect

pub fn to_coords(&self, position: Vec2) -> UVec2

pub fn to_position(&self, point: UVec2) -> Vec2

pub fn get_tile(&self, layer_id: &str, x: u32, y: u32) -> &Option<MapTile>

pub fn get_tiles(
    &self,
    layer_id: &str,
    rect: Option<URect>
) -> MapTileIterator<'_>

pub fn get_path(&self, start: Vec2, end: Vec2) -> Option<NavigationPath>

pub fn get_collisions(&self, collider: Collider) -> Vec<(Vec2, CollisionKind)>

pub fn draw(&self, rect: Option<URect>)

pub fn default_background_color() -> Color

pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<()>

Trait Implementations

impl Algorithm2D for Map

fn dimensions(&self) -> Point

Retrieve the map’s dimensions. Made optional to reduce API breakage.

fn point2d_to_index(&self, pt: Point) -> usize

Convert a Point (x/y) to an array index. Defaults to an index based on an array strided X first.

fn index_to_point2d(&self, idx: usize) -> Point

Convert an array index to a point. Defaults to an index based on an array strided X first.

fn in_bounds(&self, pos: Point) -> bool

impl BaseMap for Map

fn is_opaque(&self, idx: usize) -> bool

True is you cannot see through the tile, false otherwise. Default implementation always returns true, and is provided so you don’t have to implement it if you aren’t using it.

fn get_available_exits(&self, idx: usize) -> SmallVec<[(usize, f32); 10]>

Return a vector of tile indices to which one can path from the idx. These do NOT have to be contiguous - if you want to support teleport pads, that’s awesome. Default implementation is provided that proves an empty list, in case you aren’t using it.

fn get_pathing_distance(&self, idx1: usize, idx2: usize) -> f32

Return the distance you would like to use for path-finding. Generally, Pythagoras distance (implemented in geometry) is fine, but you might use Manhattan or any other heuristic that fits your problem. Default implementation returns 1.0, which isn’t what you want but prevents you from having to implement it when not using it.

impl Clone for Map

fn clone(&self) -> Map

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Map

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Map

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<TiledMap> for Map

fn from(map: TiledMap) -> Map

Performs the conversion.

impl Serialize for Map

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.