Struct MapData 

#[non_exhaustive]
pub struct MapData<M: MapTrait, T: TilesetTrait, Mus> {
    pub id: M,
    pub width: u8,
    pub height: u8,
    pub tileset: T,
    pub music: Mus,
    pub blocks: Vec<u8>,
    pub warps: Vec<WarpPoint<M>>,
    pub npcs: Vec<NpcDefinition>,
    pub signs: Vec<Sign>,
    pub connections: MapConnections<M>,
}

Complete runtime data for a loaded map.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

id: M

width: u8

height: u8

tileset: T

music: Mus

blocks: Vec<u8>

Block data — the actual tile layout. Each byte is a block index into the tileset’s block definitions. Size = width * height.

warps: Vec<WarpPoint<M>>

npcs: Vec<NpcDefinition>

signs: Vec<Sign>

connections: MapConnections<M>

Implementations

impl<M: MapTrait, T: TilesetTrait, Mus> MapData<M, T, Mus>

pub fn new( id: M, width: u8, height: u8, tileset: T, music: Mus, blocks: Vec<u8>, warps: Vec<WarpPoint<M>>, npcs: Vec<NpcDefinition>, signs: Vec<Sign>, connections: MapConnections<M>, ) -> Self

Create a new MapData with all fields.

Examples found in repository

examples/hello_dotzuki.rs (lines 530-541)

fn build_town_map() -> MapData<MapId, Tileset, ()> {
    let blocks: Vec<u8> = vec![
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0x01, 0x01, 0x01, 0xFF,
        0xFF, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    ];
    let npcs = vec![NpcDefinition::new(
        0,
        2,
        2,
        NpcMovementType::Stationary,
        Direction::Down,
        0,
        0,
    )];
    MapData::new(
        MapId(0),
        5,
        5,
        Tileset(0),
        (),
        blocks,
        vec![],
        npcs,
        vec![],
        MapConnections::default(),
    )
}

pub fn set_block(&mut self, block_x: u8, block_y: u8, block_id: u8) -> bool

Replace the block at BLOCK coords (block_x, block_y) with block_id.

Returns false (no-op) if the coordinates fall outside the map. The collision and rendering systems read blocks live every frame, so the change takes effect immediately with no cache to invalidate. The change is transient: a map reload rebuilds blocks, so callers that need a persistent change must re-apply it on map entry.

Trait Implementations

impl<M: Clone + MapTrait, T: Clone + TilesetTrait, Mus: Clone> Clone for MapData<M, T, Mus>

fn clone(&self) -> MapData<M, T, Mus>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug + MapTrait, T: Debug + TilesetTrait, Mus: Debug> Debug for MapData<M, T, Mus>

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

Formats the value using the given formatter.

impl<'de, M, T, Mus> Deserialize<'de> for MapData<M, T, Mus>

where M: Deserialize<'de> + MapTrait, T: Deserialize<'de> + TilesetTrait, Mus: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M, T, Mus> Serialize for MapData<M, T, Mus>

where M: Serialize + MapTrait, T: Serialize + TilesetTrait, Mus: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.