diff --git a/carte-monde/Cargo.lock b/carte-monde/Cargo.lock new file mode 100644 index 0000000..928cd2b --- /dev/null +++ b/carte-monde/Cargo.lock @@ -0,0 +1,14 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "carte-monde" +version = "0.1.0" +dependencies = [ + "physique", +] + +[[package]] +name = "physique" +version = "0.1.0" diff --git a/carte-monde/Cargo.toml b/carte-monde/Cargo.toml new file mode 100644 index 0000000..067db48 --- /dev/null +++ b/carte-monde/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "carte-monde" +version = "0.1.0" +edition = "2021" + +[dependencies] +physique = { path = "../physique" } + +# crate independante, n'impose pas d'espace de travail +[workspace] diff --git a/carte-monde/examples/rendu_carte.rs b/carte-monde/examples/rendu_carte.rs new file mode 100644 index 0000000..9a65f08 --- /dev/null +++ b/carte-monde/examples/rendu_carte.rs @@ -0,0 +1,18 @@ +//! cargo run --release --example rendu_carte -- [seed] [km] [pas_m] [x0_km] [z0_km] [sortie.png] +use carte_monde::CarteMonde; + +fn main() { + let a: Vec = std::env::args().collect(); + let g = |i: usize, d: &str| a.get(i).cloned().unwrap_or(d.to_string()); + let seed: u64 = g(1, "2026").parse().unwrap(); + let km: u32 = g(2, "64").parse().unwrap(); + let pas: u32 = g(3, "64").parse().unwrap(); + let x0: i64 = g(4, "0").parse::().unwrap() * 1000; + let z0: i64 = g(5, "0").parse::().unwrap() * 1000; + let sortie = g(6, r"..\..\outils\rendu\sorties\carte-monde\carte_monde_64km.png"); + let t = std::time::Instant::now(); + let png = CarteMonde::new(seed).rendu_carte(x0, z0, km, pas); + if let Some(p) = std::path::Path::new(&sortie).parent() { std::fs::create_dir_all(p).unwrap(); } + std::fs::write(&sortie, &png).unwrap(); + eprintln!("{} ({} Ko) en {:.1} s", sortie, png.len() / 1024, t.elapsed().as_secs_f32()); +} diff --git a/carte-monde/src/bruit.rs b/carte-monde/src/bruit.rs new file mode 100644 index 0000000..e61a32e --- /dev/null +++ b/carte-monde/src/bruit.rs @@ -0,0 +1,53 @@ +//! Bruit de valeur deterministe (hachage entier), sans dependance. + +fn hash(seed: u64, ix: i64, iz: i64) -> f64 { + let mut h = seed ^ (ix as u64).wrapping_mul(0x9E37_79B9_7F4A_7C15) ^ (iz as u64).wrapping_mul(0xC2B2_AE3D_27D4_EB4F); + h ^= h >> 32; + h = h.wrapping_mul(0xD6E8_FEB8_6659_FD93); + h ^= h >> 32; + h = h.wrapping_mul(0xD6E8_FEB8_6659_FD93); + h ^= h >> 32; + (h >> 11) as f64 / (1u64 << 53) as f64 +} + +fn quintic(t: f64) -> f64 { t * t * t * (t * (t * 6.0 - 15.0) + 10.0) } + +/// Bruit de valeur 0..1. +pub fn valeur(seed: u64, x: f64, z: f64) -> f64 { + let (ix, iz) = (x.floor(), z.floor()); + let (fx, fz) = (quintic(x - ix), quintic(z - iz)); + let (ix, iz) = (ix as i64, iz as i64); + let a = hash(seed, ix, iz); + let b = hash(seed, ix + 1, iz); + let c = hash(seed, ix, iz + 1); + let d = hash(seed, ix + 1, iz + 1); + let top = a + (b - a) * fx; + let bot = c + (d - c) * fx; + top + (bot - top) * fz +} + +/// fBm normalise 0..1 (gain 0.5, lacunarite 2). +pub fn fbm(seed: u64, x: f64, z: f64, oct: u32) -> f64 { + let (mut s, mut a, mut f, mut n) = (0.0, 1.0, 1.0, 0.0); + for o in 0..oct { + s += a * valeur(seed.wrapping_add(o as u64 * 7919), x * f + o as f64 * 31.7, z * f - o as f64 * 17.3); + n += a; + a *= 0.5; + f *= 2.0; + } + s / n +} + +/// Bruit "ridged" 0..1 : cretes le long des lignes ou le bruit vaut 0.5. Energie surtout basse frequence. +pub fn ridged(seed: u64, x: f64, z: f64, oct: u32) -> f64 { + let (mut s, mut a, mut f, mut n) = (0.0, 1.0, 1.0, 0.0); + for o in 0..oct { + let v = valeur(seed.wrapping_add(o as u64 * 104_729), x * f + o as f64 * 13.1, z * f + o as f64 * 5.9); + let r = 1.0 - (2.0 * v - 1.0).abs(); + s += a * r; + n += a; + a *= 0.35; + f *= 2.0; + } + s / n +} diff --git a/carte-monde/src/lib.rs b/carte-monde/src/lib.rs new file mode 100644 index 0000000..30fedcd --- /dev/null +++ b/carte-monde/src/lib.rs @@ -0,0 +1,165 @@ +//! Carte du monde : 4 champs de bruit tres basse frequence -> biome de relief -> poids lisses. +//! +//! Les types `BiomeRelief` sont definis localement (module `types`) en attendant `rt-core::proc` [A VERIFIER]. +//! Tout est deterministe (graine u64, hachage entier). `CarteMonde` est `Send + Sync`, sans verrou. + +mod bruit; +pub mod png; +pub mod types; + +pub use types::{adjacence, Adjacence, BiomeRelief, Climat, TOUS}; + +use bruit::{fbm, ridged}; + +/// Ecart-type du lissage des frontieres (m). +pub const SIGMA_M: f64 = 400.0; +/// Bande de piemont minimale entre glaciaire et le reste (m) : verifiee par test. +pub const PIEMONT_MIN_M: f64 = 3000.0; + +const T_PLAINE: f32 = 0.10; +const T_BOCAGE: f32 = 0.24; +const T_BOCAGE_HUMIDE: f32 = 0.30; +const T_KARST: f32 = 0.48; +const T_GLACIAIRE: f32 = 0.79; + +#[derive(Clone, Debug)] +pub struct CarteMonde { + seed: u64, + forcer: Option, +} + +impl CarteMonde { + pub fn new(seed: u64) -> Self { Self { seed, forcer: None } } + /// Force un biome unique partout (tests de relief isole). + pub fn forcer(mut self, b: BiomeRelief) -> Self { self.forcer = Some(b); self } + pub fn seed(&self) -> u64 { self.seed } + + /// Latitude fictive 35..70 deg : onde triangle lissee le long de z (periode 600 km). + pub fn lat_deg(z: f64) -> f32 { + let t = (z / 300_000.0).rem_euclid(2.0); + let tri = if t < 1.0 { t } else { 2.0 - t }; + let s = tri * tri * (3.0 - 2.0 * tri); + 35.0 + 35.0 * s as f32 + } + + /// Les 4 champs plus la latitude. `temperature` : au niveau de la mer (C). + pub fn climat(&self, x: f64, z: f64) -> Climat { + let s = self.seed; + let continentalite = ((fbm(s ^ 0x11, x / 40_000.0, z / 40_000.0, 1) * 2.0 - 1.0) as f32 * 1.1).clamp(-1.0, 1.0); + let soulevement = ridged(s ^ 0x22, x / 30_000.0, z / 30_000.0, 2) as f32; + let lat_deg = Self::lat_deg(z); + let t_bruit = (fbm(s ^ 0x33, x / 40_000.0, z / 40_000.0, 2) * 2.0 - 1.0) as f32 * 4.0; + let temperature = physique::temp_niveau_mer_lat(lat_deg) + t_bruit; + // foehn : sec sous le vent (vent d'ouest, x croissant) des chaines situees 15 km au vent + let souv_vent = ridged(s ^ 0x22, (x - 15_000.0) / 30_000.0, z / 30_000.0, 2) as f32; + let h0 = fbm(s ^ 0x44, x / 25_000.0, z / 25_000.0, 3) as f32; + let humidite = (h0 * 1.4 - 0.2 - 0.45 * (souv_vent - 0.4).max(0.0)).clamp(0.0, 1.0); + Climat { temperature, humidite, continentalite, soulevement, lat_deg } + } + + /// Temperature moyenne annuelle corrigee de l'altitude (C), via `physique`. + pub fn temperature_a(&self, x: f64, z: f64, alt_m: f32) -> f32 { + physique::temp_a_altitude(self.climat(x, z).temperature, 0.0, alt_m) + } + + /// Indice de relief 0..1 apres attenuation cotiere (le fjord garde son relief jusqu'a la mer). + fn niveau_et_fjord(&self, c: &Climat) -> (f32, bool) { + let froid = smooth(6.0, 2.0, c.temperature); + let f = smooth(0.50, 0.60, c.soulevement) * froid; + let fjord = f >= 0.9 && c.soulevement >= 0.62; + let ramp = ((c.continentalite - 0.25) / 0.75).clamp(0.0, 1.0); // lineaire : pente minimale + let g = ramp.max(smooth(0.6, 0.9, f)); // continu : pas de saut a l'entree du regime fjord + (c.soulevement * g, fjord) + } + + /// Biome discret (sans lissage) en un point. + pub fn biome(&self, x: f64, z: f64) -> BiomeRelief { + if let Some(b) = self.forcer { return b; } + self.biome_climat(x, z, &self.climat(x, z)) + } + + fn biome_climat(&self, x: f64, z: f64, c: &Climat) -> BiomeRelief { + use BiomeRelief::*; + if c.continentalite < 0.0 { return Mer; } + let (n, fjord) = self.niveau_et_fjord(c); + if c.continentalite < 0.25 { + return if fjord { Fjord } else { CoteRocheuse }; + } + let t_boc = T_BOCAGE + (T_BOCAGE_HUMIDE - T_BOCAGE) * smooth(0.40, 0.60, c.humidite); // continu en humidite + if n < T_PLAINE { + Plaine + } else if n < t_boc { + Bocage + } else if n < T_KARST { + let g = fbm(self.seed ^ 0x55, x / 6_000.0, z / 6_000.0, 2); + if n > 0.36 && g > 0.62 { Gorges } else { Karst } + } else if n < T_GLACIAIRE { + Prealpes + } else { + Glaciaire + } + } + + /// Poids de biomes lisses (gaussienne sigma = 400 m), accentues (exposant 3), 3 biomes max, somme = 1. + /// Les emplacements inutilises ont un poids 0. + pub fn poids_biomes(&self, x: f64, z: f64) -> [(BiomeRelief, f32); 3] { + if let Some(b) = self.forcer { return [(b, 1.0), (b, 0.0), (b, 0.0)]; } + const N: i32 = 5; // pochoir (2N+1)^2, pas 120 m (+-600 m = 1,5 sigma) + const PAS: f64 = 120.0; + let mut acc = [0.0f32; 9]; + let mut tot = 0.0f32; + for j in -N..=N { + for i in -N..=N { + let (dx, dz) = (i as f64 * PAS, j as f64 * PAS); + let w = (-(dx * dx + dz * dz) / (2.0 * SIGMA_M * SIGMA_M)).exp() as f32; + acc[self.biome(x + dx, z + dz) as usize] += w; + tot += w; + } + } + let mut v = [(BiomeRelief::Mer, 0.0f32); 9]; + for (k, &b) in TOUS.iter().enumerate() { v[k] = (b, (acc[b as usize] / tot).powi(3)); } + v.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap().then((a.0 as u8).cmp(&(b.0 as u8)))); + let s = v[0].1 + v[1].1 + v[2].1; + [(v[0].0, v[0].1 / s), (v[1].0, v[1].1 / s), (v[2].0, v[2].1 / s)] + } + + /// Couleur RGB d'un point : melange des couleurs de biome selon les poids. + pub fn couleur(&self, x: f64, z: f64) -> [u8; 3] { + let mut c = [0.0f32; 3]; + for (b, w) in self.poids_biomes(x, z) { + let k = b.couleur(); + for i in 0..3 { c[i] += k[i] as f32 * w; } + } + [c[0] as u8, c[1] as u8, c[2] as u8] + } + + /// Rendu PNG : `km` x `km` depuis (x0, z0) en metres, 1 px = `pas_m` metres, couleurs melangees par les poids. + pub fn rendu_carte(&self, x0: i64, z0: i64, km: u32, pas_m: u32) -> Vec { + let n = (km as u64 * 1000 / pas_m as u64) as usize; + let mut rgb = vec![0u8; n * n * 3]; + let band = (n + 3) / 4; + std::thread::scope(|sc| { + for (t, chunk) in rgb.chunks_mut(band * n * 3).enumerate() { + sc.spawn(move || { + for (r, row) in chunk.chunks_mut(n * 3).enumerate() { + let z = z0 as f64 + ((t * band + r) as f64 + 0.5) * pas_m as f64; + for px in 0..n { + let x = x0 as f64 + (px as f64 + 0.5) * pas_m as f64; + row[px * 3..px * 3 + 3].copy_from_slice(&self.couleur(x, z)); + } + } + }); + } + }); + png::encoder(n, n, &rgb) + } +} + +/// Smoothstep entre a et b (b < a autorise : decroissant). +fn smooth(a: f32, b: f32, x: f32) -> f32 { + let t = ((x - a) / (b - a)).clamp(0.0, 1.0); + t * t * (3.0 - 2.0 * t) +} + +#[cfg(test)] +mod tests; diff --git a/carte-monde/src/png.rs b/carte-monde/src/png.rs new file mode 100644 index 0000000..48c3709 --- /dev/null +++ b/carte-monde/src/png.rs @@ -0,0 +1,49 @@ +//! Ecriture PNG RGB minimale (deflate non compresse), sans dependance. +use std::io::Write; + +fn crc32(data: &[u8]) -> u32 { + let mut c = 0xFFFF_FFFFu32; + for &b in data { + c ^= b as u32; + for _ in 0..8 { c = if c & 1 != 0 { 0xEDB8_8320 ^ (c >> 1) } else { c >> 1 }; } + } + !c +} + +fn chunk(out: &mut Vec, kind: &[u8; 4], data: &[u8]) { + out.extend_from_slice(&(data.len() as u32).to_be_bytes()); + let mut b = kind.to_vec(); + b.extend_from_slice(data); + out.extend_from_slice(&b); + out.extend_from_slice(&crc32(&b).to_be_bytes()); +} + +/// `rgb` : w*h*3 octets. +pub fn encoder(w: usize, h: usize, rgb: &[u8]) -> Vec { + let mut raw = Vec::with_capacity((w * 3 + 1) * h); + for y in 0..h { raw.push(0); raw.extend_from_slice(&rgb[y * w * 3..(y + 1) * w * 3]); } + let mut z = vec![0x78, 0x01]; + let mut it = raw.chunks(65535).peekable(); + while let Some(c) = it.next() { + z.push(if it.peek().is_none() { 1 } else { 0 }); + z.extend_from_slice(&(c.len() as u16).to_le_bytes()); + z.extend_from_slice(&(!(c.len() as u16)).to_le_bytes()); + z.extend_from_slice(c); + } + let (mut a, mut b) = (1u32, 0u32); + for &x in &raw { a = (a + x as u32) % 65521; b = (b + a) % 65521; } + z.extend_from_slice(&((b << 16) | a).to_be_bytes()); + let mut out = vec![0x89, b'P', b'N', b'G', 0x0D, 0x0A, 0x1A, 0x0A]; + let mut ihdr = vec![]; + ihdr.extend_from_slice(&(w as u32).to_be_bytes()); + ihdr.extend_from_slice(&(h as u32).to_be_bytes()); + ihdr.extend_from_slice(&[8, 2, 0, 0, 0]); + chunk(&mut out, b"IHDR", &ihdr); + chunk(&mut out, b"IDAT", &z); + chunk(&mut out, b"IEND", &[]); + out +} + +pub fn ecrire(path: &str, w: usize, h: usize, rgb: &[u8]) -> std::io::Result<()> { + std::fs::File::create(path)?.write_all(&encoder(w, h, rgb)) +} diff --git a/carte-monde/src/tests.rs b/carte-monde/src/tests.rs new file mode 100644 index 0000000..e232b0c --- /dev/null +++ b/carte-monde/src/tests.rs @@ -0,0 +1,146 @@ +use super::*; + +const LARGEUR: i32 = 160; // cellules de 250 m -> 40 km +const PAS: f64 = 250.0; + +fn grille(c: &CarteMonde, x0: f64, z0: f64) -> Vec { + let mut v = Vec::new(); + for j in 0..LARGEUR { for i in 0..LARGEUR { v.push(c.biome(x0 + i as f64 * PAS, z0 + j as f64 * PAS)); } } + v +} + +#[test] +fn send_sync() { + fn f() {} + f::(); +} + +#[test] +fn determinisme() { + let a = CarteMonde::new(42); + let b = CarteMonde::new(42); + for k in 0..200 { + let (x, z) = (k as f64 * 913.7 - 50_000.0, k as f64 * 1217.3 - 90_000.0); + assert_eq!(a.poids_biomes(x, z), b.poids_biomes(x, z)); + assert_eq!(a.climat(x, z).soulevement, b.climat(x, z).soulevement); + } + assert_ne!(grille(&a, 0.0, 0.0), grille(&CarteMonde::new(43), 0.0, 0.0)); +} + +#[test] +fn somme_poids_un() { + let c = CarteMonde::new(7); + for k in 0..600 { + let (x, z) = (k as f64 * 733.1 - 200_000.0, (k * 7 % 311) as f64 * 1511.9 - 100_000.0); + let p = c.poids_biomes(x, z); + let s: f32 = p.iter().map(|q| q.1).sum(); + assert!((s - 1.0).abs() < 1e-4, "somme {s}"); + assert!(p.iter().all(|q| q.1 >= 0.0)); + assert!(p[0].1 >= p[1].1 && p[1].1 >= p[2].1); + } +} + +#[test] +fn tous_les_biomes_apparaissent() { + // sur plusieurs graines et regions : chacun des 9 biomes existe quelque part + let mut vu = [false; 9]; + for seed in 1..=3u64 { + let c = CarteMonde::new(seed); + for j in 0..400 { for i in 0..400 { vu[c.biome(i as f64 * 1000.0 - 200_000.0, j as f64 * 1000.0 - 200_000.0) as usize] = true; } } + } + for b in TOUS { assert!(vu[b as usize], "biome absent : {b:?}"); } +} + +/// Aucun couple O/P/N interdit (P ou N) a moins de 1 km. +#[test] +fn voisinages_respectes() { + for seed in [1u64, 2, 3] { + let c = CarteMonde::new(seed); + for (x0, z0) in [(0.0, 0.0), (-80_000.0, 30_000.0), (120_000.0, -60_000.0)] { + let g = grille(&c, x0, z0); + let r = 4i32; // 4 cellules = 1 km + for j in 0..LARGEUR { + for i in 0..LARGEUR { + let a = g[(j * LARGEUR + i) as usize]; + for (di, dj) in [(r, 0), (0, r), (r, r), (r, -r)] { + let (ii, jj) = (i + di, j + dj); + if ii < 0 || jj < 0 || ii >= LARGEUR || jj >= LARGEUR { continue; } + let b = g[(jj * LARGEUR + ii) as usize]; + assert_eq!(adjacence(a, b), Adjacence::O, "seed {seed} : {a:?} a moins de 1 km de {b:?} pres de ({}, {})", x0 + i as f64 * PAS, z0 + j as f64 * PAS); + } + } + } + } + } +} + +/// Bande de piemont : dans 3 km autour d'un glaciaire : uniquement glaciaire, prealpes ou fjord. +#[test] +fn piemont_obligatoire() { + for seed in [1u64, 2, 3] { + let c = CarteMonde::new(seed); + let g = grille(&c, -20_000.0, -20_000.0); + let r = (PIEMONT_MIN_M / PAS) as i32; // 12 cellules + for j in 0..LARGEUR { + for i in 0..LARGEUR { + if g[(j * LARGEUR + i) as usize] != BiomeRelief::Glaciaire { continue; } + for dj in -r..=r { + for di in -r..=r { + if di * di + dj * dj > r * r { continue; } + let (ii, jj) = (i + di, j + dj); + if ii < 0 || jj < 0 || ii >= LARGEUR || jj >= LARGEUR { continue; } + let b = g[(jj * LARGEUR + ii) as usize]; + assert!(matches!(b, BiomeRelief::Glaciaire | BiomeRelief::Prealpes | BiomeRelief::Fjord), + "seed {seed} : {b:?} a {} m d'un glaciaire", ((di * di + dj * dj) as f64).sqrt() * PAS); + } + } + } + } + } +} + +/// Continuite : un pas de 64 m ne fait pas sauter les poids (forme pointue incluse). +#[test] +fn continuite() { + let c = CarteMonde::new(5); + let mut pire = 0.0f32; + for k in 0..400 { + let (x, z) = (k as f64 * 977.0 - 150_000.0, (k * 13 % 97) as f64 * 1303.0 - 60_000.0); + let a = c.poids_biomes(x, z); + let b = c.poids_biomes(x + 64.0, z); + for bi in TOUS { + let w = |p: &[(BiomeRelief, f32); 3]| p.iter().filter(|q| q.0 == bi).map(|q| q.1).sum::(); + pire = pire.max((w(&a) - w(&b)).abs()); + } + } + assert!(pire < 0.45, "saut de poids {pire} en 64 m"); +} + +/// Des zones de transition existent bien (poids partages) mais restent minoritaires. +#[test] +fn transitions_visibles() { + let c = CarteMonde::new(9); + let (mut mix, mut tot) = (0, 0); + for j in 0..200 { for i in 0..200 { + let p = c.poids_biomes(i as f64 * 200.0, j as f64 * 200.0); + tot += 1; + if p[0].1 < 0.9 { mix += 1; } + } } + let f = mix as f32 / tot as f32; + assert!(f > 0.01 && f < 0.5, "part en transition {f}"); +} + +#[test] +fn forcer_et_latitude() { + let c = CarteMonde::new(1).forcer(BiomeRelief::Karst); + assert_eq!(c.poids_biomes(10.0, 10.0)[0], (BiomeRelief::Karst, 1.0)); + assert_eq!(c.biome(1e6, 1e6), BiomeRelief::Karst); + for k in 0..100 { + let l = CarteMonde::lat_deg(k as f64 * 37_000.0 - 1e6); + assert!((35.0..=70.0).contains(&l)); + } + let cl = CarteMonde::new(1).climat(0.0, 0.0); + assert!((cl.lat_deg - CarteMonde::lat_deg(0.0)).abs() < 1e-6); + let m = CarteMonde::new(1); + assert!(m.temperature_a(0.0, 0.0, 2000.0) < m.temperature_a(0.0, 0.0, 0.0)); +} diff --git a/carte-monde/src/types.rs b/carte-monde/src/types.rs new file mode 100644 index 0000000..6e9934d --- /dev/null +++ b/carte-monde/src/types.rs @@ -0,0 +1,64 @@ +//! Types locaux, a remplacer par `rt-core::proc` quand il existera [A VERIFIER]. + +#[repr(u8)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum BiomeRelief { Mer, Prealpes, Glaciaire, Karst, Gorges, Bocage, CoteRocheuse, Fjord, Plaine } + +pub const TOUS: [BiomeRelief; 9] = [ + BiomeRelief::Mer, BiomeRelief::Prealpes, BiomeRelief::Glaciaire, BiomeRelief::Karst, BiomeRelief::Gorges, + BiomeRelief::Bocage, BiomeRelief::CoteRocheuse, BiomeRelief::Fjord, BiomeRelief::Plaine, +]; + +impl BiomeRelief { + pub fn couleur(self) -> [u8; 3] { + use BiomeRelief::*; + match self { + Mer => [30, 70, 150], Prealpes => [110, 150, 90], Glaciaire => [235, 240, 250], Karst => [190, 175, 140], + Gorges => [140, 100, 70], Bocage => [90, 170, 70], CoteRocheuse => [150, 150, 160], Fjord => [60, 130, 170], + Plaine => [200, 210, 90], + } + } + /// Rang sur l'echelle de relief des terres ; None pour mer, cote et fjord. + pub fn rang(self) -> Option { + use BiomeRelief::*; + match self { Plaine => Some(0), Bocage => Some(1), Karst | Gorges => Some(2), Prealpes => Some(3), Glaciaire => Some(4), _ => None } + } +} + +/// Voisinage entre deux biomes : O permis, P seulement via un biome intermediaire (piemont), N interdit a moins de 1 km. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Adjacence { O, P, N } + +pub fn adjacence(a: BiomeRelief, b: BiomeRelief) -> Adjacence { + use BiomeRelief::*; + if a == b { return Adjacence::O; } + let est = |x: BiomeRelief, y: BiomeRelief| (a == x && b == y) || (a == y && b == x); + let a_ou_b = |x: BiomeRelief| a == x || b == x; + let autre = |x: BiomeRelief| if a == x { b } else { a }; + if a_ou_b(Mer) { + return if est(Mer, CoteRocheuse) || est(Mer, Fjord) { Adjacence::O } else { Adjacence::N }; + } + if a_ou_b(Fjord) { + return if matches!(autre(Fjord), Prealpes | Glaciaire | CoteRocheuse) { Adjacence::O } else { Adjacence::N }; + } + if a_ou_b(CoteRocheuse) { + return if autre(CoteRocheuse) == Glaciaire { Adjacence::N } else { Adjacence::O }; + } + let (ra, rb) = (a.rang().unwrap(), b.rang().unwrap()); + match ra.abs_diff(rb) { 0 | 1 => Adjacence::O, 2 => Adjacence::P, _ => Adjacence::N } +} + +/// Champs climatiques en un point (rapport 20, section 6). +#[derive(Clone, Copy, Debug)] +pub struct Climat { + /// Temperature moyenne annuelle au niveau de la mer (C). + pub temperature: f32, + /// 0..1 + pub humidite: f32, + /// -1..1 (< 0 : mer) + pub continentalite: f32, + /// 0..1 (1 : coeur de chaine) + pub soulevement: f32, + /// Latitude fictive 35..70 deg + pub lat_deg: f32, +} diff --git a/physique/src/lib.rs b/physique/src/lib.rs index 2350013..60c9709 100644 --- a/physique/src/lib.rs +++ b/physique/src/lib.rs @@ -150,3 +150,19 @@ mod tests { } #[test] fn divers() { assert!(debit_relatif(5) > debit_relatif(8)); assert!(lac_gele(-6.0)); assert!(jours_enneigement(2000.0) > jours_enneigement(800.0)); } } + +/// Temperature moyenne annuelle au niveau de la mer pour une latitude fictive (35..70 deg). +/// Lineaire : 15 C a 35 deg, -3 C a 70 deg. [A VERIFIER] calage climatique. +pub fn temp_niveau_mer_lat(lat_deg: f32) -> f32 { + 15.0 - (lat_deg.clamp(35.0, 70.0) - 35.0) * (18.0 / 35.0) +} + +#[cfg(test)] +mod tests_lat { + use super::*; + #[test] + fn temp_lat_decroit() { + assert!(temp_niveau_mer_lat(35.0) > temp_niveau_mer_lat(50.0)); + assert!((temp_niveau_mer_lat(70.0) + 3.0).abs() < 1e-4); + } +}