/// The location of this chunk, in chunk

/// coordinates.

location: ChunkPosition,

/// An array of the sections in this chunk.

/// A section with Y value `y` can be found at

/// index `y` in this array.

/// When an entry in this array is set to `None`,

/// the section at the entry's Y coordinate

/// is assumed to empty, meaning that it consists

/// of only air.

sections: [Option<ChunkSection>; NUM_SECTIONS],

/// The biomes in this section, indexable by

/// ((z << 4) | x).

biomes: [Biome; SECTION_WIDTH * SECTION_WIDTH],

/// Whether this chunk has been modified since the most recent

/// call to `check_modified`().

modified: bool,

heightmaps: Box<[HeightMap]>,

motion_blocking: u8,

motion_blocking_no_leaves: u8,

ocean_floor: u8,

ocean_floor_wg: u8,

world_surface: u8,

world_surface_wg: u8,

/// The highest block that is solid or contains a fluid.

pub fn motion_blocking(self) -> u8 {

self.motion_blocking

}

pub fn set_motion_blocking(&mut self, motion_blocking: u8) {

self.motion_blocking = motion_blocking;

}

/// The highest block that is solid or contains a fluid and is not leaves.

pub fn motion_blocking_no_leaves(self) -> u8 {

self.motion_blocking_no_leaves

}

pub fn set_motion_blocking_no_leaves(&mut self, motion_blocking_no_leaves: u8) {

self.motion_blocking_no_leaves = motion_blocking_no_leaves;

}

/// The highest block that is solid.

pub fn ocean_floor(self) -> u8 {

self.ocean_floor

}

pub fn set_ocean_floor(&mut self, ocean_floor: u8) {

self.ocean_floor = ocean_floor;

}

/// The highest block that is solid for world generation.

pub fn ocean_floor_wg(self) -> u8 {

self.ocean_floor_wg

}

/// The highest block that is not air.

pub fn world_surface(self) -> u8 {

self.world_surface

}

pub fn set_world_surface(&mut self, world_surface: u8) {

self.world_surface = world_surface;

}

/// The highest block is not air for world generation.

pub fn world_surface_wg(self) -> u8 {

self.world_surface_wg

}

fn default() -> Self {

// Rust apparently forces you to implement

// `Copy` on types if you want to use the

// `[ChunkSection::new(); 16]` syntax,

// so I had to do this.

let sections = [

None, None, None, None, None, None, None, None, None, None, None, None, None, None,

None, None,

];

Self {

location: ChunkPosition::new(0, 0),

modified: true,

sections,

biomes: [Biome::Plains; SECTION_WIDTH * SECTION_WIDTH],

heightmaps: vec![HeightMap::default(); CHUNK_WIDTH * CHUNK_WIDTH].into_boxed_slice(),

}

}

/// Creates a new empty chunk

/// with the specified location.

pub fn new(location: ChunkPosition) -> Self {

Self {

location,

modified: true,

..Default::default()

}

}

/// Creates a new empty chunk

/// with the specified location,

/// and filling its biomes with

/// the provided `default_biome`.

pub fn new_with_default_biome(location: ChunkPosition, default_biome: Biome) -> Self {

Self {

location,

modified: true,

biomes: [default_biome; SECTION_WIDTH * SECTION_HEIGHT],

..Default::default()

}

}

/// Gets the block at the specified

/// position in this chunk. The position

/// is in the chunk's local coordinate

/// space.

///

/// The specified coordinates must be inside

/// this chunk, so the function will panic

/// if `x >= 16 || y >= 256 || z >= 16`.

pub fn block_at(&self, x: usize, y: usize, z: usize) -> Block {

Self::check_coords(x, y, z);

let chunk_section = &self.sections[(y / 16) as usize];

match chunk_section {

Some(section) => section.block_at(x, y % 16, z),

None => Block::Air,

}

}

/// Sets the block at the specified

/// position in this chunk. The position

/// is in the chunk's local coordinate

/// space.

///

/// The specified coordinates must be inside

/// this chunk, so the function will panic

/// if `x >= 16 || y >= 256 || z >= 16`.

pub fn set_block_at(&mut self, x: usize, y: usize, z: usize, block: Block) {

Self::check_coords(x, y, z);

self.modified = true;

let chunk_section = &mut self.sections[y / 16];

let section;

if let Some(sec) = chunk_section {

section = sec;

} else {

// The section is empty - create it

if block == Block::Air {

return; // Nothing to do - section already empty

}

let new_section = ChunkSection::default();

self.set_section_at(y / 16, Some(new_section));

section = self.section_mut(y / 16).unwrap();

}

section.set_block_at(x, y % 16, z, block);

self.update_heightmap(x, y, z, block);

}

pub fn heightmap(&self, x: usize, z: usize) -> &HeightMap {

Self::check_coords(x, 0, z);

&self.heightmaps[x + z * CHUNK_WIDTH]

}

pub fn heightmap_mut(&mut self, x: usize, z: usize) -> &mut HeightMap {

Self::check_coords(x, 0, z);

&mut self.heightmaps[x + z * CHUNK_WIDTH]

}

pub fn heightmaps(&self) -> &[HeightMap] {

&self.heightmaps

}

fn update_heightmap(&mut self, x: usize, y: usize, z: usize, block: Block) -> HeightMapMask {

let heightmap = self.heightmap_mut(x, z);

let mut mask: HeightMapMask = HeightMapMask::empty();

if (block.is_solid() || block.is_fluid()) && heightmap.motion_blocking() < y as u8 {

heightmap.set_motion_blocking(y as u8);

mask |= HeightMapMask::MOTION_BLOCKING;

}

if (block.is_solid() || block.is_fluid())

&& !block.is_leaves()

&& heightmap.motion_blocking_no_leaves() < y as u8

{

heightmap.set_motion_blocking_no_leaves(y as u8);

mask |= HeightMapMask::MOTION_BLOCKING_NO_LEAVES;

}

if block.is_solid() && heightmap.ocean_floor() < y as u8 {

heightmap.set_ocean_floor(y as u8);

mask |= HeightMapMask::OCEAN_FLOOR;

}

if !block.is_air() && heightmap.world_surface() < y as u8 {

heightmap.set_world_surface(y as u8);

mask |= HeightMapMask::WORLD_SURFACE;

}

mask

}

/// Recalculate the heightmap for the chunk

pub fn recalculate_heightmap(&mut self) {

// This function can be optimized, instead of

// fetching heightmap every time, and sections

for x in 0..CHUNK_WIDTH {

for z in 0..CHUNK_WIDTH {

let mut mask: HeightMapMask = HeightMapMask::empty();

for y in (0..CHUNK_HEIGHT).rev() {

if mask.is_all() {

break;

}

let block = self.block_at(x, y, z);

mask |= self.update_heightmap(x, y, z, block);

}

}

}

}

pub fn sky_light_at(&self, x: usize, y: usize, z: usize) -> u8 {

Self::check_coords(x, y, z);

let chunk_section = self.section_for_y(y);

match chunk_section {

Some(chunk_section) => chunk_section.sky_light_at(x, y % 16, z),

None => 0,

}

}

pub fn block_light_at(&self, x: usize, y: usize, z: usize) -> u8 {

Self::check_coords(x, y, z);

let chunk_section = self.section_for_y(y);

match chunk_section {

Some(chunk_section) => chunk_section.block_light_at(x, y % 16, z),

None => 0,

}

}

pub fn set_sky_light_at(&mut self, x: usize, y: usize, z: usize, value: u8) {

Self::check_coords(x, y, z);

let chunk_section = self.section_for_y_mut(y);

chunk_section.set_sky_light_at(x, y % 16, z, value);

}

pub fn set_block_light_at(&mut self, x: usize, y: usize, z: usize, value: u8) {

Self::check_coords(x, y, z);

let chunk_section = self.section_for_y_mut(y);

chunk_section.set_block_light_at(x, y % 16, z, value);

}

fn section_for_y(&self, y: usize) -> &Option<ChunkSection> {

&self.sections[y / 16]

}

fn section_for_y_mut(&mut self, y: usize) -> &mut ChunkSection {

self.sections[y / 16].get_or_insert_with(ChunkSection::default)

}

fn check_coords(x: usize, y: usize, z: usize) {

assert!(x < CHUNK_WIDTH);

assert!(y < CHUNK_HEIGHT);

assert!(z < CHUNK_WIDTH);

}

/// Returns a slice of the 16

/// chunk sections in the chunk.

pub fn sections(&self) -> Vec<Option<&ChunkSection>> {

self.sections.iter().map(|sec| sec.as_ref()).collect()

}

/// Returns a mutable slice of the 16 sections

/// in this chunk.

pub fn sections_mut(&mut self) -> Vec<Option<&mut ChunkSection>> {

self.modified = true;

self.sections.iter_mut().map(|sec| sec.as_mut()).collect()

}

/// Returns the position in chunk coordinates

/// of this chunk.

pub fn position(&self) -> ChunkPosition {

self.location

}

/// Sets the position of this chunk.

pub fn set_position(&mut self, pos: ChunkPosition) {

self.location = pos

}

/// Returns a reference to the chunk section at the given

/// Y offset. The Y offset must be between 0 and 15, inclusive;

/// each Y offset value corresponds to 16 blocks vertically.

///

/// If this function returns `None`, the section is assumed

/// to be empty, meaning it consists only of air.

pub fn section(&self, index: usize) -> Option<&ChunkSection> {

assert!(index < NUM_SECTIONS);

self.sections[index].as_ref()

}

/// Returns a mutable reference to the chunk section at the given

/// Y offset. The Y offset must be between 0 and 15, inclusive;

/// each Y offset value corresponds to 16 blocks vertically.

///

/// If this function returns `None`, the section is assumed

/// to be empty, meaning it consists only of air.

pub fn section_mut(&mut self, index: usize) -> Option<&mut ChunkSection> {

assert!(index < NUM_SECTIONS);

self.modified = true;

self.sections[index].as_mut()

}

/// Sets the section at the given section index.

pub fn set_section_at(&mut self, index: usize, section: Option<ChunkSection>) {

assert!(index < NUM_SECTIONS);

self.sections[index] = section;

self.modified = true;

}

/// Optimizes each section in this chunk.

///

/// Returns the number of sections which were actually

/// optimized - sections which have not been

/// modified since the last time they were optimized

/// are not optimized.

pub fn optimize(&mut self) -> u32 {

let modified = self.modified;

let mut count = 0;

let mut to_remove = vec![];

for (i, s) in self.sections.iter_mut().enumerate() {

if let Some(section) = s {

if section.optimize() {

// Section was optimized - increment count

count += 1;

}

if section.empty() {

to_remove.push(i);

}

}

}

for i in to_remove {

self.set_section_at(i, None);

}

self.modified = modified;

count

}

/// Returns the biomes of this chunk.

pub fn biomes(&self) -> &[Biome] {

&self.biomes

}

/// Returns a mutable reference to the biomes of this chunk.

pub fn biomes_mut(&mut self) -> &mut [Biome] {

self.modified = true;

&mut self.biomes

}

/// Gets the biome for the specified column.

///

/// # Panics

/// Panics if `x < 16` or `z < 16`.

pub fn biome_at(&self, x: usize, z: usize) -> Biome {

let index = Self::biome_index(x, z);

self.biomes[index]

}

/// Sets the biome for the specified column.

///

/// # Panics

/// Panics if `x < 16` or `z < 16`.

pub fn set_biome_at(&mut self, x: usize, z: usize, biome: Biome) {

let index = Self::biome_index(x, z);

self.modified = true;

self.biomes[index] = biome;

}

/// Checks whether this chunk has been modified since the last

/// call to this function.

pub fn check_modified(&mut self) -> bool {

let res = self.modified;

self.modified = false;

res

}

fn biome_index(x: usize, z: usize) -> usize {

assert!(x < 16);

assert!(z < 16);

(z << 4) | x

}

/// The block state data for this chunk section.

data: BitArray,

/// This section's palette. `None` if using the global palette.

/// The palette should always remain sorted so that a binary

/// search can be performed on it.

palette: Option<Vec<u16>>,

/// The number of solid blocks in this chunk, i.e. those

/// that are not air. This value is used to figure out when

/// the section becomes empty.

solid_block_count: u16,

block_light: BitArray,

sky_light: BitArray,

/// A section is considered dirty when it has been

/// modified since the last time it was optimized.

dirty: bool,

/// Creates a new, empty `ChunkSection`.

pub fn new(

mut data: BitArray,

mut palette: Option<Vec<u16>>,

block_light: BitArray,

sky_light: BitArray,

) -> Self {

// Correct palette if not using the global palette

if let Some(palette) = palette.as_mut() {

Self::correct_data_and_palette(&mut data, palette);

}

// Count solid blocks

let mut solid_block_count = 0;

for x in 0..16 {

for y in 0..16 {

for z in 0..16 {

if data.get(block_index(x, y, z)) != 0 {

solid_block_count += 1;

}

}

}

}

Self {

data,

palette,

solid_block_count,

dirty: false,

block_light,

sky_light,

}

}

/// Corrects a given raw palette and data array.

///

/// Since chunk data stored by external sources

/// (e.g. Vanilla) might not require a sorted palette

/// like Feather does, we need to sort the palette and

/// correct data in the array when reading from external

/// sources.

///

/// The correction is done in-place.

fn correct_data_and_palette(data: &mut BitArray, palette: &mut Vec<u16>) {

let original_palette = palette.clone(); // Palette without sorting guarantees

palette.sort_unstable();

for x in 0..16 {

for y in 0..16 {

for z in 0..16 {

// Replace index into palette of each block with

// new index into the sorted palette.

let block_index = block_index(x, y, z);

let old_index = data.get(block_index);

let new_index = palette

.binary_search(&original_palette[old_index as usize])

.unwrap();

data.set(block_index, new_index as u64);

}

}

}

}

/// Returns whether this chunk section is empty.

pub fn empty(&self) -> bool {

self.solid_block_count == 0

}

/// Retrieves the block at the given position in this chunk section.

/// The position is local to this section.

pub fn block_at(&self, x: usize, y: usize, z: usize) -> Block {

let index = block_index(x, y, z);

let block_id = self.data.get(index);

let global_id = match &self.palette {

Some(palette) => palette[block_id as usize] as u16,

None => block_id as u16,

};

Block::from_native_state_id(global_id).unwrap()

}

/// Sets the block at the given position in this chunk section.

/// The position is local to this section.

pub fn set_block_at(&mut self, x: usize, y: usize, z: usize, block: Block) {

self.dirty = true;

let index = block_index(x, y, z);

let block_id = block.native_state_id();

// The value that will be put into the

let mut paletted_index;

if let Some(palette) = self.palette.as_mut() {

// Retrieve the block index from the palette.

// If necessary, add the block to the palette.

match palette.binary_search(&block_id) {

Ok(index) => paletted_index = index,

Err(insertion_index) => {

palette.insert(insertion_index, block_id);

paletted_index = insertion_index;

// Resize if necessary

if needed_bits((palette.len() - 1) as u64) > self.data.bits_per_value {

let new_bits_per_value = self.data.bits_per_value + 1;

if new_bits_per_value <= MAX_BITS_PER_BLOCK {

self.data = self.data.resize_to(self.data.bits_per_value + 1).unwrap();

paletted_index = insertion_index;

} else {

// Switch to the global palette

let mut new_data = BitArray::new(GLOBAL_BITS_PER_BLOCK, SECTION_VOLUME);

for _x in 0..16 {

for _y in 0..16 {

for _z in 0..16 {

let block = self.block_at(_x, _y, _z);

new_data.set(

block_index(_x, _y, _z),

block.native_state_id() as u64,

);

}

}

}

self.palette = None;

paletted_index = block_id as usize;

self.data = new_data;

}

}

// Correct data, since palette entries after

// the one which was inserted will be offsetted

// by one.

for x in 0..16 {

for y in 0..16 {

for z in 0..16 {

let index = block_index(x, y, z);

let entry = self.data.get(index);

if entry >= insertion_index as u64 {

self.data.set(index, entry + 1);

}

}

}

}

}

}

} else {

// Use the global palette.

paletted_index = block_id as usize;

}

let old_block = self.block_at(x, y, z);

if block == Block::Air && old_block != Block::Air {

self.solid_block_count -= 1;

} else if block != Block::Air && old_block == Block::Air {

self.solid_block_count += 1;

}

self.data.set(index, paletted_index as u64);

debug_assert_eq!(self.block_at(x, y, z), block);

}

/// Optimizes this chunk section, reducing the bits

/// per block value as much as possible and removing unused

/// entries from the palette.

///

/// This function only optimizes the chunk if it is dirt,

/// i.e. if it has been modified since the last time

/// it was optimized. The returned value is `true` when

/// the chunk was optimized and `false` when it wasn't.

pub fn optimize(&mut self) -> bool {

// Only optimize the chunk if it has been modified.

if !self.dirty {

return false;

}

self.dirty = false;

// Replace palette with new one.

let mut new_palette = vec![];

for x in 0..16 {

for y in 0..16 {

for z in 0..16 {

let block = self.block_at(x, y, z).native_state_id();

match new_palette.binary_search(&block) {

Ok(_) => (),

Err(insert_index) => {

new_palette.insert(insert_index, block);

}

}

}

}

}

// Recalculate all block IDs to match with the new palette.

for x in 0..16 {

for y in 0..16 {

for z in 0..16 {

let block = self.block_at(x, y, z).native_state_id();

self.data.set(

block_index(x, y, z),

new_palette.binary_search(&block).unwrap() as u64,

);

}

}

}

self.palette = Some(new_palette);

// Recalculate bits per block value.

let mut new_bits_per_block = needed_bits(self.palette.as_ref().unwrap().len() as u64);

if new_bits_per_block > MAX_BITS_PER_BLOCK {

self.palette = None;

} else {

if new_bits_per_block < MIN_BITS_PER_BLOCK {

new_bits_per_block = MIN_BITS_PER_BLOCK;

}

self.data = self.data.resize_to(new_bits_per_block).unwrap();

}

true // Chunk was optimized

}

/// If the global palette is in use, convert it to a section palette.

/// This is used for chunk saving.

pub fn convert_palette_to_section(&mut self) {

if self.palette.is_some() {

// Nothing to do: section palette already in use.

return;

}

let mut blocks = MultiMap::with_capacity(1024);

for x in 0..16 {

for y in 0..16 {

for z in 0..16 {

blocks.insert(self.block_at(x, y, z), (x, y, z));

}

}

}

// Create a palette based on the blocks in the chunk.

// We also have to modify the data array based on the new palette.

let mut palette = Vec::with_capacity(1024);

for (block, positions) in blocks.into_iter() {

palette.push(block.native_state_id());

for (x, y, z) in positions {

let index = block_index(x, y, z);

self.data.set(index, (palette.len() - 1) as u64);

}

}

self.palette = Some(palette);

}

/// Returns the internal data array for this section.

pub fn data(&self) -> &BitArray {

&self.data

}

/// Returns the palette for this section.

pub fn palette(&self) -> Option<&Vec<u16>> {

self.palette.as_ref()

}

/// Returns the number of bits used to store each block.

pub fn bits_per_block(&self) -> u8 {

self.data.bits_per_value

}

pub fn sky_light(&self) -> &BitArray {

&self.sky_light

}

pub fn block_light(&self) -> &BitArray {

&self.block_light

}

pub fn sky_light_mut(&mut self) -> &mut BitArray {

&mut self.sky_light

}

pub fn block_light_mut(&mut self) -> &mut BitArray {

&mut self.block_light

}

pub fn sky_light_at(&self, x: usize, y: usize, z: usize) -> u8 {

let index = block_index(x, y, z);

self.sky_light.get(index) as u8

}

pub fn block_light_at(&self, x: usize, y: usize, z: usize) -> u8 {

let index = block_index(x, y, z);

self.block_light.get(index) as u8

}

pub fn set_sky_light_at(&mut self, x: usize, y: usize, z: usize, value: u8) {

assert!(value < 16, "light level cannot exceed 15");

let index = block_index(x, y, z);

self.sky_light.set(index, u64::from(value));

}

pub fn set_block_light_at(&mut self, x: usize, y: usize, z: usize, value: u8) {

assert!(value < 16, "light level cannot exceed 15");

let index = block_index(x, y, z);

self.block_light.set(index, u64::from(value));

}

fn default() -> Self {

let air_id = Block::Air.native_state_id();

Self {

data: BitArray::new(4, SECTION_VOLUME),

palette: Some(vec![air_id]),

solid_block_count: 0,

dirty: false,

block_light: BitArray::new(4, SECTION_VOLUME),

sky_light: BitArray::new(4, SECTION_VOLUME),

}

}

assert!(x < 16);

assert!(y < 16);

assert!(z < 16);

(y << 8) | (z << 4) | x

/// The internal data array containing all values

data: Vec<u64>,

/// The capacity, in values, of this array

capacity: usize,

/// The number of bits used to represent each value

bits_per_value: u8,

/// The maximum value represented by an entry in this array

value_mask: u64,

/// Creates a new `BitArray` with the given

/// bits per value and capacity. The array

/// will be initialized with zeroes.

pub fn new(bits_per_value: u8, capacity: usize) -> Self {

assert!(

bits_per_value <= 64,

"Bits per value cannot be more than 64"

);

assert!(bits_per_value > 0, "Bits per value must be positive");

let data = {

let len = (((capacity * (bits_per_value as usize)) as f64) / 64.0).ceil() as usize;

vec![0u64; len]

};

let value_mask = (1 << (bits_per_value as u64)) - 1;

Self {

data,

capacity,

bits_per_value,

value_mask,

}

}

/// Creates a new `BitArray` based on the given raw parts.

pub fn from_raw(data: Vec<u64>, bits_per_value: u8, capacity: usize) -> Self {

assert!(

bits_per_value <= 64,

"Bits per value cannot be more than 64"

);

assert!(bits_per_value > 0, "Bits per value must be positive");

let value_mask = (1 << (bits_per_value as u64)) - 1;

Self {

data,

capacity,

bits_per_value,

value_mask,

}

}

/// Returns the highest possible value represented

/// by and entry in this `BitArray`.

pub fn highest_possible_value(&self) -> u64 {

self.value_mask

}

/// Returns the value at the given location in this `BitArray`.

pub fn get(&self, index: usize) -> u64 {

assert!(index < self.capacity, "Index out of bounds");

let bit_index = index * (self.bits_per_value as usize);

let start_long_index = bit_index / 64;

let start_long = self.data[start_long_index];

let index_in_start_long = (bit_index % 64) as u64;

let mut result = start_long >> index_in_start_long;

let end_bit_offset = index_in_start_long + self.bits_per_value as u64;

if end_bit_offset > 64 {

// Value stretches across multiple longs

let end_long = self.data[start_long_index + 1];

result |= end_long << (64 - index_in_start_long);

}

result & self.value_mask

}

/// Sets the value at the given index into this `BitArray`

pub fn set(&mut self, index: usize, val: u64) {

assert!(index < self.capacity, "Index out of bounds");

assert!(

val <= self.value_mask,

"Value does not fit into bits_per_value"

);

let bit_index = index * (self.bits_per_value as usize);

let start_long_index = bit_index / 64;

let index_in_start_long = (bit_index % 64) as u64;

// Clear bits of this value first

self.data[start_long_index] = (self.data[start_long_index]

& !(self.value_mask << index_in_start_long))

| ((val & self.value_mask) << index_in_start_long);

let end_bit_offset = index_in_start_long + self.bits_per_value as u64;

if end_bit_offset > 64 {

// Value stretches across multiple longs

self.data[start_long_index + 1] = (self.data[start_long_index + 1]