carte-monde: 4 champs, biome par point, poids lisses 400 m, matrice d'adjacence, piemont, rendu PNG; physique: temp_niveau_mer_lat
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
56426dcb6f
révision
21a50dc5b2
9 fichiers modifiés
+535
Aucun fichier ne correspond à votre recherche
Générée
+14
@@ -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"
|
||||||
@@ -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]
|
||||||
@@ -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<String> = 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::<i64>().unwrap() * 1000;
|
||||||
|
let z0: i64 = g(5, "0").parse::<i64>().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());
|
||||||
|
}
|
||||||
@@ -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
|
||||||
|
}
|
||||||
@@ -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<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;
|
||||||
@@ -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<u8>, 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<u8> {
|
||||||
|
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))
|
||||||
|
}
|
||||||
@@ -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<BiomeRelief> {
|
||||||
|
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<T: Send + Sync>() {}
|
||||||
|
f::<CarteMonde>();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[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::<f32>();
|
||||||
|
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));
|
||||||
|
}
|
||||||
@@ -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<u8> {
|
||||||
|
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,
|
||||||
|
}
|
||||||
@@ -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)); }
|
#[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);
|
||||||
|
}
|
||||||
|
}
|
||||||
Référencer dans un nouveau ticket
Bloquer un utilisateur