fn generate_chunk(&self, position: ChunkPosition) -> Chunk {

Chunk::new(position)

}

/// The biome generator.

biome: Box<dyn BiomeGenerator>,

/// The height map generator.

density_map: Box<dyn DensityMapGenerator>,

/// The composition generator.

composition: Box<dyn CompositionGenerator>,

/// A vector of finishing generators used

/// by this composable generator.

finishers: SmallVec<[Box<dyn FinishingGenerator>; 8]>,

/// The world seed.

seed: u64,

/// Creates a new `ComposableGenerator` with the given stages.

pub fn new<B, D, C, F>(

biome: B,

density_map: D,

composition: C,

finishers: F,

seed: u64,

) -> Self

where

B: BiomeGenerator + 'static,

D: DensityMapGenerator + 'static,

C: CompositionGenerator + 'static,

F: IntoIterator<Item = Box<dyn FinishingGenerator>>,

{

Self {

biome: Box::new(biome),

density_map: Box::new(density_map),

composition: Box::new(composition),

finishers: finishers.into_iter().collect(),

seed,

}

}

/// A default composable generator, used

/// for worlds with "default" world type.

pub fn default_with_seed(seed: u64) -> Self {

let finishers: Vec<Box<dyn FinishingGenerator>> = vec![

Box::new(SnowFinisher::default()),

Box::new(SingleFoliageFinisher::default()),

Box::new(ClumpedFoliageFinisher::default()),

];

Self::new(

TwoLevelBiomeGenerator::default(),

DensityMapGeneratorImpl::default(),

BasicCompositionGenerator::default(),

finishers,

seed,

)

}

fn generate_chunk(&self, position: ChunkPosition) -> Chunk {

let mut seed_shuffler = XorShiftRng::seed_from_u64(self.seed);

// Generate biomes for 3x3 grid of chunks around current chunk.

let biome_seed = seed_shuffler.gen();

let mut biomes = vec![];

for z in -1..=1 {

for x in -1..=1 {

let pos = ChunkPosition::new(position.x + x, position.z + z);

biomes.push(self.biome.generate_for_chunk(pos, biome_seed));

}

}

let biomes = NearbyBiomes::from_slice(&biomes[..]).unwrap();

let density_map =

self.density_map

.generate_for_chunk(position, &biomes, seed_shuffler.gen());

let mut chunk = Chunk::new(position);

*chunk.biomes_mut() = *biomes.center();

self.composition.generate_for_chunk(

&mut chunk,

position,

&biomes.biome_stores[4], // Center chunk

density_map.as_bitslice(),

seed_shuffler.gen(),

);

// Calculate top blocks in chunk.

// TODO: perhaps this should be moved to `Chunk`?

let mut top_blocks = TopBlocks::new();

for x in 0..16 {

for z in 0..16 {

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

if chunk.block_at(x, y, z).unwrap() != BlockId::air() {

top_blocks.set_top_block_at(x, z, y);

break;

}

}

}

}

chunk.recalculate_heightmaps();

// Finishers.

for finisher in &self.finishers {

finisher.generate_for_chunk(

&mut chunk,

&biomes.biome_stores[4],

&top_blocks,

seed_shuffler.gen(),

);

}

chunk

}

/// Generates the biomes for a given chunk.

/// This function should be deterministic.

fn generate_for_chunk(&self, chunk: ChunkPosition, seed: u64) -> BiomeStore;

/// Generates the density map for a given chunk.

/// A compact array of booleans is returned, indexable

/// by (y << 8) | (x << 4) | z. Those set to `true` will

/// contain solid blacks; those set to `false` will be air.

fn generate_for_chunk(

&self,

chunk: ChunkPosition,

biomes: &NearbyBiomes,

seed: u64,

) -> BitVec<LocalBits, u8>;

/// Populates the given chunk with blocks based on the given

/// biomes and density map.

fn generate_for_chunk(

&self,

chunk: &mut Chunk,

pos: ChunkPosition,

biomes: &BiomeStore,

density: &BitSlice<LocalBits, u8>,

seed: u64,

);

/// Populates the given chunk with any

/// finishing blocks.

fn generate_for_chunk(

&self,

chunk: &mut Chunk,

biomes: &BiomeStore,

top_blocks: &TopBlocks,

seed: u64,

);

pub fn new() -> Self {

Self {

top_blocks: vec![0; 16 * 16],

}

}

/// Fetches the highest solid blocks for the

/// given column coordinates (chunk-local).

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

self.top_blocks[x + (z << 4)] as usize

}

pub fn set_top_block_at(&mut self, x: usize, z: usize, top: usize) {

self.top_blocks[x + (z << 4)] = top as u8;

}

/// 2D array of chunk biomes. The chunk biomes

/// for a given chunk position relative to the center

/// chunk can be obtained using (x + 1) + (z + 1) * 3.

pub biome_stores: [BiomeStore; 3 * 3],

pub fn from_slice(biome_store_slice: &[BiomeStore]) -> Option<Self> {

let mut biome_stores = [BiomeStore::new(Biome::Badlands); 9];

if biome_store_slice.len() != biome_stores.len() {

return None;

}

biome_stores.clone_from_slice(biome_store_slice);

Some(Self { biome_stores })

}

/// Gets the biome at the given coordinates.

///

/// # Panics

/// Panics if `x >= 16`, `z >= 16`, or `y >= 256`.

pub fn get_at_block<N: ToPrimitive>(&self, x: N, y: N, z: N) -> Biome {

let (index, local_x, local_y, local_z) = self.index(x, y, z);

self.biome_stores[index].get_at_block(local_x, local_y, local_z)

}

/// Gets the biome at the given coordinates, in multiples

/// of 4 blocks.

///

/// # Panics

/// Panics if `x >= 4`, `z >= 4`, or `y >= 64`.

pub fn get<N: ToPrimitive>(&self, x: N, y: N, z: N) -> Biome {

let (index, local_x, local_y, local_z) = self.index(

x.to_isize().unwrap() * 4,

y.to_isize().unwrap() * 4,

z.to_isize().unwrap() * 4,

);

self.biome_stores[index].get(local_x / 4, local_y / 4, local_z / 4)

}

/// Sets the biome at the given coordinates, in multiples

/// of 4 blocks.

///

/// # Panics

/// Panics if `x >= 4`, `z >= 4`, or `y >= 64`.

pub fn set<N: ToPrimitive>(&mut self, x: N, y: N, z: N, biome: Biome) {

let (index, local_x, local_y, local_z) = self.index(

x.to_isize().unwrap() * 4,

y.to_isize().unwrap() * 4,

z.to_isize().unwrap() * 4,

);

self.biome_stores[index].set(local_x / 4, local_y / 4, local_z / 4, biome);

}

pub fn center(&self) -> &BiomeStore {

&self.biome_stores[4]

}

pub fn center_mut(&mut self) -> &mut BiomeStore {

&mut self.biome_stores[4]

}

/// Returns a tuple of (chunk_index, local_x, local_y, local_z)

fn index<N: ToPrimitive>(&self, ox: N, oy: N, oz: N) -> (usize, usize, usize, usize) {

// FIXME: Does this function need to so complicated?

let ox = ox.to_isize().unwrap();

let oy = oy.to_isize().unwrap();

let oz = oz.to_isize().unwrap();

let x = ox + 16;

let z = oz + 16;

let chunk_x = (x / 16) as usize;

let chunk_z = (z / 16) as usize;

let mut local_x = (ox % 16).unsigned_abs();

let local_y = (oy % 16).unsigned_abs();

let mut local_z = (oz % 16).unsigned_abs();

if ox < 0 {

local_x = 16 - local_x;

}

if oz < 0 {

local_z = 16 - local_z;

}

(chunk_x + chunk_z * 3, local_x, local_y, local_z)

}

fn generate_for_chunk(&self, _chunk: ChunkPosition, _seed: u64) -> BiomeStore {

BiomeStore::new(Biome::Plains)

}

use super::*;

#[test]

fn test_reproducability() {

let seeds: [u64; 4] = [std::u64::MAX, 3243, 0, 100];

let chunks = [

ChunkPosition::new(0, 0),

ChunkPosition::new(-1, -1),

ChunkPosition::new(1, 1),

];

for seed in seeds.iter() {

let gen = ComposableGenerator::default_with_seed(*seed);

for chunk in chunks.iter() {

let first = gen.generate_chunk(*chunk);

let second = gen.generate_chunk(*chunk);

test_chunks_eq(&first, &second);

}

}

}

fn test_chunks_eq(a: &Chunk, b: &Chunk) {

for x in 0..16 {

for z in 0..16 {

for y in 0..256 {

assert_eq!(a.block_at(x, y, z), b.block_at(x, y, z));

}

}

}

for x in 0..4 {

for z in 0..4 {

for y in 0..64 {

assert_eq!(a.biomes().get(x, y, z), b.biomes().get(x, y, z));

}

}

}

}

#[test]

pub fn test_worldgen_void() {

let chunk_pos = ChunkPosition { x: 1, z: 2 };

let generator = VoidWorldGenerator;

let chunk = generator.generate_chunk(chunk_pos);

// No sections have been generated

assert!(chunk.sections().iter().all(|sec| sec.is_none()));

assert_eq!(chunk_pos, chunk.position());

}

#[test]

fn test_chunk_biomes() {

let mut biomes = BiomeStore::new(Biome::Plains);

for x in 0..4 {

for z in 0..4 {

for y in 0..64 {

assert_eq!(biomes.get(x, y, z), Biome::Plains);

biomes.set(x, y, z, Biome::Ocean);

assert_eq!(biomes.get(x, y, z), Biome::Ocean);

}

}

}

}

#[test]

fn test_static_biome_generator() {

let gen = StaticBiomeGenerator::default();

let biomes = gen.generate_for_chunk(ChunkPosition::new(0, 0), 0);

for x in 0..4 {

for z in 0..4 {

for y in 0..64 {

assert_eq!(biomes.get(x, y, z), Biome::Plains);

}

}

}

}

#[test]

fn test_nearby_biomes() {

let biomes = vec![

BiomeStore::new(Biome::Plains),

BiomeStore::new(Biome::Swamp),

BiomeStore::new(Biome::Savanna),

BiomeStore::new(Biome::BirchForest),

BiomeStore::new(Biome::DarkForest),

BiomeStore::new(Biome::Mountains),

BiomeStore::new(Biome::Ocean),

BiomeStore::new(Biome::Desert),

BiomeStore::new(Biome::Taiga),

];

let biomes = NearbyBiomes::from_slice(&biomes[..]).unwrap();

assert_eq!(biomes.get_at_block(0, 0, 0), Biome::DarkForest);

assert_eq!(biomes.get_at_block(16, 0, 16), Biome::Taiga);

assert_eq!(biomes.get_at_block(-1, 0, -1), Biome::Plains);

assert_eq!(biomes.get_at_block(-1, 0, 0), Biome::BirchForest);

}