127 lignes
5.1 KiB
Rust
127 lignes
5.1 KiB
Rust
use std::sync::Arc;
|
|
|
|
use proc_relief::*;
|
|
|
|
fn pts(n: u64, etendue: f64) -> Vec<(f64, f64)> {
|
|
(0..n)
|
|
.map(|i| {
|
|
(
|
|
bruit::unif(bruit::melange64(i)) as f64 * etendue - etendue / 2.0,
|
|
bruit::unif(bruit::melange64(i ^ 0x5bd1)) as f64 * etendue - etendue / 2.0,
|
|
)
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn determinisme_hauteur_brute() {
|
|
for b in BiomeRelief::TOUS {
|
|
let p = params_initiaux(b);
|
|
for (x, z) in pts(500, 1.0e6) {
|
|
assert_eq!(hauteur_brute(b, &p, 99, x, z).to_bits(), hauteur_brute(b, &p, 99, x, z).to_bits());
|
|
}
|
|
let diff = pts(200, 1.0e5).iter().filter(|&&(x, z)| hauteur_brute(b, &p, 1, x, z) != hauteur_brute(b, &p, 2, x, z)).count();
|
|
assert!(diff > 150, "{b:?} : la graine doit changer le relief");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn determinisme_erosion_et_ordre() {
|
|
let g1 = Generateur::biome_unique(7, BiomeRelief::Prealpes);
|
|
let g2 = Generateur::biome_unique(7, BiomeRelief::Prealpes);
|
|
let id = TileId { tx: 3, tz: -2 };
|
|
let a = g1.eroder_tuile(id);
|
|
let b = g2.eroder_tuile(id);
|
|
assert!(a.delta.iter().zip(&b.delta).all(|(x, y)| x.to_bits() == y.to_bits()));
|
|
assert!(a.delta.iter().any(|d| d.abs() > 0.05), "l'érosion doit modifier le relief");
|
|
// ordre de génération différent → mêmes hauteurs
|
|
let pts = [(1536.3, -1024.7), (1600.0, -700.0), (2047.5, -1023.5)];
|
|
let h1: Vec<f32> = pts.iter().map(|&(x, z)| g1.hauteur(x, z)).collect();
|
|
let g3 = Generateur::biome_unique(7, BiomeRelief::Prealpes);
|
|
g3.erodee(TileId { tx: 4, tz: -2 });
|
|
g3.erodee(TileId { tx: 3, tz: -3 });
|
|
let h3: Vec<f32> = pts.iter().rev().map(|&(x, z)| g3.hauteur(x, z)).rev().collect();
|
|
assert_eq!(h1, h3);
|
|
}
|
|
|
|
#[test]
|
|
fn continuite_bords_de_tuiles() {
|
|
for b in [BiomeRelief::Glaciaire, BiomeRelief::Gorges, BiomeRelief::Bocage] {
|
|
let g = Generateur::biome_unique(11, b);
|
|
let ta = g.tuile(TileId { tx: 0, tz: 0 });
|
|
let tb = g.tuile(TileId { tx: 1, tz: 0 });
|
|
let tc = g.tuile(TileId { tx: 0, tz: 1 });
|
|
let n = 512;
|
|
// valeurs de bord égales à la fonction ponctuelle (calculée sans passer par la tuile)
|
|
let g2 = Generateur::biome_unique(11, b);
|
|
for j in (0..n).step_by(37) {
|
|
assert_eq!(ta.h[j * n + 511], g2.hauteur(511.5, j as f64 + 0.5));
|
|
assert_eq!(tb.h[j * n], g2.hauteur(512.5, j as f64 + 0.5));
|
|
}
|
|
// pas de couture : saut au bord comparable aux sauts intérieurs
|
|
let mut saut_bord = 0.0f64;
|
|
let mut saut_int = 0.0f64;
|
|
for j in 0..n {
|
|
saut_bord += (tb.h[j * n] - ta.h[j * n + 511]).abs() as f64;
|
|
saut_int += (ta.h[j * n + 256] - ta.h[j * n + 255]).abs() as f64;
|
|
saut_bord += (tc.h[j] - ta.h[511 * n + j]).abs() as f64;
|
|
saut_int += (ta.h[256 * n + j] - ta.h[255 * n + j]).abs() as f64;
|
|
}
|
|
assert!(saut_bord < 2.0 * saut_int + 0.5 * n as f64, "{b:?} couture : bord {saut_bord} intérieur {saut_int}");
|
|
// le saut maximal au bord reste plausible (pas de marche)
|
|
let max_bord = (0..n).map(|j| (tb.h[j * n] - ta.h[j * n + 511]).abs()).fold(0.0f32, f32::max);
|
|
let max_int = (0..n).map(|j| (ta.h[j * n + 101] - ta.h[j * n + 100]).abs()).fold(0.0f32, f32::max);
|
|
assert!(max_bord < max_int.max(1.0) * 4.0, "{b:?} marche {max_bord} vs {max_int}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn plages_altitude() {
|
|
// [p5 min, p95 max] tolérés, d'après le tableau du cadrage (§ 2), avec marge.
|
|
let attendu: [(BiomeRelief, f32, f32); 9] = [
|
|
(BiomeRelief::Prealpes, 300.0, 2500.0),
|
|
(BiomeRelief::Glaciaire, 900.0, 4400.0),
|
|
(BiomeRelief::Karst, 200.0, 1300.0),
|
|
(BiomeRelief::Gorges, 250.0, 1600.0),
|
|
(BiomeRelief::Bocage, 0.0, 450.0),
|
|
(BiomeRelief::CoteRocheuse, -60.0, 150.0),
|
|
(BiomeRelief::Fjord, -800.0, 1900.0),
|
|
(BiomeRelief::Plaine, -5.0, 170.0),
|
|
(BiomeRelief::Mer, -250.0, 30.0),
|
|
];
|
|
for (b, lo, hi) in attendu {
|
|
let p = params_initiaux(b);
|
|
let mut v: Vec<f32> = pts(4000, 2.0e5).iter().map(|&(x, z)| hauteur_brute(b, &p, 5, x, z)).collect();
|
|
v.sort_by(|a, b| a.total_cmp(b));
|
|
let (p5, p95) = (v[200], v[3800]);
|
|
assert!(p5 >= lo && p95 <= hi, "{b:?} : p5 {p5} p95 {p95} hors [{lo}, {hi}]");
|
|
assert!(p95 - p5 > 0.3 * (hi - lo) * 0.5, "{b:?} : relief trop plat ({p5}..{p95})");
|
|
assert!(v.iter().all(|h| h.is_finite()));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn tuile_altitudes_finies_et_send_sync() {
|
|
let g = Arc::new(Generateur::biome_unique(3, BiomeRelief::Fjord));
|
|
let hs: Vec<_> = (0..4)
|
|
.map(|k| {
|
|
let g = g.clone();
|
|
std::thread::spawn(move || g.chunk(k * 7, -k * 3))
|
|
})
|
|
.collect();
|
|
for h in hs {
|
|
let c = h.join().unwrap();
|
|
assert!(c.iter().all(|v| v.is_finite() && *v > -2000.0 && *v < 3000.0));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn params_serde_aller_retour() {
|
|
for b in BiomeRelief::TOUS {
|
|
let p = params_initiaux(b);
|
|
let s = serde_json::to_string(&p).unwrap();
|
|
let q: ParamsRelief = serde_json::from_str(&s).unwrap();
|
|
assert_eq!(p, q);
|
|
}
|
|
}
|