diff --git a/biomes/.gitignore b/biomes/.gitignore new file mode 100644 index 0000000..2f7896d --- /dev/null +++ b/biomes/.gitignore @@ -0,0 +1 @@ +target/ diff --git a/biomes/Cargo.lock b/biomes/Cargo.lock new file mode 100644 index 0000000..b576fa0 --- /dev/null +++ b/biomes/Cargo.lock @@ -0,0 +1,107 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "biomes" +version = "0.1.0" +dependencies = [ + "physique", + "png", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "crc32fast" +version = "1.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ba106e844045ddc02c20768ac4b0b7cb45f2cc2ecbd833ac9f5dacb183c2055" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "fdeflate" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "flate2" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb" +dependencies = [ + "crc32fast", + "miniz_oxide 0.9.1", + "zlib-rs", +] + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "miniz_oxide" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "physique" +version = "0.1.0" + +[[package]] +name = "png" +version = "0.17.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526" +dependencies = [ + "bitflags", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide 0.8.9", +] + +[[package]] +name = "simd-adler32" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" + +[[package]] +name = "zlib-rs" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112" diff --git a/biomes/Cargo.toml b/biomes/Cargo.toml new file mode 100644 index 0000000..ac076c7 --- /dev/null +++ b/biomes/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "biomes" +version = "0.1.0" +edition = "2021" + +[dependencies] +physique = { path = "../physique" } + +[dev-dependencies] +png = "0.17" diff --git a/biomes/examples/vue_lans.rs b/biomes/examples/vue_lans.rs new file mode 100644 index 0000000..fb5ac89 --- /dev/null +++ b/biomes/examples/vue_lans.rs @@ -0,0 +1,69 @@ +//! PNG de dessus de la tuile de Lans (1000x1000 m). Usage : +//! cargo run --release --example vue_lans -- +use biomes::*; +use std::io::{BufWriter, Read}; + +fn npy(path: &str) -> (Vec, usize) { + let mut b = Vec::new(); + std::fs::File::open(path).unwrap().read_to_end(&mut b).unwrap(); + let hl = u16::from_le_bytes([b[8], b[9]]) as usize; + (b[10 + hl..].to_vec(), 10 + hl) +} + +fn main() { + let a: Vec = std::env::args().collect(); + let (mnt_b, _) = npy(&a[1]); + let z: Vec = mnt_b.chunks_exact(4).map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]])).collect(); + let rd = |n: &str| npy(&format!("{}/{}.npy", a[2], n)).0; + let (sol, eau, routes, bati) = (rd("sol"), rd("eau"), rd("routes"), rd("bati")); + let n = 1000usize; + let mut img = vec![0u8; n * n * 3]; + let mut stats = std::collections::BTreeMap::new(); + let seed = 42; + for r in 0..n { + for c in 0..n { + let i = r * n + c; + let g = |dr: isize, dc: isize| z[(r as isize + dr).clamp(0, n as isize - 1) as usize * n + (c as isize + dc).clamp(0, n as isize - 1) as usize]; + let dx = (g(0, 1) - g(0, -1)) / 2.0; + let dy = (g(1, 0) - g(-1, 0)) / 2.0; // vers le sud + let pente = dx.hypot(dy).atan().to_degrees(); + let aspect = (-dx).atan2(dy).to_degrees().rem_euclid(360.0); + let col = Colonne { alt_m: z[i], pente_deg: pente, aspect_deg: aspect, sol: sol[i], eau: eau[i], route: routes[i], bati: bati[i] }; + let (x, zz) = (c as i32, r as i32); + let pal = palette(&col, x, zz, seed); + let bi = biome(&col, x, zz, seed); + *stats.entry(bi.id()).or_insert(0u32) += 1; + let mut rgb: [f32; 3] = match pal.haut { + "minecraft:grass_block" => match bi { Biome::Forest => [76., 140., 50.], Biome::Taiga => [70., 120., 80.], Biome::Meadow | Biome::Grove => [100., 165., 60.], Biome::Swamp => [90., 110., 60.], _ => [95., 159., 53.] }, + "minecraft:stone" => [125., 125., 125.], "minecraft:andesite" => [136., 136., 136.], + "minecraft:gravel" => [131., 127., 126.], "minecraft:coarse_dirt" => [119., 85., 59.], + "minecraft:podzol" => [91., 63., 24.], "minecraft:mud" => [60., 57., 60.], + "minecraft:farmland" => [143., 103., 71.], "minecraft:dirt_path" => [148., 122., 65.], + "minecraft:gray_concrete_powder" => [76., 81., 84.], "minecraft:stone_bricks" => [150., 150., 150.], + _ => [200., 0., 200.], + }; + if eau[i] == 1 || eau[i] == 3 { rgb = [50., 90., 200.]; } + if let Some(t) = arbre_en(&col, x, zz, seed) { + let (tc, big) = if t.essence.coniferes() { ([20., 70., 40.], 2) } else { ([45., 110., 30.], 2) }; + for dr in 0..big { for dc in 0..big { + let (rr, cc) = (r + dr, c + dc); + if rr < n && cc < n { let j = (rr * n + cc) * 3; for k in 0..3 { img[j + k] = tc[k] as u8; } } + } } + continue; + } + let sh = (1.0 + (dx - dy) * 0.04).clamp(0.6, 1.3); + let j = i * 3; + if img[j] == 0 && img[j + 1] == 0 && img[j + 2] == 0 || true { + // ne pas ecraser les arbres deja poses (pixels proches deja colores) + if !(img[j] != 0 && img[j + 1] != 0 && is_tree(&img[j..j + 3])) { for k in 0..3 { img[j + k] = (rgb[k] * sh).clamp(0., 255.) as u8; } } + } + } + } + let f = BufWriter::new(std::fs::File::create(&a[3]).unwrap()); + let mut e = png::Encoder::new(f, n as u32, n as u32); + e.set_color(png::ColorType::Rgb); e.set_depth(png::BitDepth::Eight); + e.write_header().unwrap().write_image_data(&img).unwrap(); + for (k, v) in stats { println!("{k}: {:.1} %", v as f32 / 1e4); } +} + +fn is_tree(p: &[u8]) -> bool { (p == [20, 70, 40]) || (p == [45, 110, 30]) } diff --git a/biomes/src/lib.rs b/biomes/src/lib.rs new file mode 100644 index 0000000..3c1e084 --- /dev/null +++ b/biomes/src/lib.rs @@ -0,0 +1,250 @@ +//! Choix du biome vanilla, de la palette de surface et des arbres (prototype 10). +//! Fonctions pures, deterministes (bruit par hash), independantes de Pumpkin. +//! Valeurs seuils [A VERIFIER] sur le terrain. Codes sol : donnees/raster-sol-eau/codes.json. +use physique::{etage_vegetation, Etage, Exposition}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Biome { Plains, Meadow, Forest, Taiga, Grove, StonyPeaks, River, Swamp } +impl Biome { + pub fn id(self) -> &'static str { + match self { + Biome::Plains => "minecraft:plains", Biome::Meadow => "minecraft:meadow", + Biome::Forest => "minecraft:forest", Biome::Taiga => "minecraft:taiga", + Biome::Grove => "minecraft:grove", Biome::StonyPeaks => "minecraft:stony_peaks", + Biome::River => "minecraft:river", Biome::Swamp => "minecraft:swamp", + } + } +} + +/// Echantillon d'une colonne (1 m). `aspect_deg` : direction de descente, 0 = nord, 90 = est. +#[derive(Clone, Copy, Debug)] +pub struct Colonne { pub alt_m: f32, pub pente_deg: f32, pub aspect_deg: f32, pub sol: u8, pub eau: u8, pub route: u8, pub bati: u8 } + +pub fn exposition(aspect_deg: f32, pente_deg: f32) -> Exposition { + if pente_deg < 8.0 { return Exposition::Neutre; } + let a = aspect_deg.rem_euclid(360.0); + if !(45.0..315.0).contains(&a) { Exposition::Ubac } // pente regardant le nord + else if (135.0..225.0).contains(&a) { Exposition::Adret } // regardant le sud + else { Exposition::Neutre } +} + +// ---------- bruit deterministe ---------- +fn hash(seed: u64, x: i32, z: i32) -> u64 { + let mut h = seed ^ (x as i64 as u64).wrapping_mul(0x9E37_79B9_7F4A_7C15) ^ (z as i64 as u64).wrapping_mul(0xC2B2_AE3D_27D4_EB4F); + h ^= h >> 33; h = h.wrapping_mul(0xFF51_AFD7_ED55_8CCD); + h ^= h >> 33; h = h.wrapping_mul(0xC4CE_B9FE_1A85_EC53); + h ^ (h >> 33) +} +/// Bruit blanc dans [0,1). +pub fn bruit(seed: u64, x: i32, z: i32) -> f32 { (hash(seed, x, z) >> 40) as f32 / (1u64 << 24) as f32 } +/// Bruit de valeur lisse, cellules de `taille` blocs, dans [0,1). +pub fn bruit_lisse(seed: u64, x: i32, z: i32, taille: i32) -> f32 { + let (cx, cz) = (x.div_euclid(taille), z.div_euclid(taille)); + let fx = x.rem_euclid(taille) as f32 / taille as f32; + let fz = z.rem_euclid(taille) as f32 / taille as f32; + let s = |t: f32| t * t * (3.0 - 2.0 * t); + let (u, v) = (s(fx), s(fz)); + let a = bruit(seed, cx, cz); let b = bruit(seed, cx + 1, cz); + let c = bruit(seed, cx, cz + 1); let d = bruit(seed, cx + 1, cz + 1); + (a + (b - a) * u) * (1.0 - v) + (c + (d - c) * u) * v +} + +/// Altitude effective d'etage, perturbee par un bruit lisse (+-60 m) : transitions irregulieres. +fn alt_perturbee(c: &Colonne, x: i32, z: i32, seed: u64) -> f32 { + c.alt_m + (bruit_lisse(seed ^ 0xA1, x, z, 48) - 0.5) * 120.0 +} +pub fn etage(c: &Colonne, x: i32, z: i32, seed: u64) -> Etage { + etage_vegetation(alt_perturbee(c, x, z, seed), exposition(c.aspect_deg, c.pente_deg)) +} +fn est_foret(sol: u8) -> bool { matches!(sol, 2 | 3 | 4 | 5) } + +/// Biome vanilla de la colonne (fige dans le chunk ; le client colore herbe et feuilles). +pub fn biome(c: &Colonne, x: i32, z: i32, seed: u64) -> Biome { + if c.eau == 1 || c.eau == 3 { return Biome::River; } + if c.sol == 10 { return Biome::Swamp; } + let e = etage(c, x, z, seed); + let foret = est_foret(c.sol); + let conif = c.sol == 3 || (c.sol == 4 && bruit_lisse(seed ^ 0xB2, x, z, 64) > 0.5); + match e { + Etage::Collineen => if foret { Biome::Forest } else { Biome::Plains }, + Etage::Montagnard => if foret { if conif { Biome::Taiga } else { Biome::Forest } } else { Biome::Meadow }, + Etage::Subalpin => if foret { Biome::Taiga } else { Biome::Grove }, + Etage::Alpin => Biome::Meadow, + Etage::Nival => Biome::StonyPeaks, + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Palette { pub haut: &'static str, pub sous: &'static str, pub epaisseur: u8 } +const fn p(haut: &'static str, sous: &'static str, epaisseur: u8) -> Palette { Palette { haut, sous, epaisseur } } + +/// Palette de surface : pente (herbe, terre grossiere, gravier, pierre), occupation du sol, bruit. +pub fn palette(c: &Colonne, x: i32, z: i32, seed: u64) -> Palette { + let n = bruit(seed ^ 0xC3, x, z); + let lisse = bruit_lisse(seed ^ 0xD4, x, z, 6); + if c.bati > 0 { return p("minecraft:stone_bricks", "minecraft:stone", 1); } + match c.route { + 1 => return p("minecraft:gray_concrete_powder", "minecraft:gravel", 2), + 2 => return p("minecraft:gravel", "minecraft:coarse_dirt", 2), + 3 => return p("minecraft:dirt_path", "minecraft:dirt", 2), + 4 => return if n < 0.7 { p("minecraft:dirt_path", "minecraft:dirt", 1) } else { p("minecraft:coarse_dirt", "minecraft:dirt", 1) }, + _ => {} + } + if c.eau == 1 || c.eau == 3 { return p("minecraft:gravel", "minecraft:sand", 2); } + if c.eau == 2 { return p("minecraft:mud", "minecraft:dirt", 1); } + let alt = alt_perturbee(c, x, z, seed); + // pente : transitions bruitees de +-4 degres + let pente = c.pente_deg + (lisse - 0.5) * 8.0; + if pente > 55.0 { return p("minecraft:stone", "minecraft:stone", 0); } + if pente > 42.0 { return if n < 0.6 { p("minecraft:stone", "minecraft:stone", 0) } else { p("minecraft:andesite", "minecraft:stone", 0) }; } + if pente > 32.0 { + return if n < 0.45 { p("minecraft:stone", "minecraft:stone", 1) } + else if n < 0.75 { p("minecraft:gravel", "minecraft:stone", 1) } + else { p("minecraft:coarse_dirt", "minecraft:dirt", 2) }; + } + if pente > 22.0 { + return if n < 0.35 { p("minecraft:coarse_dirt", "minecraft:dirt", 2) } + else if n < 0.5 { p("minecraft:gravel", "minecraft:dirt", 2) } + else { p("minecraft:grass_block", "minecraft:dirt", 3) }; + } + match c.sol { + 10 => if n < 0.5 { p("minecraft:mud", "minecraft:dirt", 2) } else { p("minecraft:grass_block", "minecraft:dirt", 3) }, + 9 => p("minecraft:farmland", "minecraft:dirt", 3), + 12 => p("minecraft:coarse_dirt", "minecraft:gravel", 2), + 7 | 8 | 11 => p("minecraft:grass_block", "minecraft:dirt", 3), + 2..=5 => if alt > 1500.0 && n < 0.25 { p("minecraft:coarse_dirt", "minecraft:dirt", 2) } + else if n < 0.12 { p("minecraft:podzol", "minecraft:dirt", 3) } + else { p("minecraft:grass_block", "minecraft:dirt", 3) }, + _ => if alt > 2100.0 { p("minecraft:stone", "minecraft:gravel", 1) } + else if alt > 1900.0 && n < 0.4 { p("minecraft:coarse_dirt", "minecraft:dirt", 2) } + else { p("minecraft:grass_block", "minecraft:dirt", 3) }, + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Essence { Hetre, Chene, Sapin, Epicea, PinCrochets } +impl Essence { + pub fn tronc(self) -> &'static str { + match self { Essence::Hetre | Essence::Chene => "minecraft:oak_log", _ => "minecraft:spruce_log" } + } + pub fn feuilles(self) -> &'static str { + match self { Essence::Hetre | Essence::Chene => "minecraft:oak_leaves", _ => "minecraft:spruce_leaves" } + } + pub fn coniferes(self) -> bool { matches!(self, Essence::Sapin | Essence::Epicea | Essence::PinCrochets) } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Arbre { pub essence: Essence, pub hauteur: u8 } + +/// Probabilite qu'une cellule de 4x4 contienne un arbre (densite ~ couvert reel). +pub fn densite(c: &Colonne, e: Etage) -> f32 { + if c.bati > 0 || c.route > 0 || c.eau > 0 || c.pente_deg > 45.0 { return 0.0; } + let base = match c.sol { + 2..=4 => 0.75, 5 => 0.5, 6 => 0.45, 7 => 0.08, 11 => 0.1, 10 => 0.04, + 0 | 1 => 0.004, _ => 0.0, + }; + let f = match e { Etage::Collineen | Etage::Montagnard => 1.0, Etage::Subalpin => 0.55, Etage::Alpin => 0.06, Etage::Nival => 0.0 }; + base * f +} + +/// Essence selon feuillus/coniferes, etage et adret/ubac. +pub fn essence(c: &Colonne, e: Etage, x: i32, z: i32, seed: u64) -> Essence { + let r = bruit(seed ^ 0xE5, x, z); + let conif = c.sol == 3 || (c.sol == 4 && r < 0.5); + let expo = exposition(c.aspect_deg, c.pente_deg); + match e { + Etage::Collineen => if conif { if r < 0.5 { Essence::Epicea } else { Essence::Sapin } } + else if expo == Exposition::Adret && r > 0.5 { Essence::Chene } else { Essence::Hetre }, + Etage::Montagnard => if conif { if r < 0.6 { Essence::Sapin } else { Essence::Epicea } } + else if r > 0.8 { Essence::Sapin } else { Essence::Hetre }, + _ => if r < 0.2 && expo == Exposition::Adret { Essence::PinCrochets } else { Essence::Epicea }, + } +} + +/// Arbre eventuel dont le tronc est place en (x, z). Un candidat par cellule 4x4 avec jitter. +pub fn arbre_en(c: &Colonne, x: i32, z: i32, seed: u64) -> Option { + const CELL: i32 = 4; + let (cx, cz) = (x.div_euclid(CELL), z.div_euclid(CELL)); + let jx = cx * CELL + (hash(seed ^ 0x11, cx, cz) % CELL as u64) as i32; + let jz = cz * CELL + (hash(seed ^ 0x22, cx, cz) % CELL as u64) as i32; + if (jx, jz) != (x, z) { return None; } + let e = etage(c, x, z, seed); + let d = densite(c, e); + let m = 0.6 + 0.8 * bruit_lisse(seed ^ 0x33, x, z, 40); // clairieres et lisieres + if bruit(seed ^ 0x44, cx, cz) >= (d * m).min(1.0) { return None; } + let es = essence(c, e, x, z, seed); + let r = bruit(seed ^ 0x55, x, z); + let (h0, dh) = match (es, e) { + (Essence::PinCrochets, _) => (5.0, 4.0), + (_, Etage::Subalpin) | (_, Etage::Alpin) => (6.0, 5.0), + (Essence::Sapin, _) => (14.0, 10.0), + (Essence::Epicea, _) => (11.0, 9.0), + (Essence::Chene, _) => (9.0, 6.0), + _ => (12.0, 8.0), + }; + Some(Arbre { essence: es, hauteur: (h0 + dh * r) as u8 }) +} + +#[cfg(test)] +mod tests { + use super::*; + fn col(alt: f32, pente: f32, sol: u8) -> Colonne { Colonne { alt_m: alt, pente_deg: pente, aspect_deg: 180.0, sol, eau: 0, route: 0, bati: 0 } } + + #[test] fn deterministe() { + let c = col(1000.0, 10.0, 2); + assert_eq!(biome(&c, 5, 7, 1), biome(&c, 5, 7, 1)); + assert_eq!(palette(&c, 5, 7, 1), palette(&c, 5, 7, 1)); + assert_eq!(arbre_en(&c, 8, 8, 3), arbre_en(&c, 8, 8, 3)); + } + #[test] fn bruit_borne() { + for i in -50..50 { let v = bruit_lisse(9, i * 7, i * 3, 16); assert!((0.0..1.0).contains(&v)); } + } + #[test] fn eau_et_marais() { + let mut c = col(1000.0, 1.0, 1); c.eau = 1; + assert_eq!(biome(&c, 0, 0, 1), Biome::River); + assert_eq!(biome(&col(1000.0, 1.0, 10), 0, 0, 1), Biome::Swamp); + } + #[test] fn biomes_par_etage() { + assert_eq!(biome(&col(300.0, 5.0, 1), 3, 3, 1), Biome::Plains); + assert_eq!(biome(&col(1200.0, 5.0, 1), 3, 3, 1), Biome::Meadow); + assert_eq!(biome(&col(1200.0, 5.0, 3), 3, 3, 1), Biome::Taiga); + assert_eq!(biome(&col(1200.0, 5.0, 2), 3, 3, 1), Biome::Forest); + assert_eq!(biome(&col(2800.0, 5.0, 1), 3, 3, 1), Biome::StonyPeaks); + } + #[test] fn pente_donne_roche() { + assert_eq!(palette(&col(1200.0, 80.0, 1), 1, 1, 1).haut, "minecraft:stone"); + assert_eq!(palette(&col(1200.0, 2.0, 1), 1, 1, 1).haut, "minecraft:grass_block"); + } + #[test] fn routes_et_bati() { + let mut c = col(1000.0, 2.0, 1); c.route = 1; + assert_eq!(palette(&c, 0, 0, 1).haut, "minecraft:gray_concrete_powder"); + c.route = 0; c.bati = 1; + assert_eq!(palette(&c, 0, 0, 1).haut, "minecraft:stone_bricks"); + } + #[test] fn exposition_ok() { + assert_eq!(exposition(180.0, 20.0), Exposition::Adret); + assert_eq!(exposition(0.0, 20.0), Exposition::Ubac); + assert_eq!(exposition(180.0, 2.0), Exposition::Neutre); + } + #[test] fn densite_arbres_foret_vs_prairie() { + let (mut f, mut p) = (0, 0); + let (cf, cp) = (col(1000.0, 10.0, 3), col(1000.0, 10.0, 1)); + for x in 0..200 { for z in 0..200 { + if arbre_en(&cf, x, z, 7).is_some() { f += 1; } + if arbre_en(&cp, x, z, 7).is_some() { p += 1; } + } } + assert!(f > 1000 && f < 3000, "foret {f}"); + assert!(p < 100, "prairie {p}"); + } + #[test] fn essence_selon_foret() { + let c = col(1000.0, 10.0, 3); + let (mut n, mut nc) = (0, 0); + for x in 0..120 { for z in 0..120 { if let Some(a) = arbre_en(&c, x, z, 2) { n += 1; if a.essence.coniferes() { nc += 1; } } } } + assert!(n > 50 && n == nc); + let c = col(500.0, 5.0, 2); + let a = (0..400).flat_map(|x| (0..400).map(move |z| (x, z))).find_map(|(x, z)| arbre_en(&c, x, z, 2)).unwrap(); + assert!(!a.essence.coniferes()); + } + #[test] fn pas_d_arbre_nival() { + assert_eq!(densite(&col(3000.0, 5.0, 3), Etage::Nival), 0.0); + } +}