Fichiers
moteur-terrain/rt-live/src/delta.rs
T

217 lignes
6.9 KiB
Rust

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