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 à :
Theo GastineletClaude Sonnet 5.5 a révisé 2026-10-30 09:11:09 +01:00
1 Parent 56426dcb6f
révision 21a50dc5b2
9 fichiers modifiés
+535

Aucun fichier ne correspond à votre recherche

+14
Voir le fichier
@@ -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"
+10
Voir le fichier
@@ -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]
+18
Voir le fichier
@@ -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());
}
+53
Voir le fichier
@@ -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
}
+165
Voir le fichier
@@ -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;
+49
Voir le fichier
@@ -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))
}
+146
Voir le fichier
@@ -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));
}
+64
Voir le fichier
@@ -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,
}
+16
Voir le fichier
@@ -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);
}
}