Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
217 lignes
6.9 KiB
Rust
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
|
|
}
|
|
}
|