Struct level_lib::anvil::region::chunk::section::ChunkSection

pub struct ChunkSection {
    pub y: i8,
    pub block_palette: Vec<BlockData>,
    pub block_data: Option<[i64; 4096]>,
    pub biome_palette: Vec<String>,
    pub biome_data: Option<[i64; 64]>,
    pub block_light: Option<[i8; 4096]>,
    pub sky_light: Option<[i8; 4096]>,
}

A structure containing important data of a section of a Chunk it stores a section of 161616 (4096) blocks

Source

• fandom.minecraft.com

Info

Everything, taged as “Not confirmed for 1.18 format” is not implemented, but will be if it turnes out to be neccessarry

Fields

y: i8

The y position of the sector

block_palette: Vec<BlockData>

A list of all used blocks in a chunk

block_data: Option<[i64; 4096]>

A list of all placed blocks, the list contains the offset into the block_palette list to save some memmory, this field is optional, if None and block_palette.len() == 1 then the whole sections is filled with that one block.

Example

full chunk of Air: the block_palette contains the data for air. the block_data is None to indicate that the same data is used accross the whole section

Info

The stored indices are always as small as possible, but at least 4 bits with no packing accross multiple elements of the array. Meaning if the chunk consists of 33 different blocks, we need 5 bits to represent all unique blocks, now we can divide 64 by the amount of needed bits and floor the result to know how much block entries we can store per element(u64). For example $⌊64/5⌋ = 12$ so if we need 5 bits to represent each unique block we can store 12 per element.

Note

The explanation above only applies to the nbt representation. The used on in the code has an entry for each element to keep the amount of computation low in a trade of with a bit more used memory

biome_palette: Vec<String>

A list of all used biomes in the chunk

biome_data: Option<[i64; 64]>

An optional list of the biomes used on each (x | z) position. If the value is None every location in the section has the same biome

block_light: Option<[i8; 4096]>

The light emitter data of each block in the chunk

Note

In the Nbt data this will be stored as a [u8; 2048] where each element will contain two block each 4-bits of light data.

sky_light: Option<[i8; 4096]>

The sky light data of each block in the chunk

Note

In the Nbt data this will be stored as a [u8; 2048] where each element will contain two block each 4-bits of light data.

Implementations

impl ChunkSection

pub fn new_filled(y: i8, filler: &str, sees_sky: bool) -> Self

creates a new ChunkSection that is filled with a specified block

pub fn new_with_height_map( y: i8, filler: &str, sees_sky: bool, heightmap: [[i16; 16]; 16] ) -> Self

creates a new chunk section, with a given heightmap

Trait Implementations

impl AsNbtValue for ChunkSection

fn as_nbt_value(&self) -> Result<NbtValue, ()>

converts the struct to a NbtValue

impl Debug for ChunkSection

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

Formats the value using the given formatter.

impl FromNbtValue for ChunkSection

fn from_nbt_value(value: NbtValue) -> Result<Self, ()>

where Self: Sized,

converts the struct to a NbtValue

impl PartialEq for ChunkSection

fn eq(&self, other: &ChunkSection) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ChunkSection