Struct mc_core::world::level::Level

pub struct Level {
    pub chunks: ChunkStorage,
    pub entities: EntityStorage,
    // some fields omitted
}

Main storage for a level, part of a World. This structure is intentionally not Sync + Send, however each chunk is stored in a RwLock in order to make them shared across threads if you want.

Fields

chunks: ChunkStorage

Chunk storage.

entities: EntityStorage

Entities storage.

Implementations

impl Level

pub fn new<S>(
    id: String,
    env: Arc<LevelEnv>,
    height: ChunkHeight,
    source: S
) -> Self where
    S: LevelSource + 'static, 

pub fn get_id(&self) -> &String

Return the unique ID (unique in the owning world).

pub fn get_env(&self) -> &Arc<LevelEnv>

Return the level environment used by this level.

pub fn get_height(&self) -> ChunkHeight

Return the minimum and maximum chunks position allowed in this world. The limits can -128 to 127, it is more than enough.

pub fn request_chunk_load(&mut self, cx: i32, cz: i32) -> bool

Request internal level source to load the given chunk.

pub fn load_chunks_with_callback<F>(&mut self, callback: F) where
    F: FnMut(i32, i32, Result<&Arc<RwLock<Chunk>>, LevelSourceError>), 

Poll loaded chunks from internal level source, all successfully loaded chunks are added to the underlying LevelStorage. The callback is called for each loaded chunks or loading error.

pub fn load_chunks(&mut self)

Poll loaded chunks from internal level source, all successfully loaded chunks are added to the underlying LevelStorage.

pub fn get_loading_chunks_count(&self) -> usize

Returns the number of chunks being loaded or queued for loading (use load_chunks or load_chunks_with_callback to load actually them.

pub fn request_chunk_save(&mut self, cx: i32, cz: i32) -> bool

pub fn spawn_entity(
    &mut self,
    entity_type: &'static EntityType,
    pos: EntityPos
) -> Option<Entity>