From 9690961cd0ec6dd6affc24de14b7a0ab5a9aa9cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= Date: Fri, 30 Oct 2026 00:33:23 +0100 Subject: [PATCH] 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 --- rt-live/.gitignore | 1 + rt-live/Cargo.lock | 137 +++++++++++++ rt-live/Cargo.toml | 14 ++ rt-live/examples/veymont.rs | 273 ++++++++++++++++++++++++++ rt-live/src/date.rs | 78 ++++++++ rt-live/src/delta.rs | 216 ++++++++++++++++++++ rt-live/src/lib.rs | 97 +++++++++ rt-live/src/manteau.rs | 257 ++++++++++++++++++++++++ rt-live/src/meteo.rs | 145 ++++++++++++++ rt-live/src/tests.rs | 382 ++++++++++++++++++++++++++++++++++++ 10 files changed, 1600 insertions(+) create mode 100644 rt-live/.gitignore create mode 100644 rt-live/Cargo.lock create mode 100644 rt-live/Cargo.toml create mode 100644 rt-live/examples/veymont.rs create mode 100644 rt-live/src/date.rs create mode 100644 rt-live/src/delta.rs create mode 100644 rt-live/src/lib.rs create mode 100644 rt-live/src/manteau.rs create mode 100644 rt-live/src/meteo.rs create mode 100644 rt-live/src/tests.rs diff --git a/rt-live/.gitignore b/rt-live/.gitignore new file mode 100644 index 0000000..2f7896d --- /dev/null +++ b/rt-live/.gitignore @@ -0,0 +1 @@ +target/ diff --git a/rt-live/Cargo.lock b/rt-live/Cargo.lock new file mode 100644 index 0000000..25c3692 --- /dev/null +++ b/rt-live/Cargo.lock @@ -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" diff --git a/rt-live/Cargo.toml b/rt-live/Cargo.toml new file mode 100644 index 0000000..1a6a54d --- /dev/null +++ b/rt-live/Cargo.toml @@ -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" } diff --git a/rt-live/examples/veymont.rs b/rt-live/examples/veymont.rs new file mode 100644 index 0000000..e6dc776 --- /dev/null +++ b/rt-live/examples/veymont.rs @@ -0,0 +1,273 @@ +//! Simulation d'une saison sur la tuile Veymont. +//! Usage : cargo run --release --example veymont -- saison +//! cargo run --release --example veymont -- calibrage +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, + pente: Vec, + aspect: Vec, + ok: Vec, +} + +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, 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![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::() / res[k].len() as f32; + let mut v: Vec = 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)]) { + 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 = 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 | calibrage "), + } +} diff --git a/rt-live/src/date.rs b/rt-live/src/date.rs new file mode 100644 index 0000000..28808ee --- /dev/null +++ b/rt-live/src/date.rs @@ -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 { + 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::().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) + } +} diff --git a/rt-live/src/delta.rs b/rt-live/src/delta.rs new file mode 100644 index 0000000..748f555 --- /dev/null +++ b/rt-live/src/delta.rs @@ -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, + pub feuilles: Vec, +} + +/// 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 { + 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 { + 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 + } +} diff --git a/rt-live/src/lib.rs b/rt-live/src/lib.rs new file mode 100644 index 0000000..3131acc --- /dev/null +++ b/rt-live/src/lib.rs @@ -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, + /// Nombre de jours simules par repli sur le climat en mode Meteo. + pub jours_repli: usize, + date: Option, + tmin: [f32; 7], +} + +impl CoucheLive { + pub fn new(mode: Mode, manteau: Manteau, climat: Climat, serie: Option) -> CoucheLive { + CoucheLive { mode, manteau, climat, serie, jours_repli: 0, date: None, tmin: [0.0; 7] } + } + pub fn date(&self) -> Option { + 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 { + let d = self.date?; + Some(Contexte { + jour_annee: d.jour_annee(), + mois: d.mois, + tmin7_ref_c: self.tmin.iter().sum::() / 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 { + match self.contexte() { + Some(ctx) => self.manteau.delta_chunk(e, &ctx, masque, actuel), + None => Vec::new(), + } + } +} + +#[cfg(test)] +mod tests; diff --git a/rt-live/src/manteau.rs b/rt-live/src/manteau.rs new file mode 100644 index 0000000..9f06306 --- /dev/null +++ b/rt-live/src/manteau.rs @@ -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, + infos: Vec, + /// cos(pente), sin(pente), cos(aspect) precalcules. + geo: Vec<[f32; 3]>, + derniere: Option, +} + +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 { + 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 } + } +} diff --git a/rt-live/src/meteo.rs b/rt-live/src/meteo.rs new file mode 100644 index 0000000..846d311 --- /dev/null +++ b/rt-live/src/meteo.rs @@ -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, +} + +impl Serie { + pub fn depuis_csv(texte: &str) -> Result { + 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 { + 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::().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 { + 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, +} + +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::()) + .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()] + } +} diff --git a/rt-live/src/tests.rs b/rt-live/src/tests.rs new file mode 100644 index 0000000..f14802f --- /dev/null +++ b/rt-live/src/tests.rs @@ -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 { + // 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 = (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 = (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::() / 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())); +}