rt-live: manteau neigeux degre-jour par cellule de 32 m, delta de chunk idempotent, modes climat/meteo/fige

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Théo GastineletClaude Sonnet 5.5 a révisé 2026-10-30 00:33:23 +01:00
1 Parent d4e96c6e47
révision 9690961cd0
10 fichiers modifiés
+1600

Aucun fichier ne correspond à votre recherche

+1
Voir le fichier
@@ -0,0 +1 @@
target/
+137
Voir le fichier
@@ -0,0 +1,137 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "adler2"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
[[package]]
name = "cfg-if"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
[[package]]
name = "crc32fast"
version = "1.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ba106e844045ddc02c20768ac4b0b7cb45f2cc2ecbd833ac9f5dacb183c2055"
dependencies = [
"cfg-if",
]
[[package]]
name = "fdeflate"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
dependencies = [
"simd-adler32",
]
[[package]]
name = "flate2"
version = "1.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
dependencies = [
"crc32fast",
"miniz_oxide 0.9.1",
"zlib-rs",
]
[[package]]
name = "libc"
version = "0.2.191"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
[[package]]
name = "memmap2"
version = "0.9.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b0ca1155a9ecc25aa12e8313a119f32edf0255fea2f44839c4ac0a12b2ac157"
dependencies = [
"libc",
]
[[package]]
name = "miniz_oxide"
version = "0.8.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
dependencies = [
"adler2",
"simd-adler32",
]
[[package]]
name = "miniz_oxide"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
dependencies = [
"adler2",
"simd-adler32",
]
[[package]]
name = "physique"
version = "0.1.0"
[[package]]
name = "png"
version = "0.17.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
dependencies = [
"bitflags",
"crc32fast",
"fdeflate",
"flate2",
"miniz_oxide 0.8.9",
]
[[package]]
name = "rt-core"
version = "0.1.0"
[[package]]
name = "rt-live"
version = "0.1.0"
dependencies = [
"physique",
"png",
"rt-core",
"rt-tiles",
]
[[package]]
name = "rt-tiles"
version = "0.1.0"
dependencies = [
"crc32fast",
"memmap2",
"rt-core",
]
[[package]]
name = "simd-adler32"
version = "0.3.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
[[package]]
name = "zlib-rs"
version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112"
+14
Voir le fichier
@@ -0,0 +1,14 @@
[package]
name = "rt-live"
version = "0.1.0"
edition = "2021"
license = "GPL-3.0-only"
description = "Couche dynamique (neige degre-jour, glace, feuilles, niveau d eau), independante de Pumpkin"
[dependencies]
physique = { path = "../physique" }
[dev-dependencies]
png = "0.17"
rt-core = { path = "../relief/rt-core" }
rt-tiles = { path = "../relief/rt-tiles" }
+273
Voir le fichier
@@ -0,0 +1,273 @@
//! Simulation d'une saison sur la tuile Veymont.
//! Usage : cargo run --release --example veymont -- saison <dossier tuiles> <dossier sortie>
//! cargo run --release --example veymont -- calibrage <dossier tuiles>
use rt_core::TileId;
use rt_live::*;
use rt_tiles::TileStore;
use std::path::PathBuf;
const X0: i32 = -4000;
const Z0: i32 = 28900;
const N: i32 = 1000;
struct Terrain {
alt: Vec<f32>,
pente: Vec<f32>,
aspect: Vec<f32>,
ok: Vec<bool>,
}
fn charger(dir: &str) -> Terrain {
let store = TileStore::new(PathBuf::from(dir));
let n = (N * N) as usize;
let mut t = Terrain { alt: vec![0.0; n], pente: vec![0.0; n], aspect: vec![0.0; n], ok: vec![false; n] };
for z in 0..N {
for x in 0..N {
let (bx, bz) = (X0 + x, Z0 + z);
let id = TileId::of_block(bx, bz);
let Ok(tile) = store.get(id) else { continue };
let s = tile.sample(bx - id.tx * TileId::SIZE, bz - id.tz * TileId::SIZE);
if s.ground_dm == 0 {
continue;
}
let i = (z * N + x) as usize;
t.alt[i] = s.ground_dm as f32 / 10.0 + tile.origin().alt_zero_dm() as f32;
t.pente[i] = s.slope_deg as f32;
t.aspect[i] = s.aspect as f32 * 360.0 / 256.0;
t.ok[i] = true;
}
}
t
}
fn params() -> Params {
// Surcharges pour le calibrage : RT_P="ddf=4,krad=0.6,..."
let mut p = Params::default();
if let Ok(s) = std::env::var("RT_P") {
for kv in s.split(',') {
if let Some((k, v)) = kv.split_once('=') {
let v: f32 = v.parse().unwrap();
match k {
"ddf" => p.ddf_mm = v,
"krad" => p.k_rad = v,
"tn" => p.t_neige_c = v,
"tp" => p.t_pluie_c = v,
"gp" => p.gain_precip_100m = v,
"sola" => p.fonte_sol_automne_mm = v,
"solh" => p.fonte_sol_hiver_mm = v,
_ => panic!("param {k}"),
}
}
}
}
p
}
fn manteau(t: &Terrain) -> Manteau {
let nc = (N / 32) as usize;
Manteau::nouveau(params(), 32, X0, Z0, nc, nc, |ix, iz| {
let (mut a, mut p, mut sx, mut sz, mut k) = (0.0, 0.0, 0.0, 0.0, 0.0);
for z in 0..32 {
for x in 0..32 {
let i = ((iz as i32 * 32 + z) * N + ix as i32 * 32 + x) as usize;
if t.ok[i] {
let w = t.pente[i].max(1.0);
a += t.alt[i];
p += t.pente[i];
sx += w * t.aspect[i].to_radians().sin();
sz += w * t.aspect[i].to_radians().cos();
k += 1.0;
}
}
}
let k = f32::max(k, 1.0);
Cellule { alt_m: a / k, pente_deg: p / k, aspect_deg: sx.atan2(sz).to_degrees().rem_euclid(360.0) }
})
}
fn graine() -> u64 {
std::env::var("RT_SEED").ok().and_then(|s| s.parse().ok()).unwrap_or(11)
}
fn pct(v: &mut Vec<f32>, q: f32) -> f32 {
v.sort_by(|a, b| a.partial_cmp(b).unwrap());
v[((v.len() - 1) as f32 * q).round() as usize]
}
fn calibrage(dir: &str) {
let t = charger(dir);
let dates = [
Date::new(2026, 9, 15), Date::new(2026, 10, 1), Date::new(2026, 10, 15), Date::new(2026, 10, 31),
Date::new(2026, 11, 15), Date::new(2026, 12, 1), Date::new(2027, 1, 15), Date::new(2027, 3, 1),
Date::new(2027, 4, 15), Date::new(2027, 5, 15), Date::new(2027, 6, 1), Date::new(2027, 6, 15), Date::new(2027, 7, 1),
];
println!("Fraction du Veymont enneigee (>= 8 mm d'equivalent en eau), 60 annees synthetiques (graines 1..=60)");
println!("date moyenne p10 p90 | 1650-1900 | 1900-2100 | 2100-2400 (moyenne)");
let mut res: Vec<Vec<[f32; 4]>> = vec![vec![]; dates.len()];
for seed in 1..=60u64 {
let mut c = CoucheLive::new(Mode::Climat, manteau(&t), Climat::nouveau(seed, 1.0), None);
for (k, d) in dates.iter().enumerate() {
c.avancer_a(*d);
let m = &c.manteau;
res[k].push([m.fraction_enneigee(0.0, 9000.0), m.fraction_enneigee(0.0, 1900.0), m.fraction_enneigee(1900.0, 2100.0), m.fraction_enneigee(2100.0, 9000.0)]);
}
}
// Jours d'enneigement par bande (annee hydrologique complete)
let mut jours = [0f32; 4];
for seed in 1..=60u64 {
let mut c = CoucheLive::new(Mode::Climat, manteau(&t), Climat::nouveau(seed, 1.0), None);
for k in 0..365 {
c.avancer_a(Date::new(2026, 8, 1).plus(k));
for (j, (a, b)) in [(0.0, 1900.0), (1900.0, 2100.0), (2100.0, 9000.0), (0.0, 9000.0)].iter().enumerate() {
jours[j] += c.manteau.fraction_enneigee(*a, *b);
}
}
}
println!("jours d'enneigement moyens : 1650-1900 m {:.0} j ; 1900-2100 m {:.0} j ; > 2100 m {:.0} j ; tout {:.0} j (physique::jours_enneigement(2000 m) = {:.0})", jours[0] / 60.0, jours[1] / 60.0, jours[2] / 60.0, jours[3] / 60.0, physique::jours_enneigement(2000.0));
for (k, d) in dates.iter().enumerate() {
let mean = |j: usize| res[k].iter().map(|r| r[j]).sum::<f32>() / res[k].len() as f32;
let mut v: Vec<f32> = res[k].iter().map(|r| r[0]).collect();
println!("{d} {:5.1} % {:5.1} {:5.1} | {:5.1} % | {:5.1} % | {:5.1} %", 100.0 * mean(0), 100.0 * pct(&mut v.clone(), 0.1), 100.0 * pct(&mut v, 0.9), 100.0 * mean(1), 100.0 * mean(2), 100.0 * mean(3));
}
}
fn hillshade(t: &Terrain, x: i32, z: i32) -> f32 {
let g = |dx: i32, dz: i32| t.alt[((z + dz).clamp(0, N - 1) * N + (x + dx).clamp(0, N - 1)) as usize];
let (dzdx, dzdz) = ((g(4, 0) - g(-4, 0)) / 8.0, (g(0, 4) - g(0, -4)) / 8.0);
// soleil au nord-ouest, 40 deg
let (sl, asp) = (dzdx.hypot(dzdz).atan(), (-dzdx).atan2(dzdz));
let az = 315f32.to_radians();
let h = 40f32.to_radians();
(h.sin() * sl.cos() + h.cos() * sl.sin() * (az - asp - std::f32::consts::FRAC_PI_2).cos()).clamp(0.0, 1.0)
}
fn png(path: &PathBuf, w: u32, h: u32, rgb: &[u8]) {
let f = std::fs::File::create(path).unwrap();
let mut e = png::Encoder::new(std::io::BufWriter::new(f), w, h);
e.set_color(png::ColorType::Rgb);
e.set_depth(png::BitDepth::Eight);
e.write_header().unwrap().write_image_data(rgb).unwrap();
}
fn rendre(t: &Terrain, c: &CoucheLive, path: &PathBuf) -> f32 {
let mut img = vec![0u8; (N * N * 3) as usize];
let (mut couv, mut tot) = (0usize, 0usize);
for z in 0..N {
for x in 0..N {
let i = (z * N + x) as usize;
let px = &mut img[i * 3..i * 3 + 3];
if !t.ok[i] {
px.copy_from_slice(&[30, 30, 30]);
continue;
}
let sh = 0.45 + 0.75 * hillshade(t, x, z);
let base: [f32; 3] = if t.pente[i] > 42.0 { [128.0, 126.0, 120.0] } else if t.alt[i] < 1900.0 { [66.0, 110.0, 50.0] } else { [118.0, 150.0, 76.0] };
let n = c.manteau.couches(X0 + x, Z0 + z, t.pente[i]);
tot += 1;
let k = (n as f32 / 2.0).min(1.0);
if n > 0 {
couv += 1;
}
for j in 0..3 {
let v = base[j] * (1.0 - k) + 246.0 * k;
px[j] = (v * sh).clamp(0.0, 255.0) as u8;
}
}
}
png(path, N as u32, N as u32, &img);
couv as f32 / tot as f32
}
fn courbe(path: &PathBuf, series: &[(&str, [u8; 3], &Vec<f32>)]) {
let (w, h) = (730usize, 260usize);
let mut img = vec![245u8; w * h * 3];
let mut px = |x: usize, y: usize, c: [u8; 3]| {
if x < w && y < h {
img[(y * w + x) * 3..(y * w + x) * 3 + 3].copy_from_slice(&c);
}
};
for k in 0..=4 {
let y = 10 + (h - 30) * k / 4;
for x in 0..w {
px(x, y, [215, 215, 215]);
}
}
for m in 0..12 {
for y in 10..h - 20 {
px(5 + m * 61, y, [225, 225, 225]);
}
}
for (_, col, v) in series {
for (d, f) in v.iter().enumerate() {
let x = 5 + d * 2;
let y = 10 + ((1.0 - f) * (h - 30) as f32) as usize;
for dy in 0..2 {
px(x, y + dy, *col);
}
}
}
png(path, w as u32, h as u32, &img);
}
fn saison(dir: &str, out: &str) {
let t = charger(dir);
let out = PathBuf::from(out);
std::fs::create_dir_all(&out).unwrap();
// Serie synthetique pour le mode Meteo : annee type seed 11 + coup de froid precoce le 11-14 octobre
let clim = Climat::nouveau(graine(), 1.0);
let mut serie = Serie::default();
let debut = Date::new(2026, 8, 1);
for k in 0..365 {
let d = debut.plus(k);
let mut o = clim.obs(d);
if d >= Date::new(2026, 10, 11) && d <= Date::new(2026, 10, 14) {
o.temp_c = -3.0;
o.precip_mm = 30.0;
}
serie.jours.insert(d, o);
}
std::fs::write(out.join("meteo_synthetique.csv"), serie.vers_csv()).unwrap();
let serie = Serie::depuis_csv(&std::fs::read_to_string(out.join("meteo_synthetique.csv")).unwrap()).unwrap();
let mut stats = String::from("date,climat_pct,meteo_pct,climat_1650_1900,climat_1900_2100,climat_2100_2400\n");
let mut cl = CoucheLive::new(Mode::Climat, manteau(&t), Climat::nouveau(graine(), 1.0), None);
let mut me = CoucheLive::new(Mode::Meteo, manteau(&t), Climat::nouveau(graine(), 1.0), Some(serie));
let (mut vc, mut vm) = (vec![], vec![]);
let rendus = [(2026, 9, 1), (2026, 10, 1), (2026, 10, 15), (2026, 10, 31), (2026, 11, 1), (2026, 12, 1), (2027, 1, 1), (2027, 2, 1), (2027, 3, 1), (2027, 4, 1), (2027, 5, 1), (2027, 6, 1), (2027, 7, 1)];
for k in 0..365 {
let d = debut.plus(k);
cl.avancer_a(d);
me.avancer_a(d);
let (fc, fm) = (cl.manteau.fraction_enneigee(0.0, 9000.0), me.manteau.fraction_enneigee(0.0, 9000.0));
vc.push(fc);
vm.push(fm);
stats += &format!("{d},{:.1},{:.1},{:.1},{:.1},{:.1}\n", 100.0 * fc, 100.0 * fm, 100.0 * cl.manteau.fraction_enneigee(0.0, 1900.0), 100.0 * cl.manteau.fraction_enneigee(1900.0, 2100.0), 100.0 * cl.manteau.fraction_enneigee(2100.0, 9000.0));
if rendus.contains(&(d.annee, d.mois, d.jour)) {
let cv = rendre(&t, &cl, &out.join(format!("climat_{d}.png")));
println!("{d} climat : {:.1} % des colonnes avec au moins 1 couche", 100.0 * cv);
if d.mois == 10 {
let cv = rendre(&t, &me, &out.join(format!("meteo_{d}.png")));
println!("{d} meteo : {:.1} %", 100.0 * cv);
}
}
}
std::fs::write(out.join("stats_saison.csv"), stats).unwrap();
courbe(&out.join("courbe_saison.png"), &[("climat", [30, 90, 200], &vc), ("meteo", [210, 80, 40], &vm)]);
}
fn main() {
let a: Vec<String> = std::env::args().collect();
match a.get(1).map(String::as_str) {
Some("saison") => saison(&a[2], &a[3]),
Some("graines") => {
let t = charger(&a[2]);
for seed in 1..=30u64 {
let mut c = CoucheLive::new(Mode::Climat, manteau(&t), Climat::nouveau(seed, 1.0), None);
let f = |c: &mut CoucheLive, d: Date| { c.avancer_a(d); c.manteau.fraction_enneigee(0.0, 9000.0) };
println!("seed {seed}: 15 oct {:.2} 31 oct {:.2} 15 nov {:.2} 1 jan {:.2} 1 avr {:.2} 15 juin {:.2}", f(&mut c, Date::new(2026,10,15)), f(&mut c, Date::new(2026,10,31)), f(&mut c, Date::new(2026,11,15)), f(&mut c, Date::new(2027,1,1)), f(&mut c, Date::new(2027,4,1)), f(&mut c, Date::new(2027,6,15)));
}
}
Some("calibrage") => calibrage(&a[2]),
_ => eprintln!("usage : saison <tuiles> <sortie> | calibrage <tuiles>"),
}
}
+78
Voir le fichier
@@ -0,0 +1,78 @@
//! Date civile sans dependance (algorithmes de Howard Hinnant).
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Date {
pub annee: i32,
pub mois: u32,
pub jour: u32,
}
const CUM: [u32; 12] = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
impl Date {
pub fn new(annee: i32, mois: u32, jour: u32) -> Date {
Date { annee, mois: mois.clamp(1, 12), jour: jour.clamp(1, 31) }
}
/// Jours depuis le 1970-01-01.
pub fn ordinal(self) -> i64 {
let y = (if self.mois <= 2 { self.annee - 1 } else { self.annee }) as i64;
let era = y.div_euclid(400);
let yoe = y - era * 400;
let mp = (self.mois as i64 + 9) % 12;
let doy = (153 * mp + 2) / 5 + self.jour as i64 - 1;
let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
era * 146_097 + doe - 719_468
}
pub fn depuis_ordinal(n: i64) -> Date {
let z = n + 719_468;
let era = z.div_euclid(146_097);
let doe = z - era * 146_097;
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
let mp = (5 * doy + 2) / 153;
let jour = (doy - (153 * mp + 2) / 5 + 1) as u32;
let mois = (if mp < 10 { mp + 3 } else { mp - 9 }) as u32;
let annee = (yoe + era * 400) as i32 + if mois <= 2 { 1 } else { 0 };
Date { annee, mois, jour }
}
pub fn plus(self, n: i64) -> Date {
Date::depuis_ordinal(self.ordinal() + n)
}
pub fn bissextile(a: i32) -> bool {
(a % 4 == 0 && a % 100 != 0) || a % 400 == 0
}
/// 1..=366.
pub fn jour_annee(self) -> u32 {
CUM[(self.mois - 1) as usize] + self.jour + u32::from(self.mois > 2 && Date::bissextile(self.annee))
}
/// 1..=365, le 29 fevrier compte comme le 28.
pub fn jour_annee_365(self) -> u32 {
if self.mois == 2 && self.jour >= 29 { 59 } else { CUM[(self.mois - 1) as usize] + self.jour }
}
/// 1er aout precedent ou egal : debut de l'annee hydrologique (neige nulle).
pub fn debut_annee_hydro(self) -> Date {
Date::new(if self.mois >= 8 { self.annee } else { self.annee - 1 }, 8, 1)
}
/// Index 0..365 depuis le 1er aout (annee a 365 jours).
pub fn index_hydro(self) -> usize {
((self.jour_annee_365() + 365 - 213) % 365) as usize
}
pub fn parse(s: &str) -> Result<Date, String> {
let p: Vec<&str> = s.trim().split('-').collect();
if p.len() != 3 {
return Err(format!("date invalide '{s}'"));
}
let n = |x: &str| x.trim().parse::<i32>().map_err(|_| format!("date invalide '{s}'"));
let (a, m, j) = (n(p[0])?, n(p[1])?, n(p[2])?);
if !(1..=12).contains(&m) || !(1..=31).contains(&j) {
return Err(format!("date hors plage '{s}'"));
}
Ok(Date { annee: a, mois: m as u32, jour: j as u32 })
}
}
impl std::fmt::Display for Date {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:04}-{:02}-{:02}", self.annee, self.mois, self.jour)
}
}
+216
Voir le fichier
@@ -0,0 +1,216 @@
//! Calcul idempotent des modifications de blocs d'un chunk.
//!
//! Principe : pour chaque position concernee, l'etat CIBLE est une fonction pure de
//! (date, manteau, entree du chunk). La modification n'est emise que si le bloc ACTUEL (fourni
//! par l'appelant) differe de la cible et appartient a la classe modifiable. Appliquer le delta
//! puis recalculer donne donc un delta vide. Les blocs poses par un joueur ne sont jamais touches.
use crate::manteau::{hash01, Manteau};
use std::collections::HashSet;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Feuille {
Verte,
Jaune,
Rousse,
}
/// Bloc abstrait (converti en bloc Pumpkin par la couche d'integration).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Bloc {
Air,
/// Couches de neige 1..=8.
Neige(u8),
Glace,
Eau,
Feuille(Feuille),
/// Tout autre bloc : jamais modifie.
Autre,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Surface {
Sol,
Roche,
Route,
Bati,
/// `lac` : eau calme (gele) ; sinon riviere (niveau saisonnier, ne gele pas).
Eau { lac: bool },
}
#[derive(Clone, Copy, Debug)]
pub struct Colonne {
/// y du bloc solide le plus haut (fond pour l'eau).
pub sol_y: i32,
pub surface: Surface,
pub pente_deg: f32,
/// Altitude reelle en m (temperature).
pub alt_m: f32,
/// y nominal du bloc d'eau de surface (surfaces d'eau seulement).
pub eau_y: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Essence {
Hetre,
Chene,
Bouleau,
Meleze,
}
/// Bloc de feuillage d'un arbre caduc, tel que genere statiquement.
#[derive(Clone, Copy, Debug)]
pub struct FeuilleEntree {
pub x: i32,
pub y: i32,
pub z: i32,
pub essence: Essence,
pub alt_m: f32,
}
pub struct ChunkEntree {
pub cx: i32,
pub cz: i32,
/// 256 colonnes, index lz * 16 + lx.
pub colonnes: Vec<Colonne>,
pub feuilles: Vec<FeuilleEntree>,
}
/// Blocs poses ou casses par un joueur : colonnes entieres (bitset 16x16) et blocs isoles.
#[derive(Clone, Debug, Default)]
pub struct MasqueJoueur {
cols: [u64; 4],
blocs: HashSet<(i32, i32, i32)>,
}
impl MasqueJoueur {
pub fn marquer_colonne(&mut self, lx: usize, lz: usize) {
let i = lz * 16 + lx;
self.cols[i / 64] |= 1 << (i % 64);
}
pub fn marquer_bloc(&mut self, x: i32, y: i32, z: i32) {
self.blocs.insert((x, y, z));
}
pub fn touche(&self, x: i32, y: i32, z: i32) -> bool {
let i = (z.rem_euclid(16) * 16 + x.rem_euclid(16)) as usize;
self.cols[i / 64] >> (i % 64) & 1 == 1 || self.blocs.contains(&(x, y, z))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Modif {
pub x: i32,
pub y: i32,
pub z: i32,
pub avant: Bloc,
pub apres: Bloc,
}
/// Etat atmospherique et saisonnier necessaire au calcul (fourni par `CoucheLive`).
#[derive(Clone, Copy, Debug)]
pub struct Contexte {
pub jour_annee: u32,
pub mois: u32,
/// Moyenne des minimas journaliers des 7 derniers jours a la station de reference.
pub tmin7_ref_c: f32,
pub alt_ref_m: f32,
}
/// Decalage du niveau des rivieres (blocs) selon le debit saisonnier relatif.
pub fn decalage_niveau_eau(mois: u32) -> i32 {
((physique::debit_relatif(mois) - 1.0) * 1.2).round() as i32
}
/// Etat des feuilles d'un caduc : `None` = absente.
pub fn etat_feuille(f: &FeuilleEntree, jour_annee: u32) -> Option<Feuille> {
let frac = physique::feuillage(jour_annee, f.alt_m);
if frac <= 0.0 {
return None;
}
let h = hash01(f.x.wrapping_add(f.y * 31), f.z, 99);
if h >= frac {
return None; // feuillage clairseme en debut/fin de saison
}
if jour_annee < 200 {
return Some(Feuille::Verte);
}
Some(if frac > 0.85 {
Feuille::Verte
} else if frac > 0.45 || matches!(f.essence, Essence::Meleze | Essence::Bouleau) {
Feuille::Jaune
} else {
Feuille::Rousse
})
}
impl Manteau {
/// Delta du chunk. `actuel(x, y, z)` donne le bloc actuellement dans le monde.
pub fn delta_chunk(
&self,
e: &ChunkEntree,
ctx: &Contexte,
masque: &MasqueJoueur,
actuel: &dyn Fn(i32, i32, i32) -> Bloc,
) -> Vec<Modif> {
let mut out = Vec::new();
let mut maj = |x: i32, y: i32, z: i32, cible: Bloc, modifiables: &[Bloc]| {
if masque.touche(x, y, z) {
return;
}
let a = actuel(x, y, z);
if a == cible {
return;
}
let ok = modifiables.iter().any(|m| match (m, a) {
(Bloc::Neige(0), Bloc::Neige(_)) => true,
(Bloc::Feuille(Feuille::Verte), Bloc::Feuille(_)) => true,
(m, a) => *m == a,
});
if ok {
out.push(Modif { x, y, z, avant: a, apres: cible });
}
};
let off_eau = decalage_niveau_eau(ctx.mois);
for lz in 0..16 {
for lx in 0..16 {
let c = &e.colonnes[lz * 16 + lx];
let (x, z) = (e.cx * 16 + lx as i32, e.cz * 16 + lz as i32);
match c.surface {
Surface::Sol | Surface::Route => {
let mut n = self.couches(x, z, c.pente_deg);
if c.surface == Surface::Route {
n = n.min(2);
}
let cible = if n == 0 { Bloc::Air } else { Bloc::Neige(n) };
maj(x, c.sol_y + 1, z, cible, &[Bloc::Air, Bloc::Neige(0)]);
}
Surface::Roche | Surface::Bati => {}
Surface::Eau { lac: true } => {
let t7 = physique::temp_a_altitude(ctx.tmin7_ref_c, ctx.alt_ref_m, c.alt_m);
let cible = if physique::lac_gele(t7) { Bloc::Glace } else { Bloc::Eau };
maj(x, c.eau_y, z, cible, &[Bloc::Eau, Bloc::Glace]);
}
Surface::Eau { lac: false } => {
// Niveau saisonnier : seul le bloc de surface nominal et celui du dessus bougent.
let haut = c.eau_y + off_eau;
if haut > c.sol_y {
for y in [c.eau_y, c.eau_y + 1] {
let cible = if y <= haut { Bloc::Eau } else { Bloc::Air };
maj(x, y, z, cible, &[Bloc::Air, Bloc::Eau]);
}
}
}
}
}
}
for f in &e.feuilles {
let cible = match etat_feuille(f, ctx.jour_annee) {
Some(s) => Bloc::Feuille(s),
None => Bloc::Air,
};
maj(f.x, f.y, f.z, cible, &[Bloc::Air, Bloc::Feuille(Feuille::Verte)]);
}
out.sort_by_key(|m| (m.x, m.y, m.z));
out
}
}
+97
Voir le fichier
@@ -0,0 +1,97 @@
//! rt-live : couche dynamique du monde (neige degre-jour, glace, feuilles, niveau d'eau).
//! Independante de Pumpkin : l'integration fournit les blocs actuels et applique le delta.
pub mod date;
pub mod delta;
pub mod manteau;
pub mod meteo;
pub use date::Date;
pub use delta::{Bloc, ChunkEntree, Colonne, Contexte, Essence, Feuille, FeuilleEntree, MasqueJoueur, Modif, Surface};
pub use manteau::{Cellule, Manteau, Params};
pub use meteo::{Climat, Obs, Serie};
/// Mode de fonctionnement.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mode {
/// Normales climatiques (annee type synthetique, date reelle).
Climat,
/// Serie reelle (CSV) ; jours manquants et periode avant la serie : repli sur le climat.
Meteo,
/// Date imposee, aucune evolution.
Fige(Date),
}
pub struct CoucheLive {
pub mode: Mode,
pub manteau: Manteau,
pub climat: Climat,
pub serie: Option<Serie>,
/// Nombre de jours simules par repli sur le climat en mode Meteo.
pub jours_repli: usize,
date: Option<Date>,
tmin: [f32; 7],
}
impl CoucheLive {
pub fn new(mode: Mode, manteau: Manteau, climat: Climat, serie: Option<Serie>) -> CoucheLive {
CoucheLive { mode, manteau, climat, serie, jours_repli: 0, date: None, tmin: [0.0; 7] }
}
pub fn date(&self) -> Option<Date> {
self.date
}
fn obs(&mut self, d: Date) -> Obs {
if self.mode == Mode::Meteo {
if let Some(o) = self.serie.as_ref().and_then(|s| s.get(d)) {
return o;
}
self.jours_repli += 1;
}
self.climat.obs(d)
}
/// Amene l'etat a `date` (ignoree en mode Fige). Un retour en arriere ou un saut de plus d'un an
/// re-simule depuis le 1er aout de l'annee hydrologique : le resultat ne depend que de la date.
pub fn avancer_a(&mut self, date: Date) {
let cible = if let Mode::Fige(d) = self.mode { d } else { date };
let depart = match self.date {
Some(d) if d <= cible && cible.ordinal() - d.ordinal() <= 366 => d.plus(1),
_ => {
self.manteau.reinitialiser();
self.jours_repli = 0;
cible.debut_annee_hydro()
}
};
if self.date == Some(cible) {
return;
}
let mut d = depart;
while d <= cible {
let o = self.obs(d);
let amp = self.manteau.p.amplitude_c(d.jour_annee_365());
self.manteau.pas_jour(d, o.temp_c, o.precip_mm);
self.tmin.rotate_left(1);
self.tmin[6] = o.temp_c - amp;
d = d.plus(1);
}
self.date = Some(cible);
}
pub fn contexte(&self) -> Option<Contexte> {
let d = self.date?;
Some(Contexte {
jour_annee: d.jour_annee(),
mois: d.mois,
tmin7_ref_c: self.tmin.iter().sum::<f32>() / 7.0,
alt_ref_m: self.manteau.p.alt_ref_m,
})
}
/// Delta d'un chunk a la date courante (apres `avancer_a`).
pub fn delta_chunk(&self, e: &ChunkEntree, masque: &MasqueJoueur, actuel: &dyn Fn(i32, i32, i32) -> Bloc) -> Vec<Modif> {
match self.contexte() {
Some(ctx) => self.manteau.delta_chunk(e, &ctx, masque, actuel),
None => Vec::new(),
}
}
}
#[cfg(test)]
mod tests;
+257
Voir le fichier
@@ -0,0 +1,257 @@
//! Manteau neigeux degre-jour par cellule (32 m) : accumulation, fonte, effet adret/ubac.
use crate::date::Date;
/// Description statique d'une cellule (moyennes sur 32x32 blocs).
#[derive(Clone, Copy, Debug)]
pub struct Cellule {
pub alt_m: f32,
pub pente_deg: f32,
/// Azimut de la descente de pente (0 = nord, 90 = est, 180 = sud : versant sud = adret).
pub aspect_deg: f32,
}
/// Parametres du modele. Valeurs recalees sur le Veymont (voir rapport 12b) [A VERIFIER].
#[derive(Clone, Copy, Debug)]
pub struct Params {
pub alt_ref_m: f32,
pub lat_deg: f32,
/// Facteur degre-jour de la neige, mm par degre-jour (Alpes : 3 a 6).
pub ddf_mm: f32,
/// Poids du terme de rayonnement dans la fonte (0 = pas d'effet d'exposition).
pub k_rad: f32,
/// Temperature (moyenne du jour, a la cellule) sous laquelle tout est neige.
pub t_neige_c: f32,
/// Temperature au-dessus de laquelle tout est pluie.
pub t_pluie_c: f32,
/// Gain relatif de precipitation par 100 m (effet orographique).
pub gain_precip_100m: f32,
pub gain_precip_max: f32,
/// Fonte basale (chaleur du sol) en mm/jour en automne, puis `fonte_sol_hiver_mm`.
pub fonte_sol_automne_mm: f32,
pub fonte_sol_hiver_mm: f32,
/// Amplitude diurne (demi-ecart) hiver / ete, C.
pub amp_hiver_c: f32,
pub amp_ete_c: f32,
}
impl Default for Params {
fn default() -> Self {
Params {
alt_ref_m: 1000.0,
lat_deg: 44.9,
ddf_mm: 5.0,
k_rad: 0.6,
t_neige_c: 0.0,
t_pluie_c: 2.0,
gain_precip_100m: 0.02,
gain_precip_max: 1.6,
fonte_sol_automne_mm: 4.0,
fonte_sol_hiver_mm: 0.3,
amp_hiver_c: 3.0,
amp_ete_c: 6.0,
}
}
}
impl Params {
pub fn amplitude_c(&self, doy365: u32) -> f32 {
let s = 0.5 - 0.5 * (std::f32::consts::TAU * (doy365 as f32 - 20.0) / 365.0).cos(); // 0 hiver, 1 ete
self.amp_hiver_c + (self.amp_ete_c - self.amp_hiver_c) * s
}
}
/// Moyenne sur la journee de max(T, 0) pour T = tm + a sin(theta) (degres-jours positifs).
pub fn degres_jours_positifs(tm: f32, a: f32) -> f32 {
if a <= 1e-4 {
return tm.max(0.0);
}
if tm >= a {
return tm;
}
if tm <= -a {
return 0.0;
}
let al = (tm / a).asin();
(tm * (std::f32::consts::PI + 2.0 * al) + 2.0 * a * al.cos()) / std::f32::consts::TAU
}
/// Facteur d'accumulation selon la pente (la neige glisse sur les pentes raides).
pub fn facteur_pente(pente_deg: f32) -> f32 {
if pente_deg <= 30.0 {
1.0
} else if pente_deg <= 40.0 {
1.0 - 0.5 * (pente_deg - 30.0) / 10.0
} else if pente_deg <= 55.0 {
0.5 * (55.0 - pente_deg) / 15.0
} else {
0.0
}
}
/// Facteur de hauteur selon la pente locale d'une colonne : parois > 50 deg nues, demi-epaisseur > 35 deg
/// (meme convention que `physique::couche_neige`).
pub fn facteur_pente_colonne(pente_deg: f32) -> f32 {
if pente_deg > 50.0 { 0.0 } else if pente_deg > 35.0 { 0.5 } else { 1.0 }
}
/// Hauteur de neige (m) pour un equivalent en eau (mm) : densite 0,10 (fraiche) a 0,35 (tassee).
pub fn hauteur_m(swe_mm: f32) -> f32 {
let rho = 0.10 + 0.25 * (1.0 - (-swe_mm / 300.0).exp());
swe_mm / 1000.0 / rho
}
pub fn hash01(x: i32, z: i32, graine: u32) -> f32 {
let mut h = (x as u32).wrapping_mul(0x9E37_79B1) ^ (z as u32).wrapping_mul(0x85EB_CA77) ^ graine.wrapping_mul(0xC2B2_AE3D);
h ^= h >> 15;
h = h.wrapping_mul(0x2C1B_3C6D);
h ^= h >> 12;
h = h.wrapping_mul(0x297A_2D39);
h ^= h >> 15;
(h >> 8) as f32 / (1u32 << 24) as f32
}
pub struct Manteau {
pub p: Params,
pub cellule_m: i32,
pub x0: i32,
pub z0: i32,
pub w: usize,
pub h: usize,
/// Equivalent en eau, dixiemes de mm (u16 : 6 553 mm max).
swe: Vec<u16>,
infos: Vec<Cellule>,
/// cos(pente), sin(pente), cos(aspect) precalcules.
geo: Vec<[f32; 3]>,
derniere: Option<Date>,
}
impl Manteau {
/// `cellule(ix, iz)` decrit la cellule dont le coin nord-ouest est (x0 + 32 ix, z0 + 32 iz).
pub fn nouveau(p: Params, cellule_m: i32, x0: i32, z0: i32, w: usize, h: usize, cellule: impl Fn(usize, usize) -> Cellule) -> Manteau {
let mut infos = Vec::with_capacity(w * h);
for iz in 0..h {
for ix in 0..w {
infos.push(cellule(ix, iz));
}
}
let geo = infos
.iter()
.map(|c| {
let s = c.pente_deg.to_radians();
[s.cos(), s.sin(), c.aspect_deg.to_radians().cos()]
})
.collect();
Manteau { p, cellule_m, x0, z0, w, h, swe: vec![0; w * h], infos, geo, derniere: None }
}
pub fn reinitialiser(&mut self) {
self.swe.iter_mut().for_each(|s| *s = 0);
self.derniere = None;
}
pub fn derniere(&self) -> Option<Date> {
self.derniere
}
pub fn cellule(&self, ix: usize, iz: usize) -> Cellule {
self.infos[iz * self.w + ix]
}
pub fn swe_cellule_mm(&self, ix: usize, iz: usize) -> f32 {
self.swe[iz * self.w + ix] as f32 / 10.0
}
pub fn fixer_swe_mm(&mut self, ix: usize, iz: usize, mm: f32) {
self.swe[iz * self.w + ix] = (mm * 10.0).round().clamp(0.0, 65535.0) as u16;
}
/// Facteur de fonte lie au rayonnement direct a midi solaire (1 = terrain plat) :
/// cos(incidence) sur la pente / sin(hauteur du soleil), borne.
pub fn facteur_rayonnement(&self, g: [f32; 3], doy: u32) -> f32 {
let decl = 23.44f32.to_radians() * ((360.0 / 365.0 * (doy as f32 - 81.0)).to_radians()).sin();
let haut = std::f32::consts::FRAC_PI_2 - self.p.lat_deg.to_radians() + decl;
let (sh, ch) = (haut.sin().max(0.05), haut.cos());
let cos_i = g[0] * sh - g[1] * ch * g[2];
let rf = cos_i.max(0.0) / sh;
(1.0 + self.p.k_rad * (rf - 1.0)).clamp(0.25, 2.2)
}
/// Un jour de simulation. Idempotent : une date deja appliquee (ou anterieure) est ignoree.
/// Renvoie `false` si ignoree.
pub fn pas_jour(&mut self, date: Date, temp_ref_c: f32, precip_ref_mm: f32) -> bool {
if let Some(d) = self.derniere {
if date <= d {
return false;
}
}
let doy = date.jour_annee_365();
let amp = self.p.amplitude_c(doy);
let jh = ((doy + 365 - 213) % 365) as f32; // jours depuis le 1er aout
let sol = if jh <= 90.0 {
self.p.fonte_sol_automne_mm
} else if jh < 150.0 {
self.p.fonte_sol_automne_mm + (self.p.fonte_sol_hiver_mm - self.p.fonte_sol_automne_mm) * (jh - 90.0) / 60.0
} else {
self.p.fonte_sol_hiver_mm
};
for i in 0..self.swe.len() {
let c = self.infos[i];
let tm = physique::temp_a_altitude(temp_ref_c, self.p.alt_ref_m, c.alt_m);
let mut s = self.swe[i] as f32 / 10.0;
// Accumulation
let gain = (1.0 + self.p.gain_precip_100m * (c.alt_m - self.p.alt_ref_m) / 100.0).clamp(0.5, self.p.gain_precip_max);
let frac_neige = ((self.p.t_pluie_c - tm) / (self.p.t_pluie_c - self.p.t_neige_c)).clamp(0.0, 1.0);
s += precip_ref_mm * gain * frac_neige * facteur_pente(c.pente_deg);
// Fonte degre-jour modulee par l'exposition, plus fonte basale
if s > 0.0 {
let fr = self.facteur_rayonnement(self.geo[i], doy);
let fonte = self.p.ddf_mm * fr * degres_jours_positifs(tm, amp) + sol;
s = (s - fonte).max(0.0);
}
self.swe[i] = (s * 10.0).round().clamp(0.0, 65535.0) as u16;
}
self.derniere = Some(date);
true
}
/// Equivalent en eau (mm) interpole bilineairement entre centres de cellules.
pub fn swe_mm_a(&self, bx: i32, bz: i32) -> f32 {
let c = self.cellule_m as f32;
let fx = ((bx - self.x0) as f32 + 0.5) / c - 0.5;
let fz = ((bz - self.z0) as f32 + 0.5) / c - 0.5;
let (ix, iz) = (fx.floor(), fz.floor());
let (tx, tz) = (fx - ix, fz - iz);
let g = |x: f32, z: f32| {
let xi = (x as i64).clamp(0, self.w as i64 - 1) as usize;
let zi = (z as i64).clamp(0, self.h as i64 - 1) as usize;
self.swe[zi * self.w + xi] as f32 / 10.0
};
let a = g(ix, iz) * (1.0 - tx) + g(ix + 1.0, iz) * tx;
let b = g(ix, iz + 1.0) * (1.0 - tx) + g(ix + 1.0, iz + 1.0) * tx;
a * (1.0 - tz) + b * tz
}
/// Couches de neige Minecraft (0..=8) sur la colonne, selon la pente locale (blocs).
/// Dithering deterministe par colonne pour des limites naturelles.
pub fn couches(&self, bx: i32, bz: i32, pente_deg: f32) -> u8 {
let swe = self.swe_mm_a(bx, bz);
if swe < 3.0 {
return 0;
}
let f = hauteur_m(swe) / 0.125 * facteur_pente_colonne(pente_deg);
if f < 0.25 {
return 0;
}
((f + hash01(bx, bz, 7)).floor() as i64).clamp(0, 8) as u8
}
/// Part de cellules couvertes (>= 8 mm d'equivalent en eau, soit ~3 cm) dans [alt_min, alt_max[.
pub fn fraction_enneigee(&self, alt_min: f32, alt_max: f32) -> f32 {
let (mut n, mut tot) = (0usize, 0usize);
for (i, c) in self.infos.iter().enumerate() {
if c.alt_m >= alt_min && c.alt_m < alt_max {
tot += 1;
if self.swe[i] >= 80 {
n += 1;
}
}
}
if tot == 0 { 0.0 } else { n as f32 / tot as f32 }
}
}
+145
Voir le fichier
@@ -0,0 +1,145 @@
//! Series meteo d'entree : CSV reel/synthetique et generateur climatique (normales + variabilite).
use crate::date::Date;
use std::collections::BTreeMap;
/// Observation journaliere a la station de reference.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Obs {
pub temp_c: f32,
pub precip_mm: f32,
}
/// Serie journaliere. Format CSV : `date,temp,precip` (YYYY-MM-DD ; degres C moyens du jour ;
/// mm/jour), separateur `,` ou `;`, en-tete et lignes `#` ignorees.
#[derive(Clone, Debug, Default)]
pub struct Serie {
pub jours: BTreeMap<Date, Obs>,
}
impl Serie {
pub fn depuis_csv(texte: &str) -> Result<Serie, String> {
let mut jours = BTreeMap::new();
for (i, l) in texte.lines().enumerate() {
let l = l.trim();
if l.is_empty() || l.starts_with('#') {
continue;
}
let c: Vec<&str> = l.split(|ch| ch == ',' || ch == ';').map(str::trim).collect();
let Ok(d) = Date::parse(c[0]) else {
if jours.is_empty() {
continue; // en-tete
}
return Err(format!("ligne {} : date invalide", i + 1));
};
let nb = |k: usize| -> Result<f32, String> {
match c.get(k) {
None => Err(format!("ligne {} : champ {} manquant", i + 1, k + 1)),
Some(s) if s.is_empty() => Ok(0.0),
Some(s) => s.parse::<f32>().map_err(|_| format!("ligne {} : nombre invalide '{s}'", i + 1)),
}
};
jours.insert(d, Obs { temp_c: nb(1)?, precip_mm: nb(2)?.max(0.0) });
}
if jours.is_empty() {
return Err("serie vide".into());
}
Ok(Serie { jours })
}
pub fn vers_csv(&self) -> String {
let mut s = String::from("date,temp,precip\n");
for (d, o) in &self.jours {
s += &format!("{d},{:.1},{:.1}\n", o.temp_c, o.precip_mm);
}
s
}
pub fn get(&self, d: Date) -> Option<Obs> {
self.jours.get(&d).copied()
}
}
/// Precipitations mensuelles a 1000 m (Hauts-Plateaux nord, ~1 470 mm/an) [A VERIFIER].
pub const PRECIP_MM_1000M: [f32; 12] = [120.0, 105.0, 115.0, 125.0, 135.0, 120.0, 90.0, 110.0, 125.0, 150.0, 145.0, 130.0];
const JOURS_MOIS: [f32; 12] = [31.0, 28.0, 31.0, 30.0, 31.0, 30.0, 31.0, 31.0, 30.0, 31.0, 30.0, 31.0];
struct Rng(u64);
impl Rng {
fn u64(&mut self) -> u64 {
self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = self.0;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
}
fn u01(&mut self) -> f32 {
(self.u64() >> 40) as f32 / (1u64 << 24) as f32
}
fn normal(&mut self) -> f32 {
let (a, b) = (self.u01().max(1e-7), self.u01());
(-2.0 * a.ln()).sqrt() * (std::f32::consts::TAU * b).cos()
}
}
/// Temperature normale du jour (interpolation entre milieux de mois), station a 1000 m.
pub fn temp_normale(doy365: u32) -> f32 {
let mut mid = [0f32; 12];
let mut cum = 0.0;
for m in 0..12 {
mid[m] = cum + JOURS_MOIS[m] / 2.0;
cum += JOURS_MOIS[m];
}
let d = doy365 as f32 - 0.5;
let t = |m: usize| physique::temp_moyenne_1000m(m as u32 + 1);
let dd = if d < mid[0] { d + 365.0 } else { d };
for m in 0..12 {
let m2 = (m + 1) % 12;
let a = mid[m];
let b = if m2 == 0 { mid[0] + 365.0 } else { mid[m2] };
if dd >= a && dd <= b {
return t(m) + (t(m2) - t(m)) * (dd - a) / (b - a);
}
}
t(0)
}
/// Annee type de 365 jours (indexee depuis le 1er aout), identique chaque annee civile.
/// `variabilite` = 0 : normales lissees (temps uniforme) ; 1 : temps synthetique (anomalie AR(1)
/// d ecart-type 3,0 C, jours humides en chaine de Markov, pluies exponentielles).
#[derive(Clone, Debug)]
pub struct Climat {
pub seed: u64,
pub variabilite: f32,
tab: Vec<Obs>,
}
impl Climat {
pub fn nouveau(seed: u64, variabilite: f32) -> Climat {
let mut r = Rng(seed ^ 0xC11A_7000);
let mut tab = Vec::with_capacity(365);
let (mut anom, mut humide) = (0.0f32, false);
let phi = 0.7f32;
for idx in 0..365u32 {
let doy = (idx + 213 - 1) % 365 + 1;
let mois = (0..12)
.rev()
.find(|&m| doy as f32 > JOURS_MOIS[..m].iter().sum::<f32>())
.unwrap_or(0);
let jm = JOURS_MOIS[mois];
let p_h = if humide { 0.60 } else { 0.25 };
humide = r.u01() < p_h;
anom = phi * anom + 3.0 * (1.0 - phi * phi).sqrt() * r.normal();
let mu = PRECIP_MM_1000M[mois] / (jm * 0.385);
let expo = -(1.0 - r.u01()).max(1e-6).ln();
let v = variabilite;
let p_var = if humide { mu * expo } else { 0.0 };
let p_uni = PRECIP_MM_1000M[mois] / jm;
let precip = p_uni + (p_var - p_uni) * v;
let temp = temp_normale(doy) + v * (anom - if humide { 1.0 } else { 0.0 });
tab.push(Obs { temp_c: temp, precip_mm: precip.max(0.0) });
}
Climat { seed, variabilite, tab }
}
pub fn obs(&self, d: Date) -> Obs {
self.tab[d.index_hydro()]
}
}
+382
Voir le fichier
@@ -0,0 +1,382 @@
use super::*;
use std::collections::HashMap;
fn champ(alts: &[f32], pente: f32, aspect: f32) -> Manteau {
let a = alts.to_vec();
Manteau::nouveau(Params::default(), 32, 0, 0, a.len(), 1, move |ix, _| Cellule { alt_m: a[ix], pente_deg: pente, aspect_deg: aspect })
}
fn veymont_synth() -> Vec<f32> {
// Altitudes 1660..2320 m par pas de 20 m, pente moderee (comme le Veymont, 1659-2322 m)
// Distribution proche de la tuile reelle (beaucoup de surface entre 1650 et 1950 m)
(0..34).map(|i| 1660.0 + 660.0 * (i as f32 / 33.0).powf(1.6)).collect()
}
fn fraction(seed: u64, d: Date, mode_aspect: f32) -> f32 {
let m = champ(&veymont_synth(), 20.0, mode_aspect);
let mut c = CoucheLive::new(Mode::Climat, m, Climat::nouveau(seed, 1.0), None);
c.avancer_a(d);
c.manteau.fraction_enneigee(0.0, 9000.0)
}
#[test]
fn dates() {
let d = Date::new(2026, 10, 30);
assert_eq!(Date::depuis_ordinal(d.ordinal()), d);
assert_eq!(Date::new(1970, 1, 1).ordinal(), 0);
assert_eq!(d.plus(2), Date::new(2026, 11, 1));
assert_eq!(Date::new(2028, 3, 1).plus(-1), Date::new(2028, 2, 29));
assert_eq!(Date::parse("2026-10-30").unwrap(), d);
assert_eq!(Date::new(2027, 2, 3).debut_annee_hydro(), Date::new(2026, 8, 1));
assert_eq!(Date::new(2026, 8, 1).index_hydro(), 0);
assert_eq!(Date::new(2026, 7, 31).index_hydro(), 364);
}
#[test]
fn csv() {
let s = Serie::depuis_csv("date,temp,precip\n# c\n2026-10-01,3.5,12\n2026-10-02;-1;0.5\n").unwrap();
assert_eq!(s.jours.len(), 2);
assert_eq!(s.get(Date::new(2026, 10, 2)).unwrap().temp_c, -1.0);
assert!(Serie::depuis_csv("date,temp,precip\n").is_err());
assert!(Serie::depuis_csv("2026-10-01,abc,1\n").is_err());
let s2 = Serie::depuis_csv(&s.vers_csv()).unwrap();
assert_eq!(s2.jours.len(), 2);
}
#[test]
fn degres_jours() {
assert!((manteau::degres_jours_positifs(10.0, 5.0) - 10.0).abs() < 1e-4);
assert_eq!(manteau::degres_jours_positifs(-6.0, 5.0), 0.0);
// tm = 0 : A / pi
assert!((manteau::degres_jours_positifs(0.0, 5.0) - 5.0 / std::f32::consts::PI).abs() < 1e-4);
}
#[test]
fn accumulation_selon_altitude_et_temperature() {
let mut m = champ(&[1000.0, 1500.0, 2000.0, 2500.0], 10.0, 0.0);
// Reference a 1000 m : -1 C => 1000 m -1, 1500 m -4.25, 2000 -7.5 : 30 mm de precipitation
m.pas_jour(Date::new(2026, 12, 1), -1.0, 30.0);
let s: Vec<f32> = (0..4).map(|i| m.swe_cellule_mm(i, 0)).collect();
assert!(s[0] > 25.0 && s[3] > s[0], "{s:?}"); // l'effet orographique renforce le haut
// Pluie : +6 C a 1000 m => 1000 m pluie, 2500 m neige (-3.75)
let mut m2 = champ(&[1000.0, 2500.0], 10.0, 0.0);
m2.pas_jour(Date::new(2026, 12, 1), 6.0, 30.0);
assert_eq!(m2.swe_cellule_mm(0, 0), 0.0);
assert!(m2.swe_cellule_mm(1, 0) > 20.0);
}
#[test]
fn pas_jour_idempotent() {
let mut m = champ(&[2000.0], 10.0, 0.0);
assert!(m.pas_jour(Date::new(2026, 12, 1), -5.0, 20.0));
let a = m.swe_cellule_mm(0, 0);
assert!(!m.pas_jour(Date::new(2026, 12, 1), -5.0, 20.0));
assert!(!m.pas_jour(Date::new(2026, 11, 30), -5.0, 20.0));
assert_eq!(m.swe_cellule_mm(0, 0), a);
}
#[test]
fn fonte_degre_jour() {
// Cellule plate a 1000 m (= station), mi-avril, 12 C moyens : fonte ~ ddf * (12 + ..) par jour
let mut m = champ(&[1000.0], 0.0, 0.0);
m.fixer_swe_mm(0, 0, 200.0);
let mut prec = 200.0;
let mut d = Date::new(2027, 4, 15);
for _ in 0..5 {
m.pas_jour(d, 12.0, 0.0);
let s = m.swe_cellule_mm(0, 0);
assert!(s < prec || s == 0.0, "la neige doit fondre");
prec = s;
d = d.plus(1);
}
// 5 j x (5 mm/C x ~12 C + sol 0.3) = ~300 mm > 200 mm => plus rien
assert!(prec < 5.0, "reste {prec}");
// Pas de fonte sous 0 C
let mut g = champ(&[1000.0], 0.0, 0.0);
g.fixer_swe_mm(0, 0, 100.0);
g.pas_jour(Date::new(2027, 1, 10), -10.0, 0.0);
assert!(g.swe_cellule_mm(0, 0) > 99.0);
}
#[test]
fn adret_ubac_fonte_et_accumulation() {
// Meme altitude, meme pente (30 deg), versant sud (180) contre nord (0), fin mars
let mut m = Manteau::nouveau(Params::default(), 32, 0, 0, 2, 1, |ix, _| Cellule {
alt_m: 1800.0,
pente_deg: 30.0,
aspect_deg: if ix == 0 { 180.0 } else { 0.0 },
});
m.fixer_swe_mm(0, 0, 500.0);
m.fixer_swe_mm(1, 0, 500.0);
let mut d = Date::new(2027, 3, 20);
for _ in 0..25 {
m.pas_jour(d, 8.0, 0.0); // ~ 2.8 C a 1800 m
d = d.plus(1);
}
let (adret, ubac) = (m.swe_cellule_mm(0, 0), m.swe_cellule_mm(1, 0));
assert!(ubac > adret + 40.0, "adret {adret} ubac {ubac}");
// Accumulation identique (le soleil n'intervient pas dans les chutes)
let mut n = Manteau::nouveau(Params::default(), 32, 0, 0, 2, 1, |ix, _| Cellule {
alt_m: 1800.0,
pente_deg: 30.0,
aspect_deg: if ix == 0 { 180.0 } else { 0.0 },
});
n.pas_jour(Date::new(2026, 12, 20), -6.0, 20.0);
assert_eq!(n.swe_cellule_mm(0, 0), n.swe_cellule_mm(1, 0));
}
#[test]
fn facteur_rayonnement_saison() {
let m = Manteau::nouveau(Params::default(), 32, 0, 0, 1, 1, |_, _| Cellule { alt_m: 1800.0, pente_deg: 30.0, aspect_deg: 180.0 });
let g = |a: f32| {
let s = 30f32.to_radians();
[s.cos(), s.sin(), a.to_radians().cos()]
};
// En decembre l'ecart adret/ubac est bien plus grand qu'en juin
let ecart = |doy| m.facteur_rayonnement(g(180.0), doy) - m.facteur_rayonnement(g(0.0), doy);
assert!(ecart(355) > ecart(172) + 0.3);
assert!(m.facteur_rayonnement(g(180.0), 355) > 1.0 && m.facteur_rayonnement(g(0.0), 355) < 1.0);
}
#[test]
fn couches_et_pente() {
let mut m = champ(&[2000.0], 10.0, 0.0);
m.fixer_swe_mm(0, 0, 400.0);
let n = m.couches(5, 5, 10.0);
assert_eq!(n, 8);
assert_eq!(m.couches(5, 5, 60.0), 0); // paroi
m.fixer_swe_mm(0, 0, 40.0);
let n2 = m.couches(5, 5, 10.0);
assert!((1..=4).contains(&n2), "{n2}");
m.fixer_swe_mm(0, 0, 1.0);
assert_eq!(m.couches(5, 5, 10.0), 0);
}
// ---------- modes ----------
#[test]
fn modes_climat_fige_meteo() {
let d = Date::new(2027, 1, 15);
let mk = |mode, serie| CoucheLive::new(mode, champ(&[1800.0], 10.0, 0.0), Climat::nouveau(3, 1.0), serie);
let mut a = mk(Mode::Climat, None);
let mut b = mk(Mode::Fige(d), None);
a.avancer_a(d);
b.avancer_a(Date::new(2030, 7, 1)); // la date demandee est ignoree en mode fige
assert_eq!(a.manteau.swe_cellule_mm(0, 0), b.manteau.swe_cellule_mm(0, 0));
assert_eq!(b.date(), Some(d));
// Reproductible
let mut a2 = mk(Mode::Climat, None);
a2.avancer_a(d);
assert_eq!(a.manteau.swe_cellule_mm(0, 0), a2.manteau.swe_cellule_mm(0, 0));
// Avancer par etapes == aller directement ; revenir en arriere == recalculer
let mut c = mk(Mode::Climat, None);
for k in 0..30 {
c.avancer_a(Date::new(2026, 12, 16).plus(k));
}
let mut dd = mk(Mode::Climat, None);
dd.avancer_a(Date::new(2027, 1, 14));
assert_eq!(c.manteau.swe_cellule_mm(0, 0), dd.manteau.swe_cellule_mm(0, 0));
c.avancer_a(Date::new(2026, 11, 20));
let mut e = mk(Mode::Climat, None);
e.avancer_a(Date::new(2026, 11, 20));
assert_eq!(c.manteau.swe_cellule_mm(0, 0), e.manteau.swe_cellule_mm(0, 0));
// Meteo : une chute de neige reelle (serie) bat le climat
let mut csv = String::from("date,temp,precip\n");
for k in 0..10 {
csv += &format!("{},{},{}\n", Date::new(2026, 10, 1).plus(k), -8, 15);
}
let serie = Serie::depuis_csv(&csv).unwrap();
let mut mt = mk(Mode::Meteo, Some(serie));
mt.avancer_a(Date::new(2026, 10, 10));
let mut cl = mk(Mode::Climat, None);
cl.avancer_a(Date::new(2026, 10, 10));
assert!(mt.manteau.swe_cellule_mm(0, 0) > cl.manteau.swe_cellule_mm(0, 0) + 50.0);
assert!(mt.jours_repli > 0); // aout-septembre : repli sur le climat
}
#[test]
fn hiver_synthetique_abaisse_la_limite_et_mars_doux_la_releve() {
let alts: Vec<f32> = (0..30).map(|i| 600.0 + 80.0 * i as f32).collect();
let limite = |c: &CoucheLive| {
(0..alts.len()).find(|&i| c.manteau.swe_cellule_mm(i, 0) >= 8.0).map(|i| alts[i]).unwrap_or(9999.0)
};
let mut c = CoucheLive::new(Mode::Climat, champ(&alts, 10.0, 0.0), Climat::nouveau(5, 1.0), None);
c.avancer_a(Date::new(2026, 10, 1));
let l_oct = limite(&c);
c.avancer_a(Date::new(2027, 1, 20));
let l_jan = limite(&c);
assert!(l_jan < l_oct, "janvier {l_jan} octobre {l_oct}");
assert!(l_jan <= 1100.0, "{l_jan}");
// Mars tres doux (serie) : la limite remonte
let mut csv = String::new();
for k in 0..40 {
csv += &format!("{},{},{}\n", Date::new(2027, 2, 20).plus(k), 14, 2);
}
let mut m = CoucheLive::new(Mode::Meteo, champ(&alts, 10.0, 0.0), Climat::nouveau(5, 1.0), Some(Serie::depuis_csv(&csv).unwrap()));
m.avancer_a(Date::new(2027, 2, 19));
let l_avant = limite(&m);
m.avancer_a(Date::new(2027, 3, 31));
assert!(limite(&m) > l_avant + 400.0, "{} {}", limite(&m), l_avant);
}
// ---------- calibrage : neige d'octobre au Veymont ----------
#[test]
fn calibrage_octobre_veymont() {
let moy = |d: Date| (1..=40).map(|s| fraction(s, d, 90.0)).sum::<f32>() / 40.0;
let (o1, o15, o31) = (moy(Date::new(2026, 10, 1)), moy(Date::new(2026, 10, 15)), moy(Date::new(2026, 10, 31)));
let (n15, d15, j15) = (moy(Date::new(2026, 11, 15)), moy(Date::new(2026, 12, 15)), moy(Date::new(2027, 1, 15)));
let (a1, jn, ao) = (moy(Date::new(2027, 4, 1)), moy(Date::new(2027, 6, 15)), moy(Date::new(2027, 8, 1)));
eprintln!("1 oct {o1:.2} 15 oct {o15:.2} 31 oct {o31:.2} 15 nov {n15:.2} 15 dec {d15:.2} 15 jan {j15:.2} 1 avr {a1:.2} 15 juin {jn:.2} 1 aout {ao:.2}");
// Le modele climatologique de physique donnait 54 % toute la fin d'octobre (limite 2000 m)
assert!(o1 < 0.20, "1 oct {o1}");
assert!(o15 < 0.30, "15 oct {o15}");
assert!(o31 < 0.50 && o31 > 0.15, "31 oct {o31}");
assert!(n15 > 0.40, "15 nov {n15}");
assert!(j15 > 0.85, "15 jan {j15}");
assert!(a1 > 0.75, "1 avr {a1}");
assert!(jn < 0.40, "15 juin {jn}");
assert!(ao < 0.01, "1 aout {ao}");
}
// ---------- delta de chunk ----------
fn chunk_test(surface: Surface, alt: f32) -> ChunkEntree {
let col = Colonne { sol_y: 700, surface, pente_deg: 5.0, alt_m: alt, eau_y: 700 };
let mut feuilles = Vec::new();
for i in 0..30 {
feuilles.push(FeuilleEntree { x: i % 16, y: 710 + i / 16, z: 3, essence: Essence::Hetre, alt_m: 1000.0 });
}
ChunkEntree { cx: 0, cz: 0, colonnes: vec![col; 256], feuilles }
}
struct Monde(HashMap<(i32, i32, i32), Bloc>);
impl Monde {
fn lire(&self, x: i32, y: i32, z: i32) -> Bloc {
*self.0.get(&(x, y, z)).unwrap_or(&Bloc::Air)
}
fn appliquer(&mut self, d: &[Modif]) {
for m in d {
self.0.insert((m.x, m.y, m.z), m.apres);
}
}
}
fn couche_hiver(alt: f32) -> CoucheLive {
let mut c = CoucheLive::new(Mode::Climat, champ(&[alt, alt, alt], 5.0, 0.0), Climat::nouveau(2, 1.0), None);
c.manteau = Manteau::nouveau(Params::default(), 32, 0, 0, 2, 2, |_, _| Cellule { alt_m: alt, pente_deg: 5.0, aspect_deg: 0.0 });
c.avancer_a(Date::new(2027, 1, 25));
c
}
#[test]
fn delta_idempotent_neige_glace_feuilles() {
let c = couche_hiver(1800.0);
let mut e = chunk_test(Surface::Sol, 1800.0);
// Un lac sur la moitie du chunk
for i in 0..128 {
e.colonnes[i] = Colonne { sol_y: 695, surface: Surface::Eau { lac: true }, pente_deg: 0.0, alt_m: 1800.0, eau_y: 700 };
}
let mut monde = Monde(HashMap::new());
for i in 0..128 {
monde.0.insert((i % 16, 700, i / 16), Bloc::Eau);
}
for f in &e.feuilles {
monde.0.insert((f.x, f.y, f.z), Bloc::Feuille(Feuille::Verte));
}
let masque = MasqueJoueur::default();
let d1 = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
let d1b = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
assert_eq!(d1, d1b, "meme entree, memes modifications");
assert!(d1.iter().any(|m| matches!(m.apres, Bloc::Neige(_))), "neige attendue a 1800 m en janvier");
assert!(d1.iter().any(|m| m.apres == Bloc::Glace), "lac gele attendu");
assert!(d1.iter().any(|m| m.apres == Bloc::Air && matches!(m.avant, Bloc::Feuille(_))), "feuilles tombees en hiver");
monde.appliquer(&d1);
let d2 = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
assert!(d2.is_empty(), "2e application : {d2:?}");
}
#[test]
fn delta_fonte_retire_la_neige_et_remet_les_feuilles() {
let mut c = couche_hiver(1800.0);
let e = chunk_test(Surface::Sol, 1800.0);
let mut monde = Monde(HashMap::new());
for f in &e.feuilles {
monde.0.insert((f.x, f.y, f.z), Bloc::Feuille(Feuille::Verte));
}
let masque = MasqueJoueur::default();
let d = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
monde.appliquer(&d);
assert!(monde.0.values().any(|b| matches!(b, Bloc::Neige(_))));
// Plein ete : plus de neige, feuilles vertes
c.avancer_a(Date::new(2027, 7, 15));
let d = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
monde.appliquer(&d);
assert!(!monde.0.values().any(|b| matches!(b, Bloc::Neige(_))));
assert!(e.feuilles.iter().all(|f| monde.lire(f.x, f.y, f.z) == Bloc::Feuille(Feuille::Verte)));
assert!(c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z)).is_empty());
}
#[test]
fn delta_ne_touche_jamais_un_bloc_de_joueur() {
let c = couche_hiver(1800.0);
let e = chunk_test(Surface::Sol, 1800.0);
let mut monde = Monde(HashMap::new());
for f in &e.feuilles {
monde.0.insert((f.x, f.y, f.z), Bloc::Feuille(Feuille::Verte));
}
// Un joueur a pose de la pierre sur (2,701,2) et un bloc d'eau; colonne (5,5) protegee; feuille (1,710,3) protegee
monde.0.insert((2, 701, 2), Bloc::Autre);
let mut masque = MasqueJoueur::default();
masque.marquer_bloc(2, 701, 2);
masque.marquer_colonne(5, 5);
masque.marquer_bloc(1, 710, 3);
let d = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
assert!(!d.iter().any(|m| (m.x, m.z) == (5, 5)));
assert!(!d.iter().any(|m| (m.x, m.y, m.z) == (2, 701, 2) || (m.x, m.y, m.z) == (1, 710, 3)));
assert!(d.iter().any(|m| (m.x, m.z) == (6, 5))); // les voisins sont traites
// Meme sans masque, un bloc non modifiable (plante, tronc, pierre) n'est jamais remplace
let d2 = c.delta_chunk(&e, &MasqueJoueur::default(), &|x, y, z| monde.lire(x, y, z));
assert!(!d2.iter().any(|m| (m.x, m.y, m.z) == (2, 701, 2)));
// Un joueur qui a casse la neige : si la colonne est dans le masque, elle n'est jamais re-posee
assert!(!d.iter().any(|m| m.x == 5 && m.z == 5));
}
#[test]
fn riviere_niveau_saisonnier() {
let mut e = chunk_test(Surface::Eau { lac: false }, 800.0);
e.feuilles.clear();
e.colonnes.iter_mut().for_each(|c| c.sol_y = 695);
let ctx = |mois| Contexte { jour_annee: 120, mois, tmin7_ref_c: 5.0, alt_ref_m: 1000.0 };
let m = Manteau::nouveau(Params::default(), 32, 0, 0, 1, 1, |_, _| Cellule { alt_m: 800.0, pente_deg: 0.0, aspect_deg: 0.0 });
let mut monde = Monde(HashMap::new());
for i in 0..256 {
monde.0.insert((i % 16, 700, i / 16), Bloc::Eau);
}
// Mai : crue de fonte => un bloc d'eau de plus
let d = m.delta_chunk(&e, &ctx(5), &MasqueJoueur::default(), &|x, y, z| monde.lire(x, y, z));
assert_eq!(d.len(), 256);
monde.appliquer(&d);
assert!(m.delta_chunk(&e, &ctx(5), &MasqueJoueur::default(), &|x, y, z| monde.lire(x, y, z)).is_empty());
// Aout : etiage => retour au niveau nominal ou en dessous
assert!(decalage_niveau_eau_test(8) <= 0);
let d = m.delta_chunk(&e, &ctx(8), &MasqueJoueur::default(), &|x, y, z| monde.lire(x, y, z));
monde.appliquer(&d);
assert_eq!(monde.lire(0, 701, 0), Bloc::Air);
}
fn decalage_niveau_eau_test(mois: u32) -> i32 {
delta::decalage_niveau_eau(mois)
}
#[test]
fn feuilles_saison() {
let f = FeuilleEntree { x: 1, y: 2, z: 3, essence: Essence::Hetre, alt_m: 900.0 };
assert_eq!(delta::etat_feuille(&f, 10), None);
assert_eq!(delta::etat_feuille(&f, 190), Some(Feuille::Verte));
assert_eq!(delta::etat_feuille(&f, 350), None);
// Fin octobre (doy ~ 300) : couleurs d'automne ou absence, jamais verte franche en plein automne tardif
let teintes: Vec<_> = (0..200).map(|i| delta::etat_feuille(&FeuilleEntree { x: i, y: 5, z: i * 7, essence: Essence::Hetre, alt_m: 900.0 }, 305)).collect();
assert!(teintes.iter().any(|t| *t == Some(Feuille::Rousse) || *t == Some(Feuille::Jaune)));
assert!(teintes.iter().any(|t| t.is_none()));
}