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)); }
|
||||
}
|
||||
|
||||
/// 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