//! 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 } }