Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
166 lignes
6.9 KiB
Rust
166 lignes
6.9 KiB
Rust
//! 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<BiomeRelief>,
|
|
}
|
|
|
|
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<u8> {
|
|
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;
|