Fichiers
vercora/tests/logic_tests.cpp
T
Claude c9beb5a87e Phase 30 (4/n) : construction des tuiles interieures sans relecture
Les voisins d'un sommet, au pas du noeud, sont les sommets voisins de la
tuile ; ceux du parent, au pas double, les sommets a deux rangs. Loin du
bord (aucun indice ecrete), writeTerrainNodeVertices lit donc les
altitudes UNE fois dans une grille bordee de deux rangs au lieu de cinq
lectures ecretees par echantillon, puis applique exactement les memes
operations flottantes que sampleGrid. Les tuiles de bord et le temoin
--no-tile-cache gardent le chemin de reference.

Tests : resultat identique au bit pres sur toutes les tuiles de trois
grilles, chemin rapide exerce aux pas 1, 2, 4 et 8.
Survol (lavapipe, Release) : geometrie d'une tuile ~190 -> ~104 us,
streaming terrain 1,3-1,6 -> 0,9 ms par image. Image identique.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
2026-10-13 23:23:38 +00:00

10452 lignes
501 KiB
C++

// ===========================================================================
// Tests HEADLESS de la logique de jeu de Vercora.
// ===========================================================================
// Aucun GPU, aucune fenetre, aucun Vulkan : ce fichier ne compile que des unites
// qui ne dependent que de GLM (src/world, src/assets, src/core hors Window).
// Lancement : tools\run_logic_tests.bat (voir l'en-tete de ce script pour la
// raison d'etre d'un harnais separe du CMakeLists).
//
// PHASE 15 : s'y ajoute tout l'EDITEUR sauf le dessin - assets generes,
// catalogue et scan de dossier, raycast terrain, scene editable, pile
// d'annulation, collision des objets poses, solveur composite, et le format
// de scene .vcsc (aller-retour, robustesse, independance vis-a-vis de
// l'emprise du terrain charge).
//
// Ce qui est couvert : collision joueur/troncs/souches, ramassage et inventaire,
// debitage progressif d'un arbre abattu, taillage de pierre par percussion, le
// chargement d'une heightmap LiDAR .vchm (Phase 7) avec son georeferencement et
// le refus des fichiers casses, et la non-regression des phases precedentes
// (terrain, semis, visee, chute).
//
// Ce qui n'est PAS couvert et ne peut pas l'etre ici : le rendu, les couches de
// validation Vulkan, le resize, la fermeture propre.
// ===========================================================================
#include "assets/Heightmap.hpp"
#include "assets/TerrainFile.hpp"
#include "core/CollisionSolver.hpp"
#include "core/CompositeCollisionSolver.hpp"
#include "core/Frustum.hpp"
#include "core/HeightSampler.hpp"
#include "core/SlopeLimits.hpp"
#include "core/TerrainRay.hpp"
#include "editor/AssetCatalog.hpp"
#include "editor/EditorAssets.hpp"
#include "editor/EditorController.hpp"
#include "editor/EditorScene.hpp"
#include "editor/PlacedObject.hpp"
#include "editor/SceneFile.hpp"
#include "renderer/DrawItem.hpp"
#include "renderer/GpuVertex.hpp"
#include "renderer/RangeAllocator.hpp"
#include "renderer/TerrainMesh.hpp"
#include "renderer/TerrainNodeMesh.hpp"
#include "world/AnimalMesh.hpp"
#include "world/Forest.hpp"
#include "world/Habitat.hpp"
#include "world/Ground.hpp"
#include "world/GroundItem.hpp"
#include "world/Inventory.hpp"
#include "world/Knapping.hpp"
#include "world/Crafting.hpp"
#include "world/CraftMesh.hpp"
#include "world/StoneMesh.hpp"
#include "world/Bike.hpp"
#include "world/Climber.hpp"
#include "world/Needs.hpp"
#include "world/Weather.hpp"
#include "world/WaterSource.hpp"
#include "world/Deposits.hpp"
#include "world/Resin.hpp"
#include "world/FiberPlants.hpp"
#include "world/RockMesh.hpp"
#include "world/Rocks.hpp"
#include "world/BushMesh.hpp"
#include "world/Bushes.hpp"
#include "world/HarvestMesh.hpp"
#include "world/Paraglider.hpp"
#include "assets/TextureFile.hpp"
#include "assets/DetailNoise.hpp"
#include "renderer/InstanceData.hpp"
#include "world/GrassMesh.hpp"
#include "world/TerrainQuadtree.hpp"
#include "world/Vegetation.hpp"
#include "world/Wildlife.hpp"
#include "world/Tree.hpp"
#include "world/TreeMesh.hpp"
#include "world/TreeSpecies.hpp"
#include <glm/gtc/matrix_transform.hpp>
#include <algorithm>
#include <array>
#include <cmath>
#include <chrono>
#include <cstdio>
#include <cstring>
#include <thread>
#include <filesystem>
#include <fstream>
#include <limits>
#include <stdexcept>
#include <string>
#include <vector>
using namespace vercora;
namespace {
int g_checks = 0;
int g_failures = 0;
void check(bool condition, const std::string& label) {
++g_checks;
if (!condition) {
++g_failures;
std::printf(" [ECHEC] %s\n", label.c_str());
}
}
void checkNear(float actual, float expected, float tolerance, const std::string& label) {
const bool ok = std::abs(actual - expected) <= tolerance;
if (!ok) {
std::printf(" (attendu %.4f +/- %.4f, obtenu %.4f)\n", expected, tolerance, actual);
}
check(ok, label);
}
void section(const char* name) {
std::printf("\n== %s ==\n", name);
}
// Terrain plat et parfaitement previsible : les tests de collision et de
// ramassage doivent verifier LEUR logique, pas se battre avec un relief bruite.
class FlatTerrain : public HeightSampler {
public:
explicit FlatTerrain(float height = 0.0f) : height_(height) {}
float heightAt(float, float) const override { return height_; }
private:
float height_;
};
// Terrain en PENTE constante : l'altitude ne depend que de x. Deux usages, tous
// deux impossibles sur un terrain plat :
// - Phase 11 : exercer d'un coup le filtre de pente et les seuils d'altitude du
// semis de vegetation ;
// - Phase 13 : imposer EXACTEMENT la pente sous les roues du velo, dont toute
// la dynamique longitudinale depend - la deviner sur du relief bruite ne
// prouverait rien.
// slope est un RISE PAR METRE horizontal (0,20 = 20 %), positif vers +X.
class SlopedTerrain : public HeightSampler {
public:
SlopedTerrain(float base, float slope) : base_(base), slope_(slope) {}
float heightAt(float x, float) const override { return base_ + slope_ * x; }
private:
float base_;
float slope_;
};
// Fait rouler le velo jusqu'a ce que sa vitesse se stabilise (variation sous
// 1 mm/s d'un pas a l'autre), ou jusqu'a expiration. Renvoie la vitesse finale
// en m/s. C'est ce qui permet de verifier les vitesses D'EQUILIBRE annoncees
// dans world/Bike.hpp sans les recalculer a la main dans le test.
float settleSpeed(Bike& bike, const HeightSampler& terrain, float pedal, float brake,
float maxSeconds = 120.0f) {
constexpr float dt = 1.0f / 60.0f;
float previous = -1.0f;
for (float t = 0.0f; t < maxSeconds; t += dt) {
bike.update(dt, 0.0f, pedal, brake, terrain, nullptr);
if (t > 1.0f && std::abs(bike.speed() - previous) < 1e-3f * dt * 60.0f) {
break;
}
previous = bike.speed();
}
return bike.speed();
}
// Distance horizontale entre deux points.
float horizontalDistance(const glm::vec3& a, const glm::vec3& b) {
const float dx = a.x - b.x;
const float dz = a.z - b.z;
return std::sqrt(dx * dx + dz * dz);
}
// Corps de joueur debout sur un terrain a l'altitude groundY.
BodyCylinder standingBody(float x, float z, float groundY = 0.0f) {
constexpr float kEyeHeight = 1.7f;
BodyCylinder body;
body.position = { x, groundY + kEyeHeight, z };
body.radius = 0.35f;
body.feetY = groundY;
body.headY = groundY + kEyeHeight + 0.15f;
return body;
}
// Fait tourner le monde jusqu'a ce que l'arbre soit entierement debite, ou
// jusqu'a expiration. Renvoie le temps simule.
float runUntilFallen(Forest& forest, float maxSeconds, float step = 1.0f / 60.0f) {
float elapsed = 0.0f;
while (elapsed < maxSeconds) {
forest.update(step);
elapsed += step;
const bool stillMoving =
forest.trees()[0].state != TreeState::Fallen || forest.pendingDropCount() > 0;
if (!stillMoving) {
break;
}
}
return elapsed;
}
// ---------------------------------------------------------------------------
// Non-regression des phases 1 a 5
// ---------------------------------------------------------------------------
void testExistingBehaviourStillWorks() {
section("Non-regression : terrain, meshes, semis, visee, chute");
Heightmap heightmap;
check(heightmap.resolution() == 128, "Heightmap : resolution par defaut");
check(heightmap.maxHeight() > heightmap.minHeight(), "Heightmap : relief non plat");
// Reproductibilite : deux terrains de meme graine sont identiques.
Heightmap twin;
check(heightmap.heightAt(3.5f, -7.25f) == twin.heightAt(3.5f, -7.25f),
"Heightmap : meme graine, meme altitude");
const MeshData tree = treeMeshData(kTreeProportions);
const MeshData stump = stumpMeshData(kTreeProportions);
const MeshData log = logMeshData();
const MeshData branch = branchMeshData();
check(!tree.empty() && !stump.empty(), "Meshes arbre et souche non vides");
check(!log.empty() && !branch.empty(), "Meshes buche et branche non vides");
// Tout indice doit designer un sommet existant, sur TOUS les meshes generes.
// Un depassement ici ne planterait pas le CPU mais ferait lire au GPU de la
// memoire arbitraire - exactement le genre d'erreur que les couches de
// validation signalent et qu'on ne peut pas verifier sur cette machine.
for (const MeshData* mesh : { &tree, &stump, &log, &branch }) {
bool indicesValid = true;
for (const uint32_t index : mesh->indices) {
if (index >= mesh->vertices.size()) {
indicesValid = false;
break;
}
}
check(indicesValid, "Indices dans les bornes : " + mesh->name);
check(mesh->indices.size() % 3 == 0, "Indices multiples de 3 : " + mesh->name);
}
// Semis, visee, abattage.
FlatTerrain flat;
Ground ground(flat);
ForestParams params;
params.treeCount = 0; // on plante a la main pour un test deterministe
Forest forest(flat, ground, 50.0f, params);
const int index = forest.plantTree(0.0f, -10.0f, 7.0f);
check(index == 0, "plantTree renvoie l'indice du nouvel arbre");
check(forest.treeCount() == 1, "Un seul arbre plante");
// Visee depuis l'origine, regard vers -Z : l'arbre est droit devant.
const int aimed = forest.pickTree({ 0.0f, 1.7f, 0.0f }, { 0.0f, 0.0f, -1.0f }, 40.0f);
check(aimed == 0, "pickTree touche l'arbre vise");
const int missed = forest.pickTree({ 0.0f, 1.7f, 0.0f }, { 0.0f, 0.0f, 1.0f }, 40.0f);
check(missed == kNoTree, "pickTree ne touche rien dans le dos");
Clearance clearance;
check(forest.fell(0, &clearance), "fell reussit sur un arbre debout");
check(!forest.fell(0), "fell refuse un arbre deja coupe");
checkNear(glm::length(clearance.direction), 1.0f, 1e-3f,
"Direction de chute normalisee");
}
// ---------------------------------------------------------------------------
// TACHE 1.1 : collision avec les troncs et les souches
// ---------------------------------------------------------------------------
void testCollision() {
section("Tache 1.1 : collision troncs et souches");
FlatTerrain flat;
Ground ground(flat);
ForestParams params;
params.treeCount = 0;
Forest forest(flat, ground, 50.0f, params);
forest.plantTree(0.0f, 0.0f, 7.0f);
const Tree& tree = forest.trees()[0];
const float trunkRadius = tree.trunkRadius();
const float bodyRadius = 0.35f;
const float contactDistance = trunkRadius + bodyRadius;
// 1. Loin du tronc : aucune correction.
{
const BodyCylinder body = standingBody(10.0f, 10.0f);
const glm::vec3 out = forest.resolve(body);
check(out == body.position, "Loin de tout : position inchangee");
}
// 2. Dans le tronc : repousse exactement au contact.
{
const BodyCylinder body = standingBody(0.05f, 0.0f);
const glm::vec3 out = forest.resolve(body);
const float distance = horizontalDistance(out, tree.base);
checkNear(distance, contactDistance, 1e-3f,
"Dans le tronc : repousse pile au contact");
check(out.y == body.position.y, "Collision : la verticale n'est pas touchee");
}
// 3. Pile sur l'axe du tronc : cas degenere, pas de NaN, repousse quand meme.
{
const BodyCylinder body = standingBody(0.0f, 0.0f);
const glm::vec3 out = forest.resolve(body);
check(!std::isnan(out.x) && !std::isnan(out.z), "Cas degenere : aucun NaN");
checkNear(horizontalDistance(out, tree.base), contactDistance, 1e-3f,
"Cas degenere : repousse au contact");
}
// 4. Juste en dehors du rayon de contact : rien ne bouge.
{
const BodyCylinder body = standingBody(contactDistance + 0.01f, 0.0f);
const glm::vec3 out = forest.resolve(body);
checkNear(out.x, contactDistance + 0.01f, 1e-4f,
"Juste en dehors : position inchangee");
}
// 5. Le houppier ne bloque pas : un corps place tres haut, au-dessus de la
// cime, ne doit plus rien rencontrer.
{
BodyCylinder body = standingBody(0.0f, 0.0f);
body.feetY = tree.base.y + tree.height + 1.0f;
body.headY = body.feetY + 1.85f;
const glm::vec3 out = forest.resolve(body);
check(out == body.position, "Au-dessus de la cime : pas de collision");
}
// 6. Souche : une fois l'arbre entierement debite, l'obstacle se reduit a la
// souche. Les pieds sont bloques...
{
forest.fell(0);
runUntilFallen(forest, 12.0f);
check(forest.trees()[0].state == TreeState::Fallen,
"L'arbre finit par atteindre l'etat Fallen");
const BodyCylinder body = standingBody(0.05f, 0.0f);
const glm::vec3 out = forest.resolve(body);
checkNear(horizontalDistance(out, tree.base), contactDistance, 1e-3f,
"Souche : le joueur ne la traverse pas");
}
// 7. ... mais le volume au-dessus de la souche est libre : un corps dont les
// pieds sont plus haut que la souche passe.
{
const Tree& felled = forest.trees()[0];
BodyCylinder body = standingBody(0.05f, 0.0f);
body.feetY = felled.base.y + felled.stumpHeight() + 0.05f;
body.headY = body.feetY + 1.85f;
const glm::vec3 out = forest.resolve(body);
check(out == body.position, "Au-dessus de la souche : plus d'obstacle");
}
// 8. Glissement : un joueur pousse contre le tronc mais decale lateralement
// doit ressortir decale du meme cote, pas rejete a l'oppose.
{
Ground ground2(flat);
Forest forest2(flat, ground2, 50.0f, params);
forest2.plantTree(0.0f, 0.0f, 7.0f);
const BodyCylinder body = standingBody(0.10f, 0.20f);
const glm::vec3 out = forest2.resolve(body);
check(out.x > 0.0f && out.z > 0.0f, "Glissement : repousse du bon cote");
checkNear(horizontalDistance(out, glm::vec3(0.0f)), contactDistance, 1e-3f,
"Glissement : ressort au contact");
}
// 9. MARCHE reelle vers un passage trop etroit. C'est le vrai scenario de
// jeu, et le seul qui compte : le joueur avance pas a pas, la collision
// etant resolue a chaque pas. Il ne doit JAMAIS finir a l'interieur d'un
// tronc, meme en poussant contre un entre-deux infranchissable.
//
// Deux troncs distants de 1.2 m et larges de 0.63 m laissent un passage
// de 0.57 m, alors que le joueur en fait 0.70 : le passage est
// geometriquement infranchissable, et c'est voulu - on veut verifier que
// la collision refuse proprement, pas qu'elle laisse passer.
{
Ground ground3(flat);
Forest forest3(flat, ground3, 50.0f, params);
forest3.plantTree(-0.6f, 0.0f, 7.0f);
forest3.plantTree(0.6f, 0.0f, 7.0f);
glm::vec3 position{ 0.0f, 1.7f, 4.0f };
bool everInsideATrunk = false;
bool everNaN = false;
// 200 pas de 5 cm droit vers -Z : de quoi traverser largement, si la
// collision ne faisait pas son travail. On passe par moveBody, comme la
// camera : c'est lui qui garantit qu'on ne franchit pas un passage plus
// etroit que soi.
for (int step = 0; step < 200; ++step) {
const glm::vec3 previous = position;
position.z -= 0.05f;
BodyCylinder body = standingBody(position.x, position.z);
body.position = position;
position = moveBody(forest3, body, previous);
if (std::isnan(position.x) || std::isnan(position.z)) {
everNaN = true;
break;
}
for (const Tree& other : forest3.trees()) {
if (horizontalDistance(position, other.base) <
other.trunkRadius() + 0.35f - 1e-3f) {
everInsideATrunk = true;
}
}
}
check(!everNaN, "Marche : aucun NaN sur 200 pas");
check(!everInsideATrunk, "Marche : jamais a l'interieur d'un tronc");
check(position.z > -0.6f,
"Marche : le passage trop etroit n'est pas franchi");
}
// 10. Le meme passage, mais assez large pour passer : la collision ne doit
// pas bloquer un joueur qui a la place de se faufiler.
{
Ground ground4(flat);
Forest forest4(flat, ground4, 50.0f, params);
forest4.plantTree(-1.6f, 0.0f, 7.0f);
forest4.plantTree(1.6f, 0.0f, 7.0f);
glm::vec3 position{ 0.0f, 1.7f, 4.0f };
for (int step = 0; step < 200; ++step) {
const glm::vec3 previous = position;
position.z -= 0.05f;
BodyCylinder body = standingBody(position.x, position.z);
body.position = position;
position = moveBody(forest4, body, previous);
}
check(position.z < -4.0f, "Marche : un passage assez large se franchit");
}
// 11. L'exigence de base, de bout en bout : marcher droit sur un tronc doit
// s'arreter dessus. C'est litteralement ce que la Phase 5 ne faisait pas.
{
Ground ground5(flat);
Forest forest5(flat, ground5, 50.0f, params);
forest5.plantTree(0.0f, 0.0f, 7.0f);
const float stopDistance = forest5.trees()[0].trunkRadius() + 0.35f;
glm::vec3 position{ 0.0f, 1.7f, 4.0f };
for (int step = 0; step < 200; ++step) {
const glm::vec3 previous = position;
position.z -= 0.05f;
BodyCylinder body = standingBody(position.x, position.z);
body.position = position;
position = moveBody(forest5, body, previous);
}
check(position.z > 0.0f, "Marche : le tronc arrete le joueur");
checkNear(horizontalDistance(position, glm::vec3(0.0f)), stopDistance, 0.06f,
"Marche : le joueur s'arrete au contact du tronc");
}
// 12. Une souche, elle, arrete aussi le joueur (exigence explicite), et
// resolve()/overlaps() doivent etre d'accord sur leur propre sortie.
{
Ground ground6(flat);
Forest forest6(flat, ground6, 50.0f, params);
forest6.plantTree(0.0f, 0.0f, 7.0f);
forest6.fell(0);
runUntilFallen(forest6, 12.0f);
glm::vec3 position{ 0.0f, 1.7f, 4.0f };
for (int step = 0; step < 200; ++step) {
const glm::vec3 previous = position;
position.z -= 0.05f;
BodyCylinder body = standingBody(position.x, position.z);
body.position = position;
position = moveBody(forest6, body, previous);
}
check(position.z > 0.0f, "Marche : la souche arrete le joueur");
BodyCylinder settled = standingBody(position.x, position.z);
settled.position = position;
check(!forest6.overlaps(settled),
"overlaps() et resolve() sont d'accord sur la position finale");
}
}
// ---------------------------------------------------------------------------
// TACHE 1.2 : ramassage reel des buches et branches
// ---------------------------------------------------------------------------
void testPickup() {
section("Tache 1.2 : ramassage et inventaire");
FlatTerrain flat(12.0f);
Ground ground(flat);
check(ground.itemCount() == 0, "Sol vide au depart");
ground.drop(GroundItemKind::Log, 2.0f, 0.0f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Branch, 20.0f, 0.0f, 0.0f, 0.0f);
check(ground.itemCount() == 2, "Deux objets deposes");
// Depose sur le terrain, pas dedans ni au-dessus.
checkNear(ground.items()[0].position.y, 12.0f + kLogRadius, 1e-4f,
"Buche posee sur la surface du terrain");
const glm::vec3 player{ 0.0f, 13.7f, 0.0f };
// Hors de portee : rien.
check(ground.findNearest(player, 1.0f) == kNoGroundItem,
"Rien a portee de 1 m");
// A portee : la buche, pas la branche lointaine.
const int nearest = ground.findNearest(player, 3.0f);
check(nearest != kNoGroundItem, "Buche trouvee a portee de 3 m");
GroundItemKind picked = GroundItemKind::Stone;
check(ground.pickUp(nearest, &picked), "Ramassage reussi");
check(picked == GroundItemKind::Log, "L'objet ramasse est bien la buche");
check(ground.itemCount() == 1, "L'objet a disparu de la scene");
// Le meme indice ne doit plus rien donner de valide au-dela de la taille.
check(!ground.pickUp(5), "Indice hors bornes refuse");
check(!ground.pickUp(-1), "Indice negatif refuse");
// Inventaire.
Inventory inventory;
check(inventory.total() == 0, "Inventaire vide au depart");
inventory.add(picked);
check(inventory.count(GroundItemKind::Log) == 1, "Une buche comptee");
check(inventory.total() == 1, "Total d'inventaire coherent");
check(!inventory.remove(GroundItemKind::Log, 2), "Retrait impossible refuse");
check(inventory.count(GroundItemKind::Log) == 1,
"Un retrait refuse ne modifie rien");
check(inventory.remove(GroundItemKind::Log), "Retrait possible accepte");
check(inventory.total() == 0, "Inventaire vide apres retrait");
// Le resume doit nommer les quatre natures : c'est ce qui s'affiche dans le
// titre de la fenetre.
const std::string summary = inventory.summary();
check(summary.find("buches") != std::string::npos, "Resume : buches");
check(summary.find("branches") != std::string::npos, "Resume : branches");
check(summary.find("pierres") != std::string::npos, "Resume : pierres");
check(summary.find("eclats") != std::string::npos, "Resume : eclats");
// Ramassage a repetition : tout doit pouvoir etre vide sans trou ni doublon
// (le pickUp par echange avec le dernier element est un piege classique).
{
Ground bulk(flat);
for (int i = 0; i < 10; ++i) {
bulk.drop(GroundItemKind::Stone, static_cast<float>(i) * 0.1f, 0.0f, 0.0f, 0.0f);
}
int collected = 0;
while (true) {
const int index = bulk.findNearest({ 0.0f, 13.7f, 0.0f }, 50.0f);
if (index == kNoGroundItem) {
break;
}
if (!bulk.pickUp(index)) {
break;
}
++collected;
}
check(collected == 10, "Les 10 objets sont tous ramassables");
check(bulk.itemCount() == 0, "Sol vide apres ramassage complet");
}
}
// ---------------------------------------------------------------------------
// TACHE 1.3 : transition de chute et debitage progressif
// ---------------------------------------------------------------------------
void testProgressiveFall() {
section("Tache 1.3 : chute, amortissement, debitage progressif");
FlatTerrain flat;
Ground ground(flat);
ForestParams params;
params.treeCount = 0;
Forest forest(flat, ground, 50.0f, params);
forest.plantTree(0.0f, 0.0f, 7.0f);
check(forest.trees()[0].state == TreeState::Standing, "Arbre debout au depart");
forest.fell(0);
check(forest.trees()[0].state == TreeState::Falling, "Arbre en chute apres fell");
constexpr float kStep = 1.0f / 60.0f;
// Phase 1 : la bascule. Rien ne doit tomber au sol pendant ce temps.
float elapsed = 0.0f;
while (forest.trees()[0].state == TreeState::Falling && elapsed < 10.0f) {
forest.update(kStep);
elapsed += kStep;
}
check(forest.trees()[0].state == TreeState::Settling,
"La chute debouche sur l'amortissement, pas sur la disparition");
check(ground.itemCount() == 0, "Aucun bois au sol pendant la chute");
check(elapsed < 4.0f, "La chute dure un temps raisonnable");
// Phase 2 : l'amortissement. L'arbre est TOUJOURS dessine (state != Fallen)
// et reste couche, jamais au-dessus de l'horizontale.
constexpr float kHalfPi = 1.57079632679f;
float settlingFrames = 0.0f;
bool stayedBelowHorizontal = true;
while (forest.trees()[0].state == TreeState::Settling && settlingFrames < 5.0f) {
forest.update(kStep);
settlingFrames += kStep;
if (forest.trees()[0].fallAngle > kHalfPi + 1e-4f) {
stayedBelowHorizontal = false;
}
}
check(settlingFrames > 0.3f, "L'arbre reste visible au sol un temps lisible");
check(stayedBelowHorizontal,
"L'amortissement ne fait jamais repasser l'arbre sous terre");
check(forest.trees()[0].state == TreeState::Fallen,
"L'amortissement debouche sur le debitage");
// Phase 3 : le debitage. Les pieces arrivent une par une, pas toutes d'un
// coup - c'est precisement le defaut de la Phase 5 qu'on corrige ici.
const std::size_t afterFirstFrame = ground.itemCount();
check(afterFirstFrame >= 1, "La premiere buche sort des la disparition du tronc");
check(forest.pendingDropCount() > 0, "Il reste du bois a degager");
check(afterFirstFrame < 7, "Le bois n'apparait PAS tout d'un coup");
// On laisse le debitage se terminer.
int distinctCounts = 0;
std::size_t previous = afterFirstFrame;
float buckingTime = 0.0f;
while (forest.pendingDropCount() > 0 && buckingTime < 10.0f) {
forest.update(kStep);
buckingTime += kStep;
if (ground.itemCount() != previous) {
++distinctCounts;
previous = ground.itemCount();
}
}
check(forest.pendingDropCount() == 0, "Tout le bois a fini par tomber");
check(distinctCounts >= 3, "Le bois est apparu en plusieurs fois");
check(buckingTime > 0.3f, "Le debitage s'etale dans le temps");
// Un arbre de 7 m : 2 buches (7/2.4 = 2) et 4 branches.
const int logs = static_cast<int>(7.0f / 2.4f);
check(ground.itemCount() == static_cast<std::size_t>(logs + 4),
"Nombre total de pieces conforme");
int logCount = 0;
int branchCount = 0;
for (const GroundItem& item : ground.items()) {
if (item.kind == GroundItemKind::Log) ++logCount;
if (item.kind == GroundItemKind::Branch) ++branchCount;
}
check(logCount == logs, "Le bon nombre de buches");
check(branchCount == 4, "Le bon nombre de branches");
// Plus rien ne doit bouger une fois tout retombe.
const std::size_t settled = ground.itemCount();
for (int i = 0; i < 120; ++i) {
forest.update(kStep);
}
check(ground.itemCount() == settled, "Etat stable apres debitage");
}
// ---------------------------------------------------------------------------
// TACHE 2 : pierres et taillage par percussion
// ---------------------------------------------------------------------------
void testStoneKnapping() {
section("Tache 2 : pierres ramassables et percussion");
// Meshes generes en code.
const MeshData stone = stoneMeshData();
const MeshData flake = flakeMeshData();
check(!stone.empty(), "Mesh de pierre non vide");
check(!flake.empty(), "Mesh d'eclat non vide");
check(stone.indices.size() % 3 == 0, "Pierre : indices multiples de 3");
check(flake.indices.size() % 3 == 0, "Eclat : indices multiples de 3");
for (const MeshData* mesh : { &stone, &flake }) {
bool indicesValid = true;
bool normalsUnit = true;
bool withinBounds = true;
for (const uint32_t index : mesh->indices) {
if (index >= mesh->vertices.size()) {
indicesValid = false;
break;
}
}
for (const Vertex& vertex : mesh->vertices) {
if (std::abs(glm::length(vertex.normal) - 1.0f) > 1e-3f) {
normalsUnit = false;
}
// Un objet ramassable doit tenir dans un volume de la taille d'une
// main : une erreur d'echelle donnerait un rocher de 3 m qu'on
// ramasserait quand meme, sans que rien ne le signale.
if (std::abs(vertex.pos.x) > 0.4f || std::abs(vertex.pos.y) > 0.4f ||
std::abs(vertex.pos.z) > 0.4f) {
withinBounds = false;
}
}
check(indicesValid, "Indices dans les bornes : " + mesh->name);
check(normalsUnit, "Normales unitaires : " + mesh->name);
check(withinBounds, "Dimensions plausibles : " + mesh->name);
}
// Semis de pierres.
FlatTerrain flat;
Ground ground(flat);
const uint32_t placed = ground.scatterStones(2, 20.0f, 4.0f, 50.0f);
check(placed == 2, "Les deux pierres demandees sont semees");
check(ground.itemCount() == 2, "Deux objets au sol");
bool allStones = true;
bool allReachable = true;
for (const GroundItem& item : ground.items()) {
if (item.kind != GroundItemKind::Stone) allStones = false;
const float distance = std::sqrt(item.position.x * item.position.x +
item.position.z * item.position.z);
if (distance < 4.0f || distance > 20.0f) allReachable = false;
}
check(allStones, "Les objets semes sont bien des pierres");
check(allReachable, "Pierres semees dans la couronne demandee");
checkNear(ground.items()[0].position.y, kStoneRadius, 1e-4f,
"Pierre posee sur la surface du terrain");
// Percussion.
Inventory inventory;
const glm::vec3 player{ 0.0f, 1.7f, 0.0f };
const glm::vec3 facing{ 0.0f, -0.2f, -1.0f }; // regard vers -Z, legerement baisse
check(knapStones(inventory, ground, player, facing) == KnapResult::NotEnoughStones,
"Percussion refusee sans pierre");
inventory.add(GroundItemKind::Stone);
check(knapStones(inventory, ground, player, facing) == KnapResult::NotEnoughStones,
"Percussion refusee avec une seule pierre");
check(inventory.count(GroundItemKind::Stone) == 1,
"Un echec ne consomme aucune pierre");
inventory.add(GroundItemKind::Stone);
const std::size_t beforeKnap = ground.itemCount();
check(knapStones(inventory, ground, player, facing) == KnapResult::Success,
"Percussion reussie avec deux pierres");
check(inventory.count(GroundItemKind::Stone) == 1,
"La percussion consomme exactement une pierre");
check(ground.itemCount() == beforeKnap + 1, "Un objet est apparu dans le monde");
// L'eclat existe dans le MONDE (et non dans l'inventaire), devant le joueur.
const GroundItem& produced = ground.items().back();
check(produced.kind == GroundItemKind::Flake, "L'objet produit est un eclat");
check(inventory.count(GroundItemKind::Flake) == 0,
"L'eclat n'atterrit pas directement dans l'inventaire");
check(produced.position.z < player.z, "L'eclat tombe devant le joueur (vers -Z)");
checkNear(horizontalDistance(produced.position, player), 1.1f, 1e-3f,
"L'eclat tombe a portee de bras");
// ... et il est ramassable comme n'importe quoi d'autre.
const int index = ground.findNearest(player, 2.0f);
check(index != kNoGroundItem, "L'eclat est a portee de ramassage");
GroundItemKind kind = GroundItemKind::Log;
check(ground.pickUp(index, &kind) && kind == GroundItemKind::Flake,
"L'eclat se ramasse");
// Regard parfaitement vertical : cas degenere, aucun NaN dans la position.
{
Inventory vertical;
vertical.add(GroundItemKind::Stone, 2);
Ground groundVertical(flat);
check(knapStones(vertical, groundVertical, player, { 0.0f, -1.0f, 0.0f }) ==
KnapResult::Success,
"Percussion possible en regardant ses pieds");
const GroundItem& item = groundVertical.items().back();
check(!std::isnan(item.position.x) && !std::isnan(item.position.z),
"Regard vertical : aucun NaN dans la position de l'eclat");
}
}
// ---------------------------------------------------------------------------
// Construction de la liste d'objets a dessiner
// ---------------------------------------------------------------------------
// main.cpp ne peut PAS etre compile par ce harnais : il tire le Renderer, donc
// Vulkan. Mais DrawItem, lui, ne depend que de GLM - on peut donc rejouer ici la
// partie la plus facile a casser de la boucle de rendu (quel objet est dessine
// dans quel etat, et avec quel mesh) et verifier qu'elle tient.
//
// Ce test ne prouve pas que main.cpp compile. Il prouve que la LOGIQUE qu'il
// applique est correcte, ce qui est le principal risque a cet endroit.
void testDrawListConstruction() {
section("Rendu : composition de la liste d'objets");
FlatTerrain flat;
Ground ground(flat);
ForestParams params;
params.treeCount = 0;
Forest forest(flat, ground, 50.0f, params);
forest.plantTree(0.0f, -8.0f, 7.0f);
// Table mesh-par-nature, exactement comme dans main.cpp : c'est le passage
// ou un oubli donnerait un kInvalidMesh envoye au Renderer.
std::array<MeshHandle, kGroundItemKindCount> groundMeshes{};
groundMeshes.fill(kInvalidMesh);
groundMeshes[static_cast<std::size_t>(GroundItemKind::Log)] = 10;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Branch)] = 11;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Stone)] = 12;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Flake)] = 13;
// PHASE 22 : les quatre matieres ajoutees doivent elles aussi avoir leur
// mesh. C'est CE test qui a signale leur oubli quand l'enum a grandi.
groundMeshes[static_cast<std::size_t>(GroundItemKind::Clay)] = 14;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Sand)] = 15;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Resin)] = 16;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Fiber)] = 17;
// PHASE 28 : les cinq objets faconnes, comme dans main.cpp.
groundMeshes[static_cast<std::size_t>(GroundItemKind::Cord)] = 18;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Axe)] = 19;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Hearth)] = 20;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Ash)] = 21;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Pitch)] = 22;
// PHASE 28 (Agent 3) : hache renforcee et abri.
groundMeshes[static_cast<std::size_t>(GroundItemKind::PitchedAxe)] = 23;
groundMeshes[static_cast<std::size_t>(GroundItemKind::Shelter)] = 24;
bool everyKindHasAMesh = true;
for (const MeshHandle handle : groundMeshes) {
if (handle == kInvalidMesh) {
everyKindHasAMesh = false;
}
}
check(everyKindHasAMesh,
"Chaque nature d'objet au sol a son mesh (aucun trou dans la table)");
constexpr MeshHandle kTreeMesh = 1;
constexpr MeshHandle kStumpMesh = 2;
// Reproduit la boucle de main.cpp.
const auto buildDrawItems = [&]() {
std::vector<DrawItem> items;
for (const Tree& tree : forest.trees()) {
if (tree.state != TreeState::Standing) {
items.push_back({ kStumpMesh, tree.stumpMatrix(), Material::Object });
}
if (tree.state != TreeState::Fallen) {
items.push_back({ kTreeMesh, tree.modelMatrix(), Material::Object });
}
}
for (const GroundItem& item : ground.items()) {
const MeshHandle mesh = groundMeshes[static_cast<std::size_t>(item.kind)];
if (mesh != kInvalidMesh) {
items.push_back({ mesh, item.modelMatrix(), Material::Object });
}
}
return items;
};
// Debout : l'arbre seul, pas de souche.
{
const std::vector<DrawItem> items = buildDrawItems();
check(items.size() == 1, "Arbre debout : un seul objet dessine");
check(items[0].mesh == kTreeMesh, "Arbre debout : c'est le mesh d'arbre");
}
constexpr float kStep = 1.0f / 60.0f;
forest.fell(0);
// En chute : souche + arbre incline. C'est ce couple qui rend le trait de
// coupe lisible.
forest.update(kStep);
{
const std::vector<DrawItem> items = buildDrawItems();
check(items.size() == 2, "Arbre en chute : souche + arbre");
}
// Amortissement : l'arbre est TOUJOURS dessine. C'est tout l'objet de la
// Tache 1.3 - en Phase 5 il avait deja disparu a cet instant.
while (forest.trees()[0].state == TreeState::Falling) {
forest.update(kStep);
}
{
const std::vector<DrawItem> items = buildDrawItems();
check(forest.trees()[0].state == TreeState::Settling, "Etat Settling atteint");
check(items.size() == 2, "Arbre couche en amortissement : encore dessine");
check(ground.items().empty(), "Amortissement : rien encore au sol");
}
// Debitage termine : plus d'arbre, une souche, et tout le bois.
runUntilFallen(forest, 12.0f);
{
const std::vector<DrawItem> items = buildDrawItems();
const std::size_t expected = 1 + ground.items().size(); // souche + bois
check(items.size() == expected, "Arbre debite : souche + tout le bois");
bool anyTreeMesh = false;
bool allHandlesValid = true;
for (const DrawItem& item : items) {
if (item.mesh == kTreeMesh) anyTreeMesh = true;
if (item.mesh == kInvalidMesh) allHandlesValid = false;
}
check(!anyTreeMesh, "Arbre debite : le mesh d'arbre n'est plus dessine");
check(allHandlesValid, "Aucun mesh invalide envoye au rendu");
}
// Les matrices d'instance doivent rester finies : un NaN dans une model
// matrix ne fait pas planter le CPU, il fait disparaitre l'objet a l'ecran
// (ou pire, tout l'ecran) sans le moindre message.
{
ground.drop(GroundItemKind::Stone, 3.0f, 4.0f, 1.2f, 0.4f);
const std::vector<DrawItem> items = buildDrawItems();
bool allFinite = true;
for (const DrawItem& item : items) {
for (int column = 0; column < 4; ++column) {
for (int row = 0; row < 4; ++row) {
if (std::isnan(item.model[column][row]) ||
std::isinf(item.model[column][row])) {
allFinite = false;
}
}
}
}
check(allFinite, "Toutes les matrices d'instance sont finies");
}
}
// ---------------------------------------------------------------------------
// PHASE 7 : heightmap chargee depuis un fichier .vchm (donnees LiDAR reelles)
// ---------------------------------------------------------------------------
// La grille de test est construite ICI, octet par octet, plutot que lue depuis
// assets/ : le harnais reste ainsi executable sur un depot frais, ou les 4 Mo de
// heightmap et les 167 Mo de nuage de points ne sont pas versionnes. Le vrai
// fichier, s'il est present, est verifie en plus a la fin.
constexpr std::size_t kVchmHeaderSize = 120;
// Ecrit un .vchm minimal. Reproduit le format decrit dans TerrainFile.hpp, sans
// rien partager avec le lecteur : une erreur de decalage dans l'un ne peut pas
// se compenser dans l'autre.
void writeVchm(const std::filesystem::path& path, uint32_t nx, uint32_t nz,
float spacing, const std::vector<float>& heights,
const char* label = "grille de test",
uint32_t version = 1, const char* magic = "VCHM",
double originEast = 907000.0, double originNorth = 6440000.0,
uint32_t epsg = 2154, uint32_t flags = 1,
bool lieAboutBounds = false) {
unsigned char header[kVchmHeaderSize] = {};
std::memcpy(header + 0, magic, 4);
std::memcpy(header + 4, &version, 4);
std::memcpy(header + 8, &nx, 4);
std::memcpy(header + 12, &nz, 4);
std::memcpy(header + 16, &spacing, 4);
std::memcpy(header + 24, &originEast, 8);
std::memcpy(header + 32, &originNorth, 8);
float lo = heights.empty() ? 0.0f : heights[0];
float hi = lo;
for (float h : heights) { lo = std::min(lo, h); hi = std::max(hi, h); }
if (lieAboutBounds) { lo -= 100.0f; hi += 100.0f; }
std::memcpy(header + 40, &lo, 4);
std::memcpy(header + 44, &hi, 4);
std::memcpy(header + 48, &epsg, 4);
std::memcpy(header + 52, &flags, 4);
std::memcpy(header + 56, label, std::min<std::size_t>(std::strlen(label), 63));
std::ofstream out(path, std::ios::binary | std::ios::trunc);
out.write(reinterpret_cast<const char*>(header), kVchmHeaderSize);
out.write(reinterpret_cast<const char*>(heights.data()),
static_cast<std::streamsize>(heights.size() * sizeof(float)));
}
// true si loadTerrainFile refuse le fichier. Un fichier casse DOIT lever :
// charger un terrain a moitie faux et s'en apercevoir a l'ecran est exactement
// ce que ces gardes-fous evitent.
bool rejects(const std::filesystem::path& path) {
try {
loadTerrainFile(path.string());
return false;
} catch (const std::exception&) {
return true;
}
}
void testTerrainFile() {
section("Phase 7 : heightmap LiDAR chargee depuis un fichier .vchm");
const std::filesystem::path dir =
std::filesystem::temp_directory_path() / "vercora_tests";
std::filesystem::create_directories(dir);
// Grille ASYMETRIQUE dans les deux directions, et avec des coefficients
// differents sur chaque axe : c'est ce qui rend un axe inverse ou deux axes
// echanges detectables. Une grille symetrique passerait tous les tests
// ci-dessous meme lue de travers.
const uint32_t n = 5;
const float spacing = 2.0f;
std::vector<float> heights(static_cast<std::size_t>(n) * n);
for (uint32_t iz = 0; iz < n; ++iz) {
for (uint32_t ix = 0; ix < n; ++ix) {
heights[static_cast<std::size_t>(iz) * n + ix] =
400.0f + static_cast<float>(ix) + 10.0f * static_cast<float>(iz);
}
}
const std::filesystem::path good = dir / "good.vchm";
writeVchm(good, n, n, spacing, heights, "dalle de test");
{
const Heightmap loaded = loadTerrainFile(good.string());
check(loaded.resolution() == n, "Fichier : resolution relue");
checkNear(loaded.spacing(), spacing, 1e-6f, "Fichier : pas relu");
// worldSize DECOULE du pas : (n - 1) cellules de 2 m = 8 m.
checkNear(loaded.worldSize(), 8.0f, 1e-6f, "Fichier : emprise deduite du pas");
checkNear(loaded.minHeight(), 400.0f, 1e-4f, "Fichier : altitude minimale");
checkNear(loaded.maxHeight(), 444.0f, 1e-4f, "Fichier : altitude maximale");
check(loaded.describe() == "dalle de test", "Fichier : label repris dans describe()");
// Indexation : at(ix, iz), donc l'altitude doit croitre de 1 vers l'est
// et de 10 vers le sud. Inverser les deux boucles de lecture donnerait
// ici 10 et 1 - le test discrimine.
checkNear(loaded.at(0, 0), 400.0f, 1e-4f, "Fichier : coin (0,0)");
checkNear(loaded.at(4, 0), 404.0f, 1e-4f, "Fichier : +1 par pas vers l'est");
checkNear(loaded.at(0, 4), 440.0f, 1e-4f, "Fichier : +10 par pas vers le sud");
checkNear(loaded.at(4, 4), 444.0f, 1e-4f, "Fichier : coin oppose");
// Le terrain est centre sur l'origine : l'echantillon (0,0) est donc en
// (-4, -4) et le dernier en (+4, +4).
checkNear(loaded.worldCoord(0), -4.0f, 1e-6f, "Fichier : bord ouest a -worldSize/2");
checkNear(loaded.worldCoord(4), 4.0f, 1e-6f, "Fichier : bord est a +worldSize/2");
checkNear(loaded.heightAt(-4.0f, -4.0f), 400.0f, 1e-4f,
"Fichier : heightAt au coin nord-ouest");
checkNear(loaded.heightAt(4.0f, 4.0f), 444.0f, 1e-4f,
"Fichier : heightAt au coin sud-est");
// Milieu d'une cellule : l'interpolation affine doit donner la moyenne
// exacte des deux extremites sur cette grille lineaire.
checkNear(loaded.heightAt(-3.0f, -4.0f), 400.5f, 1e-4f,
"Fichier : heightAt interpole entre deux echantillons");
// Georeferencement.
check(loaded.geo().isGeoreferenced(), "Fichier : grille georeferencee");
check(loaded.geo().epsg == 2154, "Fichier : EPSG relu");
check(loaded.geo().absoluteAltitude, "Fichier : drapeau d'altitude absolue");
// toProjected : le centre du monde tombe au centre de la dalle, et les
// deux axes ont des SIGNES OPPOSES en projection (est croissant, nord
// decroissant). C'est la seule verification ecrite de cette regle.
double east = 0.0, north = 0.0;
loaded.toProjected(0.0f, 0.0f, &east, &north);
checkNear(static_cast<float>(east), 907004.0f, 1e-2f,
"toProjected : centre, coordonnee est");
checkNear(static_cast<float>(north), 6439996.0f, 1e-2f,
"toProjected : centre, coordonnee nord");
loaded.toProjected(-4.0f, -4.0f, &east, &north);
checkNear(static_cast<float>(east), 907000.0f, 1e-2f,
"toProjected : coin nord-ouest = origine du fichier (est)");
checkNear(static_cast<float>(north), 6440000.0f, 1e-2f,
"toProjected : coin nord-ouest = origine du fichier (nord)");
loaded.toProjected(4.0f, 4.0f, &east, &north);
checkNear(static_cast<float>(east), 907008.0f, 1e-2f,
"toProjected : aller a l'est AUGMENTE l'abscisse projetee");
checkNear(static_cast<float>(north), 6439992.0f, 1e-2f,
"toProjected : aller au sud (+Z) DIMINUE l'ordonnee projetee");
// Le maillage reste celui de la Phase 4, sans adaptation : c'etait tout
// l'interet de faire passer les donnees par Heightmap.
const MeshData mesh = terrainMeshData(loaded);
check(mesh.vertices.size() == static_cast<std::size_t>(n) * n,
"TerrainMesh : un sommet par echantillon");
check(mesh.triangleCount() == (n - 1) * (n - 1) * 2,
"TerrainMesh : deux triangles par cellule");
check(mesh.name == "dalle de test", "TerrainMesh : nom repris de la heightmap");
bool posMatches = true;
for (uint32_t iz = 0; iz < n; ++iz) {
for (uint32_t ix = 0; ix < n; ++ix) {
const Vertex& v = mesh.vertices[static_cast<std::size_t>(iz) * n + ix];
if (std::abs(v.pos.y - loaded.at(ix, iz)) > 1e-4f) { posMatches = false; }
}
}
check(posMatches, "TerrainMesh : altitude de chaque sommet = celle de la grille");
}
// --- Fichiers refuses ---------------------------------------------------
{
const std::filesystem::path bad = dir / "bad.vchm";
writeVchm(bad, n, n, spacing, heights, "x", 1, "NOPE");
check(rejects(bad), "Refus : magie incorrecte");
writeVchm(bad, n, n, spacing, heights, "x", 99);
check(rejects(bad), "Refus : version inconnue");
// Grille rectangulaire : limite assumee, mais elle doit etre SIGNALEE.
std::vector<float> rect(static_cast<std::size_t>(n) * (n + 1), 1.0f);
writeVchm(bad, n, n + 1, spacing, rect);
check(rejects(bad), "Refus : grille non carree");
writeVchm(bad, n, n, 0.0f, heights);
check(rejects(bad), "Refus : pas de grille nul");
writeVchm(bad, 1, 1, spacing, std::vector<float>{1.0f});
check(rejects(bad), "Refus : grille d'un seul echantillon");
// Tronque : l'en-tete annonce 25 altitudes, le fichier n'en contient
// que 10. Sans le controle de taille, on lirait des zeros en silence.
writeVchm(bad, n, n, spacing, heights);
std::filesystem::resize_file(bad, kVchmHeaderSize + 10 * sizeof(float));
check(rejects(bad), "Refus : fichier tronque");
// NaN : le cas typique d'une cellule sans point de retour mal traitee en
// amont. Un seul suffit a produire un triangle degenere.
std::vector<float> withNan = heights;
withNan[7] = std::numeric_limits<float>::quiet_NaN();
writeVchm(bad, n, n, spacing, withNan);
check(rejects(bad), "Refus : altitude NaN");
check(rejects(dir / "ce-fichier-n-existe-pas.vchm"), "Refus : fichier absent");
// En-tete qui ment sur les bornes : accepte (les donnees font foi) mais
// doit produire un avertissement. On verifie au moins que ca ne casse pas.
writeVchm(bad, n, n, spacing, heights, "bornes fausses", 1, "VCHM",
907000.0, 6440000.0, 2154, 1, /*lieAboutBounds=*/true);
bool loadedDespiteBadBounds = false;
try {
const Heightmap h = loadTerrainFile(bad.string());
loadedDespiteBadBounds = (std::abs(h.minHeight() - 400.0f) < 1e-4f);
} catch (const std::exception&) {}
check(loadedDespiteBadBounds,
"Bornes d'en-tete fausses : les DONNEES font foi, le chargement passe");
}
std::filesystem::remove_all(dir);
// --- La vraie dalle, si elle a ete produite ------------------------------
// Conditionnel a dessein : le depot ne versionne pas les 4 Mo de heightmap.
// Quand elle est la, ce bloc est le seul test qui touche de VRAIES donnees.
const std::filesystem::path realTile =
std::filesystem::path(ASSETS_DIR) / "terrain" / "LHD_0907_6440_1m.vchm";
if (!std::filesystem::exists(realTile)) {
std::printf(" (dalle reelle absente, bloc ignore : %s)\n",
realTile.string().c_str());
return;
}
const Heightmap tile = loadTerrainFile(realTile.string());
check(tile.resolution() == 1001, "Dalle reelle : 1001 echantillons par cote");
checkNear(tile.spacing(), 1.0f, 1e-6f, "Dalle reelle : pas de 1 m");
checkNear(tile.worldSize(), 1000.0f, 1e-3f, "Dalle reelle : emprise de 1 km");
check(tile.geo().epsg == 2154, "Dalle reelle : Lambert 93");
// Altitudes plausibles pour un relief de moyenne montagne, et surtout un
// denivele qui exclut un terrain plat par erreur de lecture.
check(tile.minHeight() > 400.0f && tile.maxHeight() < 1000.0f,
"Dalle reelle : altitudes dans une plage plausible");
check(tile.maxHeight() - tile.minHeight() > 500.0f,
"Dalle reelle : denivele reel de plus de 500 m");
double east = 0.0, north = 0.0;
tile.toProjected(0.0f, 0.0f, &east, &north);
checkNear(static_cast<float>(east - 907000.0), 500.0f, 1e-2f,
"Dalle reelle : l'origine du monde est au centre de la dalle (est)");
checkNear(static_cast<float>(north - 6439000.0), 500.0f, 1e-2f,
"Dalle reelle : l'origine du monde est au centre de la dalle (nord)");
// Valeur relevee independamment par tools\check_terrain_file.py sur le nuage
// brut : la mediane des points sol a E 907500 / N 6439500 vaut 605.38 m.
checkNear(tile.heightAt(0.0f, 0.0f), 605.38f, 0.01f,
"Dalle reelle : altitude au point de depart conforme au nuage brut");
const MeshData mesh = terrainMeshData(tile);
check(mesh.vertices.size() == 1001u * 1001u, "Dalle reelle : 1 002 001 sommets");
check(mesh.triangleCount() == 1000u * 1000u * 2u, "Dalle reelle : 2 000 000 triangles");
}
// ---------------------------------------------------------------------------
// Phase 8 : physique de base du parapente
// ---------------------------------------------------------------------------
void testParaglider() {
section("Phase 8 : physique de base du parapente");
// --- Vol droit devant, air calme -----------------------------------------
{
Paraglider glider;
glider.launch(glm::vec3(0.0f, 100.0f, 0.0f), 0.0f); // cap = +X
check(glider.flying(), "launch() met le vol en cours");
checkNear(glm::length(glider.forward()), 1.0f, 1e-4f,
"forward() est unitaire au decollage");
constexpr float dt = 1.0f / 60.0f;
for (int i = 0; i < 120; ++i) {
glider.update(dt, /*turnInput=*/0.0f, /*brakeInput=*/0.0f);
}
// 2 s en ligne droite, cap +X : Z ne doit pas avoir bouge, Y doit avoir
// baisse d'a peu pres cruiseSinkRate * 2 s des que la reponse
// exponentielle du taux de chute (partant deja au regime de croisiere,
// donc sans transitoire ici) s'est stabilisee.
checkNear(glider.position().z, 0.0f, 1e-3f,
"Vol tout droit (cap +X) : aucune derive laterale");
check(glider.position().x > 0.0f, "Vol tout droit : avance bien vers +X");
checkNear(glider.position().y, 100.0f - ParagliderParams{}.cruiseSinkRate * 2.0f,
0.05f, "Taux de chute de croisiere respecte sur 2 s");
}
// --- Virage : rayon fini, pas une rotation instantanee --------------------
{
Paraglider glider;
glider.launch(glm::vec3(0.0f, 200.0f, 0.0f), 0.0f);
constexpr float dt = 1.0f / 60.0f;
for (int i = 0; i < 60; ++i) {
glider.update(dt, /*turnInput=*/1.0f, /*brakeInput=*/0.0f);
}
// Une seconde de virage plein a droite : le cap a change d'exactement
// turnRateDegPerSec degres (integration a vitesse angulaire constante),
// ni plus (pas de rotation instantanee sur la premiere frame) ni moins.
checkNear(glider.headingDegrees(), ParagliderParams{}.turnRateDegPerSec, 0.5f,
"Le cap tourne a vitesse angulaire constante, pas instantanement");
check(glider.position().z > 0.1f,
"Le virage courbe bien la trajectoire (Z s'est ecarte de 0)");
}
// --- Frein : vitesse plus faible, taux de chute plus fort, progressivement -
{
Paraglider glider;
glider.launch(glm::vec3(0.0f, 200.0f, 0.0f), 0.0f);
const float yAfterOneFrameNoBrake = [&] {
Paraglider probe;
probe.launch(glm::vec3(0.0f, 200.0f, 0.0f), 0.0f);
probe.update(1.0f / 60.0f, 0.0f, 0.0f);
return probe.position().y;
}();
glider.update(1.0f / 60.0f, 0.0f, /*brakeInput=*/1.0f);
check(glider.position().y < yAfterOneFrameNoBrake,
"Freiner degrade le taux de chute des la premiere frame (mais peu : "
"reponse progressive, pas un saut)");
constexpr float dt = 1.0f / 60.0f;
for (int i = 0; i < 180; ++i) {
glider.update(dt, 0.0f, 1.0f);
}
// Apres 3 s de frein a fond, la vitesse doit s'etre stabilisee pres de
// brakeSpeed : on le verifie indirectement via la distance parcourue au
// pas suivant plutot que d'exposer un accesseur de vitesse rien que pour
// le test.
const glm::vec3 beforeStep = glider.position();
glider.update(dt, 0.0f, 1.0f);
const float stepDistance = horizontalDistance(glider.position(), beforeStep);
checkNear(stepDistance, ParagliderParams{}.brakeSpeed * dt, 0.02f,
"Plein frein maintenu : la vitesse s'est stabilisee pres de brakeSpeed");
}
// --- Atterrissage : le vol s'arrete pile au niveau du terrain ------------
{
FlatTerrain terrain(50.0f);
constexpr float kEyeHeight = 1.7f;
Paraglider glider;
glider.launch(glm::vec3(0.0f, 52.0f, 0.0f), 0.0f);
check(!glider.checkLanding(terrain, kEyeHeight),
"checkLanding() ne declenche rien tant qu'on est au-dessus du sol");
bool landed = false;
for (int i = 0; i < 6000 && !landed; ++i) {
glider.update(1.0f / 60.0f, 0.0f, 0.0f);
landed = glider.checkLanding(terrain, kEyeHeight);
}
check(landed, "Le vol finit par atterrir sur un terrain plat");
check(!glider.flying(), "flying() redevient faux apres l'atterrissage");
checkNear(glider.position().y, terrain.heightAt(0.0f, 0.0f) + kEyeHeight, 1e-3f,
"Position posee EXACTEMENT au niveau du terrain (hauteur d'oeil incluse)");
}
// --- abort() : filet de securite, independant de l'altitude --------------
{
Paraglider glider;
glider.launch(glm::vec3(0.0f, 500.0f, 0.0f), 0.0f);
glider.abort();
check(!glider.flying(), "abort() termine le vol immediatement, quelle que soit l'altitude");
}
// --- update()/checkLanding() sans vol en cours : aucun effet -------------
{
FlatTerrain terrain(10.0f);
Paraglider glider;
const glm::vec3 before = glider.position();
glider.update(1.0f / 60.0f, 1.0f, 1.0f);
check(glider.position() == before, "update() sans launch() ne deplace rien");
check(!glider.checkLanding(terrain, 1.7f),
"checkLanding() sans vol en cours ne fait rien");
}
}
// ---------------------------------------------------------------------------
// Phase 13 : physique de base du velo
// ---------------------------------------------------------------------------
// Ce que ces tests verifient, et pourquoi ils sont ecrits ainsi : la valeur d'un
// modele simplifie ne tient pas dans ses formules mais dans les VITESSES qu'il
// produit. Chaque bloc ci-dessous mesure donc une vitesse d'equilibre reelle et
// la confronte a la fourchette annoncee dans world/Bike.hpp et
// NOTES-PHASE-VELO.md - au lieu de re-deriver l'equation, ce qui ne prouverait
// que l'accord du test avec lui-meme.
void testBike() {
section("Phase 13 : physique de base du velo");
const BikeParams defaults;
// --- Contact permanent avec le sol ---------------------------------------
{
SlopedTerrain slope(0.0f, 0.10f); // 10 %, monte vers +X
Bike bike;
// On enfourche a une altitude VOLONTAIREMENT fausse : le velo doit se
// recoller au terrain de lui-meme, des mount().
bike.mount(glm::vec3(20.0f, 999.0f, 0.0f), 0.0f, slope);
check(bike.riding(), "mount() met la sortie en cours");
checkNear(bike.position().y, slope.heightAt(20.0f, 0.0f) + defaults.eyeHeight,
1e-3f, "mount() recolle le velo au terrain, quelle que soit "
"l'altitude demandee");
checkNear(bike.speed(), 0.0f, 1e-6f, "On part a l'arret, pas lance");
// Cap +X = plein dans la montee : la pente lue doit etre celle du plan.
checkNear(bike.slopeAlongHeading(slope), 0.10f, 1e-4f,
"La pente le long du cap est bien celle du terrain (montee)");
// Demi-tour : la meme pente, en descente.
bike.mount(glm::vec3(20.0f, 0.0f, 0.0f), 180.0f, slope);
checkNear(bike.slopeAlongHeading(slope), -0.10f, 1e-4f,
"Cap inverse : meme pente, signe oppose");
// En travers : pente nulle le long du cap.
bike.mount(glm::vec3(20.0f, 0.0f, 0.0f), 90.0f, slope);
checkNear(bike.slopeAlongHeading(slope), 0.0f, 1e-4f,
"Cap en travers de la pente : pente longitudinale nulle");
// Et le contact tient pendant qu'on roule : une seule assertion pour les
// 300 pas, sans quoi un test isole pesserait 300 fois dans le compte.
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, slope);
bool alwaysOnGround = true;
for (int i = 0; i < 300; ++i) {
bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, slope, nullptr);
const float expected =
slope.heightAt(bike.position().x, bike.position().z) + defaults.eyeHeight;
if (std::abs(bike.position().y - expected) > 1e-3f) {
alwaysOnGround = false;
}
}
check(alwaysOnGround,
"Le velo reste colle a la surface a chacun des 300 pas (jamais en l'air)");
}
// --- Inertie : ni acceleration ni freinage instantanes -------------------
{
FlatTerrain flat;
Bike bike;
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr);
const float afterOneFrame = bike.speed();
check(afterOneFrame > 0.0f, "Pedaler fait avancer");
// Une frame de pedalage a fond ne peut pas donner plus que
// pedalAcceleration * dt, soit ~3,7 cm/s : c'est ca, l'inertie, et c'est
// verifiable sans connaitre la vitesse finale.
check(afterOneFrame < defaults.pedalAcceleration / 60.0f + 1e-4f,
"Une frame de pedalage ne donne qu'une fraction de m/s (inertie)");
// Vitesse de croisiere sur le plat, puis freinage.
const float cruise = settleSpeed(bike, flat, 1.0f, 0.0f);
bike.update(1.0f / 60.0f, 0.0f, 0.0f, 1.0f, flat, nullptr);
check(bike.speed() > 0.0f,
"Le frein a fond ne met pas a l'arret en une frame (inertie)");
check(bike.speed() < cruise, "Le frein ralentit bien des la premiere frame");
// Distance et duree d'arret depuis la croisiere.
const glm::vec3 beforeStop = bike.position();
float stopTime = 0.0f;
for (int i = 0; i < 600 && bike.speed() > 0.0f; ++i) {
bike.update(1.0f / 60.0f, 0.0f, 0.0f, 1.0f, flat, nullptr);
stopTime += 1.0f / 60.0f;
}
checkNear(bike.speed(), 0.0f, 1e-6f,
"Le frein maintenu finit par arreter le velo");
const float stopDistance = horizontalDistance(bike.position(), beforeStop);
check(stopTime > 3.0f / 60.0f, "L'arret prend plusieurs frames, pas une seule");
check(stopDistance > 0.3f && stopDistance < 3.0f,
"Distance d'arret plausible depuis la croisiere (entre 0,3 et 3 m)");
}
// --- Vitesses d'equilibre : LE chiffre qui compte ------------------------
{
// Plat, pedalage a fond.
FlatTerrain flat;
Bike bike;
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
const float flatKmh = settleSpeed(bike, flat, 1.0f, 0.0f) * 3.6f;
check(flatKmh > 12.0f && flatKmh < 22.0f,
"Plat, pedalage a fond : 12 a 22 km/h (VTT sur chemin)");
// Montee a 10 % : nettement plus lent, mais on monte.
SlopedTerrain up10(0.0f, 0.10f);
Bike climber;
climber.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, up10);
const float up10Kmh = settleSpeed(climber, up10, 1.0f, 0.0f) * 3.6f;
check(up10Kmh > 4.0f && up10Kmh < 12.0f,
"Montee a 10 %, pedalage a fond : 4 a 12 km/h");
check(up10Kmh < flatKmh - 3.0f,
"La montee ralentit franchement par rapport au plat");
// Montee a 25 % : le velo cale. C'est VOULU (25 % est du portage), et
// c'est aussi la garantie qu'il ne recule jamais.
SlopedTerrain up25(0.0f, 0.25f);
Bike staller;
staller.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, up25);
const float up25Speed = settleSpeed(staller, up25, 1.0f, 0.0f, 20.0f);
checkNear(up25Speed, 0.0f, 1e-6f,
"Montee a 25 % : le velo cale (pas de portage simule) ...");
check(staller.position().x >= -1e-3f,
"... et il ne RECULE pas : la vitesse est ecretee a zero");
// Descente a 20 %, en roue libre : la fourchette VTT demandee.
SlopedTerrain down20(0.0f, -0.20f); // descend vers +X
Bike descender;
descender.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, down20);
const float down20Kmh = settleSpeed(descender, down20, 0.0f, 0.0f) * 3.6f;
check(down20Kmh > 30.0f && down20Kmh <= 50.0f,
"Descente a 20 % en roue libre : 30 a 50 km/h (fourchette VTT visee)");
// Descente a 30 % : plus vite, mais toujours sous le plafond.
SlopedTerrain down30(0.0f, -0.30f);
Bike descender30;
descender30.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, down30);
const float down30Kmh = settleSpeed(descender30, down30, 0.0f, 0.0f) * 3.6f;
check(down30Kmh > down20Kmh,
"Une descente plus raide donne une vitesse plus elevee");
check(down30Kmh <= defaults.maxSpeed * 3.6f + 1e-3f,
"Le plafond de 50 km/h n'est jamais depasse");
// Falaise LiDAR : meme a 200 % de pente, la vitesse reste bornee. C'est
// le cas que la zone de jeu contient reellement (parois verticales, cf.
// NOTES-PHASE9.md), et celui ou une formule en tan() divergerait.
SlopedTerrain cliff(0.0f, -2.0f);
Bike faller;
faller.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, cliff);
const float cliffKmh = settleSpeed(faller, cliff, 1.0f, 0.0f, 60.0f) * 3.6f;
check(cliffKmh <= defaults.maxSpeed * 3.6f + 1e-3f,
"Pente de 200 % : la vitesse reste bornee par maxSpeed, sans divergence");
check(!std::isnan(cliffKmh), "Pente extreme : aucun NaN");
// Le frein bat la gravite : on doit pouvoir descendre au pas.
Bike braker;
braker.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, down30);
const float brakedKmh = settleSpeed(braker, down30, 0.0f, 1.0f, 20.0f) * 3.6f;
checkNear(brakedKmh, 0.0f, 1e-3f,
"Frein a fond en descente a 30 % : le velo s'arrete (le frein "
"l'emporte sur la gravite)");
}
// --- Roue libre sur pente tres faible : le velo ne part pas tout seul ----
{
SlopedTerrain gentle(0.0f, -0.02f); // 2 % de descente
Bike bike;
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, gentle);
const float speed = settleSpeed(bike, gentle, 0.0f, 0.0f, 20.0f);
checkNear(speed, 0.0f, 1e-6f,
"Descente a 2 %, sans pedaler : la resistance au roulement "
"empeche le velo de partir seul");
}
// --- Direction : rayon de braquage fini, et croissant avec la vitesse ----
{
FlatTerrain flat;
// Rayon mesure a deux vitesses differentes, par la vitesse angulaire
// effectivement obtenue (R = v / omega).
auto measureRadius = [&](float targetSpeed) {
Bike bike;
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
// On amene le velo a la vitesse voulue en pedalant en ligne droite,
// puis on mesure UN pas de virage a fond.
for (int i = 0; i < 4000 && bike.speed() < targetSpeed; ++i) {
bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr);
}
const float v = bike.speed();
const float before = bike.headingDegrees();
bike.update(1.0f / 60.0f, 1.0f, 0.0f, 0.0f, flat, nullptr);
const float omega = glm::radians(bike.headingDegrees() - before) * 60.0f;
return std::make_pair(v, v / omega);
};
const std::pair<float, float> slow = measureRadius(3.0f);
const std::pair<float, float> fast = measureRadius(4.5f);
check(slow.second > 0.0f && fast.second > 0.0f,
"Le rayon de braquage est fini et positif : pas de rotation sur place "
"en roulant");
check(fast.second > slow.second + 0.5f,
"Le rayon de braquage GRANDIT avec la vitesse (pas de virage a angle "
"droit a pleine vitesse)");
// R = v^2 / maxLateralAccel : c'est la formule annoncee, on la confronte
// a la mesure.
checkNear(fast.second, fast.first * fast.first / defaults.maxLateralAccel, 0.2f,
"Le rayon mesure vaut bien v^2 / maxLateralAccel");
// A l'arret, le plafond de vitesse angulaire prend le relais : on peut
// replacer la machine, mais pas plus vite que maxTurnRateDegPerSec.
Bike still;
still.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
const float beforeHeading = still.headingDegrees();
still.update(1.0f / 60.0f, 1.0f, 0.0f, 0.0f, flat, nullptr);
checkNear((still.headingDegrees() - beforeHeading) * 60.0f,
defaults.maxTurnRateDegPerSec, 1e-2f,
"A l'arret : rotation plafonnee a maxTurnRateDegPerSec, jamais "
"infinie");
// Sens de rotation : +1 tourne a droite (vers +Z depuis le cap +X, meme
// convention que Camera et Paraglider).
//
// On lance d'abord le velo EN LIGNE DROITE avant de tourner. Tourner des
// l'arret ne prouverait rien : a vitesse nulle le braquage est plafonne a
// 140 deg/s, donc deux secondes de virage font trois quarts de tour et la
// trajectoire revient sur elle-meme - le signe de z ne dirait plus rien
// du sens de rotation.
Bike turner;
turner.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
for (int i = 0; i < 600; ++i) {
turner.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr);
}
const float zBeforeTurn = turner.position().z;
const float headingBeforeTurn = turner.headingDegrees();
for (int i = 0; i < 30; ++i) { // une demi-seconde de virage a droite
turner.update(1.0f / 60.0f, 1.0f, 1.0f, 0.0f, flat, nullptr);
}
check(turner.headingDegrees() > headingBeforeTurn,
"steerInput > 0 fait croitre le cap");
check(turner.position().z > zBeforeTurn,
"steerInput > 0 courbe la trajectoire vers +Z (a droite du cap +X)");
// Et le miroir, pour ecarter un test qui passerait avec n'importe quel
// signe.
Bike turnerLeft;
turnerLeft.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
for (int i = 0; i < 600; ++i) {
turnerLeft.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr);
}
const float zBeforeLeft = turnerLeft.position().z;
for (int i = 0; i < 30; ++i) {
turnerLeft.update(1.0f / 60.0f, -1.0f, 1.0f, 0.0f, flat, nullptr);
}
check(turnerLeft.position().z < zBeforeLeft,
"steerInput < 0 courbe la trajectoire dans l'autre sens");
}
// --- Assiette visuelle : suit la pente locale ----------------------------
{
SlopedTerrain up20(0.0f, 0.20f);
Bike bike;
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, up20);
bike.update(1.0f / 60.0f, 0.0f, 0.0f, 0.0f, up20, nullptr);
checkNear(bike.pitchDegrees(), glm::degrees(std::atan(0.20f)), 0.1f,
"Tangage : le nez se leve de l'angle de la pente en montee");
checkNear(bike.rollDegrees(), 0.0f, 0.1f,
"Roulis nul quand on monte droit dans la pente");
// Meme plan, cap en travers : plus de tangage, mais du devers.
Bike crossing;
crossing.mount(glm::vec3(0.0f, 0.0f, 0.0f), 90.0f, up20); // cap +Z
crossing.update(1.0f / 60.0f, 0.0f, 0.0f, 0.0f, up20, nullptr);
checkNear(crossing.pitchDegrees(), 0.0f, 0.1f,
"Cap en travers : plus de tangage");
check(std::abs(crossing.rollDegrees()) > 5.0f,
"Cap en travers : le velo epouse le devers (roulis non nul)");
// Descente : le nez pique.
SlopedTerrain down20(0.0f, -0.20f);
Bike descender;
descender.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, down20);
descender.update(1.0f / 60.0f, 0.0f, 0.0f, 0.0f, down20, nullptr);
check(descender.pitchDegrees() < -5.0f, "Tangage negatif en descente");
// Inclinaison en virage : a vitesse non nulle, tourner penche la machine
// vers l'interieur, en plus du devers.
FlatTerrain flat;
Bike leaner;
leaner.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
for (int i = 0; i < 600; ++i) {
leaner.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr);
}
leaner.update(1.0f / 60.0f, 1.0f, 1.0f, 0.0f, flat, nullptr);
check(leaner.rollDegrees() > 2.0f,
"Virage a droite sur le plat : le velo s'incline a droite");
leaner.update(1.0f / 60.0f, -1.0f, 1.0f, 0.0f, flat, nullptr);
check(leaner.rollDegrees() < -2.0f, "Virage a gauche : inclinaison opposee");
// L'ecretage tient sur une paroi.
SlopedTerrain wall(0.0f, 3.0f);
Bike onWall;
onWall.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, wall);
onWall.update(1.0f / 60.0f, 0.0f, 0.0f, 0.0f, wall, nullptr);
check(std::abs(onWall.pitchDegrees()) <= defaults.maxVisualTiltDegrees + 1e-3f,
"L'assiette visuelle est ecretee sur une paroi (pas de marqueur a plat)");
}
// --- Obstacles : LE MEME systeme de collision que le joueur a pied -------
{
FlatTerrain flat;
Ground ground(flat);
ForestParams noAutoSeed;
noAutoSeed.treeCount = 0;
Forest forest(flat, ground, 50.0f, noAutoSeed);
forest.plantTree(10.0f, 0.0f, 7.0f); // droit devant un velo cap +X
Bike bike;
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
// On roule droit sur le tronc pendant largement de quoi le depasser.
for (int i = 0; i < 1200; ++i) {
bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, &forest);
}
const float trunkRadius = forest.trees()[0].trunkRadius();
const float contact = trunkRadius + BikeParams{}.bodyRadius;
check(bike.position().x < 10.0f,
"Le velo n'a PAS traverse le tronc (il est reste en deca)");
check(horizontalDistance(bike.position(), forest.trees()[0].base) >=
contact - 1e-2f,
"Le velo est arrete au contact du tronc, pas dedans");
check(bike.speed() < 1.0f,
"Le choc coute sa vitesse au velo (il ne pousse pas l'arbre a 16 km/h)");
// Temoin : sans solveur, le meme trajet TRAVERSE. Sans ce controle, un
// test qui bloque parce que le velo n'avance pas du tout passerait aussi.
Bike ghost;
ghost.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
for (int i = 0; i < 1200; ++i) {
ghost.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr);
}
check(ghost.position().x > 12.0f,
"TEMOIN : sans solveur de collision, le meme trajet depasse l'arbre "
"(donc le blocage ci-dessus vient bien de la collision)");
// Une souche basse arrete aussi le velo : c'est la bande verticale du
// BodyCylinder qui le garantit, exactement comme pour le joueur a pied.
Forest stumpOnly(flat, ground, 50.0f, noAutoSeed);
stumpOnly.plantTree(10.0f, 0.0f, 7.0f);
stumpOnly.fell(0);
runUntilFallen(stumpOnly, 12.0f);
check(stumpOnly.trees()[0].state == TreeState::Fallen,
"L'arbre du test de souche est bien entierement debite");
Bike overStump;
overStump.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
for (int i = 0; i < 1200; ++i) {
overStump.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, &stumpOnly);
}
check(overStump.position().x < 10.0f,
"Une souche basse arrete le velo comme elle arrete les jambes");
}
// --- Sans mount() : aucun effet -----------------------------------------
{
FlatTerrain flat;
Bike bike;
const glm::vec3 before = bike.position();
bike.update(1.0f / 60.0f, 1.0f, 1.0f, 1.0f, flat, nullptr);
check(bike.position() == before, "update() sans mount() ne deplace rien");
check(!bike.riding(), "Un velo neuf n'est pas en cours d'utilisation");
bike.mount(glm::vec3(5.0f, 0.0f, 5.0f), 0.0f, flat);
bike.dismount();
check(!bike.riding(), "dismount() termine la sortie");
const glm::vec3 parked = bike.position();
bike.update(1.0f / 60.0f, 1.0f, 1.0f, 0.0f, flat, nullptr);
check(bike.position() == parked,
"Apres dismount(), plus aucun pas n'est simule");
// deltaTime nul : pas d'integration, pas de NaN.
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
const glm::vec3 atMount = bike.position();
bike.update(0.0f, 1.0f, 1.0f, 0.0f, flat, nullptr);
check(bike.position() == atMount, "deltaTime nul : aucun pas simule");
}
// --- Ecretage des entrees : des valeurs brutes hors bornes sont sures ----
{
FlatTerrain flat;
Bike wild;
wild.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
Bike tame;
tame.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
for (int i = 0; i < 300; ++i) {
wild.update(1.0f / 60.0f, 50.0f, 50.0f, 0.0f, flat, nullptr);
tame.update(1.0f / 60.0f, 1.0f, 1.0f, 0.0f, flat, nullptr);
}
checkNear(wild.speed(), tame.speed(), 1e-5f,
"Les entrees sont ecretees : 50 se comporte comme 1");
checkNear(wild.headingDegrees(), tame.headingDegrees(), 1e-3f,
"Ecretage aussi sur la direction");
}
}
// ---------------------------------------------------------------------------
// Phase 14 : physique de base de l'escalade
// ---------------------------------------------------------------------------
// Deux terrains de test que les precedents ne fournissaient pas. SlopedTerrain
// est un plan infini : parfait pour mesurer une vitesse ou un cout par metre sur
// une pente EXACTE, mais il n'a ni pied ni sommet, donc il ne peut prouver
// aucune des transitions de mode. D'ou les deux ci-dessous.
// Falaise minimale : plat en bas, paroi, plat en haut. C'est le plus petit
// terrain qui contienne les trois situations de l'escalade (s'engager, monter,
// topper), et il est PARFAITEMENT previsible - contrairement a du relief LiDAR,
// ou un test qui echoue laisse toujours le doute entre le modele et la donnee.
class CliffTerrain : public HeightSampler {
public:
CliffTerrain(float baseHeight, float slope, float footX, float topX)
: base_(baseHeight), slope_(slope), footX_(footX), topX_(topX) {}
float heightAt(float x, float) const override {
if (x <= footX_) return base_;
if (x >= topX_) return base_ + slope_ * (topX_ - footX_);
return base_ + slope_ * (x - footX_);
}
private:
float base_, slope_, footX_, topX_;
};
// Meme falaise, mais avec une VIRE horizontale a mi-hauteur, de largeur
// reglable. C'est le terrain qui met a l'epreuve la confirmation du sommet :
// une vire d'un metre ne doit pas terminer l'escalade (on serait debout en plein
// vide), une vire de six metres si (on y tient reellement debout).
class LedgedCliffTerrain : public HeightSampler {
public:
LedgedCliffTerrain(float slope, float topX, float ledgeWidth)
: slope_(slope), topX_(topX), ledgeWidth_(ledgeWidth) {
ledgeStart_ = 0.5f * topX_;
}
float heightAt(float x, float) const override {
if (x <= 0.0f) return 0.0f;
if (x <= ledgeStart_) return slope_ * x;
const float ledgeY = slope_ * ledgeStart_;
if (x <= ledgeStart_ + ledgeWidth_) return ledgeY;
const float afterLedge = x - (ledgeStart_ + ledgeWidth_);
const float wallLeft = topX_ - ledgeStart_;
if (afterLedge >= wallLeft) return ledgeY + slope_ * wallLeft;
return ledgeY + slope_ * afterLedge;
}
private:
float slope_, topX_, ledgeWidth_, ledgeStart_;
};
// Ce qui fait la valeur d'un modele simplifie n'est pas sa formule mais les
// GRANDEURS qu'il produit - meme intention que les tests du velo. Chaque bloc
// mesure donc un comportement reel (une vitesse d'ascension, une hauteur
// maximale, une position de repli) et le confronte a ce qu'annonce
// world/Climber.hpp, au lieu de re-deriver l'equation, ce qui ne prouverait que
// l'accord du test avec lui-meme.
void testClimber() {
section("Phase 14 : physique de base de l'escalade");
const ClimberParams defaults;
constexpr float dt = 1.0f / 60.0f;
// --- Detection de paroi --------------------------------------------------
{
Climber climber;
FlatTerrain flat(100.0f);
checkNear(climber.slopeAt(flat, 3.0f, -7.0f), 0.0f, 1e-6f,
"Terrain plat : pente nulle");
check(!climber.isWall(flat, 3.0f, -7.0f),
"Terrain plat : ce n'est pas une paroi");
// Un versant raide MAIS marchable : 60 %, la valeur type de ce massif.
// C'est le cas qui compte - si celui-la passait pour une paroi, le seuil
// ne servirait a rien, la moitie du terrain etant au-dessus de 50 %.
SlopedTerrain steep(0.0f, 0.60f);
checkNear(climber.slopeAt(steep, 12.0f, 5.0f), 0.60f, 1e-4f,
"Versant a 60 % : la pente lue est exacte");
check(!climber.isWall(steep, 12.0f, 5.0f),
"Versant a 60 % : ce n'est PAS une paroi (sous le seuil de paroi)");
SlopedTerrain wall(0.0f, 1.05f);
check(climber.isWall(wall, 12.0f, 5.0f), "Pente a 105 % : c'est une paroi");
SlopedTerrain exactly(0.0f, defaults.wallSlope);
check(climber.isWall(exactly, 0.0f, 0.0f),
"Pente exactement au seuil : c'est une paroi (comparaison >=)");
// La pente est une MAGNITUDE : une paroi qui descend vers +X en est une
// aussi. Un signe oublie se verrait ici et nulle part ailleurs.
SlopedTerrain descending(0.0f, -1.50f);
check(climber.isWall(descending, 0.0f, 0.0f),
"Paroi de pente negative : c'est une paroi (magnitude, pas signe)");
// Ce n'est pas un detail de reglage : si walkableSlope rattrapait
// wallSlope, l'hysteresis disparaitrait et le mode escalade se mettrait
// a clignoter d'une frame a l'autre sur une paroi reelle.
check(defaults.walkableSlope < defaults.wallSlope,
"Hysteresis : le seuil de sortie est STRICTEMENT sous celui d'entree");
}
// --- Engagement : tryStart ------------------------------------------------
{
CliffTerrain cliff(0.0f, 3.0f, 0.0f, 10.0f);
{
Climber climber;
const glm::vec3 eye(-1.5f, 1.7f, 0.0f);
check(climber.tryStart(cliff, eye, glm::vec3(1.0f, 0.0f, 0.0f)),
"Engagement : une paroi a portee, on s'accroche");
check(climber.climbing(), "Engagement : l'escalade est en cours");
checkNear(climber.anchor().y,
cliff.heightAt(climber.anchor().x, climber.anchor().z), 1e-4f,
"Engagement : le point d'accroche est SUR la surface");
check(climber.isWall(cliff, climber.anchor().x, climber.anchor().z),
"Engagement : le point d'accroche est bien sur une paroi");
}
{
Climber climber;
check(!climber.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f),
glm::vec3(-1.0f, 0.0f, 0.0f)),
"Engagement refuse : la paroi est dans le dos");
check(!climber.climbing(), "Engagement refuse : rien n'a change");
}
{
Climber climber;
check(!climber.tryStart(cliff, glm::vec3(-5.0f, 1.7f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f)),
"Engagement refuse : la paroi est hors de portee");
}
{
Climber climber;
FlatTerrain flat;
check(!climber.tryStart(flat, glm::vec3(0.0f, 1.7f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f)),
"Engagement refuse : il n'y a pas de paroi du tout");
}
{
// Regard strictement vertical : aucune direction au sol, donc aucune
// cible. Le cas degenere doit REFUSER, pas normaliser un vecteur nul.
Climber climber;
check(!climber.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f)),
"Engagement refuse : regard strictement vertical (cas degenere)");
}
}
// --- Contact permanent avec la surface ------------------------------------
{
// Le meme invariant que le velo, et pour la meme raison : la verticale
// n'est jamais une variable d'etat, elle est relue de heightAt().
SlopedTerrain wall(0.0f, 3.0f);
Climber climber;
check(climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f)),
"Contact : engagement sur une paroi uniforme a 300 %");
bool alwaysOnSurface = true;
bool everNaN = false;
for (int i = 0; i < 400; ++i) {
climber.update(dt, 1.0f, 0.3f, wall, nullptr);
const float expected = wall.heightAt(climber.anchor().x, climber.anchor().z);
if (std::abs(climber.anchor().y - expected) > 1e-3f) {
alwaysOnSurface = false;
}
if (std::isnan(climber.anchor().x) || std::isnan(climber.anchor().y) ||
std::isnan(climber.anchor().z) || std::isnan(climber.stamina())) {
everNaN = true;
}
}
check(alwaysOnSurface, "Le grimpeur reste sur la surface a chacun des 400 pas");
check(!everNaN, "Escalade : aucun NaN sur 400 pas");
}
// --- Vitesse le long de la surface ----------------------------------------
{
// Ce que le modele promet : on avance a climbSpeed LE LONG DE LA
// SURFACE. La montee verticale qui en resulte vaut donc climbSpeed x
// sin(theta), pas climbSpeed. Le verifier sur une pente connue est la
// seule facon de prouver que la projection est reellement faite.
const float slope = 3.0f; // 300 %, 71,6 degres
SlopedTerrain wall(0.0f, slope);
Climber climber;
climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
const glm::vec3 before = climber.anchor();
const int steps = 60; // une seconde
for (int i = 0; i < steps; ++i) {
climber.update(dt, 1.0f, 0.0f, wall, nullptr);
}
const glm::vec3 after = climber.anchor();
const float dx = after.x - before.x;
const float dz = after.z - before.z;
const float dy = after.y - before.y;
const float alongSurface = std::sqrt(dx * dx + dz * dz + dy * dy);
const float elapsed = steps * dt;
checkNear(alongSurface / elapsed, defaults.climbSpeed, 1e-2f,
"Vitesse le long de la SURFACE : c'est bien climbSpeed");
checkNear(dy / elapsed,
defaults.climbSpeed * slope / std::sqrt(1.0f + slope * slope), 1e-2f,
"Vitesse VERTICALE = climbSpeed x sin(pente)");
check(dy / elapsed < defaults.climbSpeed,
"La montee verticale est plus lente que la progression sur la paroi");
check(defaults.climbSpeed < 14.0f / 10.0f,
"Grimper est au moins dix fois plus lent que marcher (14 m/s)");
}
// --- Une paroi quasi verticale se monte quasi verticalement ---------------
{
// Aucun cas particulier n'est ecrit pour ca dans Climber : c'est la
// projection 1/sqrt(1+pente^2) qui le produit toute seule. Ce test fige
// ce comportement emergent, qui est le coeur du modele.
SlopedTerrain sheer(0.0f, 20.0f); // 2000 %, 87,1 degres
Climber climber;
climber.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
const glm::vec3 before = climber.anchor();
for (int i = 0; i < 60; ++i) {
climber.update(dt, 1.0f, 0.0f, sheer, nullptr);
}
const glm::vec3 after = climber.anchor();
const float dHoriz = horizontalDistance(after, before);
const float dAlt = after.y - before.y;
check(dAlt > 0.99f * defaults.climbSpeed,
"Paroi a 87 degres : la montee est quasi integralement verticale");
check(dHoriz < 0.06f * defaults.climbSpeed,
"Paroi a 87 degres : l'avance horizontale est negligeable");
}
// --- Traversee : le long de la LIGNE DE NIVEAU ----------------------------
{
// Sur un terrain dont l'altitude ne depend que de x, la ligne de niveau
// est l'axe z. Traverser doit donc deplacer en z et laisser l'altitude ou
// elle est - c'est ce qui distingue une traversee d'une diagonale.
SlopedTerrain wall(0.0f, 2.0f);
Climber climber;
climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
const glm::vec3 before = climber.anchor();
for (int i = 0; i < 60; ++i) {
climber.update(dt, 0.0f, 1.0f, wall, nullptr);
}
const glm::vec3 after = climber.anchor();
checkNear(after.y, before.y, 1e-3f,
"Traversee : l'altitude ne change pas (ligne de niveau)");
checkNear(std::abs(after.z - before.z), defaults.traverseSpeed, 1e-2f,
"Traversee : on parcourt traverseSpeed en une seconde");
checkNear(after.x, before.x, 1e-3f,
"Traversee : aucune avance dans la ligne de plus grande pente");
const float rightward = after.z - before.z;
Climber other;
other.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
const glm::vec3 b2 = other.anchor();
for (int i = 0; i < 60; ++i) {
other.update(dt, 0.0f, -1.0f, wall, nullptr);
}
checkNear(other.anchor().z - b2.z, -rightward, 1e-3f,
"Traversee : gauche et droite sont exactement symetriques");
}
// --- L'oeil est HORS du relief --------------------------------------------
{
// Une camera a la premiere personne collee a une falaise est le piege
// evident de cette phase : un oeil sous la surface montre l'interieur du
// terrain. Le decalage vers l'AVAL doit le rendre impossible, sur toute
// une ascension et pas seulement au depart.
SlopedTerrain wall(0.0f, 4.0f);
Climber climber;
climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
bool alwaysOutside = true;
for (int i = 0; i < 200; ++i) {
climber.update(dt, 1.0f, 0.0f, wall, nullptr);
const glm::vec3 eye = climber.position();
if (eye.y <= wall.heightAt(eye.x, eye.z)) {
alwaysOutside = false;
}
}
check(alwaysOutside,
"L'oeil du grimpeur reste au-dessus de la surface sur 200 pas");
check(climber.position().y > climber.anchor().y,
"L'oeil est au-dessus du point d'accroche (eyeRise)");
check(horizontalDistance(climber.position(), climber.anchor()) > 0.5f,
"L'oeil est ecarte de la paroi (wallOffset)");
}
// --- Energie : les couts sont PAR METRE, pas par seconde ------------------
{
SlopedTerrain sheer(0.0f, 20.0f);
Climber climber;
climber.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
checkNear(climber.stamina(), 1.0f, 1e-6f,
"Energie : on part avec la jauge pleine");
const float startY = climber.anchor().y;
for (int i = 0; i < 300; ++i) {
climber.update(dt, 1.0f, 0.0f, sheer, nullptr);
}
const float climbed = climber.anchor().y - startY;
const float spent = 1.0f - climber.stamina();
check(climbed > 4.0f, "Energie : l'ascension de reference a bien eu lieu");
// Sur une paroi a 2000 % la composante horizontale ne vaut que 5 % : le
// cout par metre monte doit donc etre celui annonce, a 2 % pres.
checkNear(spent / climbed, defaults.staminaPerMeterUp,
0.02f * defaults.staminaPerMeterUp,
"Energie : le cout par metre monte est bien staminaPerMeterUp");
// Le meme trajet en DEUX FOIS PLUS DE TEMPS coute pareil : c'est la
// consequence d'un cout par metre, et ca rend la jauge independante du
// nombre d'images par seconde.
Climber slow;
slow.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
const float slowStart = slow.anchor().y;
for (int i = 0; i < 600; ++i) {
slow.update(dt, 0.5f, 0.0f, sheer, nullptr);
}
checkNear(slow.anchor().y - slowStart, climbed, 1e-2f,
"Meme ascension, moitie moins vite, deux fois plus longtemps");
checkNear(1.0f - slow.stamina(), spent, 0.02f * spent,
"Energie : monter lentement coute la MEME chose (cout par metre)");
}
// --- Energie : suspendu, desescalader -------------------------------------
{
SlopedTerrain sheer(0.0f, 20.0f);
Climber hanging;
hanging.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
for (int i = 0; i < 300; ++i) { // 5 secondes
hanging.update(dt, 0.0f, 0.0f, sheer, nullptr);
}
checkNear(1.0f - hanging.stamina(), defaults.staminaHangPerSecond * 5.0f, 1e-4f,
"Energie : suspendu immobile, cout par SECONDE");
check(hanging.stamina() > 0.97f,
"Energie : rester suspendu 5 s ne vide pas la jauge");
// Descendre coute moins cher que monter - le choix de JEU qui garde la
// desescalade comme porte de sortie.
Climber up;
up.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
for (int i = 0; i < 120; ++i) up.update(dt, 1.0f, 0.0f, sheer, nullptr);
const float upCost = 1.0f - up.stamina();
Climber down;
down.tryStart(sheer, glm::vec3(50.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
const float downStart = down.anchor().y;
for (int i = 0; i < 120; ++i) down.update(dt, -1.0f, 0.0f, sheer, nullptr);
const float downCost = 1.0f - down.stamina();
check(down.anchor().y < downStart, "Desescalade : on descend bien");
check(downCost < upCost, "Energie : desescalader coute moins cher que monter");
checkNear(downCost / upCost,
defaults.staminaPerMeterDown / defaults.staminaPerMeterUp, 0.05f,
"Energie : le rapport descente/montee est celui annonce");
}
// --- Recuperation : au sol seulement --------------------------------------
{
SlopedTerrain sheer(0.0f, 20.0f);
Climber climber;
climber.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
for (int i = 0; i < 600; ++i) climber.update(dt, 1.0f, 0.0f, sheer, nullptr);
const float inWall = climber.stamina();
check(inWall < 1.0f, "Recuperation : la jauge a bien baisse");
// En paroi, restOnGround ne doit RIEN faire - sans quoi l'appelant, qui
// l'appelle a chaque frame, rechargerait le grimpeur pendant sa montee.
climber.restOnGround(1.0f);
checkNear(climber.stamina(), inWall, 1e-6f,
"Recuperation : aucune recuperation en paroi");
climber.release();
climber.restOnGround(2.0f);
checkNear(climber.stamina(), inWall + 2.0f * defaults.staminaRecoveryPerSecond,
1e-4f, "Recuperation : au sol, staminaRecoveryPerSecond par seconde");
climber.restOnGround(1000.0f);
checkNear(climber.stamina(), 1.0f, 1e-6f,
"Recuperation : la jauge ne depasse jamais 1");
}
// --- LA hauteur qui compte : ce qu'une jauge pleine permet ----------------
{
// Le chiffre annonce dans world/Climber.hpp (62,5 m de paroi strictement
// verticale) est une limite theorique. Sur une paroi a 87 degres - la
// plus raide qu'on trouve reellement dans la zone de jeu - la composante
// horizontale en retire un peu. C'est CE chiffre-la qu'il faut mesurer,
// parce que c'est lui qui decide quelles parois du massif sont faisables.
SlopedTerrain sheer(0.0f, 20.0f);
Climber climber;
climber.tryStart(sheer, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
float highest = climber.anchor().y;
ClimbExit exit = ClimbExit::None;
int steps = 0;
while (exit == ClimbExit::None && steps < 200000) {
exit = climber.update(dt, 1.0f, 0.0f, sheer, nullptr);
if (exit == ClimbExit::None) {
highest = climber.anchor().y;
}
++steps;
}
check(exit == ClimbExit::Exhausted,
"Jauge pleine : sur une paroi sans sommet, on finit par tomber");
std::printf(" [mesure] jauge pleine sur une paroi a 87 deg : %.1f m atteints\n",
static_cast<double>(highest));
check(highest > 58.0f && highest < 63.0f,
"Jauge pleine : entre 58 et 63 m de paroi a 87 degres");
// Corollaire qui donne son sens a l'activite : les grandes falaises de
// ce massif (250 a 276 m, mesurees par tools/find_climb_walls.py) sont
// HORS DE PORTEE d'une seule jauge. C'est voulu, pas un reglage rate.
check(highest < 250.0f,
"Jauge pleine : les falaises de 250 m du massif restent hors de portee");
}
// --- Les trois sorties ----------------------------------------------------
{
CliffTerrain cliff(0.0f, 3.0f, 0.0f, 10.0f); // 30 m de paroi a 300 %
// 1. SOMMET.
{
Climber climber;
check(climber.tryStart(cliff, glm::vec3(-1.0f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f)),
"Sortie sommet : engagement");
ClimbExit exit = ClimbExit::None;
int steps = 0;
while (exit == ClimbExit::None && steps < 200000) {
exit = climber.update(dt, 1.0f, 0.0f, cliff, nullptr);
++steps;
}
check(exit == ClimbExit::ToppedOut,
"Sortie sommet : une paroi de 30 m se termine par un SOMMET");
check(!climber.climbing(), "Sortie sommet : l'escalade est terminee");
// Au sommet on reste OU L'ON EST : c'est la seule des trois sorties
// qui ne ramene pas au pied, et c'est toute la recompense.
check(climber.anchor().x > 9.0f,
"Sortie sommet : on reste sur le plateau, pas au pied");
check(climber.heightGained() > 28.0f,
"Sortie sommet : la trentaine de metres a bien ete gagnee");
check(climber.stamina() > 0.0f, "Sortie sommet : il restait de l'energie");
checkNear(climber.anchor().y,
cliff.heightAt(climber.anchor().x, climber.anchor().z), 1e-3f,
"Sortie sommet : la position finale est sur la surface");
}
// 2. LACHAGE VOLONTAIRE.
{
Climber climber;
climber.tryStart(cliff, glm::vec3(-1.0f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f));
const glm::vec3 foot = climber.groundAnchor();
for (int i = 0; i < 300; ++i) climber.update(dt, 1.0f, 0.0f, cliff, nullptr);
check(climber.heightGained() > 3.0f, "Lachage : on etait bien monte");
const ClimbExit exit = climber.release();
check(exit == ClimbExit::Released, "Lachage : la sortie est Released");
check(!climber.climbing(), "Lachage : l'escalade est terminee");
check(climber.anchor() == foot,
"Lachage : retour EXACT au point d'engagement");
checkNear(climber.heightGained(), 0.0f, 1e-6f,
"Lachage : le gain d'altitude est annule");
check(climber.release() == ClimbExit::None,
"Lachage : lacher deux fois ne fait rien la seconde fois");
}
// 3. EPUISEMENT.
{
Climber climber;
climber.tryStart(cliff, glm::vec3(-1.0f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f));
const glm::vec3 foot = climber.groundAnchor();
ClimbExit exit = ClimbExit::None;
int steps = 0;
// On monte puis on redescend en boucle : l'altitude ne progresse pas,
// mais l'energie, elle, se consomme. C'est le scenario "je tourne en
// rond sur la paroi", celui ou la chute doit finir par arriver.
while (exit == ClimbExit::None && steps < 400000) {
const float input = ((steps / 120) % 2 == 0) ? 1.0f : -1.0f;
exit = climber.update(dt, input, 0.0f, cliff, nullptr);
++steps;
}
check(exit == ClimbExit::Exhausted,
"Epuisement : tourner en rond sur la paroi finit par une CHUTE");
check(!climber.climbing(), "Epuisement : l'escalade est terminee");
checkNear(climber.stamina(), 0.0f, 1e-6f,
"Epuisement : la jauge est bien a zero");
check(climber.anchor() == foot,
"Epuisement : reinitialisation EXACTE au point d'engagement");
check(!std::isnan(climber.anchor().x) && !std::isnan(climber.anchor().y),
"Epuisement : la position de repli est valide");
}
}
// --- Le sommet l'emporte sur l'epuisement ---------------------------------
{
// L'ordre des deux tests de sortie dans update() est un choix, pas un
// hasard : poser la main sur la vire avec sa derniere goutte d'energie,
// c'est topper, pas tomber. Le figer ici evite qu'un remaniement
// n'inverse les deux sans que personne ne s'en apercoive.
CliffTerrain cliff(0.0f, 3.0f, 0.0f, 3.0f); // paroi courte : 9 m
Climber climber;
climber.tryStart(cliff, glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
ClimbExit exit = ClimbExit::None;
int steps = 0;
while (exit == ClimbExit::None && steps < 200000) {
exit = climber.update(dt, 1.0f, 0.0f, cliff, nullptr);
++steps;
}
check(exit == ClimbExit::ToppedOut,
"Paroi courte : on toppe, la jauge n'a pas le temps de se vider");
}
// --- Hysteresis : pas de sortie au milieu d'une paroi ---------------------
{
// Le piege de cette phase : une vire etroite au milieu de la face ne doit
// PAS terminer l'escalade, sinon le joueur se retrouve debout en plein
// vide. Climber confirme donc le terrain marchable 3 m plus loin.
LedgedCliffTerrain narrow(3.0f, 15.0f, 1.0f);
Climber climber;
climber.tryStart(narrow, glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
ClimbExit exit = ClimbExit::None;
int steps = 0;
while (exit == ClimbExit::None && steps < 200000) {
exit = climber.update(dt, 1.0f, 0.0f, narrow, nullptr);
++steps;
}
check(exit == ClimbExit::ToppedOut,
"Vire etroite : l'escalade se poursuit jusqu'au VRAI sommet");
check(climber.anchor().x > 15.0f,
"Vire etroite de 1 m : on ne s'y arrete PAS (pas de sortie en plein vide)");
// Vire de 6 m : assez profonde pour s'y tenir debout. S'y arreter est le
// comportement CORRECT et non un pis-aller - 6 m de terrain marchable,
// on y est reellement.
LedgedCliffTerrain wide(3.0f, 15.0f, 6.0f);
Climber other;
other.tryStart(wide, glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
exit = ClimbExit::None;
steps = 0;
while (exit == ClimbExit::None && steps < 200000) {
exit = other.update(dt, 1.0f, 0.0f, wide, nullptr);
++steps;
}
check(exit == ClimbExit::ToppedOut, "Vire large : sortie par le sommet");
check(other.anchor().x < 15.0f,
"Vire large de 6 m : on s'y arrete, c'est du terrain ou l'on tient debout");
}
// --- Seuil d'energie a l'engagement ---------------------------------------
{
SlopedTerrain wall(0.0f, 3.0f);
Climber climber;
climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
while (climber.climbing()) {
climber.update(dt, 1.0f, 0.0f, wall, nullptr);
}
checkNear(climber.stamina(), 0.0f, 1e-6f, "Seuil d'engagement : jauge videe");
check(!climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f)),
"Seuil d'engagement : jauge vide, on refuse de s'engager");
climber.restOnGround(Climber::minStaminaToStart() /
defaults.staminaRecoveryPerSecond + 1.0f);
check(climber.stamina() >= Climber::minStaminaToStart(),
"Seuil d'engagement : la jauge est remontee au-dessus du seuil");
check(climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f)),
"Seuil d'engagement : au-dessus du seuil, on peut repartir");
}
// --- Collision : le meme moveBody que le joueur a pied --------------------
{
// Rien de la collision n'est reecrit dans Climber : si ce test passe,
// c'est que le grimpeur emprunte bien le point d'entree unique du projet.
SlopedTerrain wall(0.0f, 3.0f);
Ground ground(wall);
ForestParams params;
params.treeCount = 0; // on plante a la main : test deterministe
Forest forest(wall, ground, 200.0f, params);
Climber climber;
climber.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
const glm::vec3 start = climber.anchor();
forest.plantTree(start.x, start.z + 1.5f, 8.0f);
for (int i = 0; i < 300; ++i) {
climber.update(dt, 0.0f, 1.0f, wall, &forest);
}
// Sans obstacle, 5 s de traversee a 0,6 m/s feraient 3 m. Le tronc est a
// 1,5 m : on ne doit pas l'avoir traverse.
const float travelled = climber.anchor().z - start.z;
check(travelled < 1.5f,
"Collision : le grimpeur bute sur le tronc au lieu de le traverser");
check(travelled > 0.0f, "Collision : il a quand meme progresse jusqu'au tronc");
// Rester coince contre un tronc ne doit PAS etre un repos gratuit. Une
// premiere version de ce test attendait l'inverse ("buter coute moins
// que traverser") ; la mesure a montre que c'est faux, et que c'est tant
// mieux : un grimpeur bloque est facture au tarif SUSPENDU (par seconde),
// et sur ce modele suspendre 5 s coute 0,020 quand traverser 3 m n'en
// coute que 0,015. Pousser contre un obstacle est donc plus couteux que
// d'avancer, ce qui est le bon comportement - on ne se repose pas en
// s'appuyant sur un arbre.
const float pushedCost = 1.0f - climber.stamina();
check(pushedCost > 0.0f,
"Collision : rester bloque contre un tronc consomme quand meme de "
"l'energie (pas de repos gratuit)");
Climber unobstructed;
unobstructed.tryStart(wall, glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f));
for (int i = 0; i < 300; ++i) {
unobstructed.update(dt, 0.0f, 1.0f, wall, nullptr);
}
check(horizontalDistance(unobstructed.anchor(),
glm::vec3(0.0f, 0.0f, 0.0f)) > travelled,
"Collision : sans obstacle, la meme duree fait parcourir plus de "
"chemin - c'est bien le tronc qui a arrete le grimpeur");
}
// --- LA VRAIE PAROI DU TERRAIN LIDAR --------------------------------------
// Conditionnel a dessein, comme le bloc de dalle reelle de testTerrainFile :
// le depot ne versionne pas les heightmaps. Quand la dalle est la, c'est le
// SEUL test d'escalade qui touche du relief mesure - et c'est celui qui
// compte, parce qu'un plan incline synthetique ne porte aucun bruit et n'a
// jamais prouve grand-chose (lecon de la Phase 13).
{
const std::filesystem::path realTile =
std::filesystem::path(ASSETS_DIR) / "terrain" / "LHD_0899_6436_1m.vchm";
if (!std::filesystem::exists(realTile)) {
std::printf(" (dalle reelle absente, bloc ignore : %s)\n",
realTile.string().c_str());
} else {
const Heightmap tile = loadTerrainFile(realTile.string());
// VOIE de reference de la Phase 14, trouvee par
// `find_climb_walls.py --routes` : depart E 899900 / N 6435550, soit
// x = +400 / z = -50 dans le monde moteur de cette dalle, cap 0 degre
// (plein est). 21,4 m gagnes sur 27 m de trajet en ligne droite, dont
// 63 % au-dessus du seuil de paroi, et un depart a 57 % de pente -
// donc du terrain ou l'on tient debout.
//
// POURQUOI UNE "VOIE" ET PAS UNE "PAROI" : le premier essai de ce
// test visait le centre d'une paroi reperee par le mode par defaut de
// l'outil (E 899850 / N 6435230) et l'abordait plein est. Il a echoue,
// et l'echec etait instructif : cette paroi DESCEND vers l'est. Le
// test approchait donc par le SOMMET, marchait au bord de la falaise,
// et le grimpeur remontait correctement les 3,9 m qu'il venait de
// descendre avant de topper. Le modele avait raison, c'est la
// geometrie du test qui etait fausse.
//
// C'est exactement la lecon du scenario E de la Phase 13 : savoir
// qu'il y a de la pente quelque part ne dit pas PAR OU l'aborder, et
// le terrain de l'autre cote d'un point est un AUTRE terrain. D'ou le
// mode --routes de l'outil, qui evalue le relief le long de chaque
// cap depuis un pied marchable.
const float footX = 400.0f;
const float footZ = -50.0f;
const float headingRad = glm::radians(0.0f);
const glm::vec3 lookDir(std::cos(headingRad), 0.0f, std::sin(headingRad));
Climber climber;
const float measured = climber.slopeAt(tile, footX, footZ);
std::printf(" [mesure] voie de reference E 899900 N 6435550 : "
"pente au depart %.1f %%\n",
static_cast<double>(100.0f * measured));
check(!climber.isWall(tile, footX, footZ),
"Voie LiDAR reelle : le pied n'est PAS une paroi (on y marche)");
// Engagement : on marche vers la paroi le long du cap jusqu'a
// l'avoir a portee - exactement ce que fait le joueur.
float approach = 0.0f;
bool engaged = false;
for (int step = 0; step < 160 && !engaged; ++step) {
const float ex = footX + lookDir.x * approach;
const float ez = footZ + lookDir.z * approach;
const glm::vec3 eye(ex, tile.heightAt(ex, ez) + 1.7f, ez);
engaged = climber.tryStart(tile, eye, lookDir);
approach += 0.25f;
}
check(engaged,
"Voie LiDAR reelle : on s'engage en marchant vers la paroi");
check(climber.isWall(tile, climber.anchor().x, climber.anchor().z),
"Voie LiDAR reelle : le point d'accroche est bien sur une paroi");
if (engaged) {
const float startY = climber.anchor().y;
ClimbExit exit = ClimbExit::None;
int steps = 0;
float peak = startY;
bool everNaN = false;
bool alwaysOnSurface = true;
bool eyeAlwaysOutside = true;
while (exit == ClimbExit::None && steps < 200000) {
exit = climber.update(dt, 1.0f, 0.0f, tile, nullptr);
const glm::vec3 a = climber.anchor();
if (std::isnan(a.x) || std::isnan(a.y) || std::isnan(a.z) ||
std::isnan(climber.stamina())) {
everNaN = true;
}
if (exit == ClimbExit::None) {
peak = std::max(peak, a.y);
if (std::abs(a.y - tile.heightAt(a.x, a.z)) > 1e-2f) {
alwaysOnSurface = false;
}
const glm::vec3 eye = climber.position();
if (eye.y <= tile.heightAt(eye.x, eye.z)) {
eyeAlwaysOutside = false;
}
}
++steps;
}
std::printf(" [mesure] ascension sur relief LiDAR reel : %.1f m "
"gagnes en %.1f s, sortie %s, energie restante %.0f %%\n",
static_cast<double>(peak - startY),
static_cast<double>(steps * dt),
exit == ClimbExit::ToppedOut ? "SOMMET"
: "epuisement",
static_cast<double>(100.0f * climber.stamina()));
check(!everNaN,
"Voie LiDAR reelle : aucun NaN sur toute l'ascension");
check(alwaysOnSurface,
"Voie LiDAR reelle : le grimpeur ne quitte jamais la surface");
check(eyeAlwaysOutside,
"Voie LiDAR reelle : l'oeil ne passe jamais sous le relief");
// 15 m et non 21,4 : le grimpeur suit la ligne de PLUS GRANDE
// PENTE, qui s'incurve, alors que l'outil mesure le relief le
// long d'un cap FIXE. Les deux trajets divergent, et le gain
// reellement obtenu (~19 m) est donc inferieur a la projection en
// ligne droite. C'est un resultat, pas un defaut - mais ca
// interdit de recopier le chiffre de l'outil dans une assertion.
check(peak - startY > 15.0f,
"Voie LiDAR reelle : plus de 15 m reellement gagnes");
check(exit == ClimbExit::ToppedOut,
"Voie LiDAR reelle : la voie de reference se TOPPE");
check(climber.stamina() > 0.0f,
"Voie LiDAR reelle : il restait de l'energie au sommet");
check(!climber.isWall(tile, climber.anchor().x, climber.anchor().z),
"Voie LiDAR reelle : on termine sur du terrain non-paroi");
}
}
}
}
// ---------------------------------------------------------------------------
// PHASE 24 : LA MARCHE A UNE LIMITE DE PENTE, ET ELLE REJOINT L'ESCALADE
// ---------------------------------------------------------------------------
// Ce qui est teste ici est core/SlopeLimits.hpp, pas core/Camera : la camera se
// contente d'appeler resolveWalkStep() une fois par frame avec le pas que le
// clavier demandait. Tester la fonction plutot que la camera n'est pas un
// contournement du fait que Camera::update() exige une Window - c'est le bon
// niveau : toute la decision est dans le filtre, la camera n'y ajoute que la
// lecture des touches.
//
// L'assertion qui compte le plus est celle du premier bloc : celle qui verifie
// qu'il n'existe aucune pente ou l'on ne puisse ni marcher ni grimper. C'etait
// le vrai defaut de coherence, et c'est la seule chose ici qu'un reglage
// distrait pourrait reintroduire sans rien casser d'autre.
void testWalkSlopeLimit() {
section("Phase 24 : limite de pente a la marche, et sa jonction avec l'escalade");
const WalkSlopeParams walkParams;
const ClimberParams climbing;
constexpr float dt = 1.0f / 60.0f;
constexpr float walkSpeed = 14.0f; // la vitesse de marche du moteur
const float step = walkSpeed * dt;
// --- LA PROPRIETE STRUCTURELLE : AUCUN TROU ENTRE LES DEUX ACTIVITES -----
// Elle se verifie sans terrain du tout, parce qu'elle ne porte que sur les
// seuils. Deux nombres regles separement finissent toujours par diverger ;
// cette assertion est ce qui l'empeche.
{
check(climbing.wallSlope <= walkParams.maxSlope,
"Coherence : l'escalade s'engage AU PLUS TARD la ou la marche "
"s'arrete (aucune bande interdite aux deux)");
check(climbing.walkableSlope < walkParams.maxSlope,
"Coherence : on sort de l'escalade sur du terrain reellement "
"marchable, pas sur du terrain deja trop raide");
check(walkParams.comfortSlope < walkParams.maxSlope,
"Coherence : le ralentissement precede le blocage (pas de mur sec)");
// Le balayage explicite, parce que l'inegalite ci-dessus se lit vite
// mais se croit mal : pour 300 pentes reparties de 0 a 300 %, il y a
// TOUJOURS au moins une des deux activites qui accepte.
bool everStuck = false;
float worstSlope = -1.0f;
for (int i = 0; i <= 300; ++i) {
const float slope = 0.01f * static_cast<float>(i);
const bool canWalk = walkSpeedFactor(slope, walkParams) > 0.0f;
const bool canClimb = slope >= climbing.wallSlope;
if (!canWalk && !canClimb) {
everStuck = true;
worstSlope = slope;
}
}
if (everStuck) {
std::printf(" [mesure] pente sans issue trouvee : %.0f %%\n",
static_cast<double>(100.0f * worstSlope));
}
check(!everStuck,
"Aucune pente de 0 a 300 % n'est a la fois trop raide pour "
"marcher et trop douce pour grimper");
}
// --- LE FACTEUR DE VITESSE ----------------------------------------------
{
checkNear(walkSpeedFactor(0.0f, walkParams), 1.0f, 1e-6f,
"A plat : pleine vitesse");
checkNear(walkSpeedFactor(walkParams.comfortSlope, walkParams), 1.0f, 1e-6f,
"Au seuil de confort (60 %) : encore pleine vitesse");
checkNear(walkSpeedFactor(0.5f * (walkParams.comfortSlope + walkParams.maxSlope),
walkParams),
0.5f, 1e-4f, "A mi-chemin (72 %) : demi-vitesse");
checkNear(walkSpeedFactor(walkParams.maxSlope, walkParams), 0.0f, 1e-6f,
"Au seuil maximal (84 %) : plus aucune progression");
checkNear(walkSpeedFactor(30.0f, walkParams), 0.0f, 1e-6f,
"Sur une paroi a 3000 % : toujours zero, jamais de negatif");
// La rampe doit etre MONOTONE : un joueur qui aborde une pente de plus
// en plus raide ne doit jamais reaccelerer.
bool monotone = true;
float previous = 1.0f;
for (int i = 0; i <= 200; ++i) {
const float f = walkSpeedFactor(0.01f * static_cast<float>(i), walkParams);
if (f > previous + 1e-6f) monotone = false;
previous = f;
}
check(monotone, "Le ralentissement est monotone : jamais de reprise de "
"vitesse quand ca se redresse");
}
// --- UN VERSANT DE RANDONNEE NORMALE N'EST PAS TOUCHE --------------------
// C'est la contrainte explicite de la consigne : ne pas casser la traversee
// des pentes raides de randonnee. 30 %, c'est un sentier de montagne
// soutenu ; il doit se marcher exactement comme avant la Phase 24.
{
SlopedTerrain hike(0.0f, 0.30f);
const glm::vec3 from(0.0f, 0.0f, 0.0f);
const WalkStepResult up =
resolveWalkStep(hike, from, glm::vec3(step, 0.0f, 0.0f), dt, walkParams);
checkNear(up.speedFactor, 1.0f, 1e-6f,
"Sentier a 30 % : aucun ralentissement");
checkNear(up.position.x - from.x, step, 1e-4f,
"Sentier a 30 % : le pas complet est accorde en montee");
check(!up.sliding, "Sentier a 30 % : on ne glisse pas");
// Et le raidillon ponctuel a 80 % passe encore, ralenti. S'il etait
// refuse, la limite serait mal placee.
SlopedTerrain hard(0.0f, 0.80f);
const WalkStepResult tough =
resolveWalkStep(hard, from, glm::vec3(step, 0.0f, 0.0f), dt, walkParams);
check(tough.position.x - from.x > 0.0f,
"Raidillon a 80 % : ca monte encore, meme ralenti");
std::printf(" [mesure] vitesse de marche accordee : 30 %% -> %.0f %%, "
"60 %% -> %.0f %%, 72 %% -> %.0f %%, 80 %% -> %.0f %%, "
"84 %% -> %.0f %%\n",
static_cast<double>(100.0f * walkSpeedFactor(0.30f, walkParams)),
static_cast<double>(100.0f * walkSpeedFactor(0.60f, walkParams)),
static_cast<double>(100.0f * walkSpeedFactor(0.72f, walkParams)),
static_cast<double>(100.0f * walkSpeedFactor(0.80f, walkParams)),
static_cast<double>(100.0f * walkSpeedFactor(0.84f, walkParams)));
}
// --- LA DISSYMETRIE AMONT / AVAL ----------------------------------------
// Point de conception : on refuse de MONTER, jamais de redescendre. Sans
// cette dissymetrie, un joueur pose sur du trop raide serait fige, ce qui
// est exactement le blocage frustrant qu'il fallait eviter.
{
SlopedTerrain wall(0.0f, 1.00f); // 100 %, au-dessus du maximum
const glm::vec3 from(0.0f, 0.0f, 0.0f);
const WalkStepResult up =
resolveWalkStep(wall, from, glm::vec3(step, 0.0f, 0.0f), dt, walkParams);
check(up.speedFactor <= 0.0f,
"Pente a 100 % : la montee a pied n'est plus accordee du tout");
const WalkStepResult down =
resolveWalkStep(wall, from, glm::vec3(-step, 0.0f, 0.0f), dt, walkParams);
check(down.position.x - from.x < -step * 0.99f,
"Pente a 100 % : REDESCENDRE reste possible, a pleine vitesse");
check(up.sliding && down.sliding,
"Pente a 100 % : on glisse, qu'on pousse la touche ou non");
// La glissade descend, et elle est douce a 100 % (0,16 d'exces).
const WalkStepResult idle =
resolveWalkStep(wall, from, glm::vec3(0.0f), dt, walkParams);
check(idle.position.x < from.x,
"Pente a 100 %, sans aucune touche : le joueur glisse vers l'AVAL");
const float slideSpeed = (from.x - idle.position.x) / dt;
std::printf(" [mesure] glissade : %.2f m/s a 100 %% de pente\n",
static_cast<double>(slideSpeed));
check(slideSpeed > 0.0f && slideSpeed < 1.0f,
"Glissade a 100 % : un decrochage lent (<1 m/s), pas une ejection");
// Et sur une vraie paroi elle est plafonnee : sans plafond, les 5018 %
// mesures sur cette dalle ejecteraient le joueur a 150 m/s.
SlopedTerrain cliff(0.0f, 30.0f);
const WalkStepResult ejected =
resolveWalkStep(cliff, from, glm::vec3(0.0f), dt, walkParams);
const float cliffSpeed = (from.x - ejected.position.x) / dt;
check(cliffSpeed <= walkParams.slideSpeedMax + 1e-3f,
"Glissade sur une paroi a 3000 % : plafonnee, pas d'ejection");
}
// --- AUCUNE POSITION N'EST UN PIEGE -------------------------------------
// La garantie de fond du chantier : ou qu'on depose le joueur, il finit sur
// du terrain marchable sans rien faire. C'est ce qui rend le blocage
// acceptable - il n'immobilise jamais, il renvoie en arriere.
{
CliffTerrain cliff(0.0f, 1.60f, 0.0f, 40.0f); // plat / paroi 160 % / plat
glm::vec3 player(20.0f, 0.0f, 0.0f); // depose en pleine paroi
int frames = 0;
while (frames < 60 * 60) { // une minute de jeu au maximum
const WalkStepResult r =
resolveWalkStep(cliff, player, glm::vec3(0.0f), dt, walkParams);
player = r.position;
if (!r.sliding) break;
++frames;
}
const float finalSlope =
walkTerrainSlope(cliff, player.x, player.z, walkParams.sampleStep);
std::printf(" [mesure] depose en pleine paroi a 160 %% : ramene sur du "
"%.0f %% en %.1f s\n",
static_cast<double>(100.0f * finalSlope),
static_cast<double>(frames * dt));
check(finalSlope <= walkParams.maxSlope + 1e-3f,
"Depose sur du trop raide : la glissade ramene sur du marchable");
check(player.x < 20.0f, "La glissade va bien vers l'AVAL de la paroi");
}
// --- LE ZIGZAG NE CONTOURNE PAS LA LIMITE -------------------------------
// Controle negatif de la decision de facturer aussi le deplacement LATERAL.
// Si le lateral etait gratuit, monter en travers a 45 degres rendrait 71 %
// du gain d'altitude a pleine vitesse et la limite ne servirait a rien.
{
SlopedTerrain slope(0.0f, 0.80f);
const glm::vec3 from(0.0f, 0.0f, 0.0f);
const WalkStepResult direct =
resolveWalkStep(slope, from, glm::vec3(step, 0.0f, 0.0f), dt, walkParams);
const float diagonal = step * 0.70710678f;
const WalkStepResult zigzag = resolveWalkStep(
slope, from, glm::vec3(diagonal, 0.0f, diagonal), dt, walkParams);
const float riseDirect = 0.80f * (direct.position.x - from.x);
const float riseZigzag = 0.80f * (zigzag.position.x - from.x);
check(riseZigzag <= riseDirect + 1e-5f,
"Zigzag : monter en travers ne fait pas gagner plus de hauteur "
"que monter droit");
}
// --- LA JONCTION, SUR UNE FALAISE SYNTHETIQUE ---------------------------
// Le scenario du joueur : il marche vers une paroi, il est arrete par la
// pente. La question qui decide de tout le chantier est celle-ci - a
// l'endroit exact ou la marche s'arrete, est-ce que l'escalade accepte ?
{
CliffTerrain cliff(0.0f, 1.60f, 30.0f, 70.0f);
const glm::vec3 lookDir(1.0f, 0.0f, 0.0f);
glm::vec3 player(0.0f, 0.0f, 0.0f);
int frames = 0;
float lastAdvance = step;
while (frames < 60 * 60 && lastAdvance > 1e-4f) {
const WalkStepResult r =
resolveWalkStep(cliff, player, glm::vec3(step, 0.0f, 0.0f), dt, walkParams);
lastAdvance = r.position.x - player.x;
player = r.position;
++frames;
}
const float stopSlope =
walkTerrainSlope(cliff, player.x, player.z, walkParams.sampleStep);
std::printf(" [mesure] falaise synthetique : la marche s'arrete a "
"x = %.2f m, pente sous les pieds %.0f %%\n",
static_cast<double>(player.x),
static_cast<double>(100.0f * stopSlope));
check(player.x < 70.0f,
"Falaise : la marche ne franchit plus la paroi (elle passait avant "
"la Phase 24)");
check(stopSlope <= walkParams.maxSlope + 1e-3f,
"Falaise : le joueur s'arrete AU PIED, sur du terrain ou il tient "
"encore debout - pas coince en pleine paroi");
// ET C'EST ICI QUE LE CHANTIER SE JOUE : depuis ce point d'arret,
// l'escalade doit accepter de s'engager.
Climber climber;
const glm::vec3 eye(player.x, cliff.heightAt(player.x, player.z) + 1.7f,
player.z);
check(climber.tryStart(cliff, eye, lookDir),
"Falaise : la ou la marche s'arrete, l'ESCALADE PREND LE RELAIS");
}
// --- LA MEME JONCTION, SUR LE VRAI RELIEF LIDAR -------------------------
// Meme raison d'etre que le bloc LiDAR de testClimber() : un plan incline
// synthetique n'a jamais rien prouve sur ce projet. La voie employee est
// celle de reference de la Phase 14 - pied marchable a E 899900 /
// N 6435550, cap plein est - precisement parce qu'elle est deja connue
// comme une VRAIE transition marche / paroi.
{
const std::filesystem::path realTile =
std::filesystem::path(ASSETS_DIR) / "terrain" / "LHD_0899_6436_1m.vchm";
if (!std::filesystem::exists(realTile)) {
std::printf(" (dalle reelle absente, bloc ignore : %s)\n",
realTile.string().c_str());
} else {
const Heightmap tile = loadTerrainFile(realTile.string());
const glm::vec3 lookDir(1.0f, 0.0f, 0.0f);
glm::vec3 player(400.0f, 0.0f, -50.0f);
const float startSlope =
walkTerrainSlope(tile, player.x, player.z, walkParams.sampleStep);
check(startSlope < walkParams.maxSlope,
"Voie LiDAR reelle : le pied de la voie se marche encore");
float travelled = 0.0f;
int frames = 0;
float lastAdvance = step;
while (frames < 60 * 120 && lastAdvance > 1e-4f) {
const WalkStepResult r = resolveWalkStep(
tile, player, glm::vec3(step, 0.0f, 0.0f), dt, walkParams);
lastAdvance = r.position.x - player.x;
travelled += lastAdvance;
player = r.position;
++frames;
}
const float stopSlope =
walkTerrainSlope(tile, player.x, player.z, walkParams.sampleStep);
std::printf(" [mesure] relief LiDAR reel : la marche progresse de "
"%.1f m puis s'arrete, pente au point d'arret %.0f %%, "
"altitude gagnee %.1f m\n",
static_cast<double>(travelled),
static_cast<double>(100.0f * stopSlope),
static_cast<double>(tile.heightAt(player.x, player.z) -
tile.heightAt(400.0f, -50.0f)));
check(travelled > 1.0f,
"Voie LiDAR reelle : le joueur avance reellement avant d'etre "
"arrete (ce n'est pas un blocage des le premier pas)");
check(stopSlope <= walkParams.maxSlope + 1e-3f,
"Voie LiDAR reelle : l'arret se fait sur du terrain ou l'on "
"tient debout");
Climber climber;
const glm::vec3 eye(player.x, tile.heightAt(player.x, player.z) + 1.7f,
player.z);
const bool engaged = climber.tryStart(tile, eye, lookDir);
check(engaged,
"Voie LiDAR reelle : l'escalade prend le relais LA OU la "
"marche s'est arretee");
if (!engaged) {
// Diagnostic plutot qu'une simple croix : sur ce projet, savoir
// POURQUOI un engagement echoue a deja fait gagner des phases
// entieres (pente insuffisante ? ou ressaut sans relief ?).
std::printf(" [diagnostic] pente devant = %.0f %%, seuil de "
"paroi = %.0f %%\n",
static_cast<double>(
100.0f * climber.slopeAt(tile, player.x + 1.0f, player.z)),
static_cast<double>(100.0f * climber.params().wallSlope));
}
}
}
}
// ---------------------------------------------------------------------------
// Phase 10 : quadtree de terrain, selection de LOD, frustum culling
// ---------------------------------------------------------------------------
void testTerrainQuadtree() {
section("Phase 10 : quadtree, LOD et frustum culling");
// Matrice view-projection reutilisee par les tests de culling : camera a
// l'origine regardant vers -Z (la convention du moteur : Camera part avec un
// yaw de -90 degres), 60 degres de champ, exactement comme le Renderer.
const auto viewProjectionLookingNorth = [](float farPlane) {
glm::mat4 proj = glm::perspective(glm::radians(60.0f), 16.0f / 9.0f, 0.1f, farPlane);
proj[1][1] *= -1.0f; // convention Vulkan, comme Renderer::projectionMatrix
const glm::mat4 view = glm::lookAt(glm::vec3(0.0f), glm::vec3(0.0f, 0.0f, -1.0f),
glm::vec3(0.0f, 1.0f, 0.0f));
return proj * view;
};
// --- Frustum : ce qui est devant est vu, ce qui est derriere ne l'est pas -
{
const Frustum frustum = Frustum::fromViewProjection(viewProjectionLookingNorth(1000.0f));
check(frustum.intersectsAABB(glm::vec3(-1.0f, -1.0f, -51.0f),
glm::vec3(1.0f, 1.0f, -49.0f)),
"Frustum : une boite droit devant est visible");
check(!frustum.intersectsAABB(glm::vec3(-1.0f, -1.0f, 49.0f),
glm::vec3(1.0f, 1.0f, 51.0f)),
"Frustum : une boite DERRIERE la camera est ecartee");
check(!frustum.intersectsAABB(glm::vec3(499.0f, -1.0f, -51.0f),
glm::vec3(501.0f, 1.0f, -49.0f)),
"Frustum : une boite loin sur le cote est ecartee");
check(!frustum.intersectsAABB(glm::vec3(-1.0f, -1.0f, -2001.0f),
glm::vec3(1.0f, 1.0f, -1999.0f)),
"Frustum : une boite au-dela du plan lointain est ecartee");
check(frustum.intersectsAABB(glm::vec3(-10000.0f, -10000.0f, -10000.0f),
glm::vec3(10000.0f, 10000.0f, 10000.0f)),
"Frustum : une boite qui englobe la camera est visible");
}
// --- distanceToAABB -----------------------------------------------------
{
const glm::vec3 lo(-1.0f, -1.0f, -1.0f);
const glm::vec3 hi(1.0f, 1.0f, 1.0f);
checkNear(distanceToAABB(glm::vec3(0.0f), lo, hi), 0.0f, 1e-5f,
"distanceToAABB : nulle a l'interieur de la boite");
checkNear(distanceToAABB(glm::vec3(4.0f, 0.0f, 0.0f), lo, hi), 3.0f, 1e-5f,
"distanceToAABB : distance a la FACE la plus proche, pas au centre");
}
// --- Structure de l'arbre ----------------------------------------------
Heightmap::Params params;
params.resolution = 257; // 256 cellules = 4 x 4 feuilles de 64
params.worldSize = 256.0f; // pas de 1 unite, pour raisonner en metres ronds
const Heightmap heightmap(params);
TerrainQuadtree::Params quadtreeParams;
quadtreeParams.nodeCells = 64;
const TerrainQuadtree quadtree(heightmap, quadtreeParams);
check(quadtree.rootLevel() == 2,
"Quadtree : 256 cellules / 64 = 4 x 4 feuilles -> racine au niveau 2");
check(quadtree.nodeCount() == 21, "Quadtree : 16 feuilles + 4 noeuds + 1 racine = 21");
check(quadtree.trianglesPerNode() == 64 * 64 * 2,
"Quadtree : un noeud dessine le meme nombre de triangles a tous les niveaux");
check(quadtree.range(1) > quadtree.range(0),
"Quadtree : la portee croit avec le niveau");
checkNear(quadtree.range(1), 2.0f * quadtree.range(0), 1e-3f,
"Quadtree : la portee DOUBLE d'un niveau au suivant");
// La racine couvre tout le terrain, et ses bornes verticales encadrent
// reellement le relief : une boite trop petite ferait disparaitre du terrain
// au culling.
{
const TerrainQuadtree::Node& root = quadtree.node(0);
check(root.level == quadtree.rootLevel(), "Quadtree : le noeud 0 est la racine");
checkNear(root.boundsMin.x, -128.0f, 1e-3f, "Quadtree : la racine part du bord ouest");
checkNear(root.boundsMax.x, 128.0f, 1e-3f, "Quadtree : la racine va au bord est");
check(root.boundsMin.y <= heightmap.minHeight() + 1e-3f &&
root.boundsMax.y >= heightmap.maxHeight() - 1e-3f,
"Quadtree : la boite de la racine englobe TOUTE la plage d'altitudes");
}
// --- Selection : plus on est pres, plus le niveau est fin ---------------
std::vector<TerrainQuadtree::SelectedNode> selection;
{
// Frustum permissif (tout est visible) : on isole ici le critere de
// DISTANCE, le culling est teste separement juste apres.
const Frustum everything = Frustum::fromViewProjection(glm::mat4(0.0f));
const glm::vec3 corner(-120.0f, heightmap.maxHeight(), -120.0f);
quadtree.select(corner, everything, selection);
check(!selection.empty(), "Selection : au moins un noeud retenu");
// Le noeud le plus proche doit etre au niveau le plus fin, et le plus
// lointain a un niveau plus grossier : c'est exactement la promesse du
// LOD par distance.
check(selection.front().level == 0,
"Selection : la tuile la plus proche est a la PLEINE resolution");
check(selection.back().level >= selection.front().level,
"Selection : la tuile la plus lointaine n'est pas plus fine que la plus proche");
bool sorted = true;
for (std::size_t i = 1; i < selection.size(); ++i) {
sorted = sorted && (selection[i - 1].distance <= selection[i].distance + 1e-4f);
}
check(sorted, "Selection : triee du plus proche au plus lointain");
// Bande de morphing : condition ANTI-FISSURE. Un noeud de niveau L doit
// etre entierement morphe sur la grille L+1 avant range[L], sans quoi son
// voisin plus grossier ne le rejoint pas.
bool bandsValid = true;
for (const TerrainQuadtree::SelectedNode& node : selection) {
bandsValid = bandsValid &&
node.morphStart > 0.5f * quadtree.range(node.level) &&
node.morphEnd > node.morphStart &&
node.morphEnd <= quadtree.range(node.level);
}
check(bandsValid,
"Selection : bande de morphing dans (range/2, range] pour chaque tuile");
// COUVERTURE : les tuiles retenues doivent paver tout le terrain, sans
// trou ni recouvrement. On le verifie en surface : la somme des emprises
// horizontales doit valoir exactement celle du terrain.
double coveredArea = 0.0;
for (const TerrainQuadtree::SelectedNode& selected : selection) {
const TerrainQuadtree::Node& node = quadtree.node(selected.nodeIndex);
coveredArea += static_cast<double>(node.boundsMax.x - node.boundsMin.x) *
static_cast<double>(node.boundsMax.z - node.boundsMin.z);
}
checkNear(static_cast<float>(coveredArea), 256.0f * 256.0f, 1.0f,
"Selection : les tuiles retenues pavent le terrain, sans trou ni recouvrement");
}
// --- Frustum culling : regarder ailleurs retire des tuiles ---------------
{
const Frustum everything = Frustum::fromViewProjection(glm::mat4(0.0f));
const glm::vec3 eye(0.0f, heightmap.maxHeight() + 50.0f, 0.0f);
quadtree.select(eye, everything, selection);
const std::size_t withoutCulling = selection.size();
const Frustum frustum = Frustum::fromViewProjection(viewProjectionLookingNorth(2000.0f));
quadtree.select(eye, frustum, selection);
const std::size_t withCulling = selection.size();
check(withCulling < withoutCulling,
"Culling : regarder dans une direction retient MOINS de tuiles que tout voir");
check(withCulling > 0, "Culling : il reste des tuiles devant la camera");
}
// --- Maillage d'un noeud ------------------------------------------------
{
// Une feuille : pas de 1 echantillon, donc les sommets doivent tomber
// EXACTEMENT sur la grille - c'est ce qui garantit qu'au contact du
// joueur la surface affichee est celle sur laquelle il marche.
uint32_t leafIndex = 0;
for (uint32_t i = 0; i < quadtree.nodeCount(); ++i) {
if (quadtree.node(i).level == 0) {
leafIndex = i;
break;
}
}
const TerrainQuadtree::Node& leaf = quadtree.node(leafIndex);
check(leaf.stride == 1, "Tuile : une feuille echantillonne au pas de la donnee");
const MeshData mesh = terrainNodeMeshData(heightmap, quadtree, leafIndex);
check(mesh.vertices.size() == 65u * 65u, "Tuile : 65 x 65 sommets");
check(mesh.triangleCount() == 64u * 64u * 2u, "Tuile : 8192 triangles");
// --- PHASE 18 -----------------------------------------------------
// La cible de morphing est desormais lue dans une grille grossiere
// calculee une fois par tuile, au lieu d'etre recalculee par sommet.
// Cela n'est legitime QUE si les quatre sommets d'un bloc 2x2 partagent
// bien la meme cible - c'est l'hypothese sur laquelle repose toute
// l'optimisation, et elle merite d'etre verifiee plutot que crue.
bool blockShared = true;
for (uint32_t j = 0; j + 1 <= 64 && blockShared; j += 2) {
for (uint32_t i = 0; i + 1 <= 64 && blockShared; i += 2) {
const Vertex& reference = mesh.vertices[j * 65u + i];
for (uint32_t dj = 0; dj < 2; ++dj) {
for (uint32_t di = 0; di < 2; ++di) {
const Vertex& other = mesh.vertices[(j + dj) * 65u + (i + di)];
if (other.morphPos != reference.morphPos ||
other.morphNormal != reference.morphNormal) {
blockShared = false;
}
}
}
}
}
check(blockShared,
"Tuile : les 4 sommets d'un bloc 2x2 visent la MEME cible de morphing");
// `withIndices = false` (le chemin du TerrainStreamer depuis la
// Phase 18) doit produire exactement les memes SOMMETS et laisser la
// topologie a l'appelant. Sans cette verification, une tuile pourrait
// etre construite differemment selon l'appelant.
const MeshData bare = terrainNodeMeshData(heightmap, quadtree, leafIndex, false);
check(bare.indices.empty(), "Tuile : withIndices=false laisse la topologie vide");
bool sameVertices = (bare.vertices.size() == mesh.vertices.size());
for (std::size_t v = 0; v < bare.vertices.size() && sameVertices; ++v) {
sameVertices = (bare.vertices[v].pos == mesh.vertices[v].pos) &&
(bare.vertices[v].normal == mesh.vertices[v].normal) &&
(bare.vertices[v].morphPos == mesh.vertices[v].morphPos);
}
check(sameVertices, "Tuile : memes sommets avec et sans la topologie");
check(terrainNodeIndices(64u).size() == 64u * 64u * 6u &&
terrainNodeIndices(64u) == mesh.indices,
"Tuile : la topologie posee par l'appelant est bien la meme");
bool onGrid = true;
for (uint32_t j = 0; j <= 64 && onGrid; ++j) {
for (uint32_t i = 0; i <= 64 && onGrid; ++i) {
const Vertex& vertex = mesh.vertices[j * 65 + i];
onGrid = std::abs(vertex.pos.y -
heightmap.at(leaf.ix0 + i, leaf.iz0 + j)) < 1e-4f;
}
}
check(onGrid, "Tuile de niveau 0 : chaque sommet porte l'altitude EXACTE de la grille");
// Geomorphing : un sommet d'indice local PAIR est deja sur la grille du
// niveau superieur et ne doit pas bouger ; un sommet IMPAIR doit venir se
// confondre avec son voisin pair. C'est cette propriete qui fait qu'a
// morph = 1 la tuile a exactement la forme de son parent.
bool evenStaysPut = true;
bool oddCollapses = true;
for (uint32_t j = 0; j <= 64; j += 2) {
for (uint32_t i = 0; i <= 64; ++i) {
const Vertex& vertex = mesh.vertices[j * 65 + i];
if (i % 2 == 0) {
evenStaysPut = evenStaysPut &&
glm::length(vertex.morphPos - vertex.pos) < 1e-4f;
} else {
const Vertex& evenNeighbour = mesh.vertices[j * 65 + (i - 1)];
oddCollapses = oddCollapses &&
glm::length(vertex.morphPos - evenNeighbour.pos) < 1e-4f;
}
}
}
check(evenStaysPut, "Geomorphing : un sommet d'indice pair ne bouge pas");
check(oddCollapses,
"Geomorphing : un sommet impair rejoint son voisin pair (grille du parent)");
// Les indices sont les MEMES pour toutes les tuiles : c'est ce qui
// permettra de partager un seul index buffer le jour ou on le fera.
const std::vector<uint32_t> shared = terrainNodeIndices(quadtree.nodeCells());
check(shared == mesh.indices, "Tuile : topologie identique pour tous les noeuds");
}
// --- Une tuile grossiere reste DANS les bornes de son noeud -------------
{
const MeshData rootMesh = terrainNodeMeshData(heightmap, quadtree, 0);
const TerrainQuadtree::Node& root = quadtree.node(0);
bool inside = true;
for (const Vertex& vertex : rootMesh.vertices) {
inside = inside &&
vertex.pos.x >= root.boundsMin.x - 1e-3f &&
vertex.pos.x <= root.boundsMax.x + 1e-3f &&
vertex.pos.z >= root.boundsMin.z - 1e-3f &&
vertex.pos.z <= root.boundsMax.z + 1e-3f &&
vertex.pos.y >= root.boundsMin.y - 1e-3f &&
vertex.pos.y <= root.boundsMax.y + 1e-3f;
}
check(inside, "Tuile grossiere : tous ses sommets tiennent dans la boite du noeud");
}
// --- DECOUPLAGE RENDU / COLLISION ---------------------------------------
// Le point le plus important de la Phase 10 cote gameplay : la physique ne
// doit RIEN devoir au niveau de detail affiche. La Heightmap reste la source
// unique et pleine resolution de heightAt() ; construire, selectionner ou
// mailler le quadtree ne la touche pas.
{
const float before = heightmap.heightAt(12.5f, -33.25f);
const Frustum everything = Frustum::fromViewProjection(glm::mat4(0.0f));
quadtree.select(glm::vec3(0.0f, 5000.0f, 0.0f), everything, selection); // tout au loin
const float farAway = heightmap.heightAt(12.5f, -33.25f);
quadtree.select(glm::vec3(12.5f, 0.0f, -33.25f), everything, selection); // au contact
const float closeUp = heightmap.heightAt(12.5f, -33.25f);
check(before == farAway && before == closeUp,
"Collision : heightAt() est insensible au niveau de detail selectionne");
// Et la surface de collision est bien celle de la donnee, pas celle
// d'une tuile grossiere : au noeud de grille, heightAt() vaut at().
checkNear(heightmap.heightAt(heightmap.worldCoord(70), heightmap.worldCoord(70)),
heightmap.at(70, 70), 1e-3f,
"Collision : heightAt() reste la surface pleine resolution");
}
// --- Grilles non multiples de la taille de tuile -------------------------
// Le terrain procedural (128 echantillons, donc 127 cellules) et la zone
// assemblee (5001, donc 5000) ne tombent PAS sur un multiple de 64. Le
// quadtree doit les accepter en ecretant, sans deborder ni laisser de trou.
{
Heightmap::Params odd;
odd.resolution = 128;
odd.worldSize = 127.0f;
const Heightmap oddMap(odd);
const TerrainQuadtree oddTree(oddMap, quadtreeParams);
check(oddTree.rootLevel() == 1, "Grille de 127 cellules : racine au niveau 1");
const MeshData mesh = terrainNodeMeshData(oddMap, oddTree, 0);
const float edge = oddMap.worldCoord(oddMap.resolution() - 1);
bool clamped = true;
for (const Vertex& vertex : mesh.vertices) {
clamped = clamped && vertex.pos.x <= edge + 1e-3f && vertex.pos.z <= edge + 1e-3f;
}
check(clamped,
"Grille non multiple : aucun sommet ne depasse le bord (ecretage, pas d'etagere)");
}
// --- Parametres invalides refuses ---------------------------------------
{
const auto rejected = [&](const TerrainQuadtree::Params& bad) {
try {
TerrainQuadtree tree(heightmap, bad);
return false;
} catch (const std::runtime_error&) {
return true;
}
};
TerrainQuadtree::Params notPowerOfTwo = quadtreeParams;
notPowerOfTwo.nodeCells = 60;
check(rejected(notPowerOfTwo), "Refus : nodeCells qui n'est pas une puissance de deux");
// morphStartRatio <= 0.5 rouvrirait les fissures entre niveaux : le
// constructeur doit le refuser plutot que de produire un terrain fendu.
TerrainQuadtree::Params tooEarly = quadtreeParams;
tooEarly.morphStartRatio = 0.4f;
check(rejected(tooEarly), "Refus : bande de morphing qui commence trop tot");
}
}
// ===========================================================================
// PHASE 11 : orthophoto, vegetation de decor, herbe
// ===========================================================================
// Carte constante : sert a verifier que le semis SUIT bien la carte, en
// comparant deux mondes qui ne different QUE par elle.
class ConstantMap : public HeightSampler {
public:
explicit ConstantMap(float value) : value_(value) {}
float heightAt(float, float) const override { return value_; }
private:
float value_;
};
// Couvert coupe en deux : boise a l'est de x = 0, nu a l'ouest. C'est le test
// decisif de la tache 2 - le semis doit reproduire la frontiere.
class HalfCoveredMap : public HeightSampler {
public:
float heightAt(float x, float) const override { return x > 0.0f ? 1.0f : 0.0f; }
};
// Frustum qui accepte tout : les tests de SEMIS ne doivent pas dependre du
// cadrage. Les six plans delimitent un volume immense.
Frustum permissiveFrustum() {
Frustum frustum;
const float far = 1.0e6f;
frustum.planes[0] = { 1.0f, 0.0f, 0.0f, far };
frustum.planes[1] = { -1.0f, 0.0f, 0.0f, far };
frustum.planes[2] = { 0.0f, 1.0f, 0.0f, far };
frustum.planes[3] = { 0.0f, -1.0f, 0.0f, far };
frustum.planes[4] = { 0.0f, 0.0f, 1.0f, far };
frustum.planes[5] = { 0.0f, 0.0f, -1.0f, far };
return frustum;
}
// Le semis d'arbres est BUDGETE : gatherTrees ne construit qu'un nombre limite
// de cellules neuves par appel (VegetationParams::treeCellBudget), pour qu'une
// arrivee dans une zone vierge n'engendre pas des milliers de cellules d'un coup
// et ne fasse pas un a-coup visible. En jeu, les cellules manquantes arrivent aux
// images suivantes ; dans un test, il faut donc appeler jusqu'a ce que le semis
// se stabilise, sinon on ne juge que du premier lot construit - c'est-a-dire du
// coin le plus au sud-ouest de la zone balayee, ce qui n'a aucun sens.
void gatherTreesUntilStable(Vegetation& vegetation, const glm::vec3& eye,
const Frustum& frustum, std::vector<InstanceData>& out) {
std::size_t previous = 0;
int stable = 0;
for (int pass = 0; pass < 400 && stable < 3; ++pass) {
vegetation.gatherTrees(eye, frustum, out);
stable = (out.size() == previous) ? stable + 1 : 0;
previous = out.size();
}
}
void testTextureFile() {
section("Phase 11 : format de texture .vcto");
// BC1 : blocs de 4x4 texels sur 8 octets.
check(textureLevelSize(TextureFormat::BC1, 8, 8) == 4ull * 8ull,
"BC1 8x8 = 4 blocs de 8 octets");
check(textureLevelSize(TextureFormat::BC1, 8192, 8192) == 33554432ull,
"BC1 8192x8192 = 32 Mo");
// Les derniers niveaux de mipmap ne sont PAS multiples de 4 : ils occupent
// quand meme un bloc entier. Se tromper ici decale toute la fin de la chaine
// et le fichier ne correspond plus a son en-tete.
check(textureLevelSize(TextureFormat::BC1, 2, 2) == 8ull,
"BC1 2x2 occupe un bloc entier");
check(textureLevelSize(TextureFormat::BC1, 1, 1) == 8ull,
"BC1 1x1 occupe un bloc entier");
check(textureLevelSize(TextureFormat::RGBA8, 16, 8) == 512ull,
"RGBA8 16x8 = 512 octets");
// La chaine complete d'une texture de 8192, telle que la calcule le
// chargeur, doit valoir exactement la taille produite par l'outil Python.
uint64_t total = 0;
for (uint32_t level = 0; level < 14; ++level) {
const uint32_t side = std::max(1u, 8192u >> level);
total += textureLevelSize(TextureFormat::BC1, side, side);
}
check(total == 44739256ull,
"Chaine de 14 mipmaps BC1 8192 = 44 739 256 octets");
TextureData data;
data.width = 8192;
data.height = 8192;
data.eastMin = 899000.0;
data.eastMax = 904000.0;
data.northMin = 6435000.0;
data.northMax = 6440000.0;
checkNear(static_cast<float>(data.metresPerTexel()), 0.6104f, 0.001f,
"0,61 m par texel sur 5 km en 8192 texels");
// Un fichier absent doit LEVER, pas renvoyer une texture vide qui serait
// ensuite drapee en silence sur le terrain.
bool threw = false;
try {
loadTextureFile("chemin/qui/n/existe/pas.vcto");
} catch (const std::exception&) {
threw = true;
}
check(threw, "Refus : fichier .vcto absent");
// --- PHASE 30 : en-tete seul, puis charge utile lue a la demande --------
// Le chargement de l'orthophoto ne tient plus la charge utile en RAM : il
// lit l'en-tete, puis des TRANCHES directement dans le staging. Les deux
// chemins doivent rendre exactement les memes octets que loadTextureFile.
{
const std::string path =
(std::filesystem::temp_directory_path() / "vercora_phase30_test.vcto").string();
std::vector<unsigned char> payload;
const uint32_t width = 8;
const uint32_t height = 4;
uint32_t levels = 0;
for (uint32_t w = width, h = height;; w = std::max(1u, w / 2), h = std::max(1u, h / 2)) {
for (uint32_t k = 0; k < w * h * 4; ++k) {
payload.push_back(static_cast<unsigned char>((payload.size() * 37u + 11u) & 0xFFu));
}
++levels;
if (w == 1 && h == 1) {
break;
}
}
unsigned char header[128] = {};
std::memcpy(header, "VCTO", 4);
const uint32_t fields[5] = { 1u, width, height, levels, 0u /* RGBA8 */ };
std::memcpy(header + 4, fields, sizeof(fields));
const double extent[4] = { 899000.0, 6435000.0, 904000.0, 6440000.0 };
std::memcpy(header + 24, extent, sizeof(extent));
const uint32_t epsg = 2154u;
std::memcpy(header + 56, &epsg, sizeof(epsg));
{
std::ofstream out(path, std::ios::binary);
out.write(reinterpret_cast<const char*>(header), sizeof(header));
out.write(reinterpret_cast<const char*>(payload.data()),
static_cast<std::streamsize>(payload.size()));
}
const TextureData full = loadTextureFile(path);
const TextureData headerOnly = loadTextureFileHeader(path);
check(full.pixels == payload && full.payloadSize() == payload.size(),
"Phase 30 : loadTextureFile rend la charge utile complete");
check(headerOnly.pixels.empty() && headerOnly.payloadSize() == payload.size() &&
headerOnly.mips.size() == full.mips.size(),
"Phase 30 : l'en-tete seul decrit la meme chaine, sans aucun texel");
std::vector<unsigned char> whole(payload.size());
readTexturePayload(path, headerOnly, whole.data());
std::vector<unsigned char> banded(payload.size());
std::ifstream in(path, std::ios::binary);
for (uint64_t offset = 0; offset < payload.size(); offset += 24) {
const uint64_t bytes = std::min<uint64_t>(24, payload.size() - offset);
readTexturePayload(in, offset, bytes, banded.data() + offset);
}
check(whole == payload && banded == payload,
"Phase 30 : lecture directe et lecture par tranches = memes octets");
std::filesystem::remove(path);
}
}
void testGrassMesh() {
section("Phase 11 : maillage de touffe d'herbe");
const MeshData tuft = grassTuftMeshData(3);
check(tuft.vertices.size() == 12, "3 quads croises = 12 sommets");
check(tuft.triangleCount() == 6, "3 quads croises = 6 triangles");
// CONVENTION UNITE, la meme que l'arbre : pied a l'origine, hauteur 1. Une
// touffe deja a l'echelle obligerait a une echelle non uniforme, donc a
// transporter une vraie normal matrix (voir InstanceData.hpp).
float lowest = 1.0e9f;
float highest = -1.0e9f;
for (const Vertex& vertex : tuft.vertices) {
lowest = std::min(lowest, vertex.pos.y);
highest = std::max(highest, vertex.pos.y);
}
checkNear(lowest, 0.0f, 1e-5f, "Pied de la touffe a l'altitude zero");
checkNear(highest, 1.0f, 1e-5f, "Sommet de la touffe a l'altitude un");
// L'UV.y porte la hauteur dans le brin : c'est ce que lit le vertex shader
// pour plier la touffe SANS decoller son pied du sol. Un uv.y non nul au
// pied ferait glisser la touffe hors de terre a chaque coup de vent.
bool feetPinned = true;
bool normalsRaised = true;
for (const Vertex& vertex : tuft.vertices) {
if (vertex.pos.y < 0.5f && std::abs(vertex.uv.y) > 1e-5f) {
feetPinned = false;
}
if (vertex.normal.y <= 0.5f) {
normalsRaised = false;
}
}
check(feetPinned, "uv.y nul au pied de chaque brin");
// Normale relevee vers le haut : un quad vertical dont la normale serait
// horizontale ne recevrait presque rien d'une lumiere zenithale.
check(normalsRaised, "Normales de brin relevees vers le haut");
}
// ---------------------------------------------------------------------------
// PHASE 19 : le maillage d'une tuile est-il vraiment insensible au thread ?
// ---------------------------------------------------------------------------
// La Phase 19 deplace terrainNodeMeshData du thread de rendu vers un petit
// groupe de threads. Tout repose sur UNE affirmation : cette fonction est PURE,
// donc N tuiles maillees en parallele donnent exactement les memes octets que
// les memes N tuiles maillees en sequence.
//
// C'est une affirmation qu'on ne peut PAS verifier en regardant l'image. Deux
// captures du jeu different deja entre deux executions identiques (l'herbe et
// la faune s'animent avec le temps ecoule, et le temps ecoule depend du debit
// d'images, que la phase change justement) : la comparaison de pixels a un
// plancher de bruit de l'ordre du pour-cent, largement au-dessus de ce qu'on
// cherche a detecter. Le seul controle qui tranche est celui-ci, deterministe
// et bit a bit.
//
// Le test compare les SOMMETS octet par octet, et non a une tolerance pres :
// une course sur une donnee partagee ne produirait pas un petit ecart
// numerique, elle produirait un sommet pris a la mauvaise tuile.
void testTileMeshingIsThreadSafe() {
section("Phase 19 : maillage de tuiles en parallele");
Heightmap::Params hparams;
hparams.resolution = 513; // 512 cellules = 8 x 8 feuilles de 64
hparams.worldSize = 512.0f;
hparams.seed = 1907u;
const Heightmap heightmap(hparams);
TerrainQuadtree::Params qparams;
qparams.nodeCells = 64;
const TerrainQuadtree quadtree(heightmap, qparams);
// Un lot volontairement plus GROS que le nombre de threads, et melangeant
// les niveaux : une tuile grossiere lit la heightmap au pas du noeud et
// touche donc une tout autre partie de la donnee qu'une feuille. Si un etat
// etait partage quelque part dans terrainNodeMeshData, c'est ce melange qui
// le ferait sortir.
std::vector<uint32_t> nodes;
for (uint32_t index = 0; index < quadtree.nodeCount() && nodes.size() < 40; ++index) {
nodes.push_back(index);
}
check(nodes.size() >= 8, "Phase 19 : assez de tuiles pour un lot de test");
// --- Reference : tout en sequence, sur ce thread -----------------------
std::vector<MeshData> reference(nodes.size());
for (std::size_t k = 0; k < nodes.size(); ++k) {
reference[k] = terrainNodeMeshData(heightmap, quadtree, nodes[k], false);
}
// --- Le meme lot, sur 4 threads, decoupe en tranches contigues ----------
// Meme decoupage que TerrainStreamer::meshBatch : chaque thread ecrit dans
// des elements disjoints d'un vecteur deja dimensionne.
const std::size_t slices = 4;
std::vector<MeshData> parallel(nodes.size());
{
std::vector<std::thread> threads;
const std::size_t total = nodes.size();
const auto sliceBegin = [total, slices](std::size_t s) {
return (total * s) / slices;
};
const auto worker = [&](std::size_t begin, std::size_t end) {
for (std::size_t k = begin; k < end; ++k) {
parallel[k] = terrainNodeMeshData(heightmap, quadtree, nodes[k], false);
}
};
for (std::size_t s = 1; s < slices; ++s) {
threads.emplace_back(worker, sliceBegin(s), sliceBegin(s + 1));
}
worker(sliceBegin(0), sliceBegin(1));
for (std::thread& t : threads) {
t.join();
}
}
bool sameCount = true;
bool sameBytes = true;
bool sameNames = true;
for (std::size_t k = 0; k < nodes.size(); ++k) {
if (reference[k].vertices.size() != parallel[k].vertices.size()) {
sameCount = false;
continue;
}
sameNames = sameNames && (reference[k].name == parallel[k].name);
// memcmp, et non une comparaison champ a champ : on veut que le test
// echoue aussi sur un champ qu'on aurait oublie d'ajouter ici le jour
// ou Vertex grandira.
if (std::memcmp(reference[k].vertices.data(), parallel[k].vertices.data(),
reference[k].vertices.size() * sizeof(Vertex)) != 0) {
sameBytes = false;
}
}
check(sameCount, "Phase 19 : meme nombre de sommets par tuile en parallele");
check(sameNames, "Phase 19 : meme nom de tuile en parallele");
check(sameBytes,
"Phase 19 : sommets BIT A BIT identiques, en sequence et sur 4 threads");
// Le temoin du test lui-meme : si le lot etait constitue de tuiles toutes
// identiques, la verification ci-dessus passerait sans rien prouver. On
// s'assure donc que les tuiles comparees sont bien DIFFERENTES entre elles.
bool tilesDiffer = false;
for (std::size_t k = 1; k < reference.size() && !tilesDiffer; ++k) {
tilesDiffer = std::memcmp(reference[0].vertices.data(),
reference[k].vertices.data(),
reference[0].vertices.size() * sizeof(Vertex)) != 0;
}
check(tilesDiffer,
"Phase 19 : le lot compare contient bien des tuiles distinctes (temoin)");
// Repetitions : une course se manifeste rarement. Un seul passage qui
// reussit ne dit presque rien ; c'est la raison d'etre de cette boucle.
bool stableOverRuns = true;
for (int attempt = 0; attempt < 12 && stableOverRuns; ++attempt) {
std::vector<MeshData> again(nodes.size());
std::vector<std::thread> threads;
const std::size_t total = nodes.size();
const auto sliceBegin = [total, slices](std::size_t s) {
return (total * s) / slices;
};
const auto worker = [&](std::size_t begin, std::size_t end) {
for (std::size_t k = begin; k < end; ++k) {
again[k] = terrainNodeMeshData(heightmap, quadtree, nodes[k], false);
}
};
for (std::size_t s = 1; s < slices; ++s) {
threads.emplace_back(worker, sliceBegin(s), sliceBegin(s + 1));
}
worker(sliceBegin(0), sliceBegin(1));
for (std::thread& t : threads) {
t.join();
}
for (std::size_t k = 0; k < nodes.size() && stableOverRuns; ++k) {
stableOverRuns =
(again[k].vertices.size() == reference[k].vertices.size()) &&
std::memcmp(again[k].vertices.data(), reference[k].vertices.data(),
reference[k].vertices.size() * sizeof(Vertex)) == 0;
}
}
check(stableOverRuns,
"Phase 19 : 12 passages paralleles de plus, tous identiques a la reference");
}
void testGrassPhase18() {
section("Phase 18 : herbe plus dense et brins decoupes");
// --- Le quad est devenu une PLANCHE a decouper -------------------------
// La silhouette n'est plus portee par le contour du polygone mais par le
// masque de shaders/foliage.frag. Le quad doit donc etre large et peu
// effile, faute de quoi les brins decoupes seraient plus maigres que le
// ruban de la Phase 11 - c'est-a-dire un recul.
const MeshData tuft = grassTuftMeshData(3);
float baseHalfWidth = 0.0f;
float tipHalfWidth = 0.0f;
for (const Vertex& vertex : tuft.vertices) {
const float halfWidth = std::sqrt(vertex.pos.x * vertex.pos.x +
vertex.pos.z * vertex.pos.z);
if (vertex.pos.y < 0.5f) {
baseHalfWidth = std::max(baseHalfWidth, halfWidth);
} else {
tipHalfWidth = std::max(tipHalfWidth, halfWidth);
}
}
check(baseHalfWidth > 0.35f, "Quad large au pied : le masque a la place de decouper");
check(tipHalfWidth > 0.25f,
"Quad a peine effile : c'est le masque, et non le polygone, qui effile le brin");
// --- Densite ----------------------------------------------------------
SlopedTerrain terrain(1200.0f, 0.0f);
const Frustum frustum = permissiveFrustum();
const glm::vec3 eye(0.0f, 1200.0f, 0.0f);
ConstantMap dense(1.0f);
ConstantMap lowCanopy(0.0f);
VegetationParams phase18;
VegetationParams phase11 = phase18;
phase11.grassSlots = 24; // le reglage d'avant la Phase 18
std::vector<InstanceData> now;
std::vector<InstanceData> before;
Vegetation(terrain, &dense, &lowCanopy, 2000.0f, phase18)
.gatherGrass(eye, frustum, now);
Vegetation(terrain, &dense, &lowCanopy, 2000.0f, phase11)
.gatherGrass(eye, frustum, before);
check(!before.empty(), "Temoin Phase 11 : de l'herbe est bien semee");
check(now.size() > before.size() * 2,
"Phase 18 : plus du DOUBLE de touffes sur la meme vue et la meme carte");
// --- La decoupe alpha ne touche pas au SEMIS --------------------------
// grassCutout est un parametre de RENDU. S'il changeait le nombre de
// touffes, le temoin --no-grass-cutout ne mesurerait plus la decoupe seule
// mais un melange des deux, et la mesure de la phase n'aurait aucune valeur.
VegetationParams opaque = phase18;
opaque.grassCutout = 0.0f;
std::vector<InstanceData> opaqueGrass;
Vegetation(terrain, &dense, &lowCanopy, 2000.0f, opaque)
.gatherGrass(eye, frustum, opaqueGrass);
check(opaqueGrass.size() == now.size(),
"grassCutout ne change pas d'une touffe le semis (temoin honnete)");
// --- Le pied des touffes reste SUR le sol ------------------------------
// La hauteur n'est plus echantillonnee par touffe mais interpolee entre les
// quatre coins de la cellule. Sur un plan incline - que les deux triangles
// reproduisent exactement - l'ecart doit etre nul : c'est ce qui prouve que
// l'optimisation n'a pas decolle l'herbe du terrain.
SlopedTerrain ramp(1200.0f, 0.35f);
std::vector<InstanceData> onRamp;
Vegetation(ramp, &dense, &lowCanopy, 2000.0f, phase18)
.gatherGrass(glm::vec3(0.0f, 1200.0f, 0.0f), frustum, onRamp);
check(!onRamp.empty(), "De l'herbe pousse aussi sur le versant");
float worstGap = 0.0f;
for (const InstanceData& blade : onRamp) {
worstGap = std::max(worstGap,
std::abs(blade.position.y -
ramp.heightAt(blade.position.x, blade.position.z)));
}
checkNear(worstGap, 0.0f, 1e-3f,
"Pied pose au sol malgre l'interpolation par cellule (versant a 35 %)");
}
void testVegetationPlacement() {
section("Phase 11 : semis de la vegetation de decor");
SlopedTerrain terrain(1200.0f, 0.0f); // plat a 1200 m : pente nulle
const Frustum frustum = permissiveFrustum();
const glm::vec3 eye(0.0f, 1200.0f, 0.0f);
VegetationParams params;
ConstantMap dense(1.0f);
ConstantMap canopy(20.0f);
// --- Le couvert commande bien le semis ---------------------------------
{
ConstantMap bare(0.0f);
Vegetation wooded(terrain, &dense, &canopy, 2000.0f, params);
Vegetation empty(terrain, &bare, &canopy, 2000.0f, params);
std::vector<InstanceData> woodedTrees;
std::vector<InstanceData> emptyTrees;
gatherTreesUntilStable(wooded, eye, frustum, woodedTrees);
gatherTreesUntilStable(empty, eye, frustum, emptyTrees);
check(!woodedTrees.empty(), "Couvert a 1 : des arbres sont semes");
check(emptyTrees.empty(),
"Couvert a 0 : AUCUN arbre - c'est ce qui garde les lapiaz nus");
}
// --- Frontiere de foret : le semis reproduit la carte -------------------
{
HalfCoveredMap half;
Vegetation vegetation(terrain, &half, &canopy, 2000.0f, params);
std::vector<InstanceData> trees;
gatherTreesUntilStable(vegetation, eye, frustum, trees);
check(!trees.empty(), "Carte a deux moities : des arbres sont semes");
std::size_t west = 0;
for (const InstanceData& tree : trees) {
if (tree.position.x < -params.treeCell) {
++west;
}
}
check(west == 0, "Aucun arbre du cote NU de la frontiere de couvert");
}
// --- Determinisme : meme graine, meme foret ----------------------------
{
Vegetation a(terrain, &dense, &canopy, 2000.0f, params);
Vegetation b(terrain, &dense, &canopy, 2000.0f, params);
std::vector<InstanceData> first;
std::vector<InstanceData> second;
gatherTreesUntilStable(a, eye, frustum, first);
gatherTreesUntilStable(b, eye, frustum, second);
check(first.size() == second.size(), "Meme graine : meme nombre d'arbres");
bool identical = first.size() == second.size();
for (std::size_t i = 0; identical && i < first.size(); ++i) {
identical = first[i].position == second[i].position &&
first[i].scale == second[i].scale &&
first[i].yaw == second[i].yaw;
}
check(identical, "Meme graine : arbres identiques au bit pres");
}
// --- Le semis ne depend PAS du chemin parcouru -------------------------
// C'est la propriete qui autorise a ne rien stocker pour les 25 km2 : une
// cellule decouverte de loin puis approchee doit donner les memes arbres
// qu'une cellule decouverte directement au contact. Un generateur A ETAT
// (mt19937) echouerait ici ; un hachage passe.
{
Vegetation direct(terrain, &dense, &canopy, 2000.0f, params);
Vegetation wandered(terrain, &dense, &canopy, 2000.0f, params);
std::vector<InstanceData> scratch;
gatherTreesUntilStable(wandered, { 700.0f, 1200.0f, -400.0f }, frustum, scratch);
gatherTreesUntilStable(wandered, { -900.0f, 1200.0f, 850.0f }, frustum, scratch);
gatherTreesUntilStable(wandered, { 120.0f, 1200.0f, 60.0f }, frustum, scratch);
std::vector<InstanceData> a;
std::vector<InstanceData> b;
gatherTreesUntilStable(direct, eye, frustum, a);
gatherTreesUntilStable(wandered, eye, frustum, b);
check(a.size() == b.size(),
"Semis independant du chemin : meme nombre d'arbres");
bool identical = a.size() == b.size();
for (std::size_t i = 0; identical && i < a.size(); ++i) {
identical = a[i].position == b[i].position && a[i].scale == b[i].scale;
}
check(identical, "Semis independant du chemin : arbres identiques");
}
// --- Rien hors des donnees ---------------------------------------------
{
const float extent = 300.0f;
Vegetation vegetation(terrain, &dense, &canopy, extent, params);
std::vector<InstanceData> trees;
gatherTreesUntilStable(vegetation, eye, frustum, trees);
bool inside = true;
for (const InstanceData& tree : trees) {
inside = inside && std::abs(tree.position.x) <= extent &&
std::abs(tree.position.z) <= extent;
}
check(inside, "Aucun arbre au-dela de l'emprise du terrain");
}
// --- Niveau de detail de DENSITE ---------------------------------------
// Les arbres proches doivent etre plus nombreux, PAR UNITE DE SURFACE, que
// les arbres lointains : c'est tout l'objet de la portee par emplacement.
{
Vegetation vegetation(terrain, &dense, &canopy, 4000.0f, params);
std::vector<InstanceData> trees;
gatherTreesUntilStable(vegetation, eye, frustum, trees);
std::size_t near = 0;
std::size_t far = 0;
for (const InstanceData& tree : trees) {
const float d = glm::length(tree.position - eye);
if (d < 200.0f) {
++near;
} else if (d > 600.0f && d < 1000.0f) {
++far;
}
}
// On compare des DENSITES et non des comptes bruts : la couronne
// lointaine est bien plus vaste que le disque proche.
const double nearArea = 3.14159 * 200.0 * 200.0;
const double farArea = 3.14159 * (1000.0 * 1000.0 - 600.0 * 600.0);
const double nearDensity = static_cast<double>(near) / nearArea;
const double farDensity = static_cast<double>(far) / farArea;
check(near > 0 && far > 0, "Des arbres proches ET lointains");
check(nearDensity > farDensity * 1.5,
"Niveau de detail de densite : la foret s'eclaircit avec la distance");
}
// --- Attenuation : les plus lointains retrecissent ---------------------
{
Vegetation vegetation(terrain, &dense, &canopy, 4000.0f, params);
std::vector<InstanceData> trees;
gatherTreesUntilStable(vegetation, eye, frustum, trees);
bool fadeInRange = true;
bool someFaded = false;
for (const InstanceData& tree : trees) {
fadeInRange = fadeInRange && tree.fade >= 0.0f && tree.fade <= 1.0f;
if (tree.fade < 0.999f) {
someFaded = true;
}
}
check(fadeInRange, "Attenuation toujours dans [0,1]");
check(someFaded, "Certains arbres lointains sont attenues");
}
// --- Substitut sans carte LiDAR ----------------------------------------
// Sans carte, le semis doit encore produire quelque chose de plausible et
// refuser les hautes altitudes (limite des arbres).
{
SlopedTerrain low(1200.0f, 0.0f);
SlopedTerrain high(2100.0f, 0.0f);
Vegetation belowTreeline(low, nullptr, nullptr, 2000.0f, params);
Vegetation aboveTreeline(high, nullptr, nullptr, 2000.0f, params);
std::vector<InstanceData> lowTrees;
std::vector<InstanceData> highTrees;
gatherTreesUntilStable(belowTreeline, { 0.0f, 1200.0f, 0.0f }, frustum, lowTrees);
gatherTreesUntilStable(aboveTreeline, { 0.0f, 2100.0f, 0.0f }, frustum, highTrees);
check(!lowTrees.empty(), "Substitut : des arbres sous la limite des arbres");
check(highTrees.empty(), "Substitut : aucun arbre au-dessus de 1950 m");
}
// --- Pente : pas d'arbre sur une paroi ---------------------------------
{
SlopedTerrain cliff(1200.0f, 3.0f); // 3 m d'altitude par metre parcouru
Vegetation vegetation(cliff, &dense, &canopy, 2000.0f, params);
std::vector<InstanceData> trees;
gatherTreesUntilStable(vegetation, { 0.0f, 1200.0f, 0.0f }, frustum, trees);
check(trees.empty(), "Aucun arbre sur une pente de 3 pour 1");
}
}
void testGrassPlacement() {
section("Phase 11 : semis de l'herbe");
const Frustum frustum = permissiveFrustum();
VegetationParams params;
ConstantMap cover(0.5f);
ConstantMap noCanopy(0.0f);
// --- L'altitude commande la TAILLE et la DENSITE ------------------------
// C'est la demande explicite de la tache 3 : plus haut = plus petit et plus
// rare (pelouse alpine rase).
auto sampleAt = [&](float altitude, std::vector<InstanceData>& out) {
SlopedTerrain terrain(altitude, 0.0f);
Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f, params);
vegetation.gatherGrass({ 0.0f, altitude, 0.0f }, frustum, out);
};
std::vector<InstanceData> low;
std::vector<InstanceData> mid;
std::vector<InstanceData> high;
sampleAt(1200.0f, low); // sous grassAltitudeLush : pleine densite
sampleAt(2050.0f, mid); // entre les deux seuils
sampleAt(2400.0f, high); // au-dessus de grassAltitudeBarren
check(!low.empty(), "De l'herbe en dessous de la limite d'alpage");
check(high.empty(), "Aucune herbe au-dessus de l'altitude sterile");
check(mid.size() < low.size(), "L'herbe se rarefie avec l'altitude");
auto meanScale = [](const std::vector<InstanceData>& tufts) {
double total = 0.0;
for (const InstanceData& tuft : tufts) {
total += tuft.scale;
}
return tufts.empty() ? 0.0 : total / static_cast<double>(tufts.size());
};
check(meanScale(mid) < meanScale(low), "Les touffes rapetissent avec l'altitude");
check(meanScale(low) < params.grassSizeLow * 1.3,
"Taille des touffes coherente avec grassSizeLow");
// --- Portee COURTE ------------------------------------------------------
{
SlopedTerrain terrain(1200.0f, 0.0f);
Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f, params);
std::vector<InstanceData> tufts;
const glm::vec3 eye(0.0f, 1200.0f, 0.0f);
vegetation.gatherGrass(eye, frustum, tufts);
float furthest = 0.0f;
for (const InstanceData& tuft : tufts) {
furthest = std::max(furthest, glm::length(tuft.position - eye));
}
check(furthest <= params.grassDistanceFar + 0.001f,
"Aucune touffe au-dela de la portee de rendu");
check(furthest > 0.5f * params.grassDistanceFar,
"L'herbe occupe bien sa portee");
}
// --- Le placement n'est PAS une grille reguliere ------------------------
// Le risque explicitement a eviter. Un semis regulier donnerait des
// distances au plus proche voisin toutes egales ; un semis groupe donne une
// large dispersion. On compare l'ecart-type a la moyenne.
{
SlopedTerrain terrain(1200.0f, 0.0f);
Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f, params);
std::vector<InstanceData> tufts;
vegetation.gatherGrass({ 0.0f, 1200.0f, 0.0f }, frustum, tufts);
check(tufts.size() > 200, "Assez de touffes pour juger de la repartition");
// Distance au plus proche voisin, sur un echantillon (le calcul est
// quadratique).
const std::size_t sampleCount =
std::min<std::size_t>(150, tufts.size());
std::vector<float> nearest;
nearest.reserve(sampleCount);
for (std::size_t i = 0; i < sampleCount; ++i) {
float best = 1.0e9f;
for (std::size_t j = 0; j < tufts.size(); ++j) {
if (i == j) {
continue;
}
best = std::min(best, horizontalDistance(tufts[i].position,
tufts[j].position));
}
nearest.push_back(best);
}
double mean = 0.0;
for (float value : nearest) {
mean += value;
}
mean /= static_cast<double>(nearest.size());
double variance = 0.0;
for (float value : nearest) {
variance += (value - mean) * (value - mean);
}
variance /= static_cast<double>(nearest.size());
const double deviation = std::sqrt(variance);
// Sur une grille PARFAITE toutes les distances seraient egales et
// l'ecart-type nul. On exige une dispersion d'au moins 25 % de la
// moyenne : c'est la signature d'un placement groupe.
check(deviation > 0.25 * mean,
"Placement groupe et non regulier (dispersion du plus proche voisin)");
}
// --- Determinisme -------------------------------------------------------
{
SlopedTerrain terrain(1200.0f, 0.0f);
Vegetation a(terrain, &cover, &noCanopy, 4000.0f, params);
Vegetation b(terrain, &cover, &noCanopy, 4000.0f, params);
std::vector<InstanceData> first;
std::vector<InstanceData> second;
a.gatherGrass({ 12.0f, 1200.0f, -7.0f }, frustum, first);
b.gatherGrass({ 12.0f, 1200.0f, -7.0f }, frustum, second);
check(first.size() == second.size() && !first.empty(),
"Meme graine : meme herbe");
}
}
void testInstanceLayout() {
section("Phase 11 : format d'instance");
// Ces proprietes sont SUPPOSEES par VertexFormat.hpp, qui lit (scale, yaw)
// et (variation, fade) comme des vec2. Un membre insere entre les deux
// ferait lire n'importe quoi par le GPU, en silence.
check(sizeof(InstanceData) == 28, "InstanceData tient en 28 octets");
check(offsetof(InstanceData, yaw) == offsetof(InstanceData, scale) + sizeof(float),
"scale et yaw contigus");
check(offsetof(InstanceData, fade) == offsetof(InstanceData, variation) + sizeof(float),
"variation et fade contigus");
// Valeurs par defaut NEUTRES : une instance non renseignee doit etre visible
// a sa taille normale, pas invisible.
const InstanceData fresh;
checkNear(fresh.scale, 1.0f, 1e-6f, "Echelle par defaut a 1");
checkNear(fresh.fade, 1.0f, 1e-6f, "Attenuation par defaut a 1");
}
} // namespace
// ---------------------------------------------------------------------------
// Phase 12 : chaine de peres du quadtree et repli sur l'ancetre
// ---------------------------------------------------------------------------
// Le repli sur l'ancetre vit dans TerrainStreamer, qui pilote le Renderer donc
// Vulkan : il n'est pas testable ici. Ce qui l'EST, et qui est ce dont il
// depend entierement, c'est la structure sur laquelle il s'appuie - la chaine de
// peres et la description d'un noeud hors selection. Une erreur a ce niveau
// (chainage casse par une reallocation de nodes_, boucle, morphing different de
// celui de la selection) donnerait un repli silencieusement faux.
void testQuadtreeAncestry() {
section("Phase 12 : chaine de peres et repli sur l'ancetre");
Heightmap::Params params;
params.resolution = 513;
params.worldSize = 512.0f;
params.seed = 4242u;
Heightmap heightmap(params);
TerrainQuadtree quadtree(heightmap);
// --- La chaine de peres est complete et coherente ------------------------
{
uint32_t roots = 0;
bool levelsIncrease = true;
bool childOfItsParent = true;
uint32_t maxDepth = 0;
for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) {
const int32_t parent = quadtree.parentIndex(index);
if (parent < 0) {
++roots;
continue;
}
const TerrainQuadtree::Node& node = quadtree.node(index);
const TerrainQuadtree::Node& up = quadtree.node(static_cast<uint32_t>(parent));
// Le pere est exactement un niveau au-dessus.
if (up.level != node.level + 1) {
levelsIncrease = false;
}
// ... et il reconnait bien ce fils. C'est ce test qui attraperait un
// chainage pose sur une reference devenue pendante apres
// reallocation de nodes_ pendant la construction recursive.
bool found = false;
for (int i = 0; i < 4; ++i) {
if (up.children[i] == static_cast<int32_t>(index)) {
found = true;
}
}
if (!found) {
childOfItsParent = false;
}
// Remontee : elle doit se terminer, et sur la racine.
uint32_t depth = 0;
int32_t current = parent;
while (current >= 0 && depth <= quadtree.rootLevel() + 1u) {
current = quadtree.parentIndex(static_cast<uint32_t>(current));
++depth;
}
maxDepth = std::max(maxDepth, depth);
}
check(roots == 1, "Chaine de peres : un seul noeud sans pere (la racine)");
check(levelsIncrease, "Chaine de peres : le pere est toujours au niveau du dessus");
check(childOfItsParent, "Chaine de peres : chaque noeud est bien un fils de son pere");
check(maxDepth <= quadtree.rootLevel(),
"Chaine de peres : la remontee se termine, en au plus rootLevel etapes");
}
// --- La boite d'un ancetre contient bien celle de ses descendants --------
// C'est LA propriete qui rend le repli correct : dessiner l'ancetre a la
// place d'un descendant couvre au moins la meme surface.
{
bool contains = true;
for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) {
const int32_t parent = quadtree.parentIndex(index);
if (parent < 0) {
continue;
}
const TerrainQuadtree::Node& node = quadtree.node(index);
const TerrainQuadtree::Node& up = quadtree.node(static_cast<uint32_t>(parent));
// Emprise horizontale seulement : c'est la couverture du sol qui
// compte pour un trou, et les bornes verticales remontent deja des
// fils par construction.
if (node.boundsMin.x < up.boundsMin.x || node.boundsMin.z < up.boundsMin.z ||
node.boundsMax.x > up.boundsMax.x || node.boundsMax.z > up.boundsMax.z) {
contains = false;
}
}
check(contains,
"Repli : l'emprise d'un pere contient celle de chacun de ses fils");
}
// --- describeNode redit exactement ce que dit la selection ---------------
// Un ancetre dessine par repli doit recevoir la MEME bande de geomorphing
// que s'il avait ete selectionne normalement, sinon la geometrie sauterait
// au moment ou le repli cesse.
{
const glm::vec3 eye(3.0f, 40.0f, 7.0f);
const Frustum everything = Frustum::fromViewProjection(glm::mat4(0.0f));
std::vector<TerrainQuadtree::SelectedNode> selection;
quadtree.select(eye, everything, selection);
check(!selection.empty(), "Repli : la selection de reference n'est pas vide");
bool identical = true;
for (const TerrainQuadtree::SelectedNode& selected : selection) {
const TerrainQuadtree::SelectedNode described =
quadtree.describeNode(selected.nodeIndex, eye);
if (described.level != selected.level ||
described.morphStart != selected.morphStart ||
described.morphEnd != selected.morphEnd ||
described.distance != selected.distance) {
identical = false;
}
}
check(identical,
"Repli : describeNode redonne au bit pres ce que produit select()");
// Et pour un noeud que la selection n'a PAS retenu (un ancetre, justement),
// la bande de morphing suit bien la portee de SON niveau.
const uint32_t leaf = selection.front().nodeIndex;
const int32_t up = quadtree.parentIndex(leaf);
check(up >= 0, "Repli : la tuile la plus proche a bien un pere");
if (up >= 0) {
const TerrainQuadtree::SelectedNode described =
quadtree.describeNode(static_cast<uint32_t>(up), eye);
checkNear(described.morphStart,
quadtree.range(described.level) * quadtree.params().morphStartRatio,
1e-3f, "Repli : la bande de morphing de l'ancetre suit SON niveau");
check(described.level == quadtree.node(leaf).level + 1,
"Repli : l'ancetre immediat est bien un niveau plus grossier");
}
}
// --- Le sommet du quadtree est peu peuple --------------------------------
// Le TerrainStreamer epingle les trois niveaux les plus grossiers pour que le
// repli soit toujours disponible. Ce n'est defendable que si ces niveaux
// comptent une poignee de tuiles : ce test fige cette hypothese.
{
uint32_t top = 0;
const int lowest = std::max(0, static_cast<int>(quadtree.rootLevel()) - 2);
for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) {
if (static_cast<int>(quadtree.node(index).level) >= lowest) {
++top;
}
}
check(top <= 21,
"Sommet epingle : au plus 21 tuiles sur les trois niveaux les plus grossiers");
check(top >= 1, "Sommet epingle : au moins la racine");
}
}
// ===========================================================================
// PHASE 15 : editeur de niveau
// ===========================================================================
// Ce que ce bloc couvre, et pourquoi il peut le couvrir sans GPU : TOUT
// l'editeur sauf le dessin. Le catalogue produit des MeshData, la scene et le
// controleur ne dependent que de GLM, le format de scene ne depend que de la
// bibliotheque standard, et le raycast terrain ne connait que HeightSampler.
// C'est le meme decoupage qui avait permis de tester la physique du parapente,
// du velo et de l'escalade sans fenetre.
//
// Ce qui n'est PAS couvert ici et ne peut pas l'etre : le fantome REELLEMENT
// dessine a l'ecran, la teinte de temoin, et la lecture du clavier.
// Terrain georeference et parfaitement previsible : l'altitude ne depend que de
// X et vaut 400 + (x + 50), donc 400 au bord ouest et 500 au bord est.
//
// Construit par le constructeur "grille toute faite" - celui par lequel entrent
// les dalles LiDAR - et non par le generateur de bruit : les tests de scene
// verifient des CONVERSIONS DE COORDONNEES au millimetre, ce qui exige de savoir
// exactement quelle altitude repond le terrain, y compris apres un changement de
// resolution.
Heightmap makeGeoTerrain(uint32_t resolution, float spacing) {
std::vector<float> heights(static_cast<std::size_t>(resolution) * resolution, 0.0f);
for (uint32_t iz = 0; iz < resolution; ++iz) {
for (uint32_t ix = 0; ix < resolution; ++ix) {
heights[static_cast<std::size_t>(iz) * resolution + ix] =
400.0f + static_cast<float>(ix) * spacing;
}
}
GeoReference geo;
geo.originEast = 907000.0;
geo.originNorth = 6440000.0;
geo.epsg = 2154;
geo.absoluteAltitude = true;
return Heightmap(std::move(heights), resolution, spacing, "terrain de test", geo);
}
// Ecrit un .obj minimal (tetraedre), pour exercer le SCAN du catalogue par le
// vrai loader de la Phase 3 plutot que par un substitut.
void writeTestObj(const std::filesystem::path& path, float scale) {
std::ofstream file(path);
file << "# asset de test\n"
<< "v 0 0 0\n"
<< "v " << scale << " 0 0\n"
<< "v 0 0 " << scale << "\n"
<< "v 0 " << scale << " 0\n"
<< "f 1 2 3\n"
<< "f 1 2 4\n"
<< "f 2 3 4\n"
<< "f 1 3 4\n";
}
// Boite englobante d'un MeshData, pour verifier la convention d'ancrage.
void meshBounds(const MeshData& mesh, glm::vec3* minOut, glm::vec3* maxOut) {
glm::vec3 lo(std::numeric_limits<float>::max());
glm::vec3 hi(std::numeric_limits<float>::lowest());
for (const Vertex& vertex : mesh.vertices) {
lo = glm::min(lo, vertex.pos);
hi = glm::max(hi, vertex.pos);
}
*minOut = lo;
*maxOut = hi;
}
void testEditorAssets() {
section("Phase 15 : assets generes et convention d'ancrage");
check(builtinEditorAssets().size() >= 5,
"Assets : au moins cinq modeles generes en code");
for (const BuiltinAsset& builtin : builtinEditorAssets()) {
const MeshData mesh = builtin.build();
check(!mesh.empty(), "Asset \"" + builtin.id + "\" : geometrie non vide");
check(mesh.indices.size() % 3 == 0,
"Asset \"" + builtin.id + "\" : indices multiples de 3");
glm::vec3 lo(0.0f);
glm::vec3 hi(0.0f);
meshBounds(mesh, &lo, &hi);
// Le PIED est a zero : c'est ce qui rend "poser au point vise" exact.
checkNear(lo.y, 0.0f, 1e-4f, "Asset \"" + builtin.id + "\" : pied a y = 0");
check(hi.y > 0.05f, "Asset \"" + builtin.id + "\" : hauteur non nulle");
// L'ancrage tombe DANS l'empreinte horizontale, pas a cote : un objet
// pose entoure le point vise.
//
// Volontairement plus faible qu'un centrage exact sur la boite
// englobante. Le poteau de balisage a son MAT a l'origine et sa plaque
// qui deborde vers +X : sa boite n'est pas centree, et elle ne doit pas
// l'etre - planter un panneau, c'est planter le mat au point vise, pas y
// placer le milieu de l'ensemble mat + panneau. Voir la note
// "ancrage n'est pas centrage" dans editor/EditorAssets.hpp.
check(lo.x <= 1e-4f && hi.x >= -1e-4f,
"Asset \"" + builtin.id + "\" : ancrage dans l'empreinte en X");
check(lo.z <= 1e-4f && hi.z >= -1e-4f,
"Asset \"" + builtin.id + "\" : ancrage dans l'empreinte en Z");
// Et pas au bord non plus : l'ancrage reste dans la moitie centrale de
// l'empreinte, sinon l'objet se poserait visiblement de travers.
check(std::abs(0.5f * (lo.x + hi.x)) <= 0.5f * std::max(std::abs(lo.x), hi.x),
"Asset \"" + builtin.id + "\" : ancrage pas au bord en X");
check(std::abs(0.5f * (lo.z + hi.z)) <= 0.5f * std::max(std::abs(lo.z), hi.z),
"Asset \"" + builtin.id + "\" : ancrage pas au bord en Z");
// Toutes les normales sont unitaires : une normale nulle donnerait un
// triangle noir, et le facettage en produit une par triangle.
bool normalsOk = true;
for (const Vertex& vertex : mesh.vertices) {
normalsOk = normalsOk && std::abs(glm::length(vertex.normal) - 1.0f) < 1e-3f;
}
check(normalsOk, "Asset \"" + builtin.id + "\" : normales unitaires");
}
// DETERMINISME. Les rochers sont deformes par HACHAGE de l'indice de sommet
// et non par un generateur a etat (meme lecon qu'en Phase 11) : deux appels
// doivent donner la meme geometrie au bit pres. Ca compte parce que
// l'empreinte de COLLISION est deduite de la boite englobante du mesh - une
// geometrie qui varierait donnerait une collision qui varie, et une scene
// sauvegardee ne se rechargerait pas a l'identique.
const MeshData first = editorBoulderMeshData();
const MeshData second = editorBoulderMeshData();
bool identical = first.vertices.size() == second.vertices.size();
for (std::size_t i = 0; identical && i < first.vertices.size(); ++i) {
identical = std::memcmp(&first.vertices[i].pos, &second.vertices[i].pos,
sizeof(glm::vec3)) == 0;
}
check(identical, "Assets : le rocher est identique au bit pres a chaque appel");
}
void testAssetCatalog() {
section("Phase 15 : catalogue d'assets");
{
AssetCatalog catalog;
catalog.addBuiltins();
check(catalog.size() == builtinEditorAssets().size(),
"Catalogue : tous les builtins ajoutes");
check(catalog.indexOf("rocher") >= 0, "Catalogue : \"rocher\" retrouve par nom");
check(catalog.indexOf("inexistant") < 0, "Catalogue : nom inconnu -> -1");
const AssetEntry& boulder =
catalog.entries()[static_cast<std::size_t>(catalog.indexOf("rocher"))];
check(boulder.height > 0.5f && boulder.height < 4.0f,
"Catalogue : hauteur du rocher plausible");
// Cylindre CONTENANT : le rayon est la demi-diagonale horizontale, donc
// au moins aussi grand que la plus grande demi-etendue.
check(boulder.collisionRadius >=
std::max(boulder.halfExtentX, boulder.halfExtentZ) - 1e-4f,
"Catalogue : le rayon de collision contient la boite");
check(boulder.sourcePath.empty(), "Catalogue : un builtin n'a pas de fichier source");
// Deuxieme appel : les identifiants sont deja pris, rien ne doit doubler.
catalog.addBuiltins();
check(catalog.size() == builtinEditorAssets().size(),
"Catalogue : les doublons d'identifiant sont refuses");
}
// --- sanitizeAssetId ----------------------------------------------------
check(sanitizeAssetId("Gros Rocher") == "gros_rocher",
"Catalogue : espaces et majuscules normalises");
check(sanitizeAssetId("mur-de-pierre.v2") == "mur-de-pierre.v2",
"Catalogue : tiret et point conserves");
check(sanitizeAssetId("") == "asset", "Catalogue : identifiant vide remplace");
// --- normalizeAssetMesh -------------------------------------------------
{
MeshData mesh;
for (const glm::vec3 position : { glm::vec3(10.0f, 5.0f, -3.0f),
glm::vec3(12.0f, 9.0f, -1.0f),
glm::vec3(11.0f, 5.0f, -2.0f) }) {
Vertex vertex{};
vertex.pos = position;
vertex.normal = glm::vec3(0.0f, 1.0f, 0.0f);
mesh.vertices.push_back(vertex);
}
mesh.indices = { 0, 1, 2 };
normalizeAssetMesh(mesh);
glm::vec3 lo(0.0f);
glm::vec3 hi(0.0f);
meshBounds(mesh, &lo, &hi);
checkNear(lo.y, 0.0f, 1e-5f, "Normalisation : pied ramene a y = 0");
checkNear(0.5f * (lo.x + hi.x), 0.0f, 1e-5f, "Normalisation : recentre en X");
checkNear(0.5f * (lo.z + hi.z), 0.0f, 1e-5f, "Normalisation : recentre en Z");
// La FORME ne bouge pas : seule l'origine change.
checkNear(hi.y - lo.y, 4.0f, 1e-5f, "Normalisation : hauteur inchangee");
}
// --- scanDirectory ------------------------------------------------------
{
namespace fs = std::filesystem;
const fs::path directory =
fs::temp_directory_path() / "vercora_p15_catalogue";
std::error_code ec;
fs::remove_all(directory, ec);
fs::create_directories(directory, ec);
writeTestObj(directory / "b_deuxieme.obj", 2.0f);
writeTestObj(directory / "a_premier.obj", 1.0f);
// Un fichier illisible ne doit priver l'editeur d'AUCUN autre modele.
{
std::ofstream broken(directory / "c_casse.obj");
broken << "ceci n'est pas un maillage\nf 1 2 3\n";
}
// Une extension non reconnue est simplement ignoree.
{
std::ofstream note(directory / "notes.txt");
note << "rien a voir";
}
AssetCatalog catalog;
catalog.addBuiltins();
const std::size_t builtinCount = catalog.size();
const uint32_t added = catalog.scanDirectory(directory.string());
check(added == 2, "Catalogue : deux modeles valides charges sur trois .obj");
check(catalog.size() == builtinCount + 2,
"Catalogue : le fichier casse n'a pas interrompu le scan");
check(catalog.indexOf("a_premier") >= 0, "Catalogue : identifiant tire du nom de fichier");
check(catalog.indexOf("notes") < 0, "Catalogue : extension non reconnue ignoree");
// ORDRE : les fichiers sont tries par nom. Les touches 1..9 de l'editeur
// designent des rangs dans cette liste, et directory_iterator ne garantit
// aucun ordre - sans le tri, la meme touche poserait un modele different
// d'une execution a l'autre.
check(catalog.indexOf("a_premier") < catalog.indexOf("b_deuxieme"),
"Catalogue : les fichiers scannes sont tries par nom");
// Le scan applique la convention d'ancrage a un fichier qui ne la
// respectait pas (le tetraedre a son origine dans un coin).
const AssetEntry& scanned =
catalog.entries()[static_cast<std::size_t>(catalog.indexOf("b_deuxieme"))];
glm::vec3 lo(0.0f);
glm::vec3 hi(0.0f);
meshBounds(scanned.mesh, &lo, &hi);
checkNear(lo.y, 0.0f, 1e-4f, "Catalogue : modele scanne repose sur y = 0");
checkNear(0.5f * (lo.x + hi.x), 0.0f, 1e-4f, "Catalogue : modele scanne recentre");
check(!scanned.sourcePath.empty(), "Catalogue : chemin d'origine conserve");
// Un dossier absent n'est pas une erreur : l'editeur doit demarrer avec
// les seuls builtins.
AssetCatalog empty;
empty.addBuiltins();
check(empty.scanDirectory((directory / "nexiste_pas").string()) == 0,
"Catalogue : dossier absent -> zero modele, pas d'erreur");
check(empty.size() == builtinCount, "Catalogue : builtins intacts");
fs::remove_all(directory, ec);
}
}
void testTerrainRaycast() {
section("Phase 15 : intersection rayon / terrain");
{
const FlatTerrain flat(0.0f);
// Oeil a 10 m, regard a 45 degres vers le bas : la surface est atteinte
// a 10 m devant, donc a 10*sqrt(2) le long du rayon.
const glm::vec3 eye(0.0f, 10.0f, 0.0f);
const glm::vec3 direction = glm::normalize(glm::vec3(0.0f, -1.0f, -1.0f));
const TerrainRayHit hit = raycastTerrain(flat, eye, direction, 400.0f, 1000.0f);
check(hit.hit, "Raycast : la surface plate est touchee");
checkNear(hit.distance, 14.1421f, 0.01f, "Raycast : distance le long du rayon");
checkNear(hit.position.z, -10.0f, 0.01f, "Raycast : point d'impact en Z");
checkNear(hit.position.y, 0.0f, 1e-3f, "Raycast : le point est SUR la surface");
}
{
// Regard vers le HAUT : rien a toucher. C'est ce qui fait que viser le
// ciel ne pose aucun objet, au lieu d'en poser un a distance arbitraire.
const FlatTerrain flat(0.0f);
const TerrainRayHit hit =
raycastTerrain(flat, glm::vec3(0.0f, 10.0f, 0.0f),
glm::normalize(glm::vec3(0.0f, 1.0f, -1.0f)), 400.0f, 1000.0f);
check(!hit.hit, "Raycast : un regard vers le ciel ne touche rien");
}
{
// L'EMPRISE compte. heightAt est TOTALE par contrat (hors donnees elle
// prolonge le bord), donc sans halfExtent un rayon partant vers
// l'exterieur accrocherait une etagere plate infinie.
const FlatTerrain flat(0.0f);
const glm::vec3 eye(0.0f, 10.0f, 0.0f);
const glm::vec3 direction = glm::normalize(glm::vec3(0.0f, -0.05f, -1.0f));
const TerrainRayHit bounded =
raycastTerrain(flat, eye, direction, 400.0f, 50.0f);
const TerrainRayHit unbounded =
raycastTerrain(flat, eye, direction, 400.0f, 0.0f);
check(!bounded.hit, "Raycast : hors emprise -> aucun impact");
check(unbounded.hit, "Raycast : sans emprise declaree, le bord prolonge touche");
}
{
// Oeil DEJA sous la surface (vol libre dans le relief) : on rend le point
// de depart projete sur la surface plutot que rien du tout.
const FlatTerrain flat(100.0f);
const TerrainRayHit hit =
raycastTerrain(flat, glm::vec3(3.0f, 90.0f, 4.0f),
glm::vec3(0.0f, 0.0f, -1.0f), 400.0f, 1000.0f);
check(hit.hit, "Raycast : oeil sous la surface -> impact");
checkNear(hit.distance, 0.0f, 1e-5f, "Raycast : impact a distance nulle");
checkNear(hit.position.y, 100.0f, 1e-4f, "Raycast : projete sur la surface");
}
{
// Pente reelle : le point rendu doit etre sur la surface, quelle que
// soit son inclinaison.
const SlopedTerrain slope(0.0f, 0.40f); // 40 % vers +X
const glm::vec3 eye(-30.0f, 20.0f, 0.0f);
const glm::vec3 direction = glm::normalize(glm::vec3(1.0f, -0.35f, 0.0f));
const TerrainRayHit hit = raycastTerrain(slope, eye, direction, 400.0f, 1000.0f);
check(hit.hit, "Raycast : la pente est touchee");
checkNear(hit.position.y, slope.heightAt(hit.position.x, hit.position.z), 1e-2f,
"Raycast : le point d'impact est sur la pente");
}
{
// Normale de surface : sur une pente de 40 % vers +X, elle penche vers
// l'aval (composante X negative) et reste unitaire.
const SlopedTerrain slope(0.0f, 0.40f);
const glm::vec3 normal = terrainNormalAt(slope, 0.0f, 0.0f);
checkNear(glm::length(normal), 1.0f, 1e-4f, "Normale de terrain : unitaire");
check(normal.x < -0.3f, "Normale de terrain : penchee vers l'aval");
checkNear(normal.z, 0.0f, 1e-4f, "Normale de terrain : rien selon Z sur cette pente");
}
}
void testEditorScene() {
section("Phase 15 : scene editable, selection et annulation");
AssetCatalog catalog;
catalog.addBuiltins();
EditorScene scene(&catalog);
const auto makeObject = [](const char* asset, float x, float z) {
PlacedObject object;
object.asset = asset;
object.position = { x, 0.0f, z };
return object;
};
const uint32_t a = scene.place(makeObject("rocher", 0.0f, 0.0f));
const uint32_t b = scene.place(makeObject("cairn", 10.0f, 0.0f));
const uint32_t c = scene.place(makeObject("poteau", 20.0f, 0.0f));
check(scene.size() == 3, "Scene : trois objets poses");
check(a != b && b != c, "Scene : les identifiants sont distincts");
check(scene.find(b) != nullptr && scene.find(b)->asset == "cairn",
"Scene : retrouve un objet par identifiant");
check(scene.find(9999) == nullptr, "Scene : identifiant inconnu -> nullptr");
// --- Suppression au MILIEU, puis annulation --------------------------
// Le cas qui distingue une pile d'annulation correcte d'une pile naive :
// l'objet doit reprendre SA PLACE dans la liste, pas atterrir a la fin.
check(scene.erase(b), "Scene : suppression d'un objet du milieu");
check(scene.size() == 2, "Scene : il en reste deux");
check(scene.undo(), "Scene : annulation de la suppression");
check(scene.size() == 3, "Scene : l'objet est revenu");
check(scene.objects()[1].id == b, "Scene : il a repris SON indice, pas la fin");
// --- Annulation d'une pose ------------------------------------------
check(scene.undo(), "Scene : annulation de la pose du poteau");
check(scene.size() == 2 && scene.find(c) == nullptr,
"Scene : le poteau a disparu");
// --- Regroupement des retouches -------------------------------------
// Vingt petites rotations dans la meme seconde ne doivent laisser QU'UNE
// annulation : sans ce regroupement, "annuler" ne rendrait jamais l'etat
// d'avant la manipulation, qui est pourtant la seule chose qu'on veut.
const std::size_t depthBefore = scene.undoDepth();
for (int i = 0; i < 20; ++i) {
PlacedObject updated = *scene.find(a);
updated.yawDegrees += 5.0f;
scene.transform(a, updated, 100.0f + 0.01f * static_cast<float>(i));
}
checkNear(scene.find(a)->yawDegrees, 100.0f, 1e-3f, "Scene : 20 x 5 degres appliques");
check(scene.undoDepth() == depthBefore + 1,
"Scene : les retouches rapprochees ne font qu'UNE annulation");
check(scene.undo(), "Scene : annulation du reglage");
checkNear(scene.find(a)->yawDegrees, 0.0f, 1e-3f,
"Scene : le cap d'AVANT toute la manipulation est rendu");
// Deux retouches ESPACEES restent deux annulations distinctes : le
// regroupement ne doit pas avaler un geste separe.
{
const std::size_t before = scene.undoDepth();
PlacedObject updated = *scene.find(a);
updated.scale = 2.0f;
scene.transform(a, updated, 200.0f);
updated.scale = 3.0f;
scene.transform(a, updated, 260.0f); // une minute plus tard
check(scene.undoDepth() == before + 2,
"Scene : deux retouches espacees = deux annulations");
scene.undo();
checkNear(scene.find(a)->scale, 2.0f, 1e-4f, "Scene : retour a l'echelle intermediaire");
scene.undo();
checkNear(scene.find(a)->scale, 1.0f, 1e-4f, "Scene : retour a l'echelle d'origine");
}
// transform() ne peut PAS changer l'asset ni l'identite, meme si l'appelant
// le lui demande : c'est l'invariant qui rend la scene incassable de
// l'exterieur.
{
PlacedObject hostile = *scene.find(a);
hostile.asset = "abri";
hostile.id = 4321;
hostile.scale = -5.0f; // echelle invalide
scene.transform(a, hostile, 400.0f);
check(scene.find(a) != nullptr && scene.find(a)->asset == "rocher",
"Scene : transform() ne change ni l'asset ni l'identifiant");
check(scene.find(a)->scale > 0.0f, "Scene : une echelle invalide est corrigee");
}
// --- replaceAll : renumerotation et pile videe -----------------------
{
std::vector<PlacedObject> loaded;
loaded.push_back(makeObject("rocher", 1.0f, 1.0f));
loaded.push_back(makeObject("bloc", 2.0f, 2.0f));
scene.replaceAll(loaded);
check(scene.size() == 2, "Scene : contenu remplace");
check(scene.undoDepth() == 0,
"Scene : la pile d'annulation est videe par un chargement");
check(scene.objects()[0].id == 1 && scene.objects()[1].id == 2,
"Scene : identifiants renumerotes dans l'ordre du fichier");
check(!scene.undo(), "Scene : plus rien a annuler");
}
// --- Profondeur bornee ------------------------------------------------
// On jette la PLUS ANCIENNE, jamais la plus recente : une pile bornee doit
// continuer d'annuler ce qu'on vient de faire.
{
EditorScene deep(&catalog);
for (std::size_t i = 0; i < EditorScene::kMaxUndoDepth + 20; ++i) {
deep.place(makeObject("rocher", static_cast<float>(i), 0.0f));
}
check(deep.undoDepth() == EditorScene::kMaxUndoDepth,
"Scene : la pile d'annulation est bornee");
const std::size_t sizeBefore = deep.size();
check(deep.undo() && deep.size() == sizeBefore - 1,
"Scene : la derniere action reste annulable malgre la borne");
}
}
void testEditorSceneCollision() {
section("Phase 15 : collision des objets poses");
AssetCatalog catalog;
catalog.addBuiltins();
const AssetEntry& boulder =
catalog.entries()[static_cast<std::size_t>(catalog.indexOf("rocher"))];
EditorScene scene(&catalog);
PlacedObject rock;
rock.asset = "rocher";
rock.position = { 0.0f, 0.0f, 0.0f };
rock.solid = true;
scene.place(rock);
BodyCylinder body;
body.radius = 0.35f;
body.feetY = 0.0f;
body.headY = 1.7f;
// Le joueur veut traverser le rocher : il doit etre repousse HORS du
// cylindre, exactement comme contre un tronc depuis la Phase 6.
body.position = { 0.1f, 1.7f, 0.0f };
check(scene.overlaps(body), "Collision : le joueur chevauche le rocher");
const glm::vec3 pushed = scene.resolve(body);
const float distance = std::sqrt(pushed.x * pushed.x + pushed.z * pushed.z);
check(distance >= boulder.collisionRadius + body.radius - 1e-3f,
"Collision : repousse juste en dehors du cylindre");
// Le resultat du repoussement doit etre LIBRE, sinon moveBody() refuserait
// tout deplacement le long du rocher au lieu de laisser glisser. C'est la
// raison de la marge d'un dixieme de millimetre dans overlaps().
BodyCylinder probe = body;
probe.position = pushed;
check(!scene.overlaps(probe), "Collision : la position repoussee est libre");
// Loin : rien ne bouge.
body.position = { 40.0f, 1.7f, 0.0f };
check(!scene.overlaps(body), "Collision : pas de contact a 40 m");
checkNear(scene.resolve(body).x, 40.0f, 1e-5f, "Collision : position intacte au loin");
// Au-DESSUS de l'objet : pas de contact. Meme regle que pour les souches -
// c'est ce qui permettra de passer sur un rocher plutot qu'a travers.
body.position = { 0.0f, 60.0f, 0.0f };
body.feetY = 58.3f;
body.headY = 60.15f;
check(!scene.overlaps(body), "Collision : rien a 58 m au-dessus du rocher");
// TRAVERSABLE : le drapeau par objet est la seule reponse immediate au cas
// ou le cylindre englobant est faux (un abri a un interieur).
{
EditorScene ghostly(&catalog);
PlacedObject shelter;
shelter.asset = "abri";
shelter.solid = false;
ghostly.place(shelter);
BodyCylinder inside;
inside.radius = 0.35f;
inside.feetY = 0.0f;
inside.headY = 1.7f;
inside.position = { 0.0f, 1.7f, 0.0f };
check(!ghostly.overlaps(inside), "Collision : un objet traversable ne bloque pas");
check(ghostly.solidCount() == 0, "Collision : compte des objets solides");
}
// ASSET INCONNU : sans dimensions on ne peut pas inventer une empreinte.
{
EditorScene orphan(&catalog);
PlacedObject unknown;
unknown.asset = "modele_disparu";
unknown.solid = true;
orphan.place(unknown);
BodyCylinder here;
here.radius = 0.35f;
here.feetY = 0.0f;
here.headY = 1.7f;
here.position = { 0.0f, 1.7f, 0.0f };
check(!orphan.overlaps(here),
"Collision : un asset absent du catalogue ne bloque pas");
}
// --- Solveur COMPOSITE : foret + editeur --------------------------------
// Le vrai chemin du jeu depuis la Phase 15. On verifie que les deux sources
// d'obstacles bloquent toutes les deux, par le meme moveBody().
{
FlatTerrain flat(0.0f);
Ground ground(flat);
ForestParams noTrees;
noTrees.treeCount = 0;
Forest forest(flat, ground, 100.0f, noTrees);
forest.plantTree(6.0f, 0.0f, 8.0f);
CompositeCollisionSolver composite;
composite.add(&forest);
composite.add(&scene);
check(composite.size() == 2, "Composite : deux solveurs enregistres");
BodyCylinder walker;
walker.radius = 0.35f;
walker.feetY = 0.0f;
walker.headY = 1.7f;
// Contre le ROCHER de l'editeur.
walker.position = { 0.05f, 1.7f, 0.0f };
check(composite.overlaps(walker), "Composite : le rocher de l'editeur bloque");
const glm::vec3 outOfRock =
moveBody(composite, walker, glm::vec3(-8.0f, 1.7f, 0.0f));
BodyCylinder after = walker;
after.position = outOfRock;
check(!composite.overlaps(after), "Composite : moveBody sort du rocher");
// Contre le TRONC de la foret, inchange depuis la Phase 6.
walker.position = { 6.0f, 1.7f, 0.0f };
check(composite.overlaps(walker), "Composite : le tronc bloque toujours");
// Entre les deux : libre.
walker.position = { 3.0f, 1.7f, 0.0f };
check(!composite.overlaps(walker), "Composite : passage libre entre les deux");
// Un composite VIDE est totalement transparent : c'est le contrat de
// CollisionSolver ("une implementation qui n'a rien a dire renvoie la
// position telle quelle").
CompositeCollisionSolver nothing;
check(!nothing.overlaps(walker), "Composite : vide -> aucun obstacle");
checkNear(nothing.resolve(walker).x, 3.0f, 1e-6f,
"Composite : vide -> position inchangee");
}
}
void testEditorScenePick() {
section("Phase 15 : visee des objets poses");
AssetCatalog catalog;
catalog.addBuiltins();
EditorScene scene(&catalog);
PlacedObject near;
near.asset = "rocher";
near.position = { 0.0f, 0.0f, -10.0f };
const uint32_t nearId = scene.place(near);
PlacedObject far;
far.asset = "rocher";
far.position = { 0.0f, 0.0f, -30.0f };
const uint32_t farId = scene.place(far);
const glm::vec3 eye(0.0f, 0.9f, 0.0f);
const glm::vec3 ahead(0.0f, 0.0f, -1.0f);
check(scene.pick(eye, ahead, 100.0f) == nearId,
"Visee : le PLUS PROCHE des deux est touche");
check(scene.pick(eye, ahead, 5.0f) == kNoPlacedObject,
"Visee : hors de portee -> rien");
check(scene.pick(glm::vec3(30.0f, 0.9f, 0.0f), ahead, 100.0f) == kNoPlacedObject,
"Visee : a cote -> rien");
// En supprimant le proche, c'est le lointain qui vient.
scene.erase(nearId);
check(scene.pick(eye, ahead, 100.0f) == farId,
"Visee : le suivant apres suppression du premier");
// Trop HAUT : le rayon passe au-dessus. C'est le test de la borne verticale,
// sans laquelle un objet au sol serait selectionnable depuis le ciel.
check(scene.pick(glm::vec3(0.0f, 50.0f, 0.0f), ahead, 100.0f) == kNoPlacedObject,
"Visee : un rayon au-dessus de l'objet ne le touche pas");
}
void testSceneFile() {
section("Phase 15 : format de scene .vcsc");
namespace fs = std::filesystem;
const fs::path directory = fs::temp_directory_path() / "vercora_p15_scene";
std::error_code ec;
fs::remove_all(directory, ec);
fs::create_directories(directory, ec);
const std::string path = (directory / "test.vcsc").string();
const Heightmap terrain = makeGeoTerrain(101, 1.0f);
// --- Fichier absent : ce n'est PAS une erreur -------------------------
{
const SceneLoadResult missing = loadSceneFile(path, terrain);
check(!missing.fileExisted, "Scene : fichier absent signale comme tel");
check(!missing.ok && missing.objects.empty(),
"Scene : rien charge, aucune exception");
}
// --- Aller-retour exact ----------------------------------------------
std::vector<PlacedObject> original;
{
PlacedObject rock;
rock.asset = "rocher";
rock.position = { 12.5f, 0.0f, -7.25f };
rock.position.y = terrain.heightAt(rock.position.x, rock.position.z);
rock.yawDegrees = 137.5f;
rock.scale = 1.75f;
rock.solid = true;
original.push_back(rock);
PlacedObject post;
post.asset = "poteau";
post.position = { -30.0f, 0.0f, 41.0f };
// Volontairement SURELEVE de 2,5 m : le dz doit survivre a l'aller-retour.
post.position.y = terrain.heightAt(post.position.x, post.position.z) + 2.5f;
post.yawDegrees = -45.0f;
post.scale = 0.5f;
post.solid = false;
original.push_back(post);
}
check(saveSceneFile(path, original, terrain, "terrain_de_test.vchm"),
"Scene : ecriture reussie");
check(fs::exists(path), "Scene : le fichier existe");
check(!fs::exists(path + ".tmp"),
"Scene : le temporaire d'ecriture atomique a disparu");
{
const SceneLoadResult loaded = loadSceneFile(path, terrain);
check(loaded.fileExisted && loaded.ok, "Scene : relecture reussie");
check(loaded.version == 1, "Scene : version 1");
check(loaded.epsg == 2154, "Scene : projection conservee");
check(loaded.terrainLabel == "terrain_de_test.vchm", "Scene : terrain d'origine note");
check(loaded.objects.size() == 2, "Scene : deux objets relus");
check(loaded.skippedObjects == 0 && loaded.unknownDirectives == 0,
"Scene : aucune ligne perdue");
for (std::size_t i = 0; i < loaded.objects.size(); ++i) {
const PlacedObject& before = original[i];
const PlacedObject& after = loaded.objects[i];
check(after.asset == before.asset, "Scene : asset conserve");
// Tolerance d'un demi-millimetre : le fichier ecrit trois decimales,
// en metres, sur des coordonnees Lambert 93 de sept chiffres.
checkNear(after.position.x, before.position.x, 5e-4f, "Scene : X conserve");
checkNear(after.position.z, before.position.z, 5e-4f, "Scene : Z conserve");
checkNear(after.position.y, before.position.y, 5e-3f, "Scene : altitude conservee");
checkNear(after.yawDegrees, before.yawDegrees, 1e-2f, "Scene : cap conserve");
checkNear(after.scale, before.scale, 1e-3f, "Scene : echelle conservee");
check(after.solid == before.solid, "Scene : solidite conservee");
}
}
// --- LE point du format : independance vis-a-vis de l'emprise ---------
// La meme scene rechargee sur le MEME endroit echantillonne au pas de 2 m.
// Les coordonnees sont projetees et l'altitude est relative, donc les objets
// doivent retomber au meme endroit du massif et rester poses au sol.
{
const Heightmap coarse = makeGeoTerrain(51, 2.0f);
const SceneLoadResult loaded = loadSceneFile(path, coarse);
check(loaded.ok && loaded.objects.size() == 2,
"Scene : rechargee sur le terrain au pas de 2 m");
checkNear(loaded.objects[0].position.x, original[0].position.x, 5e-4f,
"Scene : X identique malgre le changement de resolution");
// Pose au sol : l'altitude est celle de la SURFACE du terrain courant.
checkNear(loaded.objects[0].position.y,
coarse.heightAt(loaded.objects[0].position.x, loaded.objects[0].position.z),
5e-3f, "Scene : l'objet pose au sol y reste");
// Souleve de 2,5 m : il reste souleve de 2,5 m.
checkNear(loaded.objects[1].position.y -
coarse.heightAt(loaded.objects[1].position.x,
loaded.objects[1].position.z),
2.5f, 5e-3f, "Scene : l'objet souleve garde sa hauteur relative");
}
// --- Robustesse : le fichier s'edite aussi a la main ------------------
{
const std::string messy = (directory / "messy.vcsc").string();
{
std::ofstream file(messy);
file << "# un commentaire\n"
"version 1\n"
"terrain autre.vchm\n"
"crs 2154\n"
"brouette 42\n" // directive inconnue
"object rocher 907050.000 6439950.000 0.000 0.000 1.000 1\n"
"object incomplet 907050.000\n" // champs manquants
"object cairn 907060.000 6439950.000 0.000 90.000 0.000 1\n" // echelle nulle
"\n"
"object bloc 907070.000 6439950.000 1.500 10.000 2.000 0 # avec commentaire\n";
}
const SceneLoadResult loaded = loadSceneFile(messy, terrain);
check(loaded.ok, "Scene : un fichier partiellement fautif se charge quand meme");
check(loaded.objects.size() == 2, "Scene : les deux lignes valides sont gardees");
check(loaded.skippedObjects == 2, "Scene : les deux lignes fautives sont comptees");
check(loaded.unknownDirectives == 1, "Scene : la directive inconnue est comptee");
check(loaded.objects[1].asset == "bloc" && !loaded.objects[1].solid,
"Scene : commentaire de fin de ligne ignore, solidite lue");
}
// --- En-tete obligatoire ---------------------------------------------
{
const std::string headless = (directory / "sans_entete.vcsc").string();
{
std::ofstream file(headless);
file << "object rocher 907050.000 6439950.000 0.000 0.000 1.000 1\n";
}
const SceneLoadResult loaded = loadSceneFile(headless, terrain);
check(loaded.fileExisted && !loaded.ok,
"Scene : sans directive version, le fichier est refuse");
check(!loaded.error.empty(), "Scene : le refus est explique");
}
// --- Terrain SANS georeferencement ------------------------------------
// Le terrain synthetique n'a pas de projection : les coordonnees sont alors
// locales, et l'aller-retour doit rester exact.
{
Heightmap::Params params;
params.resolution = 64;
params.worldSize = 128.0f;
const Heightmap procedural(params);
const std::string localPath = (directory / "local.vcsc").string();
std::vector<PlacedObject> objects;
PlacedObject object;
object.asset = "cairn";
object.position = { -12.0f, 0.0f, 33.0f };
object.position.y = procedural.heightAt(object.position.x, object.position.z);
objects.push_back(object);
check(saveSceneFile(localPath, objects, procedural, "procedural"),
"Scene : ecriture sur terrain non georeference");
const SceneLoadResult loaded = loadSceneFile(localPath, procedural);
check(loaded.ok && loaded.epsg == 0, "Scene : crs 0 pour un terrain local");
check(loaded.objects.size() == 1, "Scene : objet relu");
checkNear(loaded.objects[0].position.x, -12.0f, 1e-3f, "Scene : X local conserve");
checkNear(loaded.objects[0].position.z, 33.0f, 1e-3f, "Scene : Z local conserve");
}
// --- Objets hors emprise : conserves, mais comptes ---------------------
{
const std::string outside = (directory / "dehors.vcsc").string();
{
std::ofstream file(outside);
file << "version 1\ncrs 2154\n"
"object rocher 912000.000 6439950.000 0.000 0.000 1.000 1\n";
}
const SceneLoadResult loaded = loadSceneFile(outside, terrain);
check(loaded.ok && loaded.objects.size() == 1,
"Scene : un objet hors emprise est CONSERVE");
check(loaded.outsideExtent == 1, "Scene : il est signale");
}
// --- Convention de chemin ---------------------------------------------
{
const std::string derived = scenePathFor("assets/terrain/vercora_zone_1m.vchm",
"assets/scenes");
check(derived.find("vercora_zone.vcsc") != std::string::npos,
"Scene : le suffixe de resolution est retire du nom de scene");
const std::string coarse = scenePathFor("assets/terrain/vercora_zone_2m.vchm",
"assets/scenes");
check(derived == coarse,
"Scene : 1 m et 2 m partagent la MEME scene (meme endroit)");
}
// --- Conversion projetee : les deux sens sont inverses l'un de l'autre -
{
double east = 0.0;
double north = 0.0;
terrain.toProjected(17.5f, -23.25f, &east, &north);
float backX = 0.0f;
float backZ = 0.0f;
terrain.fromProjected(east, north, &backX, &backZ);
checkNear(backX, 17.5f, 1e-4f, "Georeferencement : aller-retour exact en X");
checkNear(backZ, -23.25f, 1e-4f, "Georeferencement : aller-retour exact en Z");
}
fs::remove_all(directory, ec);
}
void testEditorController() {
section("Phase 15 : controleur d'editeur");
AssetCatalog catalog;
catalog.addBuiltins();
EditorScene scene(&catalog);
EditorController controller(catalog, scene);
const FlatTerrain terrain(0.0f);
constexpr float kHalfExtent = 1000.0f;
check(controller.brushIndex() == 0, "Controleur : premier asset arme au demarrage");
// Visee : oeil a 10 m, regard a 45 degres vers -Z. Le point vise est donc
// (0, 0, -10) sur ce terrain plat.
EditorInput input;
input.deltaTime = 1.0f / 60.0f;
input.now = 0.0f;
input.eye = { 0.0f, 10.0f, 0.0f };
input.forward = glm::normalize(glm::vec3(0.0f, -1.0f, -1.0f));
controller.update(input, terrain, kHalfExtent);
check(controller.hasPreview(), "Controleur : un fantome suit la visee");
checkNear(controller.preview().position.z, -10.0f, 0.01f,
"Controleur : le fantome est au point vise");
check(controller.preview().id == kNoPlacedObject,
"Controleur : un fantome de pose n'a pas encore d'identifiant");
check(scene.empty(), "Controleur : previsualiser ne pose rien");
// Regard vers le CIEL : pas de fantome, et un clic ne pose rien.
{
EditorInput sky = input;
sky.forward = glm::normalize(glm::vec3(0.0f, 1.0f, -1.0f));
sky.placePressed = true;
controller.update(sky, terrain, kHalfExtent);
check(!controller.hasPreview(), "Controleur : rien a previsualiser vers le ciel");
check(scene.empty(), "Controleur : viser le ciel ne pose rien");
}
// --- Pose --------------------------------------------------------------
{
EditorInput place = input;
place.placePressed = true;
controller.update(place, terrain, kHalfExtent);
check(scene.size() == 1, "Controleur : un objet pose au clic");
checkNear(scene.objects()[0].position.z, -10.0f, 0.01f,
"Controleur : pose au point exactement vise");
// La pose ne SELECTIONNE PAS. Sinon les reglages, qui visent la
// selection en priorite, seraient silencieusement detournes du pinceau
// des la premiere pose - et "regler une fois, poser dix fois" deviendrait
// impossible. Voir le commentaire du bloc de pose dans
// editor/EditorController.cpp.
check(controller.selection() == kNoPlacedObject,
"Controleur : poser ne selectionne pas, le pinceau reste la cible");
}
// --- Le PINCEAU garde ses reglages d'une pose a l'autre ----------------
// C'est le comportement utile quand on aligne une serie de blocs : on regle
// une fois, on pose dix fois.
{
EditorInput turn = input;
turn.holdRotateRight = true;
turn.deltaTime = 0.5f; // 90 deg/s x 0,5 s = 45 degres
controller.update(turn, terrain, kHalfExtent);
checkNear(controller.preview().yawDegrees, 45.0f, 1e-3f,
"Controleur : le pinceau a tourne de 45 degres");
EditorInput grow = input;
grow.holdScaleUp = true;
grow.deltaTime = 1.0f; // facteur 1,8 par seconde
controller.update(grow, terrain, kHalfExtent);
checkNear(controller.preview().scale, 1.8f, 1e-3f,
"Controleur : echelle multiplicative");
EditorInput lift = input;
lift.holdRaise = true;
lift.deltaTime = 1.0f; // 0,6 m/s
controller.update(lift, terrain, kHalfExtent);
checkNear(controller.preview().position.y, 0.6f, 1e-3f,
"Controleur : decalage vertical par rapport au sol");
EditorInput place = input;
place.placePressed = true;
controller.update(place, terrain, kHalfExtent);
check(scene.size() == 2, "Controleur : deuxieme objet pose");
checkNear(scene.objects()[1].yawDegrees, 45.0f, 1e-3f,
"Controleur : le cap du pinceau est repris a la pose");
checkNear(scene.objects()[1].scale, 1.8f, 1e-3f,
"Controleur : l'echelle du pinceau est reprise");
checkNear(scene.objects()[1].position.y, 0.6f, 1e-3f,
"Controleur : la hauteur du pinceau est reprise");
}
// --- Pas fin ------------------------------------------------------------
{
EditorController fine(catalog, scene);
EditorInput slow = input;
slow.holdRotateRight = true;
slow.holdFineStep = true;
slow.deltaTime = 0.5f; // 45 degres / 8
fine.update(slow, terrain, kHalfExtent);
checkNear(fine.preview().yawDegrees, 45.0f / 8.0f, 1e-3f,
"Controleur : la touche de pas fin divise le reglage");
}
// --- Selection puis SAISIE ---------------------------------------------
{
EditorScene moving(&catalog);
EditorController tool(catalog, moving);
EditorInput place = input;
place.placePressed = true;
tool.update(place, terrain, kHalfExtent);
const uint32_t id = moving.objects()[0].id;
const std::size_t depthAfterPlace = moving.undoDepth();
// On SELECTIONNE d'abord : la saisie porte sur la selection, et poser ne
// selectionne plus rien.
EditorInput pick = input;
pick.eye = { 0.0f, 0.9f, 0.0f };
pick.forward = { 0.0f, 0.0f, -1.0f };
pick.pickPressed = true;
tool.update(pick, terrain, kHalfExtent);
check(tool.selection() == id, "Controleur : objet vise puis selectionne");
// Saisie, puis 60 images de deplacement du regard : la scene ne doit PAS
// bouger tant que l'objet est en main. Sans ca, deplacer un rocher de
// trente metres empilerait une annulation par image.
EditorInput grab = input;
grab.grabPressed = true;
tool.update(grab, terrain, kHalfExtent);
check(tool.grabbing(), "Controleur : objet en main");
check(tool.hiddenObjectId() == id,
"Controleur : l'objet en main n'est plus dessine a sa place");
EditorInput move = input;
move.eye = { 25.0f, 10.0f, 0.0f };
for (int frame = 0; frame < 60; ++frame) {
move.now = 1.0f + 0.016f * static_cast<float>(frame);
tool.update(move, terrain, kHalfExtent);
}
checkNear(moving.objects()[0].position.x, 0.0f, 1e-3f,
"Controleur : la scene ne bouge pas tant que l'objet est en main");
check(moving.undoDepth() == depthAfterPlace,
"Controleur : aucune annulation empilee pendant le deplacement");
checkNear(tool.preview().position.x, 25.0f, 0.05f,
"Controleur : la previsualisation, elle, suit la visee");
// Repose : UNE seule annulation pour tout le deplacement.
EditorInput drop = move;
drop.now = 3.0f;
drop.grabPressed = true;
tool.update(drop, terrain, kHalfExtent);
check(!tool.grabbing(), "Controleur : objet repose");
checkNear(moving.objects()[0].position.x, 25.0f, 0.05f,
"Controleur : l'objet a bien ete deplace");
check(moving.undoDepth() == depthAfterPlace + 1,
"Controleur : UNE annulation pour tout le deplacement");
EditorInput undo = input;
undo.now = 4.0f;
undo.undoPressed = true;
tool.update(undo, terrain, kHalfExtent);
checkNear(moving.objects()[0].position.x, 0.0f, 1e-3f,
"Controleur : l'annulation ramene l'objet d'ou il venait");
}
// --- Selection par la visee, puis suppression --------------------------
{
EditorScene target(&catalog);
EditorController tool(catalog, target);
EditorInput place = input;
place.placePressed = true;
tool.update(place, terrain, kHalfExtent);
const uint32_t id = target.objects()[0].id;
check(tool.selection() == kNoPlacedObject,
"Controleur : rien de selectionne juste apres la pose");
// On vise l'objet depuis le sol, a l'horizontale.
EditorInput pick = input;
pick.eye = { 0.0f, 0.9f, 0.0f };
pick.forward = { 0.0f, 0.0f, -1.0f };
pick.pickPressed = true;
tool.update(pick, terrain, kHalfExtent);
check(tool.selection() == id, "Controleur : l'objet vise est selectionne");
EditorInput erase = input;
erase.deletePressed = true;
tool.update(erase, terrain, kHalfExtent);
check(target.empty(), "Controleur : la selection est supprimee");
check(tool.selection() == kNoPlacedObject, "Controleur : plus rien de selectionne");
EditorInput undo = input;
undo.undoPressed = true;
undo.now = 10.0f;
tool.update(undo, terrain, kHalfExtent);
check(target.size() == 1, "Controleur : la suppression est annulable");
}
// --- Cycle F3/F4 parmi les objets poses, SANS viser ---------------------
// Ajoute apres la session initiale de la Phase 15 (voir NOTES-PHASE15.md
// ss13) : pickPressed exige que la visee touche l'objet, ce qui n'aide en
// rien a retrouver un objet pose hors du champ courant. F3/F4 parcourent la
// liste de la scene independamment du regard.
{
EditorScene noneScene(&catalog);
EditorController none(catalog, noneScene);
EditorInput nextOnEmpty = input;
nextOnEmpty.cycleNextPressed = true;
none.update(nextOnEmpty, terrain, kHalfExtent);
check(none.selection() == kNoPlacedObject,
"Cycle : rien a selectionner dans une scene vide");
}
{
EditorScene many(&catalog);
EditorController tool(catalog, many);
PlacedObject a; a.asset = catalog.entries()[0].id; a.position = { 0.0f, 0.0f, 0.0f };
PlacedObject b; b.asset = catalog.entries()[0].id; b.position = { 5.0f, 0.0f, 0.0f };
PlacedObject c; c.asset = catalog.entries()[0].id; c.position = { 10.0f, 0.0f, 0.0f };
const uint32_t idA = many.place(a);
const uint32_t idB = many.place(b);
const uint32_t idC = many.place(c);
EditorInput next = input;
next.cycleNextPressed = true;
tool.update(next, terrain, kHalfExtent);
check(tool.selection() == idA, "Cycle : F3 depuis rien selectionne prend le premier");
tool.update(next, terrain, kHalfExtent);
check(tool.selection() == idB, "Cycle : F3 avance d'un objet");
tool.update(next, terrain, kHalfExtent);
check(tool.selection() == idC, "Cycle : F3 avance encore");
tool.update(next, terrain, kHalfExtent);
check(tool.selection() == idA, "Cycle : F3 boucle apres le dernier");
EditorInput prev = input;
prev.cyclePrevPressed = true;
tool.update(prev, terrain, kHalfExtent);
check(tool.selection() == idC, "Cycle : F4 recule et boucle avant le premier");
// Pendant une saisie, le cycle ne doit RIEN faire - changer la selection
// sous un objet en main serait incoherent (quel objet suit alors la
// visee ?).
EditorInput grab = input;
grab.grabPressed = true;
tool.update(grab, terrain, kHalfExtent);
check(tool.grabbing(), "Cycle : objet en main avant le test d'ignorance");
EditorInput cycleWhileGrabbing = input;
cycleWhileGrabbing.cycleNextPressed = true;
tool.update(cycleWhileGrabbing, terrain, kHalfExtent);
check(tool.selection() == idC, "Cycle : ignore pendant une saisie");
check(tool.grabbing(), "Cycle : la saisie en cours n'est pas interrompue");
}
// --- Catalogue : parcours et rang direct -------------------------------
{
EditorScene empty(&catalog);
EditorController tool(catalog, empty);
EditorInput next = input;
next.nextAssetPressed = true;
tool.update(next, terrain, kHalfExtent);
check(tool.brushIndex() == 1, "Controleur : asset suivant");
EditorInput prev = input;
prev.prevAssetPressed = true;
tool.update(prev, terrain, kHalfExtent);
check(tool.brushIndex() == 0, "Controleur : asset precedent");
// Reculer depuis le premier doit ramener au DERNIER (modulo positif).
tool.update(prev, terrain, kHalfExtent);
check(tool.brushIndex() == static_cast<int>(catalog.size()) - 1,
"Controleur : le parcours est cyclique dans les deux sens");
EditorInput quick = input;
quick.quickPick = 2; // troisieme rang de la page courante
tool.update(quick, terrain, kHalfExtent);
check(tool.brushIndex() == 2, "Controleur : rang direct au clavier");
check(tool.preview().asset == catalog.entries()[2].id,
"Controleur : le fantome suit l'asset arme");
}
// --- Les requetes d'entree/sortie sont des drapeaux, consommes une fois -
{
EditorScene empty(&catalog);
EditorController tool(catalog, empty);
EditorInput ask = input;
ask.savePressed = true;
ask.reloadPressed = true;
ask.listPressed = true;
tool.update(ask, terrain, kHalfExtent);
check(tool.consumeSaveRequest(), "Controleur : sauvegarde demandee");
check(!tool.consumeSaveRequest(), "Controleur : la demande n'est consommee qu'une fois");
check(tool.consumeReloadRequest(), "Controleur : rechargement demande");
check(tool.consumeListRequest(), "Controleur : liste demandee");
}
// --- resetInteraction ---------------------------------------------------
// Appele en sortant du mode edition : laisser un objet "en main" pendant une
// partie normale le figerait sur le reticule pour toujours.
{
EditorScene held(&catalog);
EditorController tool(catalog, held);
EditorInput place = input;
place.placePressed = true;
tool.update(place, terrain, kHalfExtent);
EditorInput pick = input;
pick.eye = { 0.0f, 0.9f, 0.0f };
pick.forward = { 0.0f, 0.0f, -1.0f };
pick.pickPressed = true;
tool.update(pick, terrain, kHalfExtent);
EditorInput grab = input;
grab.grabPressed = true;
tool.update(grab, terrain, kHalfExtent);
check(tool.grabbing(), "Controleur : objet en main avant la sortie");
tool.resetInteraction();
check(!tool.grabbing() && tool.selection() == kNoPlacedObject,
"Controleur : sortie du mode -> ni saisie ni selection");
check(held.size() == 1, "Controleur : l'objet reste dans la scene");
}
}
// ===========================================================================
// PHASE 16 : besoins primaires (faim, soif, fatigue, temperature)
// ===========================================================================
// Relief qui ne varie que selon Z. Indispensable ici et nulle part ailleurs :
// SlopedTerrain penche selon X, or l'exposition adret/ubac ne depend QUE de
// l'axe nord-sud, c'est-a-dire de Z (convention Heightmap : +Z va vers le sud).
// Un test d'exposition sur SlopedTerrain lirait donc 0,5 quelle que soit la
// pente, et passerait meme avec un signe inverse.
class NorthSouthSlope : public HeightSampler {
public:
explicit NorthSouthSlope(float slope) : slope_(slope) {}
// slope > 0 : le terrain MONTE vers le sud, donc il descend vers le nord.
// C'est un UBAC.
float heightAt(float, float z) const override { return slope_ * z; }
private:
float slope_;
};
// Cuvette parabolique centree, posee dans un plateau plat. C'est le seul relief
// ou l'on sache a l'avance ou est le creux, donc le seul qui permette de dire
// si le detecteur de points d'eau trouve LE bon endroit et pas seulement un
// endroit.
class BowlTerrain : public HeightSampler {
public:
BowlTerrain(float centerX, float centerZ, float curvature, float rim)
: cx_(centerX), cz_(centerZ), k_(curvature), rim_(rim) {}
float heightAt(float x, float z) const override {
const float dx = x - cx_;
const float dz = z - cz_;
return std::min(rim_, k_ * (dx * dx + dz * dz));
}
private:
float cx_, cz_, k_, rim_;
};
// La meme, retournee : une bosse. Elle doit etre rejetee - c'est le controle
// negatif du critere de concavite, sans lequel un detecteur qui ne regarderait
// que la platitude passerait le test de la cuvette par accident.
class DomeTerrain : public HeightSampler {
public:
DomeTerrain(float centerX, float centerZ, float curvature, float floor)
: cx_(centerX), cz_(centerZ), k_(curvature), floor_(floor) {}
float heightAt(float x, float z) const override {
const float dx = x - cx_;
const float dz = z - cz_;
return std::max(floor_, 100.0f - k_ * (dx * dx + dz * dz));
}
private:
float cx_, cz_, k_, floor_;
};
// Plusieurs cuvettes creusees dans un meme plateau : la hauteur est celle de la
// cuvette la plus proche. C'est le seul relief qui produise plus d'un point
// d'eau, donc le seul sur lequel l'ecartement minimal veuille dire quelque
// chose - une cuvette unique ne rend qu'un point, et le test passerait a vide.
class MultiBowlTerrain : public HeightSampler {
public:
MultiBowlTerrain(std::vector<glm::vec2> centers, float curvature, float rim)
: centers_(std::move(centers)), k_(curvature), rim_(rim) {}
float heightAt(float x, float z) const override {
float best = rim_;
for (const glm::vec2& c : centers_) {
const float dx = x - c.x;
const float dz = z - c.y;
best = std::min(best, k_ * (dx * dx + dz * dz));
}
return best;
}
private:
std::vector<glm::vec2> centers_;
float k_, rim_;
};
// Fait tourner les jauges pendant `seconds` avec un contexte constant.
// keepFedAndWatered remet faim et soif a plein a chaque pas : c'est ce qui
// permet de mesurer la fatigue SEULE, sans l'aggravation par les autres manques
// (NeedsParams::deficitFatigueGain). Sans cette option, un test de fatigue
// mesurerait en realite le couplage.
void runNeeds(Needs& needs, const NeedsContext& context, float seconds,
bool keepFedAndWatered = false, float dt = 1.0f) {
for (float t = 0.0f; t < seconds; t += dt) {
needs.update(dt, context);
if (keepFedAndWatered) {
needs.setHunger(1.0f);
needs.setThirst(1.0f);
}
}
}
// Distance parcourue par le velo en `seconds` a pedalage donne, sur terrain
// plat. Sert a mesurer une CONSEQUENCE de la fatigue plutot qu'un coefficient :
// le cahier des charges demande "moins de distance en velo", pas "un facteur
// plus petit".
float bikeDistance(float pedalInput, float seconds) {
FlatTerrain flat(100.0f);
Bike bike;
bike.mount(glm::vec3(0.0f, 100.0f, 0.0f), 0.0f, flat);
const glm::vec3 start = bike.position();
constexpr float dt = 1.0f / 60.0f;
for (float t = 0.0f; t < seconds; t += dt) {
bike.update(dt, 0.0f, pedalInput, 0.0f, flat, nullptr);
}
return horizontalDistance(bike.position(), start);
}
void testNeeds() {
section("Phase 16 : jauges de besoins primaires");
const NeedsParams defaults;
// --- Etat de depart ------------------------------------------------------
{
Needs needs;
checkNear(needs.hunger(), 1.0f, 1e-6f, "Depart : faim pleine");
checkNear(needs.thirst(), 1.0f, 1e-6f, "Depart : soif pleine");
checkNear(needs.fatigue(), 1.0f, 1e-6f, "Depart : forme pleine");
checkNear(needs.temperature(), 1.0f, 1e-6f, "Depart : temperature pleine");
checkNear(needs.movementFactor(), 1.0f, 1e-6f,
"Depart : aucune penalite de deplacement");
check(!needs.inTrouble(), "Depart : aucun besoin critique");
// Un pas de temps nul ou negatif ne doit RIEN faire : la premiere image
// du jeu a un deltaTime issu d'une soustraction d'horloges, et une
// valeur nulle y est normale.
needs.update(0.0f, NeedsContext{});
needs.update(-1.0f, NeedsContext{});
checkNear(needs.fatigue(), 1.0f, 1e-6f, "deltaTime <= 0 : jauges intactes");
}
// --- Rythme : rien de perceptible en quelques minutes ---------------------
// C'est la contrainte explicite du cahier des charges, et c'est aussi celle
// qu'un reglage trop nerveux casserait en premier.
{
NeedsContext walking;
walking.activity = Activity::Walk;
// PHASE 23 : une ambiante douce et posee, la ou ce bloc reglait avant
// une altitude et une heure pour l'obtenir. Ce test parle du RYTHME des
// jauges, pas du climat : il ne doit dependre d'aucun modele meteo.
walking.ambientTemperatureC = 14.0f;
Needs needs;
runNeeds(needs, walking, 5.0f * 60.0f);
check(needs.hunger() > 0.90f, "5 min de marche : la faim se voit a peine");
check(needs.thirst() > 0.90f, "5 min de marche : la soif se voit a peine");
check(needs.fatigue() > 0.90f, "5 min de marche : la forme se voit a peine");
checkNear(needs.movementFactor(), 1.0f, 1e-6f,
"5 min de marche : toujours aucune penalite");
}
// --- Rythme : un vrai enjeu sur une session de 30 a 60 min ---------------
{
NeedsContext walking;
walking.activity = Activity::Walk;
// PHASE 23 : une ambiante douce et posee, la ou ce bloc reglait avant
// une altitude et une heure pour l'obtenir. Ce test parle du RYTHME des
// jauges, pas du climat : il ne doit dependre d'aucun modele meteo.
walking.ambientTemperatureC = 14.0f;
Needs needs;
runNeeds(needs, walking, 30.0f * 60.0f);
check(needs.thirst() < 0.60f, "30 min de marche : la soif est bien entamee");
check(needs.fatigue() < 0.75f, "30 min de marche : la forme est entamee");
check(needs.hunger() > 0.70f,
"30 min de marche : la faim reste le besoin le plus lent");
check(needs.hunger() > needs.thirst(),
"On a soif AVANT d'avoir faim (ordre voulu des besoins)");
}
// --- Fatigue : les taux annonces dans world/Needs.hpp ---------------------
{
NeedsContext walking;
walking.activity = Activity::Walk;
Needs half;
runNeeds(half, walking, 45.0f * 60.0f, /*keepFedAndWatered=*/true);
checkNear(half.fatigue(), 0.5f, 0.01f,
"45 min de marche : la moitie de la forme (1/(90 min) annonce)");
checkNear(half.fatigueFactor(), 1.0f, 1e-3f,
"Forme a la moitie : la penalite commence tout juste");
Needs empty;
runNeeds(empty, walking, 90.0f * 60.0f, /*keepFedAndWatered=*/true);
checkNear(empty.fatigue(), 0.0f, 0.01f, "90 min de marche : forme a plat");
checkNear(empty.fatigueFactor(), defaults.fatigueFloorFactor, 1e-3f,
"Forme a plat : le coefficient tombe a son plancher");
}
// --- Chaque activite coute selon son effort ------------------------------
{
checkNear(activityEffort(Activity::Rest), 0.0f, 1e-6f, "Effort : le repos ne coute rien");
check(activityEffort(Activity::Climb) > activityEffort(Activity::Bike),
"Effort : l'escalade coute plus que le velo");
check(activityEffort(Activity::Bike) > activityEffort(Activity::Walk),
"Effort : le velo coute plus que la marche");
check(activityEffort(Activity::Paraglide) < activityEffort(Activity::Walk),
"Effort : le parapente coute moins que la marche");
// Meme duree, quatre activites : la fatigue restante doit se classer
// dans l'ordre inverse des efforts. C'est la verification demandee -
// "l'escalade et le velo fatiguent plus vite que la marche".
auto fatigueAfter = [](Activity activity, float seconds) {
NeedsContext context;
context.activity = activity;
Needs needs;
runNeeds(needs, context, seconds, /*keepFedAndWatered=*/true);
return needs.fatigue();
};
const float minutes10 = 10.0f * 60.0f;
const float rest = fatigueAfter(Activity::Rest, minutes10);
const float walk = fatigueAfter(Activity::Walk, minutes10);
const float bike = fatigueAfter(Activity::Bike, minutes10);
const float climb = fatigueAfter(Activity::Climb, minutes10);
checkNear(rest, 1.0f, 1e-6f, "10 min a l'arret : la forme reste pleine");
check(walk > bike, "10 min : le velo fatigue plus que la marche");
check(bike > climb, "10 min : l'escalade fatigue plus que le velo");
checkNear(1.0f - climb, 4.0f * (1.0f - walk), 1e-3f,
"L'escalade fatigue exactement 4 fois plus vite que la marche");
}
// --- Repos : la seule source de recuperation de la forme ------------------
{
NeedsContext resting;
resting.activity = Activity::Rest;
Needs needs;
needs.setFatigue(0.0f);
runNeeds(needs, resting, 10.0f * 60.0f, /*keepFedAndWatered=*/true);
checkNear(needs.fatigue(), 0.5f, 0.01f,
"10 min de repos : la moitie de la forme (1/(20 min) annonce)");
runNeeds(needs, resting, 10.0f * 60.0f, /*keepFedAndWatered=*/true);
checkNear(needs.fatigue(), 1.0f, 1e-3f, "20 min de repos : forme refaite");
// Le repos ne rend NI faim NI soif : sans ca, s'arreter reglerait tout
// et le point d'eau ne servirait a rien.
Needs other;
other.setHunger(0.5f);
other.setThirst(0.5f);
runNeeds(other, resting, 5.0f * 60.0f);
check(other.hunger() < 0.5f, "Repos : la faim continue de descendre");
check(other.thirst() < 0.5f, "Repos : la soif continue de descendre");
}
// --- Aggravation croisee -------------------------------------------------
{
NeedsContext walking;
walking.activity = Activity::Walk;
Needs healthy;
runNeeds(healthy, walking, 10.0f * 60.0f, /*keepFedAndWatered=*/true);
Needs parched;
parched.setThirst(0.0f);
// On maintient la soif a zero pour isoler l'effet : sinon elle
// remonterait d'elle-meme, ce qu'aucune jauge ne fait, mais le test
// doit tenir meme si les taux changent.
for (float t = 0.0f; t < 10.0f * 60.0f; t += 1.0f) {
parched.setThirst(0.0f);
parched.update(1.0f, walking);
}
check(parched.fatigue() < healthy.fatigue(),
"Un joueur assoiffe se fatigue plus vite");
checkNear(1.0f - parched.fatigue(),
(1.0f + defaults.deficitFatigueGain) * (1.0f - healthy.fatigue()),
1e-3f, "Manque total : la fatigue double exactement");
}
// --- Consequences : les coefficients -------------------------------------
{
Needs needs;
needs.setFatigue(defaults.fatiguePenaltyThreshold);
checkNear(needs.fatigueFactor(), 1.0f, 1e-6f,
"Forme au seuil : aucune penalite encore");
needs.setFatigue(0.5f * defaults.fatiguePenaltyThreshold);
checkNear(needs.fatigueFactor(),
0.5f * (1.0f + defaults.fatigueFloorFactor), 1e-6f,
"Forme a mi-seuil : penalite a mi-chemin du plancher");
Needs thirsty;
thirsty.setThirst(defaults.criticalThreshold);
checkNear(thirsty.thirstFactor(), 1.0f, 1e-6f,
"Soif au seuil critique : aucune penalite encore");
thirsty.setThirst(0.0f);
checkNear(thirsty.thirstFactor(), defaults.thirstFloorFactor, 1e-6f,
"Soif a zero : le coefficient tombe a son plancher");
check(thirsty.inTrouble(), "Soif a zero : besoin critique signale");
Needs starving;
starving.setHunger(0.0f);
checkNear(starving.hungerFactor(), defaults.hungerFloorFactor, 1e-6f,
"Faim a zero : penalite progressive, pas de mort");
Needs frozen;
frozen.setTemperature(0.0f);
checkNear(frozen.coldFactor(), defaults.coldFloorFactor, 1e-6f,
"Froid extreme : penalite progressive, pas de mort");
}
// --- Aucune jauge ne tue, jamais -----------------------------------------
{
Needs dead;
dead.setHunger(0.0f);
dead.setThirst(0.0f);
dead.setFatigue(0.0f);
dead.setTemperature(0.0f);
checkNear(dead.movementFactor(), defaults.minimumMovementFactor, 1e-6f,
"Les quatre jauges a zero : le plancher de deplacement s'applique");
check(dead.movementFactor() > 0.3f,
"Les quatre jauges a zero : le joueur avance encore (pas de punition brutale)");
// Le plancher MORD reellement : sans lui, le produit des quatre
// penalites serait bien plus bas. C'est le controle negatif du choix.
const float rawProduct = dead.fatigueFactor() * dead.hungerFactor() *
dead.thirstFactor() * dead.coldFactor();
check(rawProduct < defaults.minimumMovementFactor,
"Le plancher n'est pas decoratif : le produit brut est sous lui");
}
// --- Regeneration : boire, manger ----------------------------------------
{
Needs needs;
needs.setThirst(0.2f);
check(needs.drink(), "Boire : la gorgee compte quand on avait soif");
checkNear(needs.thirst(), 1.0f, 1e-6f, "Boire : la soif est etanchee");
check(!needs.drink(), "Boire a soif pleine : rien a signaler");
needs.setHunger(0.5f);
check(needs.eat(0.3f), "Manger : la faim remonte");
checkNear(needs.hunger(), 0.8f, 1e-6f, "Manger : de la valeur nutritive exacte");
check(!needs.eat(0.0f), "Manger du vide : refuse");
check(!needs.eat(-1.0f), "Manger une valeur negative : refuse");
needs.eat(5.0f);
checkNear(needs.hunger(), 1.0f, 1e-6f, "Manger : la jauge ne depasse pas 1");
needs.reset();
checkNear(needs.hunger(), 1.0f, 1e-6f, "reset : tout est plein");
checkNear(needs.temperature(), 1.0f, 1e-6f, "reset : temperature pleine");
}
// --- Climat --------------------------------------------------------------
// PHASE 23 : le bloc qui verifiait ici le gradient adiabatique, le cycle
// diurne et l'adret/ubac a DEMENAGE dans testWeather(). Ce n'est pas une
// perte de couverture, c'est le deplacement du calcul : Needs ne calcule
// plus aucune ambiante, il en recoit une. Ce qui se verifie desormais ici
// est ce que Needs fait de cette ambiante, et rien d'autre.
// --- Exposition lue sur le relief ----------------------------------------
{
FlatTerrain flat(300.0f);
checkNear(terrainExposure(flat, 10.0f, -5.0f), 0.5f, 1e-6f,
"Exposition : du plat n'est ni adret ni ubac");
// SlopedTerrain penche selon X (est-ouest) : aucune exposition non plus.
SlopedTerrain eastWest(0.0f, 0.80f);
checkNear(terrainExposure(eastWest, 10.0f, 0.0f), 0.5f, 1e-6f,
"Exposition : un versant est-ouest n'est ni adret ni ubac");
// +Z va vers le SUD : un terrain qui DESCEND vers +Z est un adret.
NorthSouthSlope adret(-0.50f);
checkNear(terrainExposure(adret, 0.0f, 0.0f), 1.0f, 1e-4f,
"Exposition : versant descendant vers le sud = adret franc");
NorthSouthSlope ubac(0.50f);
checkNear(terrainExposure(ubac, 0.0f, 0.0f), 0.0f, 1e-4f,
"Exposition : versant descendant vers le nord = ubac franc");
// Pente douce : l'exposition est ponderee, elle n'est pas franche.
NorthSouthSlope gentle(kFullExposureSlope * 0.5f);
checkNear(terrainExposure(gentle, 0.0f, 0.0f), 0.25f, 1e-4f,
"Exposition : une pente a mi-seuil ne compte qu'a moitie");
}
// --- Temperature : la jauge elle-meme ------------------------------------
{
// Parametres depouilles : pas de cycle diurne, pas d'exposition, une
// ambiante fixee a 10 degres SOUS le confort. C'est le seul moyen de
// verifier une vitesse de refroidissement sans qu'elle depende de
// l'heure choisie par le test.
// PHASE 23 : plus rien a neutraliser dans les parametres - l'ambiante
// arrive du contexte, on la POSE. Le test est du meme coup plus direct
// qu'avant, ou il fallait annuler trois termes de climat pour obtenir
// une temperature stable.
NeedsParams cold = defaults;
NeedsContext still;
still.activity = Activity::Rest;
still.ambientTemperatureC = cold.comfortTemperatureC - 10.0f;
Needs needs(cold);
checkNear(needs.temperature(), 1.0f, 1e-6f, "Froid : on part au chaud");
runNeeds(needs, still, 15.0f * 60.0f);
checkNear(needs.temperature(), 0.5f, 0.01f,
"10 degres sous le confort : moitie de jauge en 15 min");
checkNear(needs.ambientTemperatureC(), cold.comfortTemperatureC - 10.0f, 1e-3f,
"Froid : l'ambiante relevee est celle attendue");
runNeeds(needs, still, 15.0f * 60.0f);
checkNear(needs.temperature(), 0.0f, 0.01f,
"10 degres sous le confort : jauge vide en 30 min");
checkNear(needs.movementFactor(), defaults.coldFloorFactor, 1e-3f,
"Gele : la seule penalite active est celle du froid");
// L'effort rechauffe : meme climat, mais en marchant.
Needs walker(cold);
NeedsContext walking = still;
walking.activity = Activity::Walk;
runNeeds(walker, walking, 15.0f * 60.0f, /*keepFedAndWatered=*/true);
check(walker.temperature() > needs.temperature() + 0.05f ||
walker.temperature() > 0.5f,
"Marcher rechauffe : on a moins froid qu'a l'arret");
check(walker.feltTemperatureC() > walker.ambientTemperatureC(),
"Marcher : le ressenti est au-dessus de l'ambiante");
// Le vol refroidit malgre l'effort : c'est le vent. PHASE 23 : ce n'est
// plus un forfait de -6 degres reserve au parapente, c'est la formule
// JAG/TI appliquee au vent que l'appelant declare - ici les 10,5 m/s de
// vitesse propre de l'aile. La MEME mecanique refroidit desormais un
// marcheur en crete par vent fort, ce qu'un forfait ne pouvait pas
// faire.
Needs pilot(cold);
NeedsContext flying = still;
flying.activity = Activity::Paraglide;
flying.windSpeedMps = 10.5f;
pilot.update(1.0f, flying);
check(pilot.feltTemperatureC() < pilot.ambientTemperatureC(),
"Parapente : le ressenti est SOUS l'ambiante (vent relatif)");
Needs windyWalker(cold);
NeedsContext exposedRidge = still;
exposedRidge.windSpeedMps = 14.0f;
windyWalker.update(1.0f, exposedRidge);
Needs calmWalker(cold);
calmWalker.update(1.0f, still);
check(windyWalker.feltTemperatureC() < calmWalker.feltTemperatureC() - 1.0f,
"Vent : a l'arret aussi, le vent refroidit le ressenti");
check(windyWalker.ambientTemperatureC() == calmWalker.ambientTemperatureC(),
"Vent : il change le RESSENTI, jamais l'ambiante");
// Un abri annule le vent, pas seulement le froid.
Needs hutted(cold);
NeedsContext shelteredGale = exposedRidge;
shelteredGale.sheltered = true;
hutted.update(1.0f, shelteredGale);
check(hutted.feltTemperatureC() > windyWalker.feltTemperatureC(),
"Abri : le refroidissement eolien ne s'y applique pas");
// L'abri est le point d'ancrage prevu pour l'artisanat a venir.
Needs sheltered(cold);
NeedsContext hut = still;
hut.sheltered = true;
runNeeds(sheltered, hut, 15.0f * 60.0f);
check(sheltered.temperature() > needs.temperature(),
"Abri : on se refroidit moins vite qu'a decouvert");
// Rechauffement : au-dessus du confort, la jauge remonte.
Needs thawing(cold);
NeedsContext mild = still;
mild.ambientTemperatureC = cold.comfortTemperatureC + 10.0f;
thawing.setTemperature(0.0f);
runNeeds(thawing, mild, 10.0f * 60.0f);
checkNear(thawing.temperature(), 1.0f, 1e-3f,
"Au chaud : la jauge se refait en 10 min");
}
// --- L'altitude mord vraiment sur la jauge -------------------------------
// C'est la demande explicite du cahier des charges : "lien avec l'altitude
// deja disponible (heightAt())". Deux joueurs, meme heure, meme activite,
// 1000 m d'ecart -> celui d'en haut a plus froid.
{
// PHASE 23 : les deux ambiantes sont desormais PRODUITES par le systeme
// meteo, a la meme heure et au meme instant, et Needs ne fait que les
// consommer. Le test verifie donc la chaine COMPLETE - Weather calcule,
// Needs subit - au lieu de la seule formule interne d'avant.
const WeatherSystem sky;
const float nightHours = 24.0f + 2.0f; // 2 h du matin, jour 1
const WeatherSample lowAir =
sky.sampleAt(glm::vec3(0.0f, 300.0f, 0.0f), nightHours, nullptr);
const WeatherSample highAir =
sky.sampleAt(glm::vec3(0.0f, 1300.0f, 0.0f), nightHours, nullptr);
NeedsContext valley;
valley.activity = Activity::Walk;
valley.ambientTemperatureC = lowAir.temperatureC;
NeedsContext summit = valley;
summit.ambientTemperatureC = highAir.temperatureC;
Needs low;
Needs high;
runNeeds(low, valley, 20.0f * 60.0f, /*keepFedAndWatered=*/true);
runNeeds(high, summit, 20.0f * 60.0f, /*keepFedAndWatered=*/true);
check(high.temperature() < low.temperature(),
"Altitude : a 1000 m plus haut, on se refroidit plus vite");
checkNear(low.ambientTemperatureC() - high.ambientTemperatureC(),
WeatherParams{}.lapseRateCPerKm, 1e-2f,
"Altitude : l'ecart d'ambiante vaut le gradient annonce");
}
// --- Horloge de jeu ------------------------------------------------------
{
GameClock clock(9.0f, 12.0f);
checkNear(clock.hours(), 9.0f, 1e-6f, "Horloge : heure de depart");
check(clock.clockText() == "09:00", "Horloge : texte a deux chiffres");
// 300 s reelles x 12 = 3600 s de jeu = une heure.
clock.advance(300.0f);
checkNear(clock.hours(), 10.0f, 1e-3f,
"Horloge : 5 min reelles = 1 h de jeu au facteur 12");
check(clock.clockText() == "10:00", "Horloge : texte apres avance");
clock.advance(150.0f);
check(clock.clockText() == "10:30", "Horloge : demi-heure lisible");
// Une session d'une heure reelle traverse bien une journee.
GameClock day(9.0f, 12.0f);
day.advance(60.0f * 60.0f);
checkNear(day.hours(), 21.0f, 1e-2f,
"Horloge : 1 h reelle = 12 h de jeu, la nuit tombe dans la session");
// Repli au tour suivant, sans heure negative ni heure >= 24.
GameClock wrap(23.5f, 12.0f);
wrap.advance(300.0f);
checkNear(wrap.hours(), 0.5f, 1e-3f, "Horloge : passage de minuit");
wrap.setHours(-2.0f);
checkNear(wrap.hours(), 22.0f, 1e-3f, "Horloge : reglage negatif ramene dans [0,24)");
wrap.setHours(26.0f);
checkNear(wrap.hours(), 2.0f, 1e-3f, "Horloge : reglage au-dela de 24 h");
}
// --- Affichage -----------------------------------------------------------
{
Needs needs;
const std::string summary = needs.summary();
check(summary.find("faim 100%") != std::string::npos,
"Titre : la faim y figure en pourcentage entier");
check(summary.find("forme 100%") != std::string::npos,
"Titre : la forme y figure (jauge a l'endroit, pas 'fatigue')");
const std::string status = needs.statusLine();
check(status.find("ambiante") != std::string::npos,
"Journal : la temperature ambiante y figure");
check(status.find("deplacement") != std::string::npos,
"Journal : le coefficient de deplacement y figure");
}
// --- CONSEQUENCE REELLE : moins de distance a velo ------------------------
// Le cahier des charges ne demande pas un coefficient, il demande un effet.
// On mesure donc la distance parcourue en une minute, pedale au plancher,
// avec et sans la penalite d'un joueur epuise.
{
Needs spent;
spent.setFatigue(0.0f);
const float factor = spent.movementFactor();
check(factor < 0.6f, "Joueur epuise : le coefficient mord");
const float fresh = bikeDistance(1.0f, 60.0f);
const float tired = bikeDistance(factor, 60.0f);
check(tired < fresh, "Velo : un joueur epuise va moins loin en une minute");
check(tired < 0.85f * fresh,
"Velo : la perte de distance est franche, pas symbolique");
check(tired > 0.30f * fresh,
"Velo : le velo avance encore (pas de blocage)");
}
// --- CONSEQUENCE REELLE : escalade plus lente ----------------------------
{
CliffTerrain cliff(0.0f, 3.0f, 0.0f, 40.0f);
constexpr float dt = 1.0f / 60.0f;
auto climbGain = [&](float climbInput) {
Climber climber;
climber.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f),
glm::vec3(1.0f, 0.0f, 0.0f));
check(climber.climbing(), "Escalade : engagement pour la mesure");
for (float t = 0.0f; t < 20.0f; t += dt) {
if (climber.update(dt, climbInput, 0.0f, cliff, nullptr) !=
ClimbExit::None) {
break;
}
}
return climber.heightGained();
};
Needs spent;
spent.setFatigue(0.0f);
const float full = climbGain(1.0f);
const float weak = climbGain(spent.movementFactor());
check(full > 0.0f, "Escalade : un grimpeur frais gagne de la hauteur");
check(weak < full, "Escalade : un joueur epuise grimpe moins haut en 20 s");
check(weak > 0.0f, "Escalade : un joueur epuise grimpe encore");
}
}
void testWaterSources() {
section("Phase 16 : detection des points d'eau");
const WaterSurveyParams defaults;
// --- Une cuvette est trouvee, et au bon endroit --------------------------
{
// Courbure 0,004 : le pourtour a 25 m est 2,5 m plus haut que le fond,
// au-dessus des 1,5 m exiges. Levre a 40 m : au-dela, plateau plat, qui
// ne doit rien produire.
BowlTerrain bowl(120.0f, -80.0f, 0.004f, 40.0f);
const auto sources = findWaterSources(bowl, -500.0f, 500.0f, -500.0f, 500.0f);
check(!sources.empty(), "Cuvette : au moins un point d'eau trouve");
if (!sources.empty()) {
// Le plus creux est le premier : c'est l'ordre annonce.
const float distance =
horizontalDistance(sources.front().position, glm::vec3(120.0f, 0.0f, -80.0f));
check(distance <= defaults.scanStep,
"Cuvette : le meilleur point est a moins d'un pas de balayage du fond");
checkNear(sources.front().position.y,
bowl.heightAt(sources.front().position.x, sources.front().position.z),
1e-3f, "Cuvette : le point est SUR la surface");
check(sources.front().depth >= defaults.minDepth,
"Cuvette : la profondeur retenue atteint le minimum exige");
for (std::size_t i = 1; i < sources.size(); ++i) {
check(sources[i].depth <= sources[i - 1].depth,
"Points d'eau : classes du plus creux au moins creux");
}
}
}
// --- Controles negatifs : ce qui ne doit RIEN produire -------------------
{
FlatTerrain flat(500.0f);
check(findWaterSources(flat, -500.0f, 500.0f, -500.0f, 500.0f).empty(),
"Terrain plat : aucun point d'eau (plat n'est pas creux)");
// Un versant a 20 % : trop pentu, l'eau s'ecoule.
SlopedTerrain steep(0.0f, 0.20f);
check(findWaterSources(steep, -500.0f, 500.0f, -500.0f, 500.0f).empty(),
"Versant a 20 % : aucun point d'eau");
// Un versant DOUX a 5 % : la pente passe le filtre, mais il n'y a
// aucune concavite. C'est le controle qui separe les deux criteres -
// sans lui, un detecteur qui ne regarderait que la platitude passerait.
SlopedTerrain gentle(0.0f, 0.05f);
check(findWaterSources(gentle, -500.0f, 500.0f, -500.0f, 500.0f).empty(),
"Versant doux a 5 % : plat ne suffit pas, il faut du creux");
// Une bosse : plate au sommet, mais convexe.
DomeTerrain dome(0.0f, 0.0f, 0.004f, 0.0f);
check(findWaterSources(dome, -500.0f, 500.0f, -500.0f, 500.0f).empty(),
"Sommet de bosse : plat mais convexe, aucun point d'eau");
}
// --- Bords : les sondes ne doivent pas fabriquer de fausses cuvettes ------
// heightAt est TOTALE (elle prolonge la hauteur du bord), donc sans le
// retrait d'une portee de sonde, tout le perimetre du terrain passerait
// pour un creux.
{
BowlTerrain bowl(0.0f, 0.0f, 0.004f, 40.0f);
const auto sources = findWaterSources(bowl, -300.0f, 300.0f, -300.0f, 300.0f);
for (const WaterSource& source : sources) {
check(source.position.x >= -300.0f + defaults.probeDistance - 1e-3f &&
source.position.x <= 300.0f - defaults.probeDistance + 1e-3f &&
source.position.z >= -300.0f + defaults.probeDistance - 1e-3f &&
source.position.z <= 300.0f - defaults.probeDistance + 1e-3f,
"Points d'eau : aucun a portee de sonde du bord du terrain");
}
// Un rectangle plus petit que deux portees de sonde ne rend rien plutot
// que de sonder hors emprise.
check(findWaterSources(bowl, -10.0f, 10.0f, -10.0f, 10.0f).empty(),
"Emprise minuscule : aucun point d'eau, aucune sonde hors bornes");
check(findWaterSources(bowl, 100.0f, -100.0f, -100.0f, 100.0f).empty(),
"Emprise inversee : rien, et pas de boucle infinie");
}
// --- Ecartement et bornage -----------------------------------------------
{
// Centres poses SUR les points du balayage (x0 = -575, pas de 20) et
// ecartes de 200 m, donc au-dessus de la separation minimale de 150 m :
// les trois doivent ressortir, tous les trois.
MultiBowlTerrain bowl({{25.0f, 25.0f}, {225.0f, 25.0f}, {25.0f, 225.0f}},
0.004f, 40.0f);
const auto sources = findWaterSources(bowl, -600.0f, 600.0f, -600.0f, 600.0f);
check(sources.size() == 3,
"Trois cuvettes ecartees : trois points d'eau, un par cuvette");
check(sources.size() <= defaults.maxSources,
"Points d'eau : la liste reste bornee");
for (std::size_t i = 0; i < sources.size(); ++i) {
for (std::size_t j = i + 1; j < sources.size(); ++j) {
check(horizontalDistance(sources[i].position, sources[j].position) >=
defaults.minSeparation - 1e-3f,
"Points d'eau : deux points retenus sont toujours ecartes");
}
}
// Reproductible : deux balayages du meme relief donnent la meme liste.
// C'est la condition pour qu'un scenario Vulkan puisse aller boire au
// meme endroit deux fois de suite.
const auto again = findWaterSources(bowl, -600.0f, 600.0f, -600.0f, 600.0f);
check(again.size() == sources.size(), "Points d'eau : meme nombre a chaque balayage");
bool identical = again.size() == sources.size();
for (std::size_t i = 0; identical && i < sources.size(); ++i) {
identical = horizontalDistance(again[i].position, sources[i].position) < 1e-3f;
}
check(identical, "Points d'eau : balayage deterministe");
}
// --- Recherche du plus proche --------------------------------------------
{
std::vector<WaterSource> empty;
float distance = -1.0f;
check(nearestWaterSource(empty, glm::vec3(0.0f), &distance) == nullptr,
"Plus proche : rien a trouver dans une liste vide");
std::vector<WaterSource> sources = {
WaterSource{glm::vec3(100.0f, 10.0f, 0.0f), 2.0f},
WaterSource{glm::vec3(0.0f, 90.0f, 20.0f), 3.0f},
};
const WaterSource* best =
nearestWaterSource(sources, glm::vec3(5.0f, 0.0f, 5.0f), &distance);
check(best == &sources[1], "Plus proche : le bon point est retenu");
// La distance est HORIZONTALE : les 90 m d'altitude du point ne doivent
// pas compter, sans quoi on ne pourrait jamais boire.
checkNear(distance, std::sqrt(25.0f + 225.0f), 1e-3f,
"Plus proche : la distance rendue est horizontale");
check(distance < kDrinkReach * 10.0f, "Plus proche : ordre de grandeur coherent");
}
// --- Boire au point d'eau : la chaine complete ----------------------------
// C'est le point d'ancrage demande : une jauge qui ne se remplit QUE si le
// joueur est reellement au bord d'un creux detecte sur le relief.
{
// Centre pose sur un point du balayage. Ce n'est pas un arrangement de
// confort : le balayage a un pas de 20 m, et le rayon utile d'une
// cuvette assez creuse pour etre retenue vaut une vingtaine de metres
// (au-dela, la pente depasse maxSlope) - c'est d'ailleurs pour ca que le
// pas du balayage vaut 20 m et non 50. Une cuvette placee entre deux
// points de grille peut malgre tout passer inapercue : c'est une limite
// REELLE de la methode, notee dans NOTES-PHASE16.md, pas un artefact de
// ce test.
BowlTerrain bowl(25.0f, 25.0f, 0.004f, 40.0f);
const auto sources = findWaterSources(bowl, -400.0f, 400.0f, -400.0f, 400.0f);
check(!sources.empty(), "Chaine complete : un point d'eau existe");
if (!sources.empty()) {
const glm::vec3 atSource = sources.front().position;
const glm::vec3 farAway = atSource + glm::vec3(500.0f, 0.0f, 0.0f);
float distance = 0.0f;
nearestWaterSource(sources, atSource, &distance);
check(distance <= kDrinkReach, "Chaine complete : au bord, on est a portee");
nearestWaterSource(sources, farAway, &distance);
check(distance > kDrinkReach,
"Chaine complete : a 500 m, on n'est pas a portee");
Needs needs;
needs.setThirst(0.1f);
nearestWaterSource(sources, atSource, &distance);
if (distance <= kDrinkReach) {
check(needs.drink(), "Chaine complete : on boit au point d'eau");
}
checkNear(needs.thirst(), 1.0f, 1e-6f,
"Chaine complete : la soif est etanchee sur place");
}
}
}
// ---------------------------------------------------------------------------
// Phase 17 : empreinte environnementale (memoire du milieu, faune, degradation)
// ---------------------------------------------------------------------------
// Ce que ces tests couvrent : les deux memoires de l'Habitat et leur asymetrie,
// les seuils de faune et leur hysteresis, la mise a nu du sol et son effet REEL
// sur le semis d'herbe, le placement de la faune par tirage-rejet et ses
// filtres, les deux declencheurs de fuite, la disparition et le retour.
//
// Ce qu'ils ne couvrent pas : le rendu des animaux (aucun GPU ici) et
// l'impression PRODUITE sur un joueur, qui ne se teste pas - seulement le
// scenario Vulkan et l'oeil peuvent dire si "la vallee s'est videe" se voit.
namespace {
// Fait tourner l'Habitat pendant `seconds` SANS presence du joueur, au pas de
// 1/60 s. Passer un seul grand deltaTime ne testerait rien : Habitat::update
// ecrete a kMaxStep (0,25 s), donc un appel unique de 240 s ne ferait
// decroitre que d'un quart de seconde. C'est precisement le genre de piege que
// le test doit exercer, pas contourner.
void idleHabitat(Habitat& habitat, float seconds) {
constexpr float dt = 1.0f / 60.0f;
for (float t = 0.0f; t < seconds; t += dt) {
habitat.update(dt);
}
}
// Presence continue du joueur au meme endroit pendant `seconds`.
void occupyHabitat(Habitat& habitat, const glm::vec3& position, float seconds,
float noise = 1.0f) {
constexpr float dt = 1.0f / 60.0f;
for (float t = 0.0f; t < seconds; t += dt) {
habitat.notePresence(position, dt, noise);
habitat.update(dt);
}
}
} // namespace
void testHabitatMemory() {
section("Phase 17 : memoire locale du milieu");
const glm::vec3 here(10.0f, 0.0f, 10.0f);
const glm::vec3 faraway(600.0f, 0.0f, 600.0f);
// --- Un monde neuf ne se souvient de rien -------------------------------
// C'est le contrat TOTAL de GroundCoverSource, et c'est ce qui garantit la
// non-regression : sans presence ni abattage, tout le reste du jeu doit se
// comporter exactement comme avant la Phase 17.
{
Habitat habitat;
check(habitat.trackedCellCount() == 0, "Neuf : aucune cellule memorisee");
checkNear(habitat.disturbanceAt(0.0f, 0.0f), 0.0f, 1e-6f,
"Neuf : aucune frequentation");
checkNear(habitat.loggingAt(0.0f, 0.0f), 0.0f, 1e-6f,
"Neuf : aucune deforestation");
checkNear(habitat.groundCover(0.0f, 0.0f), 1.0f, 1e-6f,
"Neuf : le sol est intact");
check(habitat.allowsWildlife(0.0f, 0.0f), "Neuf : la faune est chez elle");
check(!habitat.wildlifeFlees(0.0f, 0.0f), "Neuf : rien ne fait fuir");
}
// --- La presence monte, et seulement la ou l'on est ---------------------
{
Habitat habitat;
occupyHabitat(habitat, here, 60.0f);
check(habitat.disturbanceAt(here.x, here.z) > 0.9f,
"Une minute de marche sur place sature la cellule");
checkNear(habitat.disturbanceAt(faraway.x, faraway.z), 0.0f, 1e-6f,
"A 600 m, le milieu n'a rien remarque");
check(habitat.trackedCellCount() > 1,
"Le derangement deborde sur les cellules voisines");
// Le debordement DECROIT avec la distance : c'est ce qui empeche la
// grille de 32 m de se lire comme une grille.
const float atPlayer = habitat.disturbanceAt(here.x, here.z);
const float aside = habitat.disturbanceAt(here.x + 40.0f, here.z);
check(aside > 0.0f, "La cellule voisine se souvient aussi");
check(aside < atPlayer, "Mais moins que celle ou l'on se tient");
}
// --- L'oubli, et son ASYMETRIE ------------------------------------------
{
Habitat habitat;
occupyHabitat(habitat, here, 60.0f);
const float peak = habitat.disturbanceAt(here.x, here.z);
idleHabitat(habitat, 60.0f);
const float afterOneMinute = habitat.disturbanceAt(here.x, here.z);
check(afterOneMinute < peak, "La frequentation redescend quand on part");
check(afterOneMinute > 0.5f * peak,
"On derange plus vite qu'on ne se fait oublier (asymetrie 4x)");
idleHabitat(habitat, 300.0f);
checkNear(habitat.disturbanceAt(here.x, here.z), 0.0f, 1e-6f,
"Cinq minutes de calme effacent le derangement");
check(habitat.trackedCellCount() == 0,
"Une cellule revenue a neuf est OUBLIEE (la table ne gonfle pas)");
}
// --- Le bruit depend de l'activite --------------------------------------
// La table activityNoise n'est PAS celle des efforts de la Phase 16, et
// l'escalade est le cas qui le prouve : effort maximal du joueur, et l'une
// des activites qui derange le moins.
{
check(activityNoise(Activity::Bike) > activityNoise(Activity::Walk),
"Le velo derange plus que la marche");
check(activityNoise(Activity::Climb) < activityNoise(Activity::Walk),
"L'escalade derange moins que la marche");
check(activityNoise(Activity::Climb) > activityNoise(Activity::Paraglide),
"Le parapente est ce qui derange le moins");
check(activityNoise(Activity::Rest) > 0.0f,
"Meme immobile, un homme derange encore");
check(activityNoise(Activity::Paraglide) > 0.0f,
"Aucune activite n'est parfaitement transparente");
Habitat bikeHabitat;
Habitat walkHabitat;
occupyHabitat(bikeHabitat, here, 20.0f, activityNoise(Activity::Bike));
occupyHabitat(walkHabitat, here, 20.0f, activityNoise(Activity::Walk));
check(bikeHabitat.disturbanceAt(here.x, here.z) >
walkHabitat.disturbanceAt(here.x, here.z),
"A duree egale, le velo laisse plus de trace que la marche");
}
// --- Les deux seuils de faune, et l'hysteresis --------------------------
{
Habitat habitat;
occupyHabitat(habitat, here, 25.0f);
check(!habitat.wildlifeFlees(here.x, here.z),
"Vingt-cinq secondes ne suffisent pas a vider la zone");
occupyHabitat(habitat, here, 40.0f);
check(habitat.wildlifeFlees(here.x, here.z),
"Rester trop longtemps finit par faire fuir la faune");
check(!habitat.allowsWildlife(here.x, here.z),
"Et elle ne revient pas tant qu'on est la");
// La bande d'hysteresis : entre les deux seuils, la faune ne fuit plus
// mais ne revient pas encore. Sans elle, une zone posee sur le seuil
// ferait clignoter les animaux a chaque image.
idleHabitat(habitat, 60.0f);
const float mid = habitat.disturbanceAt(here.x, here.z);
if (mid < habitat.params().fleeThreshold &&
mid > habitat.params().respawnThreshold) {
check(!habitat.wildlifeFlees(here.x, here.z),
"Hysteresis : sous le seuil haut, on ne fuit plus");
check(!habitat.allowsWildlife(here.x, here.z),
"Hysteresis : mais pas encore de retour");
}
idleHabitat(habitat, 240.0f);
check(habitat.allowsWildlife(here.x, here.z),
"Une zone laissee tranquille redevient accueillante");
}
// --- La deforestation : un compteur SEPARE, bien plus lent --------------
{
Habitat habitat;
const glm::vec3 stump(16.0f, 0.0f, 16.0f); // centre de la cellule (0,0)
habitat.recordFelling(stump);
check(habitat.treesFelledAt(stump.x, stump.z) == 1u,
"Un arbre abattu est compte");
check(habitat.allowsWildlife(stump.x, stump.z),
"Un seul arbre ne suffit pas a interdire la faune");
check(habitat.groundCover(stump.x, stump.z) < 1.0f,
"Il laisse tout de meme une marque au sol");
check(habitat.groundCover(stump.x, stump.z) > 0.8f,
"Marque MODESTE : couper un arbre n'est pas une coupe rase");
habitat.recordFelling(stump);
check(!habitat.allowsWildlife(stump.x, stump.z),
"Deux arbres dans la meme cellule : la faune n'y revient plus");
habitat.recordFelling(stump);
checkNear(habitat.loggingAt(stump.x, stump.z), 1.0f, 1e-3f,
"Trois arbres saturent la cellule");
checkNear(habitat.groundCover(stump.x, stump.z),
habitat.params().minGroundCover, 1e-3f,
"Le sol est aussi nu qu'il peut l'etre");
for (int i = 0; i < 10; ++i) {
habitat.recordFelling(stump);
}
check(habitat.loggingAt(stump.x, stump.z) <= 1.0f,
"Le compteur reste ecrete a 1");
check(habitat.treesFelledAt(stump.x, stump.z) == 13u,
"Mais le COMPTE brut d'arbres, lui, continue de monter");
// Une coupe n'est PAS un derangement : elle survit tres largement au
// temps qu'il faut pour oublier un passage.
idleHabitat(habitat, 240.0f);
checkNear(habitat.disturbanceAt(stump.x, stump.z), 0.0f, 1e-6f,
"Quatre minutes plus tard, le bruit de la coupe est oublie");
check(habitat.loggingAt(stump.x, stump.z) > 0.6f,
"La coupe, elle, est toujours la");
check(habitat.groundCover(stump.x, stump.z) < 0.5f,
"Et le sol est toujours nu");
idleHabitat(habitat, 900.0f);
checkNear(habitat.groundCover(stump.x, stump.z), 1.0f, 1e-3f,
"Un quart d'heure de plus et le sous-bois est revenu");
check(habitat.allowsWildlife(stump.x, stump.z),
"La faune peut y revenir");
}
// --- La coupe est LOCALE, et son bord est adouci ------------------------
{
Habitat habitat;
const glm::vec3 stump(16.0f, 0.0f, 16.0f);
for (int i = 0; i < 3; ++i) {
habitat.recordFelling(stump);
}
checkNear(habitat.groundCover(200.0f, 200.0f), 1.0f, 1e-6f,
"Deux cents metres plus loin, le sol est intact");
// Interpolation bilineaire : le couvert doit remonter PROGRESSIVEMENT en
// s'eloignant du centre de la coupe, sans marche d'escalier au bord de la
// cellule. Une valeur constante par cellule dessinerait un damier.
const float atCentre = habitat.groundCover(stump.x, stump.z);
const float at20 = habitat.groundCover(stump.x + 20.0f, stump.z);
const float at40 = habitat.groundCover(stump.x + 40.0f, stump.z);
check(atCentre < at20, "Le couvert remonte des qu'on s'ecarte du centre");
check(at20 < at40, "Et continue de remonter : le bord est degrade");
check(at40 <= 1.0f && atCentre >= habitat.params().minGroundCover,
"Le couvert interpole reste dans ses bornes");
}
// --- Robustesse du pas de temps -----------------------------------------
// Meme garde-fou que Forest et Needs : une image anormalement longue ne doit
// pas faire un bond dans la memoire, et un pas negatif ne doit rien faire.
{
Habitat habitat;
habitat.notePresence(here, -1.0f, 1.0f);
check(habitat.trackedCellCount() == 0, "Un pas negatif n'ecrit rien");
habitat.notePresence(here, 1000.0f, 1.0f);
const float capped = habitat.disturbanceAt(here.x, here.z);
check(capped > 0.0f && capped < 0.1f,
"Une image de mille secondes est ecretee comme ailleurs");
}
}
void testAnimalMesh() {
section("Phase 17 : geometrie de la faune");
const MeshData animal = animalMeshData();
check(!animal.empty(), "Le mesh d'animal n'est pas vide");
check(animal.indices.size() % 3 == 0, "Indices par multiples de trois");
check(animal.triangleCount() < 200u,
"Bas-poly assume : moins de 200 triangles");
check(!animal.name.empty(), "Le mesh porte un nom lisible");
float minY = 1e9f, maxY = -1e9f, maxX = -1e9f, minX = 1e9f, maxAbsZ = 0.0f;
bool normalsUnit = true;
for (const Vertex& vertex : animal.vertices) {
minY = std::min(minY, vertex.pos.y);
maxY = std::max(maxY, vertex.pos.y);
minX = std::min(minX, vertex.pos.x);
maxX = std::max(maxX, vertex.pos.x);
maxAbsZ = std::max(maxAbsZ, std::abs(vertex.pos.z));
normalsUnit = normalsUnit && std::abs(glm::length(vertex.normal) - 1.0f) < 1e-3f;
}
// Convention de world/AnimalMesh.hpp : sabots a y = 0, regard vers +X. Un
// mesh centre sur l'origine s'enfoncerait de moitie dans le terrain, et un
// mesh regardant vers +Z tournerait le dos a son cap.
checkNear(minY, 0.0f, 1e-4f, "Les sabots sont a y = 0");
checkNear(maxY, kAnimalHeight, 0.02f, "La hauteur annoncee est la bonne");
check(maxX > 0.0f && std::abs(maxX) > std::abs(minX),
"L'animal regarde vers +X (la tete depasse la croupe)");
check(maxX - minX <= kAnimalLength + 0.1f, "La longueur annoncee est tenue");
check(2.0f * maxAbsZ <= kAnimalWidth + 0.1f, "La largeur annoncee est tenue");
check(normalsUnit, "Toutes les normales sont unitaires");
// La matrice d'instance : meme convention de cap que le velo.
{
Animal deer;
deer.position = { 5.0f, 100.0f, -3.0f };
deer.headingDegrees = 0.0f;
const glm::vec3 nose =
glm::vec3(deer.modelMatrix() * glm::vec4(1.0f, 0.0f, 0.0f, 1.0f)) -
deer.position;
checkNear(nose.x, 1.0f, 1e-4f, "Cap 0 : l'animal regarde vers +X");
checkNear(nose.z, 0.0f, 1e-4f, "Cap 0 : rien sur Z");
deer.headingDegrees = 90.0f;
const glm::vec3 turned =
glm::vec3(deer.modelMatrix() * glm::vec4(1.0f, 0.0f, 0.0f, 1.0f)) -
deer.position;
checkNear(turned.z, 1.0f, 1e-4f, "Cap 90 : l'animal regarde vers +Z");
checkNear(turned.x, 0.0f, 1e-4f, "Cap 90 : plus rien sur X");
// Le pied de l'animal reste ou on l'a mis, quelle que soit l'echelle :
// c'est ce qui permet de le poser sur le terrain sans correction.
deer.scale = 1.2f;
const glm::vec3 foot =
glm::vec3(deer.modelMatrix() * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
checkNear(foot.y, deer.position.y, 1e-4f,
"L'echelle ne decolle pas l'animal du sol");
}
}
void testWildlife() {
section("Phase 17 : faune, placement et fuite");
FlatTerrain flat(1200.0f);
ConstantMap wooded(0.6f); // au-dessus de WildlifeParams::minCover
ConstantMap bare(0.05f); // en dessous
const glm::vec3 player(0.0f, 1200.0f, 0.0f);
// --- Placement par tirage-rejet -----------------------------------------
{
Habitat habitat;
Wildlife wildlife(flat, &wooded, 4000.0f);
wildlife.populate(player, habitat);
check(wildlife.animalCount() > 0, "Un bois calme se peuple");
check(wildlife.animalCount() <= wildlife.params().maxAnimals,
"La population reste sous son plafond");
check(wildlife.spawnCount() == wildlife.animalCount(),
"Le compteur d'apparitions suit la population");
bool inRing = true;
bool spaced = true;
bool onGround = true;
const auto& animals = wildlife.animals();
for (std::size_t i = 0; i < animals.size(); ++i) {
const glm::vec3 delta = animals[i].position - player;
const float distance = std::sqrt(delta.x * delta.x + delta.z * delta.z);
inRing = inRing && distance >= wildlife.params().spawnRadiusMin - 0.01f &&
distance <= wildlife.params().spawnRadiusMax + 0.01f;
onGround = onGround && std::abs(animals[i].position.y - 1200.0f) < 1e-3f;
for (std::size_t j = i + 1; j < animals.size(); ++j) {
const float dx = animals[i].position.x - animals[j].position.x;
const float dz = animals[i].position.z - animals[j].position.z;
spaced = spaced && (dx * dx + dz * dz) >=
wildlife.params().minSpacing *
wildlife.params().minSpacing - 0.01f;
}
}
// Le minimum de l'anneau EST le point important : un animal qui
// apparaitrait dans le champ proche montrerait la mecanique.
check(inRing, "Aucun animal n'apparait dans le champ proche du joueur");
check(spaced, "Les animaux ne s'entassent pas");
check(onGround, "Les animaux sont poses sur la surface du terrain");
}
// --- Determinisme (meme graine, meme monde) -----------------------------
{
Habitat habitat;
Wildlife a(flat, &wooded, 4000.0f);
Wildlife b(flat, &wooded, 4000.0f);
a.populate(player, habitat);
b.populate(player, habitat);
bool identical = a.animalCount() == b.animalCount();
for (std::size_t i = 0; identical && i < a.animals().size(); ++i) {
identical = glm::length(a.animals()[i].position - b.animals()[i].position) < 1e-5f;
}
check(identical, "Deux Wildlife de meme graine placent les memes animaux");
}
// --- Les filtres refusent -----------------------------------------------
{
Habitat habitat;
Wildlife onBareRock(flat, &bare, 4000.0f);
onBareRock.populate(player, habitat);
check(onBareRock.animalCount() == 0,
"Aucun animal sur du lapiaz nu (carte de couvert)");
SlopedTerrain cliff(1200.0f, 1.6f); // 160 %, bien au-dela de maxSlope
Wildlife onCliff(cliff, &wooded, 4000.0f);
onCliff.populate(player, habitat);
check(onCliff.animalCount() == 0, "Aucun animal sur une paroi");
// Sans carte LiDAR, on ne refuse pas tout : c'est le cas du terrain
// synthetique, et un monde vide y serait un faux negatif permanent.
Wildlife noMap(flat, nullptr, 4000.0f);
noMap.populate(player, habitat);
check(noMap.animalCount() > 0, "Sans carte de couvert, la faune existe quand meme");
// Emprise : rien hors des donnees, meme si tout le reste est bon.
Wildlife tiny(flat, &wooded, 40.0f);
tiny.populate(player, habitat);
check(tiny.animalCount() == 0,
"Rien n'est place hors de l'emprise du terrain");
}
// --- Fuite 1 : le joueur s'approche trop pres ---------------------------
{
Habitat habitat;
Wildlife wildlife(flat, &wooded, 4000.0f);
wildlife.populate(player, habitat);
check(wildlife.fleeingCount() == 0, "Au repos, personne ne fuit");
const Animal target = wildlife.animals().front();
// Le joueur se teleporte a cinq metres de cet animal.
const glm::vec3 intruder(target.position.x + 5.0f, target.position.y,
target.position.z);
wildlife.update(1.0f / 60.0f, intruder, habitat);
check(wildlife.fleeingCount() >= 1, "S'approcher fait fuir");
const Animal* moved = nullptr;
for (const Animal& animal : wildlife.animals()) {
if (animal.id == target.id) {
moved = &animal;
}
}
check(moved != nullptr, "L'animal derange est toujours la (il fuit, il ne disparait pas)");
if (moved != nullptr) {
check(moved->state == AnimalState::Fleeing, "Il est en fuite");
const float before = 5.0f;
for (int i = 0; i < 60; ++i) {
wildlife.update(1.0f / 60.0f, intruder, habitat);
}
const Animal* after = nullptr;
for (const Animal& animal : wildlife.animals()) {
if (animal.id == target.id) {
after = &animal;
}
}
if (after != nullptr) {
const float dx = after->position.x - intruder.x;
const float dz = after->position.z - intruder.z;
const float distance = std::sqrt(dx * dx + dz * dz);
check(distance > before, "Il s'ELOIGNE du joueur");
check(distance > before + 0.5f * wildlife.params().fleeSpeed,
"Et il s'eloigne vite : poursuivre ne sert a rien");
}
}
}
// --- Fuite 2 : le joueur reste trop longtemps (LE point de la phase) ----
// Le joueur ne s'est jamais approche a moins de 30 m. C'est la MEMOIRE du
// milieu, remplie par sa presence prolongee, qui vide la zone.
{
Habitat habitat;
Wildlife wildlife(flat, &wooded, 4000.0f);
wildlife.populate(player, habitat);
check(wildlife.animalCount() > 0, "Depart : le bois est habite");
const Animal target = wildlife.animals().front();
// Camp installe a 40 m de l'animal : au-dela de fleeRadius (30 m), donc
// AUCUNE fuite par approche possible.
const glm::vec3 camp(target.position.x + 40.0f, target.position.y,
target.position.z);
check(glm::length(glm::vec2(camp.x - target.position.x,
camp.z - target.position.z)) >
wildlife.params().fleeRadius,
"Le camp est hors de la distance de fuite par approche");
// Quatre-vingt-dix secondes de camp. C'est ce que produit le modele a
// cette distance (ponderation 0,89 a 40 m sur un rayon de 120 m, voir
// Habitat::notePresence), et c'est le bon ordre de grandeur de jeu : on
// ne vide pas un vallon en le traversant, on le vide en s'y installant.
occupyHabitat(habitat, camp, 90.0f);
check(habitat.wildlifeFlees(target.position.x, target.position.z),
"Le milieu, lui, a retenu la presence prolongee");
wildlife.update(1.0f / 60.0f, camp, habitat);
bool stillCalm = false;
for (const Animal& animal : wildlife.animals()) {
if (animal.id == target.id) {
stillCalm = animal.state == AnimalState::Calm;
}
}
check(!stillCalm, "Rester trop longtemps vide la zone sans s'etre approche");
}
// --- Le milieu derange refuse les nouvelles apparitions ------------------
{
Habitat saturated;
// On sature tout l'anneau d'apparition : le joueur a passe une minute
// partout. C'est artificiel - un vrai joueur mettrait une heure - mais
// c'est exactement l'etat que le systeme doit savoir produire.
for (float x = -320.0f; x <= 320.0f; x += 30.0f) {
for (float z = -320.0f; z <= 320.0f; z += 30.0f) {
saturated.notePresence({ x, 1200.0f, z }, 0.25f, 1.0f);
}
}
for (int i = 0; i < 300; ++i) {
for (float x = -320.0f; x <= 320.0f; x += 30.0f) {
for (float z = -320.0f; z <= 320.0f; z += 30.0f) {
saturated.notePresence({ x, 1200.0f, z }, 0.25f, 1.0f);
}
}
}
check(!saturated.allowsWildlife(150.0f, 0.0f),
"L'anneau entier est sature de frequentation");
Wildlife wildlife(flat, &wooded, 4000.0f);
wildlife.populate(player, saturated);
check(wildlife.animalCount() == 0,
"Une zone sur-frequentee ne se repeuple pas");
// ... ET LA FAUNE PEUT REVENIR. C'est la moitie du systeme : une
// consequence qu'on ne peut pas defaire serait une punition, pas un
// milieu vivant.
idleHabitat(saturated, 400.0f);
check(saturated.allowsWildlife(150.0f, 0.0f),
"Laissee tranquille, la zone redevient accueillante");
wildlife.populate(player, saturated);
check(wildlife.animalCount() > 0, "Et la faune y revient");
}
// --- Une coupe interdit la faune bien plus longtemps qu'un passage ------
{
Habitat habitat;
Wildlife wildlife(flat, &wooded, 4000.0f);
// Deux arbres abattus dans chaque cellule de l'anneau.
for (float x = -320.0f; x <= 320.0f; x += 30.0f) {
for (float z = -320.0f; z <= 320.0f; z += 30.0f) {
habitat.recordFelling({ x, 1200.0f, z });
habitat.recordFelling({ x, 1200.0f, z });
}
}
wildlife.populate(player, habitat);
check(wildlife.animalCount() == 0, "Un versant deforeste reste vide");
// Quatre minutes suffisent a effacer un passage (test precedent) ; elles
// ne suffisent PAS a effacer une coupe.
idleHabitat(habitat, 240.0f);
wildlife.populate(player, habitat);
check(wildlife.animalCount() == 0,
"Quatre minutes plus tard, toujours vide : une coupe n'est pas un passage");
}
// --- Disparition au loin -------------------------------------------------
{
Habitat habitat;
Wildlife wildlife(flat, &wooded, 4000.0f);
wildlife.populate(player, habitat);
const std::size_t before = wildlife.animalCount();
check(before > 0, "Des animaux au depart");
const glm::vec3 elsewhere(3000.0f, 1200.0f, 3000.0f);
wildlife.update(1.0f / 60.0f, elsewhere, habitat);
check(wildlife.animalCount() == 0,
"A trois kilometres, la population precedente est oubliee");
check(wildlife.despawnCount() == static_cast<uint32_t>(before),
"Et les disparitions sont comptees");
}
}
void testEnvironmentalFootprint() {
section("Phase 17 : la coupe se VOIT au sol");
// Le bout de chaine qui compte : Habitat -> GroundCoverSource -> semis
// d'herbe. C'est la seule consequence VISUELLE de la degradation dans cette
// premiere version (voir NOTES-PHASE17.md pour ce qui a ete ecarte).
const Frustum frustum = permissiveFrustum();
SlopedTerrain terrain(1200.0f, 0.0f); // plat, sous grassAltitudeLush
ConstantMap cover(0.5f);
ConstantMap noCanopy(0.0f);
const glm::vec3 eye(16.0f, 1200.0f, 16.0f); // centre de la cellule (0,0)
std::vector<InstanceData> reference;
{
Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f);
vegetation.gatherGrass(eye, frustum, reference);
check(!reference.empty(), "Sans degradation, le pre est herbeux");
}
// NON-REGRESSION LITTERALE : un Habitat vierge branche ne doit RIEN changer,
// pas "presque rien". C'est ce que garantit le contrat total de
// GroundCoverSource, et c'est ce qui permet d'affirmer que la Phase 17 ne
// touche pas au decor d'un monde qu'on n'a pas abime.
{
Habitat habitat;
Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f);
vegetation.setGroundCover(&habitat);
std::vector<InstanceData> tufts;
vegetation.gatherGrass(eye, frustum, tufts);
check(tufts.size() == reference.size(),
"Habitat vierge : le semis d'herbe est INCHANGE");
}
// Trois arbres abattus dans la cellule sous les pieds.
{
Habitat habitat;
for (int i = 0; i < 3; ++i) {
habitat.recordFelling(eye);
}
Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f);
vegetation.setGroundCover(&habitat);
std::vector<InstanceData> tufts;
vegetation.gatherGrass(eye, frustum, tufts);
check(tufts.size() < reference.size(),
"Apres la coupe, le sol se denude");
check(!tufts.empty(),
"Mais il reste des touffes : une coupe rase n'est pas de la roche");
// La mise a nu est LOCALE : les touffes qui subsistent sont surtout
// celles des cellules voisines, epargnees par la coupe.
std::size_t nearStump = 0;
std::size_t nearStumpBefore = 0;
for (const InstanceData& tuft : tufts) {
if (std::abs(tuft.position.x - eye.x) < 12.0f &&
std::abs(tuft.position.z - eye.z) < 12.0f) {
++nearStump;
}
}
for (const InstanceData& tuft : reference) {
if (std::abs(tuft.position.x - eye.x) < 12.0f &&
std::abs(tuft.position.z - eye.z) < 12.0f) {
++nearStumpBefore;
}
}
check(nearStump < nearStumpBefore,
"Le manque se voit AU PIED de la coupe");
check(static_cast<double>(nearStump) / std::max<std::size_t>(1, nearStumpBefore) <
0.5,
"Et il s'y voit franchement (plus de la moitie de l'herbe en moins)");
}
// La repousse rend son herbe au sol : le systeme est reversible.
{
Habitat habitat;
for (int i = 0; i < 3; ++i) {
habitat.recordFelling(eye);
}
idleHabitat(habitat, 1200.0f);
Vegetation vegetation(terrain, &cover, &noCanopy, 4000.0f);
vegetation.setGroundCover(&habitat);
std::vector<InstanceData> tufts;
vegetation.gatherGrass(eye, frustum, tufts);
check(tufts.size() == reference.size(),
"Vingt minutes plus tard, l'herbe est integralement revenue");
}
}
// ===========================================================================
// PHASE 20 : la collision s'etend a la faune
// ===========================================================================
// Ce qui est verifie ici n'est pas "il y a du code de collision" mais "sans le
// solveur, on TRAVERSE ; avec lui, on s'arrete la ou le modele le dit". C'est
// la meme methode qu'en Phase 15 pour les objets d'editeur : un temoin negatif
// et un chiffre PREDIT, pas une impression.
//
// Le temoin est obtenu en rejouant EXACTEMENT le meme monde avec
// WildlifeParams::solid a false - c'est-a-dire l'option --no-animal-collision
// du jeu. Meme graine, donc meme semis, donc meme animal a la meme place : la
// seule difference entre les deux marches est la collision elle-meme.
namespace {
// Marche en ligne droite, pas par pas, par le MEME moveBody que la camera, le
// velo et le grimpeur. Renvoie la position finale ; remplit les temoins passes
// en pointeur (peuvent etre nuls).
glm::vec3 walkThrough(const CollisionSolver& solver, const glm::vec3& start,
const glm::vec3& direction, int steps, float stepLength,
const glm::vec3& landmark, float* closestApproachOut,
bool* sawNaNOut) {
glm::vec3 position = start;
float closest = horizontalDistance(start, landmark);
bool sawNaN = false;
for (int step = 0; step < steps; ++step) {
const glm::vec3 previous = position;
const glm::vec3 desired = position + direction * stepLength;
BodyCylinder body = standingBody(desired.x, desired.z);
position = moveBody(solver, body, previous);
if (std::isnan(position.x) || std::isnan(position.z)) {
sawNaN = true;
break;
}
closest = std::min(closest, horizontalDistance(position, landmark));
}
if (closestApproachOut != nullptr) {
*closestApproachOut = closest;
}
if (sawNaNOut != nullptr) {
*sawNaNOut = sawNaN;
}
return position;
}
} // namespace
void testWildlifeCollision() {
section("Phase 20 : collision de la faune");
FlatTerrain flat(0.0f);
ConstantMap wooded(0.6f);
const glm::vec3 player(0.0f, 1.7f, 0.0f);
// Deux mondes IDENTIQUES a une option pres. La graine par defaut est la
// meme, le terrain est le meme, le semis est donc le meme animal a la meme
// place - c'est ce qui autorise a comparer les deux marches.
//
// UN SEUL animal, et c'est ce qui rend la mesure interpretable : avec la
// population par defaut (24 animaux espaces d'au moins 14 m), un trajet de
// 20 m peut en croiser un SECOND, et la marche s'arrete alors sur celui-la.
// Le premier jet de ce test echouait exactement la-dessus : la collision
// fonctionnait, c'est la distance predite qui parlait du mauvais animal.
WildlifeParams soloParams;
soloParams.maxAnimals = 1;
WildlifeParams passableParams = soloParams;
passableParams.solid = false; // == --no-animal-collision
Habitat habitat;
Wildlife solidFauna(flat, &wooded, 4000.0f, soloParams);
Wildlife passableFauna(flat, &wooded, 4000.0f, passableParams);
solidFauna.populate(player, habitat);
passableFauna.populate(player, habitat);
check(solidFauna.animalCount() > 0, "Un animal est seme pour la mesure");
check(solidFauna.animalCount() == passableFauna.animalCount(),
"Temoin et mesure ont la meme population");
const Animal& animal = solidFauna.animals()[0];
const Animal& twin = passableFauna.animals()[0];
check(horizontalDistance(animal.position, twin.position) < 1e-4f,
"Temoin et mesure ont le meme animal au meme endroit");
// Rayon d'arret ATTENDU, calcule ici et pas lu dans le solveur : rayon de
// collision de cet animal + demi-largeur du joueur.
const float reach = solidFauna.colliderRadiusOf(animal) + 0.35f;
// Trajet : on part a 10 m de l'animal et on marche DROIT dessus sur 20 m,
// donc de quoi ressortir largement de l'autre cote si rien n'arrete.
const glm::vec3 toPlayer =
glm::normalize(glm::vec3(player.x - animal.position.x, 0.0f,
player.z - animal.position.z));
const glm::vec3 start = animal.position + toPlayer * 10.0f + glm::vec3(0.0f, 1.7f, 0.0f);
const glm::vec3 heading = -toPlayer;
float closestWithSolver = 0.0f;
bool sawNaN = false;
const glm::vec3 stopped = walkThrough(solidFauna, start, heading, 400, 0.05f,
animal.position, &closestWithSolver, &sawNaN);
float closestWitness = 0.0f;
bool witnessNaN = false;
const glm::vec3 crossed = walkThrough(passableFauna, start, heading, 400, 0.05f,
animal.position, &closestWitness, &witnessNaN);
const float travelled = horizontalDistance(stopped, start);
const float travelledWitness = horizontalDistance(crossed, start);
check(!sawNaN && !witnessNaN, "Aucun NaN sur les 400 pas des deux marches");
// --- LE TEMOIN : sans collision, on passe AU TRAVERS ---------------------
// Mesure : approche la plus proche 0,0010 m, soit le centre de l'animal, et
// les 20 m parcourus en entier. C'est le comportement d'avant la Phase 20.
check(closestWitness < 0.05f,
"Temoin (--no-animal-collision) : la marche passe par le centre de l'animal");
check(travelledWitness > 19.9f,
"Temoin : les 20 m sont parcourus, l'animal ne freine rien");
// --- LA MESURE : le contact a lieu au rayon PREDIT -----------------------
// La premiere version de ce test attendait un ARRET NET a `10 - reach`, et
// elle avait tort - la mesure l'a dit tout de suite : 13,20 m parcourus au
// lieu des 8,96 m attendus, pour une approche la plus proche de 1,0418 m
// EXACTEMENT egale au rayon predit.
//
// Ce n'est pas un defaut, c'est le GLISSEMENT que le solveur par
// repoussement produit exprès (voir CollisionSolver.hpp : "on longe un tronc
// au lieu de s'y coller net"). Contre un obstacle convexe ISOLE, une poussee
// frontale n'est jamais parfaitement frontale a l'arrondi pres, et la
// composante laterale accumulee fait contourner l'animal. Le joueur en sort
// par le cote, comme il contournerait un tronc.
//
// La grandeur qui est reellement PREDITE par le modele, et qu'on verifie
// donc, est le rayon de CONTACT : rayon de collision de l'animal + demi-
// largeur du joueur. Elle est atteinte au millimetre pres.
check(closestWithSolver >= reach - 1e-3f,
"Avec collision : jamais a l'interieur de l'animal");
check(std::abs(closestWithSolver - reach) < 1e-3f,
"Avec collision : le contact a lieu exactement au rayon predit");
check(travelled < travelledWitness - 5.0f,
"Avec collision : contourner l'animal coute de la distance (13,2 m contre 20,0 m)");
check(horizontalDistance(stopped, animal.position) > reach - 1e-3f,
"Avec collision : la marche finit hors de l'animal, pas dedans");
// --- Coherence resolve / overlaps ---------------------------------------
// Le contrat de CollisionSolver : la sortie de resolve() doit etre LIBRE,
// sinon moveBody() refuserait tout deplacement le long d'un animal.
{
BodyCylinder inside = standingBody(animal.position.x + 0.1f,
animal.position.z + 0.1f);
check(solidFauna.overlaps(inside), "Un corps dans l'animal est declare en contact");
BodyCylinder pushed = inside;
pushed.position = solidFauna.resolve(inside);
check(!solidFauna.overlaps(pushed), "La sortie de resolve() est libre");
check(std::abs(horizontalDistance(pushed.position, animal.position) - reach) < 1e-3f,
"resolve() repousse exactement au contact");
}
// --- Cas degenere : le joueur exactement sur l'axe de l'animal -----------
// Un animal peut venir se poser sur un joueur immobile, puisqu'il bouge et
// que le joueur n'appelle moveBody() qu'en se deplacant.
{
BodyCylinder centred = standingBody(animal.position.x, animal.position.z);
const glm::vec3 out = solidFauna.resolve(centred);
check(!std::isnan(out.x) && !std::isnan(out.z),
"Joueur exactement sur l'animal : aucun NaN");
check(std::abs(horizontalDistance(out, animal.position) - reach) < 1e-3f,
"Joueur exactement sur l'animal : ecarte au contact");
}
// --- La bande verticale : un animal n'est pas un mur -------------------
// C'est ce qui rend l'extension sans danger pour l'ESCALADE. Le grimpeur
// soumet une bande centree sur son point d'ancrage : des qu'il est plus
// haut qu'un cervide, la faune du pied de la paroi ne peut plus le
// concerner. Aucune ligne de Climber n'a ete ecrite pour ca.
{
BodyCylinder onTheWall;
onTheWall.radius = 0.35f;
onTheWall.position = { animal.position.x, animal.position.y + 3.0f,
animal.position.z };
onTheWall.feetY = animal.position.y + 2.4f;
onTheWall.headY = animal.position.y + 3.6f;
check(!solidFauna.overlaps(onTheWall),
"Un grimpeur au-dessus du cervide n'est pas gene par lui");
BodyCylinder atItsFeet = standingBody(animal.position.x, animal.position.z);
check(solidFauna.overlaps(atItsFeet),
"Le meme point, au sol, est bien bloque");
}
// --- Le rayon suit l'echelle du mesh ------------------------------------
{
bool radiusFollowsScale = true;
for (const Animal& each : solidFauna.animals()) {
radiusFollowsScale =
radiusFollowsScale &&
std::abs(solidFauna.colliderRadiusOf(each) -
solidFauna.params().colliderRadius * each.scale) < 1e-6f;
}
check(radiusFollowsScale, "Le rayon de collision suit l'echelle de l'animal");
check(std::abs(solidFauna.params().colliderRadius - 0.5f * kAnimalLength) < 1e-6f,
"Le rayon par defaut est la demi-longueur du mesh");
}
// --- Le monde entier, par le solveur composite --------------------------
// Le chemin REEL du jeu : les trois sources d'obstacles dans le meme
// CompositeCollisionSolver, comme main.cpp les y met.
{
Ground ground(flat);
ForestParams noTrees;
noTrees.treeCount = 0;
Forest forest(flat, ground, 100.0f, noTrees);
forest.plantTree(6.0f, 0.0f, 8.0f);
AssetCatalog catalog;
catalog.addBuiltins();
EditorScene scene(&catalog);
PlacedObject rock;
rock.asset = "rocher";
rock.position = { 12.0f, 0.0f, 0.0f };
rock.solid = true;
scene.place(rock);
CompositeCollisionSolver world;
world.add(&forest);
world.add(&scene);
world.add(&solidFauna);
check(world.size() == 3, "Composite : trois sources d'obstacles");
BodyCylinder walker = standingBody(6.0f, 0.0f);
check(world.overlaps(walker), "Composite : le tronc bloque toujours (Phase 6)");
walker = standingBody(12.0f, 0.0f);
check(world.overlaps(walker), "Composite : le rocher pose bloque toujours (Phase 15)");
walker = standingBody(animal.position.x, animal.position.z);
check(world.overlaps(walker), "Composite : l'animal bloque desormais (Phase 20)");
walker = standingBody(3.0f, 0.0f);
check(!world.overlaps(walker), "Composite : le passage libre le reste");
// --- DECISION DOCUMENTEE : les objets au sol ne bloquent PAS --------
// Ground n'est pas un CollisionSolver et n'est pas dans ce composite.
// Ce n'est pas un oubli : buches, branches, pierres et eclats sont des
// cibles de RAMASSAGE (Ground::findNearest exige de s'en approcher), et
// le plus haut d'entre eux - la pierre - culmine a 0,40 m, sous le
// genou. Un debitage depose 3 a 4 buches autour du joueur : les rendre
// solides pourrait l'emmurer dans le bois qu'il vient de produire.
ground.drop(GroundItemKind::Stone, 3.0f, 0.0f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Log, 3.4f, 0.0f, 0.0f, 0.0f);
check(ground.itemCount() >= 2, "Deux objets sont bien poses sur le trajet");
check(2.0f * kStoneRadius < 0.5f,
"Le plus haut objet au sol reste sous le genou");
walker = standingBody(3.0f, 0.0f);
check(!world.overlaps(walker),
"Un objet ramassable au sol ne bloque pas (decision de la Phase 20)");
}
// --- LE VELO : la meme collision, sans une ligne ecrite dans Bike --------
// La consigne de la phase demandait explicitement que l'extension vaille
// pour TOUTES les activites qui se deplacent, pas seulement la marche. Le
// velo est le cas qui compte le plus : il roule a 30 km/h, c'est-a-dire a
// la vitesse de FUITE de l'animal (8 m/s), donc c'est la seule activite qui
// peut reellement rattraper un cervide et lui rentrer dedans. A pied, on
// n'en approche jamais - il part a 30 m.
{
// On enfourche a 15 m de l'animal, cap droit dessus. Convention de cap
// du velo : 0 = +X, croissant vers +Z (voir Bike.hpp).
const glm::vec3 mountPoint = animal.position + toPlayer * 15.0f;
const glm::vec3 toAnimal = -toPlayer;
const float headingDegrees = glm::degrees(std::atan2(toAnimal.z, toAnimal.x));
auto rideAt = [&](const Wildlife& fauna) {
Bike bike;
bike.mount(mountPoint, headingDegrees, flat);
float closest = horizontalDistance(bike.position(), animal.position);
for (int i = 0; i < 900; ++i) {
bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, &fauna);
closest = std::min(closest, horizontalDistance(bike.position(),
animal.position));
}
return closest;
};
const float closestRiding = rideAt(solidFauna);
const float closestRidingWitness = rideAt(passableFauna);
check(closestRidingWitness < 0.5f,
"Velo, temoin : sans collision le velo passe sur l'animal");
check(closestRiding >= reach - 1e-3f,
"Velo : le cycliste bute sur l'animal au lieu de le traverser");
check(closestRiding > closestRidingWitness + 0.4f,
"Velo : l'ecart avec le temoin est celui d'un obstacle reel");
}
// --- L'ESCALADE : concernee au PIED de la paroi, jamais dessus -----------
// Le grimpeur recoit le meme `worldSolver` que les deux autres, donc il
// herite de la collision sans qu'une ligne de Climber change (le test de la
// Phase 14 le prouve deja pour les troncs). Mais il y a mieux, et c'est une
// propriete du MODELE, pas du code : un animal ne peut pas se tenir sur une
// surface assez raide pour etre grimpable.
//
// C'est le meme genre de rapport entre deux constantes reglees separement
// que la lecon de la Phase 17 (noiseRadius vs spawnRadiusMin) - sauf qu'ici
// le rapport est celui qu'on veut, et cette assertion est ce qui empeche de
// le perdre par inadvertance en retouchant l'une des deux.
{
const ClimberParams climbing;
// PHASE 24 : les deux nombres ont bouge ensemble (1,00 -> 0,84 pour la
// paroi, 0,90 -> 0,80 pour l'animal). L'assertion, elle, n'a pas
// change - et c'est exactement ce qu'on lui demandait : elle porte le
// RAPPORT, pas les valeurs, donc elle survit au reglage et continue
// d'interdire de le perdre.
check(WildlifeParams{}.maxSlope < climbing.wallSlope,
"Aucun animal ne peut se tenir sur une pente grimpable "
"(maxSlope < wallSlope)");
// Et en paroi, la bande verticale suffit de toute facon : verifie plus
// haut ("Un grimpeur au-dessus du cervide n'est pas gene par lui").
}
// --- Le temoin, une derniere fois, cote interface ------------------------
{
BodyCylinder centred = standingBody(twin.position.x, twin.position.z);
check(!passableFauna.overlaps(centred),
"--no-animal-collision : aucun contact declare");
check(passableFauna.resolve(centred) == centred.position,
"--no-animal-collision : resolve() rend la position telle quelle");
}
}
// ===========================================================================
// PHASE 22 : les gisements d'argile et de sable
// ===========================================================================
// Ce que ces tests peuvent prouver et ce qu'ils ne peuvent PAS prouver merite
// d'etre dit une fois : ils verifient que le detecteur applique bien la regle
// annoncee dans world/Deposits.hpp (creux + versant amont, puis partage par la
// distance a l'eau). Ils ne verifient AUCUNEMENT qu'il y a de l'argile la ou il
// en place - c'est un proxy morphologique, pas une carte geologique, et aucun
// test ne peut valider une vraisemblance.
void testMineralDeposits() {
section("Phase 22 : gisements d'argile et de sable");
const DepositSurveyParams defaults;
const std::vector<WaterSource> noWater;
// --- Un creux alimente par un versant est trouve ------------------------
{
// Cuvette de courbure 0,006 : le pourtour a 25 m est 3,75 m plus haut
// que le fond, donc au-dessus de minUpslope (3,0 m). Levre a 60 m.
BowlTerrain bowl(160.0f, -120.0f, 0.006f, 60.0f);
const auto deposits =
findMineralDeposits(bowl, -600.0f, 600.0f, -600.0f, 600.0f, noWater);
check(!deposits.empty(), "Cuvette : au moins un gisement trouve");
if (!deposits.empty()) {
const float distance = horizontalDistance(
deposits.front().position, glm::vec3(160.0f, 0.0f, -120.0f));
check(distance <= defaults.scanStep,
"Cuvette : le meilleur gisement est a moins d'un pas du fond");
checkNear(deposits.front().position.y,
bowl.heightAt(deposits.front().position.x,
deposits.front().position.z),
1e-3f, "Cuvette : le gisement est SUR la surface");
check(deposits.front().upslope >= defaults.minUpslope,
"Cuvette : le denivele amont retenu atteint le minimum exige");
for (std::size_t i = 1; i < deposits.size(); ++i) {
check(deposits[i].depth <= deposits[i - 1].depth,
"Gisements : classes du plus creux au moins creux");
}
// Ecartement : c'est la seule garantie qui empeche une grande
// cuvette de rendre quarante gisements colles.
bool spaced = true;
for (std::size_t i = 0; i < deposits.size(); ++i) {
for (std::size_t j = i + 1; j < deposits.size(); ++j) {
if (horizontalDistance(deposits[i].position, deposits[j].position)
< defaults.minSeparation - 1e-3f) {
spaced = false;
}
}
}
check(spaced,
"Gisements : deux retenus sont toujours separes de minSeparation");
}
}
// --- Controles negatifs : ce qui ne doit RIEN produire ------------------
{
FlatTerrain flat(500.0f);
check(findMineralDeposits(flat, -600.0f, 600.0f, -600.0f, 600.0f, noWater).empty(),
"TEMOIN terrain plat : aucun gisement (plat n'est ni creux ni alimente)");
// Bosse PURE : convexe PARTOUT, sans palier. Courbure choisie faible
// (0,00002) pour que la pente reste sous maxSlope sur tout le
// rectangle - sans quoi le rejet viendrait de la pente et non de la
// convexite, et le temoin ne prouverait pas ce qu'il annonce.
DomeTerrain dome(0.0f, 0.0f, 0.00002f, -1.0e6f);
check(findMineralDeposits(dome, -600.0f, 600.0f, -600.0f, 600.0f, noWater).empty(),
"TEMOIN bosse convexe partout : aucun gisement");
// Versant regulier a 40 % : pente trop forte ET aucune concavite.
SlopedTerrain steep(0.0f, 0.40f);
check(findMineralDeposits(steep, -600.0f, 600.0f, -600.0f, 600.0f, noWater).empty(),
"TEMOIN versant a 40 % : aucun gisement");
// MAIS le PIED d'une bosse, lui, doit etre retenu - et c'est une
// propriete voulue, pas un accident. La rupture de pente au bas d'un
// versant est CONCAVE et a tout le versant au-dessus d'elle : c'est
// exactement la definition d'un cone de dejection, l'endroit le plus
// credible de tout un relief pour trouver du sediment.
//
// Ce cas a d'abord ete ecrit comme un controle NEGATIF, et la mesure a
// montre qu'il ne devait pas l'etre : la bosse a palier rend deux
// gisements a 160 m du centre, avec 8,1 m de concavite et 26,8 m de
// versant au-dessus. C'est le detecteur qui avait raison.
DomeTerrain footed(0.0f, 0.0f, 0.004f, 0.0f);
const auto atFoot =
findMineralDeposits(footed, -600.0f, 600.0f, -600.0f, 600.0f, noWater);
check(!atFoot.empty(), "Pied de bosse : des gisements y sont retenus");
for (const MineralDeposit& deposit : atFoot) {
const float radius = horizontalDistance(deposit.position, glm::vec3(0.0f));
check(radius > 100.0f,
"Pied de bosse : les gisements sont au PIED, pas au sommet");
check(deposit.upslope > deposit.depth,
"Pied de bosse : le versant amont domine largement la concavite");
}
}
// --- LE controle qui distingue ce detecteur de celui des points d'eau ----
// Une cuvette TRES PLATE : concave, mais dont le pourtour ne domine le fond
// que de 1,0 m. Elle passe le critere de concavite et doit etre rejetee par
// le seul critere de denivele amont. Sans ce test, minUpslope pourrait etre
// supprime sans qu'aucune verification ne bronche.
{
// Une cuvette dont le RELIEF TOTAL est plafonne a 2 m : aucun point du
// terrain ne peut donc en dominer un autre de plus de 2 m, et le
// critere de denivele amont (3 m) est le SEUL qui puisse la rejeter.
//
// Le premier jet de ce temoin plafonnait a 40 m et il etait faux : la
// mesure a montre que le detecteur retenait alors trois points sur un
// anneau a 60 m du centre, ou le flanc de la cuvette fournit 5,5 m
// d'amont. Une cuvette n'est "sans amont" qu'a son centre, pas partout.
BowlTerrain shallow(0.0f, 0.0f, 0.0016f, 2.0f);
const auto deposits =
findMineralDeposits(shallow, -600.0f, 600.0f, -600.0f, 600.0f, noWater);
check(deposits.empty(),
"TEMOIN cuvette sans amont : rejetee par minUpslope, pas par la concavite");
// La MEME cuvette avec minUpslope abaisse : elle passe. C'est ce qui
// prouve que c'est bien ce seuil-la qui l'avait ecartee, et non un
// autre filtre.
DepositSurveyParams permissive;
permissive.minUpslope = 0.5f;
check(!findMineralDeposits(shallow, -600.0f, 600.0f, -600.0f, 600.0f,
noWater, permissive).empty(),
"Cuvette sans amont : retenue des que minUpslope est abaisse");
}
// --- Le partage argile / sable ------------------------------------------
{
BowlTerrain bowl(160.0f, -120.0f, 0.006f, 60.0f);
// Sans aucun point d'eau connu : TOUT est sable. C'est le comportement
// annonce - sans eau, on n'affirme rien sur l'argile.
const auto dry =
findMineralDeposits(bowl, -600.0f, 600.0f, -600.0f, 600.0f, noWater);
bool allSand = !dry.empty();
for (const MineralDeposit& deposit : dry) {
if (deposit.kind != DepositKind::Sand) {
allSand = false;
}
}
check(allSand, "TEMOIN sans point d'eau : tous les gisements sont du sable");
// Avec un point d'eau POSE AU FOND de la cuvette : le gisement du fond
// devient de l'argile. Meme terrain, meme balayage : la SEULE chose qui
// a change est la liste des points d'eau.
std::vector<WaterSource> water;
water.push_back(WaterSource{glm::vec3(160.0f, 0.0f, -120.0f), 3.0f});
const auto wet =
findMineralDeposits(bowl, -600.0f, 600.0f, -600.0f, 600.0f, water);
check(dry.size() == wet.size(),
"Le point d'eau ne change PAS quels creux sont retenus, seulement leur nature");
check(!wet.empty() && wet.front().kind == DepositKind::Clay,
"Creux au bord de l'eau : classe ARGILE");
check(!wet.empty() && wet.front().waterDistance <= defaults.clayWaterRadius,
"Creux classe argile : sa distance a l'eau est bien sous le rayon");
// Un gisement au-dela du rayon reste du sable, dans le MEME balayage :
// c'est ce qui prouve que le partage est local et non global.
for (const MineralDeposit& deposit : wet) {
if (deposit.waterDistance > defaults.clayWaterRadius) {
check(deposit.kind == DepositKind::Sand,
"Creux loin de l'eau : classe SABLE, dans le meme balayage");
}
}
}
// --- Recherche du plus proche, et son temoin ----------------------------
{
std::vector<MineralDeposit> deposits;
MineralDeposit a;
a.position = glm::vec3(0.0f, 10.0f, 0.0f);
a.kind = DepositKind::Clay;
MineralDeposit b;
b.position = glm::vec3(50.0f, 90.0f, 0.0f);
b.kind = DepositKind::Sand;
deposits.push_back(a);
deposits.push_back(b);
float distance = -1.0f;
const MineralDeposit* found =
nearestDeposit(deposits, glm::vec3(4.0f, 0.0f, 3.0f), &distance);
check(found != nullptr && found->kind == DepositKind::Clay,
"nearestDeposit : rend bien le plus proche a l'horizontale");
checkNear(distance, 5.0f, 1e-3f,
"nearestDeposit : la distance rendue est horizontale");
// L'altitude ne doit PAS entrer dans le calcul : b est 80 m plus haut,
// et pourtant c'est lui le plus proche depuis un point proche de lui.
found = nearestDeposit(deposits, glm::vec3(48.0f, 0.0f, 0.0f), &distance);
check(found != nullptr && found->kind == DepositKind::Sand,
"nearestDeposit : l'altitude n'intervient pas");
const std::vector<MineralDeposit> empty;
check(nearestDeposit(empty, glm::vec3(0.0f)) == nullptr,
"TEMOIN liste vide : nearestDeposit rend nullptr");
}
// --- Rectangles degeneres : aucune sortie, aucun plantage ---------------
{
FlatTerrain flat;
check(findMineralDeposits(flat, 10.0f, 10.0f, -100.0f, 100.0f, noWater).empty(),
"Rectangle de largeur nulle : aucun gisement, aucun plantage");
check(findMineralDeposits(flat, -10.0f, 10.0f, -10.0f, 10.0f, noWater).empty(),
"Rectangle plus petit qu'une portee de sonde : aucun gisement");
}
// --- Les deux natures ont un libelle ------------------------------------
{
check(std::strcmp(depositLabel(DepositKind::Clay), "gisement") != 0,
"L'argile a son libelle propre");
check(std::strcmp(depositLabel(DepositKind::Sand), "gisement") != 0,
"Le sable a son libelle propre");
}
}
// ===========================================================================
// PHASE 22 / PHASE 26 : essences d'arbres et recolte de resine
// ===========================================================================
void testResin() {
section("Phase 22 / 26 : essences d'arbres et resine de pin");
// --- TreeSpecies : Le tirage d'essence est DETERMINISTE et reparti ------
{
bool identical = true;
int coniferCount = 0;
for (int i = 0; i < 2000; ++i) {
const float x = static_cast<float>(i % 45) * 12.0f;
const float z = static_cast<float>(i / 45) * 12.0f;
const TreeSpecies a = treeSpeciesAt(x, z, 0.0f);
const TreeSpecies b = treeSpeciesAt(x, z, 0.0f);
if (a != b) {
identical = false;
}
if (a == TreeSpecies::Conifer) {
++coniferCount;
}
}
check(identical,
"Essences : deux appels de meme position designent la MEME essence");
// La part observee doit tomber pres de coniferShareNeutral (0.55).
const double share = static_cast<double>(coniferCount) / 2000.0;
check(std::fabs(share - 0.55) < 0.04,
"Essences : la part de resineux observee est bien celle demandee");
}
// --- Les deux temoins de l'essence --------------------------------------
{
TreeSpeciesParams none;
none.coniferShareNeutral = 0.0f;
none.aspectSwing = 0.0f;
none.coniferShareMin = 0.0f;
none.coniferShareMax = 0.0f;
TreeSpeciesParams all;
all.coniferShareNeutral = 1.0f;
all.aspectSwing = 0.0f;
all.coniferShareMin = 1.0f;
all.coniferShareMax = 1.0f;
bool noneTagged = true;
bool allTagged = true;
for (int i = 0; i < 500; ++i) {
const float x = static_cast<float>(i) * 7.5f;
const float z = static_cast<float>(i) * 3.2f;
if (treeSpeciesAt(x, z, 0.0f, none) == TreeSpecies::Conifer) {
noneTagged = false;
}
if (treeSpeciesAt(x, z, 0.0f, all) != TreeSpecies::Conifer) {
allTagged = false;
}
}
check(noneTagged, "TEMOIN part nulle : aucun arbre n'est resineux");
check(allTagged, "TEMOIN part pleine : tous les arbres sont resineux");
}
// --- Une graine differente donne un AUTRE tirage ------------------------
{
TreeSpeciesParams other;
other.seed = 12345u;
int differences = 0;
for (int i = 0; i < 500; ++i) {
const float x = static_cast<float>(i) * 5.0f;
const float z = static_cast<float>(i) * 8.0f;
if (treeSpeciesAt(x, z, 0.0f) != treeSpeciesAt(x, z, 0.0f, other)) {
++differences;
}
}
check(differences > 50,
"Graine differente : le tirage change reellement (pas un no-op)");
}
// --- Exposition adret / ubac : deplace la repartition -------------------
{
int ubacConifers = 0;
int adretConifers = 0;
for (int i = 0; i < 1000; ++i) {
const float x = static_cast<float>(i % 30) * 10.0f;
const float z = static_cast<float>(i / 30) * 10.0f;
if (treeSpeciesAt(x, z, -1.0f) == TreeSpecies::Conifer) {
++ubacConifers;
}
if (treeSpeciesAt(x, z, +1.0f) == TreeSpecies::Conifer) {
++adretConifers;
}
}
check(ubacConifers > adretConifers,
"Adret / ubac : plus de resineux en ubac (-1) qu'en adret (+1)");
}
// --- La recolte de resine elle-meme (ResinStand) -------------------------
{
ResinStand stand;
const int conifer = 10;
const int broadleaf = 20;
check(stand.tap(-1, TreeSpecies::Conifer, 0.0f) == ResinResult::NoTree,
"TEMOIN rien de vise : la recolte refuse");
check(stand.tap(broadleaf, TreeSpecies::Broadleaf, 0.0f) == ResinResult::NotConifer,
"TEMOIN feuillu : la recolte refuse, l'arbre n'est pas resineux");
check(stand.trackedTreeCount() == 0,
"Un refus ne memorise RIEN : la table reste vide");
check(stand.tap(conifer, TreeSpecies::Conifer, 0.0f) == ResinResult::Success,
"Resineux : la premiere recolte reussit");
check(stand.tapCount(conifer) == 1, "Resineux : la recolte est comptee");
check(stand.trackedTreeCount() == 1,
"Seul l'arbre reellement saigne entre dans la memoire");
// Aussitot apres : sec.
check(stand.tap(conifer, TreeSpecies::Conifer, 1.0f) == ResinResult::StillDry,
"Resineux : deuxieme recolte immediate refusee (il faut du temps)");
check(stand.secondsUntilFlow(conifer, 1.0f) > 0.0f,
"Resineux : un delai restant est annonce");
// Apres le delai : de nouveau.
const float delay = stand.params().flowDelay;
check(stand.tap(conifer, TreeSpecies::Conifer, 1.0f + delay) == ResinResult::Success,
"Resineux : la resine recoule apres flowDelay");
checkNear(stand.secondsUntilFlow(conifer, 1.0f + delay), delay, 1e-3f,
"Resineux : le delai repart a plein apres une recolte");
// Epuisement au bout de maxTapsPerTree.
check(stand.tap(conifer, TreeSpecies::Conifer, 1.0f + 2.0f * delay) == ResinResult::Success,
"Resineux : troisieme recolte encore possible");
check(stand.tapCount(conifer) == stand.params().maxTapsPerTree,
"Resineux : le compte atteint maxTapsPerTree");
check(stand.tap(conifer, TreeSpecies::Conifer, 1.0f + 10.0f * delay) == ResinResult::StillDry,
"Resineux epuise : refuse meme apres un temps tres long");
checkNear(stand.secondsUntilFlow(conifer, 1.0f + 10.0f * delay), 0.0f, 1e-3f,
"Resineux epuise : plus de delai annonce (c'est tapCount qui le dit)");
// Un AUTRE resineux reste intact : l'epuisement est par arbre.
const int otherConifer = 11;
check(stand.tap(otherConifer, TreeSpecies::Conifer, 0.0f) == ResinResult::Success,
"L'epuisement est PAR ARBRE : un autre resineux donne toujours");
}
// --- Les messages existent pour toutes les issues ------------------------
{
const ResinResult results[] = { ResinResult::Success, ResinResult::NotConifer,
ResinResult::StillDry, ResinResult::NoTree };
for (ResinResult result : results) {
const char* message = resinResultMessage(result);
check(message != nullptr && message[0] != '\0',
"Chaque issue de recolte a un message journalisable");
}
}
}
// ===========================================================================
// PHASE 22 : les plantes a fibres
// ===========================================================================
// Carte de couvert CONSTANTE : le seul moyen de placer le semis exactement au
// milieu, au bord ou hors de la bande de lisiere, sans dependre d'une vraie
// carte LiDAR.
class ConstantCover : public HeightSampler {
public:
explicit ConstantCover(float value) : value_(value) {}
float heightAt(float, float) const override { return value_; }
private:
float value_;
};
// Source d'ouverture CONSTANTE : le pendant du precedent pour la voie 2.
class ConstantClearing : public ClearingSource {
public:
explicit ConstantClearing(float value) : value_(value) {}
float clearing(float, float) const override { return value_; }
private:
float value_;
};
void testFiberPlants() {
section("Phase 22 : plantes a fibres (ronces, orties)");
FlatTerrain flat(800.0f);
const FiberPlantParams defaults;
const float middleCover = 0.5f * (defaults.coverOpen + defaults.coverClosed);
// --- Voie 1 : la LISIERE -------------------------------------------------
{
ConstantCover edge(middleCover);
FiberPlants plants(flat, &edge, 500.0f);
checkNear(plants.edgeDensityAt(0.0f, 0.0f), 1.0f, 1e-3f,
"Lisiere : densite maximale au MILIEU de la bande de couvert");
check(!plants.plantsNear(glm::vec3(0.0f), 30.0f).empty(),
"Lisiere : des plantes sont bien semees");
// Les deux bords de la bande, et au-dela : rien. C'est ce qui fait de ce
// critere une bordure et non un intervalle.
ConstantCover openGround(defaults.coverOpen - 0.01f);
ConstantCover deepForest(defaults.coverClosed + 0.01f);
FiberPlants onOpen(flat, &openGround, 500.0f);
FiberPlants inForest(flat, &deepForest, 500.0f);
checkNear(onOpen.edgeDensityAt(0.0f, 0.0f), 0.0f, 1e-3f,
"TEMOIN alpage nu : densite de lisiere nulle");
checkNear(inForest.edgeDensityAt(0.0f, 0.0f), 0.0f, 1e-3f,
"TEMOIN futaie fermee : densite de lisiere nulle");
check(onOpen.plantsNear(glm::vec3(0.0f), 30.0f).empty(),
"TEMOIN alpage nu : aucune plante semee");
check(inForest.plantsNear(glm::vec3(0.0f), 30.0f).empty(),
"TEMOIN futaie fermee : aucune plante semee");
// Le toit triangulaire : a mi-chemin du bord, la densite doit valoir la
// moitie. Sans ca, un creneau passerait les tests ci-dessus.
const float quarter = 0.5f * (defaults.coverOpen + middleCover);
ConstantCover slope(quarter);
FiberPlants half(flat, &slope, 500.0f);
checkNear(half.edgeDensityAt(0.0f, 0.0f), 0.5f, 0.02f,
"Lisiere : la densite decroit LINEAIREMENT vers les bords");
}
// --- Sans carte de couvert : la voie 1 est muette ------------------------
{
FiberPlants plants(flat, nullptr, 500.0f);
checkNear(plants.edgeDensityAt(0.0f, 0.0f), 0.0f, 1e-3f,
"TEMOIN sans carte de couvert : aucune lisiere connue");
check(plants.plantsNear(glm::vec3(0.0f), 30.0f).empty(),
"TEMOIN sans carte ni coupe : aucune plante a fibres dans le monde");
}
// --- Voie 2 : le SOL OUVERT, et c'est le joueur qui l'ouvre --------------
{
// Sans carte de couvert, pour que la voie 2 soit SEULE en cause : tout
// ce qui pousse ici pousse parce qu'on a coupe.
FiberPlants plants(flat, nullptr, 500.0f);
check(plants.plantsNear(glm::vec3(0.0f), 30.0f).empty(), "Avant la coupe : rien");
ConstantClearing cleared(1.0f);
plants.setClearingSource(&cleared);
checkNear(plants.clearingDensityAt(0.0f, 0.0f), 1.0f, 1e-3f,
"Sol entierement ouvert : densite de recolonisation maximale");
check(!plants.plantsNear(glm::vec3(0.0f), 30.0f).empty(),
"Apres la coupe : des plantes a fibres apparaissent");
// Le seuil bas est bien un seuil.
ConstantClearing untouched(defaults.clearingBegin - 0.01f);
FiberPlants below(flat, nullptr, 500.0f);
below.setClearingSource(&untouched);
checkNear(below.clearingDensityAt(0.0f, 0.0f), 0.0f, 1e-3f,
"TEMOIN sous clearingBegin : aucune recolonisation");
check(below.plantsNear(glm::vec3(0.0f), 30.0f).empty(),
"TEMOIN sous clearingBegin : aucune plante");
}
// --- La regle de combinaison est un MAXIMUM, pas une somme ---------------
{
ConstantCover edge(middleCover);
ConstantClearing cleared(1.0f);
FiberPlants both(flat, &edge, 500.0f);
both.setClearingSource(&cleared);
checkNear(both.densityAt(0.0f, 0.0f), 1.0f, 1e-3f,
"Lisiere ET coupe : la densite reste bornee a 1 (maximum, pas somme)");
// Une lisiere a mi-densite plus une coupe pleine doit donner la coupe.
const float quarter = 0.5f * (defaults.coverOpen + middleCover);
ConstantCover half(quarter);
FiberPlants mixed(flat, &half, 500.0f);
mixed.setClearingSource(&cleared);
checkNear(mixed.densityAt(0.0f, 0.0f), 1.0f, 1e-3f,
"La voie la plus forte l'emporte");
}
// --- Les filtres de terrain INTERDISENT, ils ne choisissent pas ----------
{
ConstantCover edge(middleCover);
// Un versant a 150 % : au-dela de maxSlope (1,0).
SlopedTerrain cliff(800.0f, 1.5f);
FiberPlants onCliff(cliff, &edge, 500.0f);
checkNear(onCliff.densityAt(0.0f, 0.0f), 0.0f, 1e-3f,
"TEMOIN paroi : aucune plante malgre un couvert de lisiere");
// Au-dessus de la limite d'altitude.
FlatTerrain high(defaults.maxAltitude + 50.0f);
FiberPlants tooHigh(high, &edge, 500.0f);
checkNear(tooHigh.densityAt(0.0f, 0.0f), 0.0f, 1e-3f,
"TEMOIN au-dessus de la limite des arbres : aucune plante");
// Et juste en dessous, la MEME configuration en produit : c'est ce qui
// prouve que c'est bien l'altitude qui a decide.
FlatTerrain justBelow(defaults.maxAltitude - 50.0f);
FiberPlants allowed(justBelow, &edge, 500.0f);
check(allowed.densityAt(0.0f, 0.0f) > 0.0f,
"Juste sous la limite : la meme configuration produit des plantes");
}
// --- Le semis est DETERMINISTE -------------------------------------------
{
ConstantCover edge(middleCover);
FiberPlants a(flat, &edge, 500.0f);
FiberPlants b(flat, &edge, 500.0f);
const auto pa = a.plantsNear(glm::vec3(20.0f, 0.0f, -13.0f), 25.0f);
const auto pb = b.plantsNear(glm::vec3(20.0f, 0.0f, -13.0f), 25.0f);
check(pa.size() == pb.size() && !pa.empty(),
"Semis : deux FiberPlants de meme graine rendent le meme nombre de plantes");
bool same = (pa.size() == pb.size());
for (std::size_t i = 0; i < pa.size() && same; ++i) {
same = (pa[i].id == pb[i].id)
&& std::fabs(pa[i].position.x - pb[i].position.x) < 1e-4f
&& std::fabs(pa[i].position.z - pb[i].position.z) < 1e-4f
&& std::fabs(pa[i].size - pb[i].size) < 1e-4f;
}
check(same, "Semis : les memes plantes, aux memes places, aux memes tailles");
// Les tailles restent dans les bornes annoncees.
bool sized = true;
for (const FiberPlant& plant : pa) {
if (plant.size < defaults.sizeMin - 1e-4f
|| plant.size > defaults.sizeMax + 1e-4f) {
sized = false;
}
}
check(sized, "Semis : toutes les tailles tiennent dans [sizeMin, sizeMax]");
}
// --- Arrachage et repousse ------------------------------------------------
{
ConstantCover edge(middleCover);
FiberPlants plants(flat, &edge, 500.0f);
const glm::vec3 player(0.0f, 800.0f, 0.0f);
const std::size_t before = plants.plantsNear(player, kPullReach).size();
check(before > 0, "Arrachage : il y a bien une plante a portee pour ce test");
FiberPlant pulled;
check(plants.pullNearest(player, kPullReach, &pulled),
"Arrachage : la plante la plus proche est arrachee");
check(!plants.isStanding(pulled.id), "Arrachage : la plante n'est plus sur pied");
check(plants.pulledPlantCount() == 1,
"Arrachage : une seule plante entre dans la memoire de repousse");
check(plants.plantsNear(player, kPullReach).size() == before - 1,
"Arrachage : le semis en rend exactement une de moins");
// Elle ne repousse PAS avant l'heure.
plants.update(defaults.regrowthDelay - 1.0f);
check(!plants.isStanding(pulled.id), "Repousse : rien avant regrowthDelay");
check(plants.pulledPlantCount() == 1,
"Repousse : la plante est toujours memorisee");
// Et elle repousse apres, a l'identique - c'est la promesse du semis
// deterministe : rien n'est stocke, donc rien ne peut se perdre.
plants.update(2.0f);
check(plants.isStanding(pulled.id), "Repousse : la plante revient apres le delai");
check(plants.pulledPlantCount() == 0,
"Repousse : la plante SORT de la memoire (grille creuse)");
check(plants.plantsNear(player, kPullReach).size() == before,
"Repousse : le semis retrouve exactement son compte");
bool identical = false;
for (const FiberPlant& plant : plants.plantsNear(player, kPullReach)) {
if (plant.id == pulled.id) {
identical = std::fabs(plant.position.x - pulled.position.x) < 1e-4f
&& std::fabs(plant.position.z - pulled.position.z) < 1e-4f
&& std::fabs(plant.size - pulled.size) < 1e-4f;
}
}
check(identical, "Repousse : la MEME plante, a la meme place, a la meme taille");
}
// --- Le temoin de l'arrachage : rien a portee ----------------------------
{
FiberPlants empty(flat, nullptr, 500.0f);
check(!empty.pullNearest(glm::vec3(0.0f), kPullReach),
"TEMOIN monde sans plantes : l'arrachage echoue proprement");
check(empty.pulledPlantCount() == 0,
"TEMOIN : un arrachage rate ne memorise rien");
ConstantCover edge(middleCover);
FiberPlants plants(flat, &edge, 500.0f);
check(!plants.pullNearest(glm::vec3(0.0f), 0.0f),
"TEMOIN portee nulle : l'arrachage echoue proprement");
}
// --- La portee est HORIZONTALE -------------------------------------------
{
ConstantCover edge(middleCover);
FiberPlants plants(flat, &edge, 500.0f);
const std::size_t atFeet =
plants.plantsNear(glm::vec3(0.0f, 800.0f, 0.0f), 10.0f).size();
const std::size_t highAbove =
plants.plantsNear(glm::vec3(0.0f, 3000.0f, 0.0f), 10.0f).size();
check(atFeet == highAbove && atFeet > 0,
"Portee : l'altitude du joueur n'intervient pas (portee horizontale)");
}
}
// ===========================================================================
// PHASE 22 : les geometries des matieres recoltees
// ===========================================================================
void testHarvestMeshes() {
section("Phase 22 : geometries des matieres recoltees");
struct MeshCase {
const char* label;
MeshData mesh;
float halfHeight; // 0 = pas de contrainte de centrage vertical
};
const MeshCase cases[] = {
{ "motte d'argile", clayLumpMeshData(), kClayRadius },
{ "poignee de sable", sandPileMeshData(), kSandRadius },
{ "perle de resine", resinBlobMeshData(), 0.0f },
{ "fagot de tiges", fiberBundleMeshData(), 0.0f },
{ "plante a fibres sur pied", fiberPlantMeshData(), 0.0f },
};
for (const MeshCase& item : cases) {
check(!item.mesh.empty(), "Mesh non vide");
check(item.mesh.indices.size() % 3 == 0, "Mesh : indices multiples de 3");
check(!item.mesh.name.empty(), "Mesh : porte un nom journalisable");
bool finite = true;
bool normalized = true;
float minY = 1e9f;
float maxY = -1e9f;
for (const Vertex& vertex : item.mesh.vertices) {
if (!std::isfinite(vertex.pos.x) || !std::isfinite(vertex.pos.y)
|| !std::isfinite(vertex.pos.z)) {
finite = false;
}
// Toute normale doit etre unitaire : un triangle degenere qui aurait
// echappe au filtre d'appendFacet donnerait une normale nulle, et
// l'eclairage s'y verrait comme un trou noir.
if (std::fabs(glm::length(vertex.normal) - 1.0f) > 1e-3f) {
normalized = false;
}
minY = std::min(minY, vertex.pos.y);
maxY = std::max(maxY, vertex.pos.y);
}
check(finite, "Mesh : aucune coordonnee non finie");
check(normalized, "Mesh : toutes les normales sont unitaires");
if (item.halfHeight > 0.0f) {
// Les objets poses au sol sont CENTRES verticalement et TIENNENT
// dans leur demi-hauteur : c'est ce qui permet a Ground::drop de les
// poser en ajoutant simplement groundItemRestRadius a l'altitude du
// terrain, sans qu'ils s'enfoncent ni qu'ils flottent.
//
// On encadre au lieu d'exiger l'egalite : ces meshes sont BRUITES
// (voir HarvestMesh.cpp), donc leur sommet extreme ne tombe pas
// pile sur la demi-hauteur. Exiger l'egalite testerait le tirage
// aleatoire et non le contrat - c'est d'ailleurs ce que le premier
// jet de ce test faisait, et il echouait sur la motte d'argile.
check(minY >= -item.halfHeight - 1e-3f && maxY <= item.halfHeight + 1e-3f,
"Mesh pose au sol : il TIENT dans sa demi-hauteur");
check(minY < 0.0f && maxY > 0.0f,
"Mesh pose au sol : il est CENTRE (il deborde des deux cotes)");
check(-minY > 0.7f * item.halfHeight && maxY > 0.7f * item.halfHeight,
"Mesh pose au sol : il REMPLIT sa demi-hauteur (pas un objet plat)");
}
}
// La plante SUR PIED, elle, part du SOL et monte : elle n'est pas centree,
// parce qu'elle est instanciee par son pied comme la touffe d'herbe.
{
const MeshData plant = fiberPlantMeshData();
float minY = 1e9f;
float maxY = -1e9f;
for (const Vertex& vertex : plant.vertices) {
minY = std::min(minY, vertex.pos.y);
maxY = std::max(maxY, vertex.pos.y);
}
checkNear(minY, 0.0f, 1e-3f, "Plante sur pied : son pied est a y = 0");
check(maxY > 0.4f && maxY <= 1.0f + 1e-3f,
"Plante sur pied : a l'echelle UNITE (au plus 1 m de haut)");
}
// --- Les quatre nouvelles natures ont tout ce qu'un objet au sol doit
// avoir. Sans ce test, ajouter une valeur a l'enum sans l'ajouter aux
// quatre switch de Ground.cpp passerait inapercu : ces switch ont un
// `return` par defaut, donc le compilateur ne dirait rien.
{
for (uint32_t i = 0; i < kGroundItemKindCount; ++i) {
const auto kind = static_cast<GroundItemKind>(i);
check(groundItemRestRadius(kind) > 0.0f,
"Chaque nature d'objet au sol a un rayon de repos non nul");
check(std::strcmp(groundItemLabel(kind), "objet") != 0,
"Chaque nature d'objet au sol a son libelle propre");
check(std::strcmp(groundItemLabelIndefinite(kind), "un objet") != 0,
"Chaque nature a son libelle avec article");
check(std::strcmp(groundItemLabelPlural(kind), "objets") != 0,
"Chaque nature a son libelle au pluriel");
}
}
// --- Elles se posent et se ramassent comme les autres --------------------
{
FlatTerrain flat(40.0f);
Ground ground(flat);
Inventory inventory;
const GroundItemKind kinds[] = { GroundItemKind::Clay, GroundItemKind::Sand,
GroundItemKind::Resin, GroundItemKind::Fiber };
for (GroundItemKind kind : kinds) {
ground.drop(kind, 3.0f, -2.0f, 0.0f, 0.0f);
}
check(ground.itemCount() == 4, "Les quatre matieres se posent au sol");
const int index = ground.findNearest(glm::vec3(3.0f, 41.7f, -2.0f), 2.5f);
check(index != kNoGroundItem, "Une matiere posee se retrouve a portee");
GroundItemKind picked = GroundItemKind::Log;
check(ground.pickUp(index, &picked), "Une matiere posee se ramasse");
inventory.add(picked);
check(inventory.count(picked) == 1, "La matiere ramassee entre dans l'inventaire");
check(inventory.summary().find("argile") != std::string::npos,
"Le resume d'inventaire mentionne les nouvelles matieres");
}
}
// ===========================================================================
// PHASE 23 - Systeme meteo deterministe
// ===========================================================================
// CE QUE CES TESTS VERIFIENT, ET CE QU'ILS NE VERIFIENT PAS.
//
// Ils verifient des PROPRIETES : un determinisme, un signe, un ordre, une
// monotonie. "Un adret est plus chaud qu'un ubac au meme instant". "Un col vente
// plus qu'un plateau". "La meme position au meme instant rend le meme resultat".
//
// Ils ne verifient PRESQUE AUCUNE valeur absolue, et c'est delibere : aucune des
// constantes de WeatherParams n'a ete validee par un climatologue (voir
// l'avertissement en tete de world/Weather.hpp). Un test qui exigerait
// "l'inversion vaut -6 degres" devrait etre reecrit le jour du recalibrage, et
// il ne dirait rien de plus que "la constante vaut ce qu'elle vaut". Les rares
// egalites numeriques ci-dessous portent sur des grandeurs qui NE SONT PAS
// provisoires : le gradient adiabatique compare a son propre parametre, et la
// formule de refroidissement eolien, qui est publiee.
// ===========================================================================
// Chaine de montagnes orientee NORD-SUD, avec un COL creuse dedans a z = 0.
//
// C'est le seul relief de ce fichier ou l'on sache a l'avance ou est le col,
// donc le seul qui permette de dire si le sondage amont trouve LE bon endroit et
// pas seulement un endroit - exactement le role que joue BowlTerrain pour les
// points d'eau depuis la Phase 16.
//
// Un vent d'ouest (+X pour le sens du flux, puisque +X va vers l'est) doit donc
// franchir la crete, et le franchir par le col.
class RidgeWithColTerrain : public HeightSampler {
public:
RidgeWithColTerrain(float base, float ridgeHeight, float ridgeWidth,
float colDepth, float colWidth)
: base_(base), height_(ridgeHeight), width_(ridgeWidth),
colDepth_(colDepth), colWidth_(colWidth) {}
float heightAt(float x, float z) const override {
// Profil de crete : une gaussienne le long de X, donc un versant au vent
// (x < 0), un sommet (x = 0) et un versant sous le vent (x > 0).
const float across = std::exp(-(x / width_) * (x / width_));
// Entaille : la crete perd colDepth_ de sa hauteur au voisinage de z = 0.
const float notch = 1.0f - colDepth_ * std::exp(-(z / colWidth_) * (z / colWidth_));
return base_ + height_ * across * notch;
}
private:
float base_, height_, width_, colDepth_, colWidth_;
};
void testWeather() {
std::printf("\n--- Meteo deterministe (Phase 23) ---\n");
const WeatherParams defaults;
const WeatherSystem sky;
// =======================================================================
// 1. DETERMINISME - la propriete fondatrice du module
// =======================================================================
{
// Purete stricte : deux appels identiques rendent BIT A BIT le meme
// resultat. Pas "a epsilon pres" - le module n'a aucun etat, il ne peut
// pas deriver.
const SynopticState a = sky.synopticAt(137.25f);
const SynopticState b = sky.synopticAt(137.25f);
check(a.seaLevelTemperatureC == b.seaLevelTemperatureC &&
a.cloudCover == b.cloudCover && a.seaLevelWindMps == b.seaLevelWindMps &&
a.windFromDegrees == b.windFromDegrees,
"Determinisme : deux appels au meme instant sont identiques");
RidgeWithColTerrain terrain(800.0f, 400.0f, 300.0f, 0.60f, 400.0f);
const glm::vec3 spot(120.0f, 1050.0f, -60.0f);
const WeatherSample s1 = sky.sampleAt(spot, 137.25f, &terrain);
const WeatherSample s2 = sky.sampleAt(spot, 137.25f, &terrain);
check(s1.temperatureC == s2.temperatureC && s1.windMps == s2.windMps &&
s1.verticalMps == s2.verticalMps && s1.wetness == s2.wetness,
"Determinisme : deux echantillons au meme point sont identiques");
// INDEPENDANCE DU CHEMIN, qui est la vraie demande du cahier des charges.
// Deux horloges couvrent la meme duree de jeu par des pas DIFFERENTS -
// 60 images par seconde contre 10 - puis on echantillonne. Un modele qui
// integrerait quoi que ce soit divergerait ici ; celui-ci ne peut pas.
GameClock fast(9.0f, 12.0f);
GameClock slow(9.0f, 12.0f);
for (int i = 0; i < 6000; ++i) { fast.advance(1.0f / 60.0f); }
for (int i = 0; i < 1000; ++i) { slow.advance(1.0f / 10.0f); }
checkNear(fast.totalHours(), slow.totalHours(), 1e-2f,
"Horloge : deux pas de temps differents, meme temps de jeu");
const WeatherSample viaFast = sky.sampleAt(spot, fast.totalHours(), &terrain);
const WeatherSample viaSlow = sky.sampleAt(spot, slow.totalHours(), &terrain);
checkNear(viaFast.temperatureC, viaSlow.temperatureC, 0.05f,
"Chemin : la meteo ne depend pas de la facon dont on est arrive");
checkNear(viaFast.windMps, viaSlow.windMps, 0.05f,
"Chemin : le vent non plus");
// Et l'inverse : deux instants ECARTES doivent, eux, differer. Sans ce
// controle negatif, une fonction constante passerait tous les tests
// ci-dessus.
bool varies = false;
const SynopticState reference = sky.synopticAt(0.0f);
for (int day = 1; day <= 20 && !varies; ++day) {
const SynopticState later = sky.synopticAt(static_cast<float>(day) * 24.0f);
if (std::abs(later.cloudCover - reference.cloudCover) > 0.10f ||
std::abs(later.seaLevelTemperatureC - reference.seaLevelTemperatureC) > 1.0f) {
varies = true;
}
}
check(varies, "Perturbations : le temps qu'il fait change d'un jour a l'autre");
}
// =======================================================================
// 2. COUCHE 1 - cycles, soleil, perturbations
// =======================================================================
{
// Cycle diurne : il fait plus chaud a l'heure de pointe qu'au petit
// matin, le meme jour. Compare a NEBULOSITE EGALE, ce qui n'est possible
// qu'en restant dans la meme journee - c'est pour ca que le test prend
// deux heures du meme jour et non deux instants au hasard.
const float day = 3.0f * 24.0f;
const SynopticState afternoon = sky.synopticAt(day + defaults.diurnalPeakHour);
const SynopticState dawn = sky.synopticAt(day + defaults.diurnalPeakHour - 12.0f);
check(afternoon.seaLevelTemperatureC > dawn.seaLevelTemperatureC,
"Cycle diurne : l'apres-midi est plus chaude que la fin de nuit");
// Soleil : leve a l'est, couche a l'ouest, culmine au sud.
const SynopticState noon = sky.synopticAt(12.0f);
check(noon.sunElevationDegrees > 0.0f, "Soleil : haut a midi");
check(noon.sunDirection.z > 0.9f * std::cos(glm::radians(noon.sunElevationDegrees)) - 1e-3f,
"Soleil : plein SUD a midi (+Z dans la convention du projet)");
check(noon.daylight > 0.8f, "Soleil : plein jour a midi");
const SynopticState morning = sky.synopticAt(8.0f);
check(morning.sunDirection.x > 0.0f, "Soleil : a l'EST le matin (+X)");
const SynopticState evening = sky.synopticAt(18.0f);
check(evening.sunDirection.x < 0.0f, "Soleil : a l'OUEST le soir (-X)");
const SynopticState midnight = sky.synopticAt(0.0f);
check(midnight.sunElevationDegrees < 0.0f, "Soleil : sous l'horizon a minuit");
checkNear(midnight.daylight, 0.0f, 1e-6f, "Soleil : aucun ensoleillement de nuit");
// Saison : le soleil monte plus haut a midi en juillet qu'en janvier.
// Le jour de depart etant mi-mai, on saute de six mois pour comparer.
WeatherParams winterParams = defaults;
winterParams.startDayOfYear = 15.0f; // mi-janvier
const WeatherSystem winter(winterParams);
const SynopticState winterNoon = winter.synopticAt(12.0f);
check(winterNoon.sunElevationDegrees < noon.sunElevationDegrees - 10.0f,
"Saison : le soleil de janvier est bien plus bas que celui de mai");
// Perturbations : sur un mois de jeu, il doit exister des journees
// claires ET des journees de pluie. Un modele qui ne produirait jamais
// de pluie - ou qui en produirait tout le temps - serait inutile.
int rainySamples = 0;
int clearSamples = 0;
float maxWind = 0.0f;
for (int h = 0; h < 30 * 24; ++h) {
const SynopticState state = sky.synopticAt(static_cast<float>(h));
if (state.precipitationMmPerHour > 0.1f) { ++rainySamples; }
if (state.cloudCover < 0.20f) { ++clearSamples; }
maxWind = std::max(maxWind, state.seaLevelWindMps);
check(state.cloudCover >= 0.0f && state.cloudCover <= 1.0f,
"Nebulosite : toujours dans [0, 1]");
check(state.seaLevelWindMps >= 0.0f, "Vent synoptique : jamais negatif");
}
check(rainySamples > 0, "Un mois de jeu contient des heures de pluie");
check(clearSamples > 0, "Un mois de jeu contient des heures de grand beau");
check(rainySamples < 30 * 24 / 2, "Il ne pleut pas la moitie du temps");
check(maxWind > defaults.baseWindMps + 1.0f,
"Le vent forcit reellement au passage des perturbations");
std::printf(" [meteo] sur 30 jours simules : %d h de pluie, %d h de grand beau, "
"vent max %.1f m/s\n",
rainySamples, clearSamples, static_cast<double>(maxWind));
}
// =======================================================================
// 3. COUCHE 2 - temperature locale
// =======================================================================
{
// --- Gradient altitudinal ------------------------------------------
// La seule egalite numerique du fichier, et elle est legitime : elle
// compare le resultat a SON PROPRE parametre. Le jour ou le climatologue
// changera 6,5, ce test continuera de passer - et c'est exactement ce
// qu'on veut d'un test de mecanisme.
const float when = 5.0f * 24.0f + 11.0f;
const WeatherSample low = sky.sampleAt(glm::vec3(0.0f, 300.0f, 0.0f), when, nullptr);
const WeatherSample high = sky.sampleAt(glm::vec3(0.0f, 1300.0f, 0.0f), when, nullptr);
checkNear(low.temperatureC - high.temperatureC, defaults.lapseRateCPerKm, 1e-2f,
"Altitude : l'ecart vaut exactement le gradient annonce");
check(high.lapseC < low.lapseC, "Altitude : le terme de gradient est bien celui qui mord");
// --- Adret / ubac ---------------------------------------------------
// MEME INSTANT, MEME ALTITUDE, seule l'orientation change. C'est la
// propriete demandee par le cahier des charges, et elle est verifiee a
// une heure ou le soleil est franchement au sud.
NorthSouthSlope adretSlope(-0.60f); // descend vers le sud
NorthSouthSlope ubacSlope(0.60f); // descend vers le nord
const float noonHours = 4.0f * 24.0f + 12.0f;
const WeatherSample adret =
sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), noonHours, &adretSlope);
const WeatherSample ubac =
sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), noonHours, &ubacSlope);
check(adret.temperatureC > ubac.temperatureC,
"Adret / ubac : le versant sud est MESURABLEMENT plus chaud a midi");
check(adret.aspectC > ubac.aspectC,
"Adret / ubac : l'ecart vient bien du terme d'exposition");
std::printf(" [meteo] a midi, 1000 m : adret %.1f C, ubac %.1f C (ecart %.1f C)\n",
static_cast<double>(adret.temperatureC),
static_cast<double>(ubac.temperatureC),
static_cast<double>(adret.temperatureC - ubac.temperatureC));
// Controle negatif : la nuit, l'orientation ne doit plus rien changer.
const float nightHours = 4.0f * 24.0f + 2.0f;
const WeatherSample adretNight =
sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), nightHours, &adretSlope);
const WeatherSample ubacNight =
sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), nightHours, &ubacSlope);
checkNear(adretNight.temperatureC, ubacNight.temperatureC, 1e-3f,
"La nuit : un versant sud n'a plus aucun avantage");
// Le matin, c'est le versant EST qui prend le soleil - ce qu'un modele
// purement nord/sud (celui de la Phase 16) ne pouvait pas produire.
SlopedTerrain eastFacing(1000.0f, -0.60f); // descend vers l'est (+X)
SlopedTerrain westFacing(1000.0f, 0.60f);
const float morningHours = 4.0f * 24.0f + 7.5f;
const WeatherSample east =
sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), morningHours, &eastFacing);
const WeatherSample west =
sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), morningHours, &westFacing);
check(east.temperatureC > west.temperatureC,
"Le matin : le versant EST est plus chaud que le versant ouest");
// --- Terrain absent : repli explicite -------------------------------
const WeatherSample freeAir = sky.sampleAt(glm::vec3(0.0f, 1000.0f, 0.0f), noonHours, nullptr);
checkNear(freeAir.aspectC, 0.0f, 1e-6f,
"Sans terrain : aucun effet de versant, et aucun plantage");
check(freeAir.windMps > 0.0f, "Sans terrain : le vent synoptique reste disponible");
}
// =======================================================================
// 4. CARTE DE PIEGEAGE D'AIR FROID ET INVERSION
// =======================================================================
{
// Une cuvette de 600 m de rayon creusee dans un plateau : le creux doit
// etre note comme piegeant, la bosse identique NON. C'est le meme
// controle negatif que la Phase 16 employait pour les points d'eau, et
// pour la meme raison - sans lui, une carte qui noterait "bas = piege"
// passerait par accident.
// Rebord a 150 m au-dessus du fond, atteint a 500 m du centre : les
// proportions d'une vraie combe de moyenne montagne. La premiere
// redaction employait 400 m de profondeur, et le test echouait pour une
// raison qui vaut d'etre notee - a 400 m de denivele, le seul gradient
// adiabatique rend deja le fond 2,6 degres PLUS CHAUD que le rebord, et
// l'inversion, pourtant bien calculee, ne suffisait pas tout a fait a
// renverser ce handicap. Ce n'etait pas un defaut du modele mais un
// relief invraisemblable : une cuvette de 400 m de creux pour 500 m de
// rayon est une falaise circulaire, pas une combe.
BowlTerrain bowl(0.0f, 0.0f, 0.0006f, 150.0f);
DomeTerrain dome(0.0f, 0.0f, 0.0006f, 0.0f);
const ColdAirTrapMap bowlMap(bowl, 2000.0f, 48);
const ColdAirTrapMap domeMap(dome, 2000.0f, 48);
check(!bowlMap.empty(), "Carte de piegeage : construite");
check(bowlMap.at(0.0f, 0.0f) > 0.5f,
"Piegeage : le fond de la cuvette est fortement enferme");
check(domeMap.at(0.0f, 0.0f) < 0.05f,
"Piegeage : le sommet d'une bosse ne piege rien (controle negatif)");
check(bowlMap.at(0.0f, 0.0f) > bowlMap.at(1800.0f, 1800.0f) + 0.3f,
"Piegeage : le fond piege bien plus que le plateau qui l'entoure");
std::printf(" [meteo] carte de piegeage : creux %.2f, plateau %.2f, bosse %.2f\n",
static_cast<double>(bowlMap.at(0.0f, 0.0f)),
static_cast<double>(bowlMap.at(1800.0f, 1800.0f)),
static_cast<double>(domeMap.at(0.0f, 0.0f)));
// Carte degeneree : ne doit ni planter ni mentir.
const ColdAirTrapMap tiny(bowl, 0.0f, 64);
check(tiny.empty() && tiny.at(0.0f, 0.0f) == 0.0f,
"Carte de piegeage : une emprise nulle rend une carte vide, pas un plantage");
// --- L'inversion elle-meme ------------------------------------------
// Le fond de cuvette doit etre plus froid que le plateau LA NUIT, alors
// qu'il est PLUS BAS - donc plus chaud par le seul gradient. C'est la
// seule facon de prouver que l'inversion existe : elle doit RENVERSER le
// signe du gradient, pas simplement s'y ajouter.
WeatherSystem inverted;
inverted.setTrapMap(&bowlMap);
// On cherche une nuit calme et claire dans les dix premiers jours : le
// phenomene ne s'installe que par ciel degage et sans vent, et exiger
// qu'il se produise a une date arbitraire serait exiger que la meteo
// soit celle qui arrange le test.
// Le critere ne porte QUE sur la nebulosite : le vent, lui, est deja
// traite par le modele au bon endroit - un fond de cuvette est abrite
// par construction, donc le vent y est faible meme quand le vent
// synoptique ne l'est pas. Une premiere version de ce test exigeait
// aussi un vent synoptique faible et ne trouvait jamais de nuit
// propice : le vent de base ne descend jamais sous baseWindMps.
bool inversionSeen = false;
float bestGap = 0.0f;
for (int day = 0; day < 20 && !inversionSeen; ++day) {
const float t = static_cast<float>(day) * 24.0f + 3.0f;
const SynopticState state = inverted.synopticAt(t);
if (state.cloudCover > 0.25f) {
continue;
}
const WeatherSample hollow =
inverted.sampleAt(glm::vec3(0.0f, bowl.heightAt(0.0f, 0.0f), 0.0f), t, &bowl);
const WeatherSample plateau = inverted.sampleAt(
glm::vec3(1800.0f, bowl.heightAt(1800.0f, 1800.0f), 1800.0f), t, &bowl);
if (hollow.inversionC < -0.5f) {
inversionSeen = true;
bestGap = plateau.temperatureC - hollow.temperatureC;
check(hollow.temperatureC < plateau.temperatureC,
"Inversion : par nuit claire et calme, le fond est plus FROID que le plateau");
std::printf(" [meteo] inversion nocturne : fond %.1f C, plateau %.1f C "
"(le fond est pourtant %.0f m plus bas)\n",
static_cast<double>(hollow.temperatureC),
static_cast<double>(plateau.temperatureC),
static_cast<double>(bowl.heightAt(1800.0f, 1800.0f) -
bowl.heightAt(0.0f, 0.0f)));
}
}
check(inversionSeen, "Inversion : une nuit propice existe dans les vingt premiers jours");
check(bestGap > 0.0f || !inversionSeen, "Inversion : l'ecart est bien dans le bon sens");
// De JOUR, au meme endroit, l'inversion doit avoir disparu.
const WeatherSample daytime =
inverted.sampleAt(glm::vec3(0.0f, bowl.heightAt(0.0f, 0.0f), 0.0f), 13.0f, &bowl);
checkNear(daytime.inversionC, 0.0f, 1e-3f,
"Inversion : rien en plein jour (controle negatif)");
// Sans carte reliee, pas d'inversion - et aucun plantage.
const WeatherSample noMap =
sky.sampleAt(glm::vec3(0.0f, 400.0f, 0.0f), 3.0f, &bowl);
checkNear(noMap.inversionC, 0.0f, 1e-6f,
"Sans carte de piegeage : l'inversion vaut zero, proprement");
}
// =======================================================================
// 5. VENT LOCAL - SONDAGE AMONT
// =======================================================================
{
RidgeWithColTerrain ridge(800.0f, 400.0f, 300.0f, 0.60f, 400.0f);
// Vent d'OUEST impose : le flux traverse la crete d'ouest en est. On fixe
// la direction au lieu de la subir, parce qu'un test sur la reponse du
// relief ne doit pas dependre de l'humeur du bruit synoptique ce jour-la.
WeatherParams westerly;
westerly.meanWindFromDegrees = 270.0f;
westerly.windDirectionSwingDegrees = 0.0f;
const WeatherSystem west(westerly);
const float t = 6.0f * 24.0f + 10.0f;
const SynopticState state = west.synopticAt(t);
checkNear(state.windFromDegrees, 270.0f, 1e-3f, "Vent : direction d'ouest imposee");
// Le vecteur vent doit POINTER vers l'est : le vent d'ouest va vers l'est.
const WeatherSample anywhere =
west.sampleAt(glm::vec3(-2500.0f, 800.0f, 0.0f), state, &ridge);
check(anywhere.windVector.x > 0.0f,
"Vent d'ouest : l'air se deplace vers l'EST (+X)");
// --- COL contre PLATEAU : la propriete centrale de cette section ------
const float colY = ridge.heightAt(0.0f, 0.0f);
const WeatherSample col = west.sampleAt(glm::vec3(0.0f, colY, 0.0f), state, &ridge);
const float plateauY = ridge.heightAt(-2500.0f, 0.0f);
const WeatherSample plateau =
west.sampleAt(glm::vec3(-2500.0f, plateauY, 0.0f), state, &ridge);
check(col.windMps > 1.5f * plateau.windMps,
"Col : le vent y est nettement plus fort que sur le plateau adjacent");
std::printf(" [meteo] vent : col %.1f m/s, plateau %.1f m/s (x%.2f)\n",
static_cast<double>(col.windMps), static_cast<double>(plateau.windMps),
static_cast<double>(col.windMps / std::max(0.01f, plateau.windMps)));
// Le col doit aussi venter plus que la crete PLEINE, a vent de reference
// egal. La crete pleine etant plus HAUTE que le col, comparer les
// vitesses brutes ne dirait rien : le vent croit deja avec l'altitude.
// On compare donc les FACTEURS - le vent local divise par le vent en air
// libre a la meme altitude. C'est la seule facon d'isoler l'effet
// d'entonnoir de l'effet d'altitude, et la premiere redaction de ce test
// ne le faisait pas : elle cherchait un point de crete a altitude egale,
// n'en trouvait aucun (il n'y en a pas, par construction du relief) et se
// sautait donc en silence.
const auto freeAirWind = [&](float y) {
return state.seaLevelWindMps + westerly.windAltitudeGainMpsPerKm * y / 1000.0f;
};
const float crestY = ridge.heightAt(0.0f, 1600.0f);
const WeatherSample onRidge =
west.sampleAt(glm::vec3(0.0f, crestY, 1600.0f), state, &ridge);
const float colFactor = col.windMps / freeAirWind(colY);
const float crestFactor = onRidge.windMps / freeAirWind(crestY);
check(colFactor > crestFactor,
"Venturi : a vent de reference egal, le col accelere plus que la crete pleine");
std::printf(" [meteo] facteur de relief : col x%.2f, crete pleine x%.2f\n",
static_cast<double>(colFactor), static_cast<double>(crestFactor));
// --- Versant au vent contre versant sous le vent ---------------------
// Meme altitude, meme instant, de part et d'autre du sommet.
const float flankY = ridge.heightAt(-250.0f, 1500.0f);
const WeatherSample windward =
west.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), state, &ridge);
const WeatherSample lee =
west.sampleAt(glm::vec3(250.0f, flankY, 1500.0f), state, &ridge);
check(windward.ridgeLiftMps > 0.5f,
"Ridge lift : le versant AU VENT porte reellement");
checkNear(lee.ridgeLiftMps, 0.0f, 1e-6f,
"Ridge lift : le versant SOUS LE VENT ne porte pas");
check(lee.subsidenceMps < 0.0f,
"Sous le vent : l'air redescend (subsidence)");
check(lee.turbulence > windward.turbulence,
"Sous le vent : l'air est plus turbulent qu'au vent");
std::printf(" [meteo] versants a %.0f m : au vent +%.2f m/s (turb %.2f), "
"sous le vent %.2f m/s (turb %.2f)\n",
static_cast<double>(flankY),
static_cast<double>(windward.ridgeLiftMps),
static_cast<double>(windward.turbulence),
static_cast<double>(lee.subsidenceMps),
static_cast<double>(lee.turbulence));
// Sans vent, pas de turbulence et pas de portance : le controle negatif
// qui prouve que ces deux termes sont bien pilotes par le vent.
WeatherParams calmParams = westerly;
calmParams.baseWindMps = 0.0f;
calmParams.frontWindAmplitudeMps = 0.0f;
calmParams.windAltitudeGainMpsPerKm = 0.0f;
const WeatherSystem calm(calmParams);
const WeatherSample stillAir =
calm.sampleAt(glm::vec3(250.0f, flankY, 1500.0f), t, &ridge);
checkNear(stillAir.turbulence, 0.0f, 1e-6f, "Air calme : aucune turbulence de relief");
checkNear(stillAir.ridgeLiftMps, 0.0f, 1e-6f, "Air calme : aucune portance de pente");
checkNear(stillAir.subsidenceMps, 0.0f, 1e-6f, "Air calme : aucune subsidence");
// Ecretage : meme dans le pire cumul, le vent reste sous le garde-fou.
for (int h = 0; h < 15 * 24; ++h) {
const WeatherSample s =
west.sampleAt(glm::vec3(0.0f, colY, 0.0f), static_cast<float>(h), &ridge);
check(s.windMps <= westerly.maxLocalWindMps + 1e-3f,
"Vent local : jamais au-dessus du garde-fou");
}
// --- Thermiques ------------------------------------------------------
// Sur un adret ensoleille en debut d'apres-midi, ca doit monter ; la
// meme pente a 3 h du matin, non.
NorthSouthSlope adretSlope(-0.60f);
WeatherParams clearParams;
clearParams.meanCloudCover = 0.0f;
clearParams.cloudAmplitude = 0.0f;
const WeatherSystem clearSky(clearParams);
const WeatherSample thermalNoon = clearSky.sampleAt(
glm::vec3(0.0f, 1200.0f, 0.0f), clearParams.thermalPeakHour, &adretSlope);
const WeatherSample thermalNight =
clearSky.sampleAt(glm::vec3(0.0f, 1200.0f, 0.0f), 3.0f, &adretSlope);
check(thermalNoon.thermalMps > 1.0f,
"Thermiques : un adret ensoleille produit une vraie ascendance");
checkNear(thermalNight.thermalMps, 0.0f, 1e-6f,
"Thermiques : rien la nuit (controle negatif)");
// Sous un ciel couvert, la meme pente au meme instant doit produire
// beaucoup moins - c'est le mecanisme reel, et c'est aussi ce qui relie
// les thermiques a la nebulosite plutot qu'a la seule heure.
WeatherParams overcastParams = clearParams;
overcastParams.meanCloudCover = 1.0f;
const WeatherSystem overcast(overcastParams);
const WeatherSample thermalDull = overcast.sampleAt(
glm::vec3(0.0f, 1200.0f, 0.0f), overcastParams.thermalPeakHour, &adretSlope);
check(thermalDull.thermalMps < 0.5f * thermalNoon.thermalMps,
"Thermiques : un ciel couvert les etouffe");
// Et l'ubac, au meme instant, doit produire moins que l'adret.
NorthSouthSlope ubacSlope(0.60f);
const WeatherSample thermalUbac = clearSky.sampleAt(
glm::vec3(0.0f, 1200.0f, 0.0f), clearParams.thermalPeakHour, &ubacSlope);
check(thermalUbac.thermalMps < thermalNoon.thermalMps,
"Thermiques : l'ubac declenche moins que l'adret");
}
// =======================================================================
// 6. PRECIPITATIONS ET MOUILLURE
// =======================================================================
{
RidgeWithColTerrain ridge(800.0f, 400.0f, 300.0f, 0.60f, 400.0f);
// Ciel forcement bouche : on veut mesurer la MODULATION par le relief,
// pas attendre qu'il pleuve.
WeatherParams wetParams;
wetParams.meanWindFromDegrees = 270.0f;
wetParams.windDirectionSwingDegrees = 0.0f;
wetParams.meanCloudCover = 1.0f;
wetParams.cloudAmplitude = 0.0f;
const WeatherSystem storm(wetParams);
const float t = 2.0f * 24.0f + 15.0f;
const float flankY = ridge.heightAt(-250.0f, 1500.0f);
const WeatherSample windward =
storm.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), t, &ridge);
const WeatherSample lee =
storm.sampleAt(glm::vec3(250.0f, flankY, 1500.0f), t, &ridge);
check(windward.precipitationMmPerHour > 0.0f, "Il pleut sous un ciel entierement couvert");
check(windward.precipitationMmPerHour > lee.precipitationMmPerHour,
"Barriere orographique : il pleut plus sur le versant AU VENT");
check(windward.cloudCover >= lee.cloudCover,
"Le versant au vent accroche aussi plus de nuages");
// Mouillure : monotone et bornee, seche quand il ne pleut plus.
check(windward.wetness > 0.5f, "Mouillure : le sol est trempe sous la pluie");
for (int h = 0; h < 200; ++h) {
const WeatherSample s =
storm.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), static_cast<float>(h), &ridge);
check(s.wetness >= 0.0f && s.wetness <= 1.0f, "Mouillure : toujours dans [0, 1]");
}
// Un ciel qui ne pleut jamais laisse un sol sec - controle negatif.
WeatherParams dryParams = wetParams;
dryParams.meanCloudCover = 0.0f;
const WeatherSystem drought(dryParams);
const WeatherSample dry =
drought.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), t, &ridge);
checkNear(dry.wetness, 0.0f, 1e-6f, "Mouillure : sol sec quand il ne pleut jamais");
// La mouillure ne depend PAS du chemin : la relire a un instant donne
// rend toujours la meme chose, qu'on y arrive en une fois ou pas du tout.
const WeatherSample again =
storm.sampleAt(glm::vec3(-250.0f, flankY, 1500.0f), t, &ridge);
check(again.wetness == windward.wetness,
"Mouillure : relue, pas accumulee - donc identique a l'identique");
// Neige : au-dessus d'une certaine altitude, la meme precipitation tombe
// en neige. On monte tres haut pour que ce soit vrai quelle que soit la
// saison tiree.
const WeatherSample summit =
storm.sampleAt(glm::vec3(0.0f, 4000.0f, 0.0f), t, nullptr);
check(summit.snowing, "Neige : a 4000 m, la precipitation tombe en neige");
check(!windward.snowing || windward.temperatureC <= wetParams.snowThresholdC,
"Neige : jamais annoncee au-dessus du seuil de temperature");
}
// =======================================================================
// 7. REFROIDISSEMENT EOLIEN (formule publiee, PAS provisoire)
// =======================================================================
{
// Valeur de reference publiee : -5 degres par 30 km/h de vent donne
// environ -13. On verifie a un degre pres, la formule etant exacte.
checkNear(windChillC(-5.0f, 30.0f / 3.6f), -13.0f, 1.0f,
"Refroidissement eolien : -5 C par 30 km/h donne environ -13 C");
check(windChillC(0.0f, 10.0f) < 0.0f, "Vent : le ressenti descend sous l'ambiante");
check(windChillC(0.0f, 20.0f) < windChillC(0.0f, 10.0f),
"Vent : plus il souffle, plus il refroidit");
check(windChillC(-10.0f, 10.0f) < windChillC(0.0f, 10.0f),
"Vent : a vent egal, plus il fait froid plus le ressenti est bas");
// Hors domaine : la fonction rend la temperature INCHANGEE plutot qu'une
// extrapolation fausse. C'est le point le plus facile a rater dans une
// implementation pressee - au-dessus de 10 degres la formule brute
// rendrait un vent RECHAUFFANT.
checkNear(windChillC(25.0f, 15.0f), 25.0f, 1e-6f,
"Hors domaine : au-dessus de 10 C, le vent ne rechauffe pas");
checkNear(windChillC(0.0f, 0.5f), 0.0f, 1e-6f,
"Hors domaine : un souffle d'air ne refroidit pas");
checkNear(windChillC(0.0f, 0.0f), 0.0f, 1e-6f, "Vent nul : aucun effet");
}
// =======================================================================
// 8. ROBUSTESSE ET COUT
// =======================================================================
{
RidgeWithColTerrain ridge(800.0f, 400.0f, 300.0f, 0.60f, 400.0f);
// Entrees degenerees : le module ne doit jamais rendre de NaN, parce
// qu'un NaN de temperature contaminerait les quatre jauges de Needs puis
// la vitesse du joueur (voir le commentaire de clamp01 dans Needs.cpp).
const float nan = std::numeric_limits<float>::quiet_NaN();
const float inf = std::numeric_limits<float>::infinity();
const glm::vec3 broken(nan, inf, -nan);
const WeatherSample wrecked = sky.sampleAt(broken, nan, &ridge);
check(std::isfinite(wrecked.temperatureC) && std::isfinite(wrecked.windMps) &&
std::isfinite(wrecked.verticalMps) && std::isfinite(wrecked.wetness),
"Robustesse : des entrees non finies ne produisent aucun NaN");
const WeatherSample past = sky.sampleAt(glm::vec3(0.0f, 900.0f, 0.0f), -500.0f, &ridge);
check(std::isfinite(past.temperatureC),
"Robustesse : un instant negatif reste calculable");
// --- COUT ------------------------------------------------------------
// Budget de reference de la Phase 19 : le frame est domine par le GPU
// (81 % dans drawFrame, en Release). Le seuil ci-dessous est TRES large
// et volontairement : ce test protege contre un facteur mille - un
// sondage qui deviendrait une recherche, une carte recalculee par image -
// et non contre une variation de 20 %, que le bruit de mesure de cette
// machine ne permet de toute facon pas de distinguer (voir la lecon de
// la Phase 17 sur les FPS bruites).
constexpr int kEvaluations = 20000;
const auto start = std::chrono::steady_clock::now();
double sink = 0.0;
for (int i = 0; i < kEvaluations; ++i) {
const float t = static_cast<float>(i) * 0.01f;
const glm::vec3 p(static_cast<float>(i % 500) * 4.0f, 900.0f,
static_cast<float>(i % 337) * 6.0f);
sink += sky.sampleAt(p, t, &ridge).temperatureC;
}
const double micros = std::chrono::duration<double, std::micro>(
std::chrono::steady_clock::now() - start).count();
const double perCall = micros / kEvaluations;
std::printf(" [meteo] cout : %.2f us par evaluation complete "
"(%d evaluations, terrain analytique, somme %.0f)\n",
perCall, kEvaluations, sink);
check(perCall < 50.0,
"Cout : une evaluation meteo complete reste tres loin d'un budget d'image");
// La couche 1 seule doit etre nettement moins chere que la couche 2 :
// c'est ce qui justifie la surcharge sampleAt(position, SynopticState,
// terrain), celle qu'il faut appeler pour plusieurs points au meme
// instant.
const auto startSky = std::chrono::steady_clock::now();
double skySink = 0.0;
for (int i = 0; i < kEvaluations; ++i) {
skySink += sky.synopticAt(static_cast<float>(i) * 0.01f).seaLevelTemperatureC;
}
const double skyMicros = std::chrono::duration<double, std::micro>(
std::chrono::steady_clock::now() - startSky).count();
std::printf(" [meteo] cout : %.2f us pour la couche synoptique seule (somme %.0f)\n",
skyMicros / kEvaluations, skySink);
}
}
// ===========================================================================
// PHASE 23 - Ce que la meteo change dans les quatre activites
// ===========================================================================
// Meme regle que testWeather() : on verifie des PROPRIETES et des SIGNES, pas
// des valeurs. Et systematiquement par COMPARAISON de deux simulations
// identiques a un parametre pres - c'est la seule facon de mesurer un effet
// sans dependre du reglage exact des constantes provisoires.
//
// Chaque bloc porte aussi son CONTROLE NEGATIF : sans meteo, le comportement
// doit etre exactement celui d'avant la Phase 23. C'est ce qui prouve que les
// valeurs par defaut des nouveaux parametres sont bien neutres, et donc que la
// non-regression des Phases 8, 13 et 14 n'est pas un hasard.
void testWeatherGameplay() {
std::printf("\n--- Phase 23 : effets meteo sur les activites ---\n");
// =======================================================================
// PARAPENTE
// =======================================================================
{
constexpr float dt = 1.0f / 60.0f;
constexpr int kSteps = 60 * 30; // 30 s de vol
// --- Controle negatif : air calme = vol de la Phase 8 ---------------
Paraglider reference;
Paraglider withDefaultAir;
reference.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f);
withDefaultAir.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f);
for (int i = 0; i < kSteps; ++i) {
reference.update(dt, 0.0f, 0.0f);
withDefaultAir.update(dt, 0.0f, 0.0f, AirState{});
}
check(reference.position() == withDefaultAir.position(),
"Parapente : AirState par defaut = air calme = vol d'avant la Phase 23");
// --- Thermique : l'aile MONTE ---------------------------------------
// Une ascendance plus forte que le taux de chute doit faire gagner de
// l'altitude. C'est la definition du vol thermique, et rien dans le
// modele ne la code explicitement : elle sort de l'addition.
Paraglider soaring;
soaring.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f);
AirState thermal;
thermal.vertical = 3.0f; // > cruiseSinkRate (1,25)
for (int i = 0; i < kSteps; ++i) {
soaring.update(dt, 0.0f, 0.0f, thermal);
}
check(soaring.position().y > 1500.0f,
"Parapente : dans une thermique, l'aile gagne de l'altitude");
check(soaring.climbRateMps() > 0.0f, "Parapente : le vario est positif en thermique");
check(soaring.position().y > reference.position().y + 50.0f,
"Parapente : la thermique change vraiment le vol, elle ne le nuance pas");
std::printf(" [vol] 30 s : air calme %.0f m, thermique 3 m/s %.0f m\n",
static_cast<double>(reference.position().y),
static_cast<double>(soaring.position().y));
// --- Subsidence : l'aile descend PLUS vite --------------------------
Paraglider sinking;
sinking.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f);
AirState lee;
lee.vertical = -2.5f;
for (int i = 0; i < kSteps; ++i) {
sinking.update(dt, 0.0f, 0.0f, lee);
}
check(sinking.position().y < reference.position().y - 50.0f,
"Parapente : sous le vent, la subsidence coute cher");
// --- Vent : la derive ------------------------------------------------
// Cap 0 = +X. Un vent d'ouest (qui pousse vers +X) doit allonger le vol
// vers l'est ; le meme vent, cap oppose, doit le raccourcir. Les deux
// sens sont testes : un modele qui ajouterait la NORME du vent passerait
// le premier test et echouerait le second.
AirState westerly;
westerly.wind = glm::vec3(6.0f, 0.0f, 0.0f);
Paraglider downwind;
Paraglider upwind;
downwind.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f); // vers +X
upwind.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 180.0f); // vers -X
for (int i = 0; i < kSteps; ++i) {
downwind.update(dt, 0.0f, 0.0f, westerly);
upwind.update(dt, 0.0f, 0.0f, westerly);
}
check(downwind.position().x > reference.position().x + 100.0f,
"Parapente : vent dans le dos, on va nettement plus loin");
check(upwind.position().x > -reference.position().x,
"Parapente : vent de face, on avance nettement moins");
std::printf(" [vol] 30 s, vent 6 m/s : vent arriere %.0f m, vent de face %.0f m, "
"air calme %.0f m\n",
static_cast<double>(downwind.position().x),
static_cast<double>(std::abs(upwind.position().x)),
static_cast<double>(reference.position().x));
// Le vent ne doit PAS changer l'altitude : c'est un vent horizontal.
checkNear(downwind.position().y, reference.position().y, 1e-2f,
"Parapente : un vent horizontal ne fait ni monter ni descendre");
// --- Turbulence ------------------------------------------------------
Paraglider tossed;
tossed.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f);
AirState rough;
rough.turbulence = 1.0f;
float maxHeadingDrift = 0.0f;
for (int i = 0; i < kSteps; ++i) {
tossed.update(dt, 0.0f, 0.0f, rough);
maxHeadingDrift = std::max(maxHeadingDrift, std::abs(tossed.headingDegrees()));
}
check(maxHeadingDrift > 1.0f,
"Parapente : la turbulence fait reellement bouger le cap");
check(maxHeadingDrift < 90.0f,
"Parapente : la turbulence chahute, elle ne met pas en vrille");
check(tossed.position().y < reference.position().y,
"Parapente : l'air brasse coute de la finesse");
// Determinisme du vol turbulent : deux vols identiques doivent donner
// exactement le meme resultat. Sans ca, un vol ne serait pas rejouable,
// et toute la Phase 23 perdrait sa propriete centrale.
Paraglider twin;
twin.launch(glm::vec3(0.0f, 1500.0f, 0.0f), 0.0f);
for (int i = 0; i < kSteps; ++i) {
twin.update(dt, 0.0f, 0.0f, rough);
}
check(twin.position() == tossed.position() &&
twin.headingDegrees() == tossed.headingDegrees(),
"Parapente : meme vol turbulent, meme trajectoire (deterministe)");
}
// =======================================================================
// ESCALADE - adherence de la paroi
// =======================================================================
{
CliffTerrain cliff(0.0f, 3.0f, 0.0f, 10.0f);
constexpr float dt = 1.0f / 60.0f;
constexpr int kSteps = 60 * 20; // 20 s de montee
const auto climbFor = [&](float grip, float* stamina) {
Climber climber;
climber.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
for (int i = 0; i < kSteps && climber.climbing(); ++i) {
climber.update(dt, 1.0f, 0.0f, cliff, nullptr, grip);
}
if (stamina) { *stamina = climber.stamina(); }
return climber.heightGained();
};
float dryStamina = 0.0f;
float wetStamina = 0.0f;
const float dryRise = climbFor(1.0f, &dryStamina);
const float wetRise = climbFor(Climber{}.params().wetGrip, &wetStamina);
check(dryRise > 0.0f, "Escalade : on monte bien sur rocher sec");
check(wetRise < dryRise,
"Escalade : sur paroi mouillee, on progresse MESURABLEMENT moins vite");
// Le cout par METRE monte, ce qui est la partie qui compte : une paroi
// mouillee n'est pas seulement plus lente, elle est plus chere. Un
// modele qui ne ferait que ralentir laisserait la jauge dire le
// contraire - moins de metres, donc moins d'energie depensee.
const float dryCost = (1.0f - dryStamina) / std::max(0.01f, dryRise);
const float wetCost = (1.0f - wetStamina) / std::max(0.01f, wetRise);
check(wetCost > dryCost,
"Escalade : chaque metre de paroi mouillee coute plus cher que sur du sec");
std::printf(" [escalade] 20 s : sec %.1f m (%.3f de jauge/m), "
"mouille %.1f m (%.3f de jauge/m)\n",
static_cast<double>(dryRise), static_cast<double>(dryCost),
static_cast<double>(wetRise), static_cast<double>(wetCost));
// Controle negatif : sans argument de grip, l'escalade est celle de la
// Phase 14.
Climber withGrip;
Climber withoutGrip;
withGrip.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
withoutGrip.tryStart(cliff, glm::vec3(-1.5f, 1.7f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
for (int i = 0; i < 600; ++i) {
withGrip.update(dt, 1.0f, 0.0f, cliff, nullptr, 1.0f);
withoutGrip.update(dt, 1.0f, 0.0f, cliff, nullptr);
}
check(withGrip.anchor() == withoutGrip.anchor() &&
withGrip.stamina() == withoutGrip.stamina(),
"Escalade : grip par defaut = rocher sec = escalade d'avant la Phase 23");
// La traduction humidite -> adherence est monotone et bornee.
Climber sample;
check(sample.gripForWetness(0.0f) == 1.0f, "Adherence : sec = 1");
check(sample.gripForWetness(1.0f) < 1.0f, "Adherence : trempe < sec");
check(sample.gripForWetness(0.5f) < sample.gripForWetness(0.0f) &&
sample.gripForWetness(0.5f) > sample.gripForWetness(1.0f),
"Adherence : monotone entre les deux");
check(sample.gripForWetness(2.0f) == sample.gripForWetness(1.0f) &&
sample.gripForWetness(-1.0f) == sample.gripForWetness(0.0f),
"Adherence : une humidite hors bornes est ecretee, pas extrapolee");
// Une paroi ruisselante reste GRIMPABLE : le plancher d'adherence existe
// pour qu'un joueur ne se retrouve jamais bloque en paroi, ni montant ni
// descendant.
check(wetRise > 0.0f, "Escalade : une paroi trempee se grimpe encore, lentement");
}
// =======================================================================
// VELO - sol detrempe
// =======================================================================
{
FlatTerrain flat;
// Vitesse d'equilibre en pedalant a fond, sec contre trempe.
const auto settleWet = [&](float wetness) {
Bike bike;
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
float previous = -1.0f;
for (int i = 0; i < 60 * 120; ++i) {
bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr, wetness);
if (std::abs(bike.speed() - previous) < 1e-3f && i > 60) { break; }
previous = bike.speed();
}
return bike.speed();
};
const float drySpeed = settleWet(0.0f);
const float wetSpeed = settleWet(1.0f);
check(wetSpeed < drySpeed,
"Velo : sur sol detrempe, la vitesse d'equilibre est plus basse");
check(wetSpeed > 0.5f * drySpeed,
"Velo : le sol mouille freine, il n'immobilise pas");
std::printf(" [velo] vitesse d'equilibre a plat : sec %.1f km/h, trempe %.1f km/h\n",
static_cast<double>(drySpeed * 3.6f),
static_cast<double>(wetSpeed * 3.6f));
// Freinage : depuis la meme vitesse, la meme commande de frein pendant la
// meme duree doit laisser PLUS de vitesse sur sol mouille.
const auto brakeFrom = [&](float wetness) {
Bike bike;
bike.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
for (int i = 0; i < 60 * 60; ++i) {
bike.update(1.0f / 60.0f, 0.0f, 1.0f, 0.0f, flat, nullptr, 0.0f);
}
const float entry = bike.speed();
for (int i = 0; i < 30; ++i) { // une demi-seconde de frein
bike.update(1.0f / 60.0f, 0.0f, 0.0f, 1.0f, flat, nullptr, wetness);
}
return entry - bike.speed();
};
const float dryLoss = brakeFrom(0.0f);
const float wetLoss = brakeFrom(1.0f);
check(wetLoss < dryLoss,
"Velo : sur sol detrempe, une demi-seconde de frein enleve moins de vitesse");
std::printf(" [velo] 0,5 s de frein : sec -%.1f km/h, trempe -%.1f km/h\n",
static_cast<double>(dryLoss * 3.6f), static_cast<double>(wetLoss * 3.6f));
// Controle negatif : sans argument, la physique est celle de la Phase 13.
Bike explicitDry;
Bike implicitDry;
explicitDry.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
implicitDry.mount(glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, flat);
for (int i = 0; i < 600; ++i) {
explicitDry.update(1.0f / 60.0f, 0.2f, 1.0f, 0.0f, flat, nullptr, 0.0f);
implicitDry.update(1.0f / 60.0f, 0.2f, 1.0f, 0.0f, flat, nullptr);
}
check(explicitDry.position() == implicitDry.position() &&
explicitDry.speed() == implicitDry.speed(),
"Velo : humidite par defaut = sol sec = physique d'avant la Phase 23");
}
// =======================================================================
// LUMIERE DU JOUR - le cycle jour/nuit visuel
// =======================================================================
{
const WeatherSystem sky;
const WeatherParams params;
const SunLight noon = sunLightFor(sky.synopticAt(12.0f), params);
const SunLight midnight = sunLightFor(sky.synopticAt(0.0f), params);
check(noon.intensity > 0.9f, "Lumiere : pleine intensite a midi");
checkNear(midnight.intensity, 0.0f, 1e-6f, "Lumiere : aucune lumiere directe a minuit");
// L'AUBE EST UNE TRANSITION, pas un interrupteur : il doit exister des
// instants ou la lumiere directe est partielle. On les CHERCHE au lieu
// de parier sur une heure : l'heure du lever depend de la saison, et une
// premiere redaction de ce test interrogeait 6 h 30 - qui est deja le
// plein jour a la mi-mai au 45e parallele.
int partialQuarters = 0;
for (int i = 0; i < 24 * 12; ++i) {
const float intensity =
sunLightFor(sky.synopticAt(static_cast<float>(i) / 12.0f), params).intensity;
if (intensity > 0.02f && intensity < 0.98f) { ++partialQuarters; }
}
check(partialQuarters >= 4,
"Lumiere : l'aube et le crepuscule durent, ce n'est pas un interrupteur");
std::printf(" [lumiere] %d intervalles de 5 min en lumiere partielle sur 24 h\n",
partialQuarters);
check(noon.direction.y > 0.5f, "Lumiere : le soleil de midi vient d'en haut");
check(midnight.direction.y > 0.9f,
"Lumiere : la nuit, la direction bascule a la verticale (rien n'est eclaire "
"par en dessous)");
check(midnight.ambient > 0.0f,
"Lumiere : la nuit n'est pas noire - choix de jouabilite assume");
check(midnight.ambient < noon.ambient,
"Lumiere : la nuit est tout de meme nettement plus sombre que le jour");
checkNear(noon.ambient, 1.0f, 1e-3f,
"Lumiere : en plein jour, l'ambiante des shaders est inchangee (x1)");
// La direction de la lumiere DOIT etre celle du soleil de la meteo : un
// second soleil qui divergerait est exactement ce que cette phase
// corrige.
const SynopticState afternoon = sky.synopticAt(15.0f);
const SunLight afternoonLight = sunLightFor(afternoon, params);
checkNear(glm::dot(afternoonLight.direction, afternoon.sunDirection), 1.0f, 1e-3f,
"Lumiere : c'est LE soleil de la meteo, pas un second soleil");
// Le soleil traverse bien le ciel : est le matin, ouest le soir.
const SunLight morningLight = sunLightFor(sky.synopticAt(8.0f), params);
const SunLight eveningLight = sunLightFor(sky.synopticAt(18.0f), params);
check(morningLight.direction.x > 0.0f && eveningLight.direction.x < 0.0f,
"Lumiere : la direction traverse le ciel d'est en ouest dans la journee");
// Determinisme : deux captures au meme instant de jeu doivent etre
// comparables, ce qui est la condition de la verification visuelle du
// projet depuis la Phase 12.
const SunLight again = sunLightFor(sky.synopticAt(15.0f), params);
check(again.direction == afternoonLight.direction &&
again.intensity == afternoonLight.intensity,
"Lumiere : deterministe, donc deux captures au meme instant sont comparables");
// Toutes les valeurs restent dans leurs bornes, a toute heure.
for (int i = 0; i < 24 * 4; ++i) {
const SunLight light = sunLightFor(sky.synopticAt(static_cast<float>(i) * 0.25f), params);
check(light.intensity >= 0.0f && light.intensity <= 1.0f,
"Lumiere : intensite toujours dans [0, 1]");
check(light.ambient >= 0.0f && light.ambient <= 1.0f,
"Lumiere : multiplicateur d'ambiante toujours dans [0, 1]");
checkNear(glm::length(light.direction), 1.0f, 1e-3f,
"Lumiere : la direction est toujours unitaire");
check(light.direction.y >= 0.0f,
"Lumiere : jamais eclaire par en dessous, a aucune heure");
}
}
}
// ===========================================================================
// PHASE 27 - Meteo visible
// ===========================================================================
// Meme regle que testWeather() : des PROPRIETES et des SIGNES. Et une regle en
// plus, propre a cette phase : chaque effet visuel doit etre NUL quand la
// grandeur meteo qui le pilote est nulle. C'est la preuve executable qu'aucun
// effet n'a ete invente - un effet qui existerait sans sa grandeur serait par
// definition une mecanique nouvelle.
// PHASE 27 - texture de bruit du micro-relief (assets/DetailNoise.hpp).
void testDetailNoise() {
std::printf("\n[Phase 27] Texture de bruit de detail\n");
const TextureData t = makeDetailNoiseTexture(256, 32);
check(t.width == 256 && t.mips.size() == 9 && t.mips.back().width == 1,
"Bruit de detail : 256x256 et chaine complete de 9 mipmaps");
const auto px = [&](uint32_t x, uint32_t y, int ch) {
return static_cast<int>(t.pixels[(static_cast<size_t>(y) * 256 + x) * 4 + ch]);
};
// Periodicite : la colonne 255 doit se raccorder a la colonne 0 aussi bien
// que deux colonnes voisines quelconques (sinon une couture en repetition).
double seam = 0.0, inner = 0.0;
for (uint32_t y = 0; y < 256; ++y) {
seam += std::abs(px(255, y, 0) - px(0, y, 0));
inner += std::abs(px(128, y, 0) - px(127, y, 0));
}
check(seam < 2.0 * inner + 256.0, "Bruit de detail : raccord periodique sans couture");
// Derivee codee coherente avec la variation reelle de la valeur :
// correlation positive entre G et (R[x+1] - R[x-1]).
double corr = 0.0;
for (uint32_t y = 0; y < 256; y += 3) {
for (uint32_t x = 1; x < 255; x += 3) {
corr += (px(x, y, 1) - 127.5) * (px(x + 1, y, 0) - px(x - 1, y, 0));
}
}
check(corr > 0.0, "Bruit de detail : la derivee codee suit la pente de la valeur");
bool inRange = true;
for (size_t i = 0; i < t.mips[0].size; i += 4) {
if (t.pixels[i] == 0 && t.pixels[i + 1] == 0) { inRange = false; }
}
check(inRange, "Bruit de detail : aucune derivee saturee a zero");
const TextureData again = makeDetailNoiseTexture(256, 32);
check(again.pixels == t.pixels, "Bruit de detail : deterministe");
}
void testWeatherVisuals() {
std::printf("\n[Phase 27] Meteo visible\n");
const WeatherSystem weather;
const WeatherParams params;
const auto sampleWith = [](float cloud, float precip, bool snowing, float wetness,
glm::vec3 wind) {
WeatherSample s;
s.cloudCover = cloud;
s.precipitationMmPerHour = precip;
s.snowing = snowing;
s.wetness = wetness;
s.windVector = wind;
return s;
};
const auto saturation = [](const glm::vec3& c) {
return std::max({c.r, c.g, c.b}) - std::min({c.r, c.g, c.b});
};
const SynopticState noon = weather.synopticAt(12.0f);
const SynopticState midnight = weather.synopticAt(24.0f);
// --- Ciel clair et sec : RIEN ne change par rapport a la Phase 23 --------
{
const WeatherVisuals clear =
weatherVisualsFor(noon, sampleWith(0.0f, 0.0f, false, 0.0f, glm::vec3(0.0f)), params);
const SunLight reference = sunLightFor(noon, params);
check(clear.light.intensity == reference.intensity &&
clear.light.ambient == reference.ambient &&
clear.light.skyColor == reference.skyColor &&
clear.light.color == reference.color &&
clear.light.direction == reference.direction,
"Meteo visible : ciel clair et sec = lumiere de la Phase 23, au bit pres");
check(clear.fogDensityPerMeter == 0.0f,
"Meteo visible : aucun brouillard sans precipitation");
check(clear.precipitation == 0.0f,
"Meteo visible : aucune precipitation dessinee sans precipitation calculee");
check(clear.groundDarkening == 0.0f,
"Meteo visible : un sol sec n'est pas assombri");
}
// --- Nebulosite : monotone, et de jour seulement pour l'ambiante ---------
{
float lastDirect = 2.0f, lastSat = 2.0f, lastAmbient = -1.0f;
bool monotone = true;
for (int i = 0; i <= 10; ++i) {
const float cloud = static_cast<float>(i) / 10.0f;
const WeatherVisuals v = weatherVisualsFor(
noon, sampleWith(cloud, 0.0f, false, 0.0f, glm::vec3(0.0f)), params);
if (v.light.intensity > lastDirect || saturation(v.light.skyColor) > lastSat ||
v.light.ambient < lastAmbient) {
monotone = false;
}
lastDirect = v.light.intensity;
lastSat = saturation(v.light.skyColor);
lastAmbient = v.light.ambient;
}
check(monotone,
"Meteo visible : plus de nuages = moins de soleil direct, ciel plus gris, "
"ambiante plus diffuse - sans inversion sur toute la plage");
const WeatherVisuals overcast = weatherVisualsFor(
noon, sampleWith(1.0f, 0.0f, false, 0.0f, glm::vec3(0.0f)), params);
checkNear(overcast.light.intensity,
sunLightFor(noon, params).intensity * (1.0f - params.cloudAspectDamping), 1e-5f,
"Meteo visible : le voile du soleil reprend cloudAspectDamping (un seul "
"chiffre pour 'les nuages cachent le soleil')");
check(saturation(overcast.light.skyColor) < 1e-4f,
"Meteo visible : un ciel entierement couvert est gris");
// AJOUTE APRES LA PREMIERE CAPTURE : le gain d'ambiante etait ecrete a
// 1, donc MORT en plein jour (ou l'ambiante vaut deja 1), et la boucle
// monotone ci-dessus ne pouvait pas le voir - "ne decroit pas" est vrai
// d'une constante. Il faut exiger que l'effet EXISTE.
check(overcast.light.ambient > sunLightFor(noon, params).ambient * 1.5f,
"Meteo visible : sous un ciel couvert de jour, l'ambiante diffuse "
"augmente REELLEMENT (pas d'ecretage qui l'annule)");
const WeatherVisuals nightClear = weatherVisualsFor(
midnight, sampleWith(0.0f, 0.0f, false, 0.0f, glm::vec3(0.0f)), params);
const WeatherVisuals nightOvercast = weatherVisualsFor(
midnight, sampleWith(1.0f, 0.0f, false, 0.0f, glm::vec3(0.0f)), params);
checkNear(nightOvercast.light.ambient, nightClear.light.ambient, 1e-6f,
"Meteo visible : une nuit couverte n'est pas plus claire qu'une nuit claire");
check(glm::dot(nightOvercast.light.skyColor, glm::vec3(1.0f)) <=
glm::dot(nightClear.light.skyColor, glm::vec3(1.0f)) + 1e-5f,
"Meteo visible : un ciel couvert de nuit reste un ciel de nuit");
}
// --- Precipitation, brouillard, neige, vent --------------------------------
{
const WeatherVisuals rain = weatherVisualsFor(
noon, sampleWith(0.95f, 5.0f, false, 0.0f, glm::vec3(0.0f)), params);
check(rain.precipitation > 0.5f && !rain.snow,
"Meteo visible : 5 mm/h de pluie se dessinent, en pluie");
const float visibilityKm = 3.912f / (rain.fogDensityPerMeter * 1000.0f);
check(visibilityKm > 1.0f && visibilityKm < 20.0f,
"Meteo visible : visibilite sous 5 mm/h entre 1 et 20 km (ordre de grandeur)");
std::printf(" [brouillard] visibilite de Koschmieder sous 5 mm/h : %.1f km\n",
visibilityKm);
const WeatherVisuals lightRain = weatherVisualsFor(
noon, sampleWith(0.95f, 1.0f, false, 0.0f, glm::vec3(0.0f)), params);
check(lightRain.fogDensityPerMeter < rain.fogDensityPerMeter &&
lightRain.precipitation < rain.precipitation,
"Meteo visible : une pluie faible voile moins et se dessine moins qu'une forte");
const WeatherVisuals snow = weatherVisualsFor(
noon, sampleWith(0.95f, 5.0f, true, 0.0f, glm::vec3(0.0f)), params);
check(snow.snow && snow.fogDensityPerMeter > rain.fogDensityPerMeter,
"Meteo visible : a lame d'eau egale, la neige voile plus que la pluie");
check(std::abs(snow.fallVelocity.y) < std::abs(rain.fallVelocity.y),
"Meteo visible : la neige tombe plus lentement que la pluie");
const glm::vec3 eastward(8.0f, 0.0f, 0.0f);
const WeatherVisuals windy = weatherVisualsFor(
noon, sampleWith(0.95f, 5.0f, false, 0.0f, eastward), params);
check(windy.fallVelocity.x > 7.9f && std::abs(windy.fallVelocity.z) < 1e-5f,
"Meteo visible : la pluie est poussee par le vent LOCAL, dans son sens");
const WeatherVisuals wet = weatherVisualsFor(
noon, sampleWith(0.0f, 0.0f, false, 1.0f, glm::vec3(0.0f)), params);
checkNear(wet.groundDarkening, params.wetGroundDarkening, 1e-6f,
"Meteo visible : un sol ruisselant est assombri de wetGroundDarkening");
check(wet.precipitation == 0.0f && wet.fogDensityPerMeter == 0.0f,
"Meteo visible : un sol encore mouille apres l'averse ne fait pas pleuvoir");
const WeatherVisuals garbage = weatherVisualsFor(
noon, sampleWith(std::nanf(""), std::nanf(""), false, std::nanf(""),
glm::vec3(0.0f)), params);
check(std::isfinite(garbage.fogDensityPerMeter) &&
std::isfinite(garbage.light.ambient) &&
std::isfinite(garbage.light.skyColor.r),
"Meteo visible : une entree non finie ne produit pas de NaN a l'ecran");
}
// --- COHERENCE AVEC LE CALENDRIER REEL, et continuite ----------------------
// Trente jours de jeu, une minute de jeu par pas : l'effet visuel doit
// exister EXACTEMENT quand la meteo le dit, et ne jamais sauter.
{
int rainyMinutes = 0, mismatches = 0, phaseFlips = 0, unexplainedFogJumps = 0;
float maxFogJump = 0.0f, maxSkyJump = 0.0f, maxPrecipJump = 0.0f;
WeatherVisuals previous{};
bool havePrevious = false;
const glm::vec3 alpage(0.0f, 1500.0f, 0.0f);
for (int minute = 0; minute < 30 * 24 * 60; ++minute) {
const float hours = static_cast<float>(minute) / 60.0f;
const SynopticState sky = weather.synopticAt(hours);
const WeatherSample local = weather.sampleAt(alpage, sky, nullptr);
const WeatherVisuals v = weatherVisualsFor(sky, local, params);
const bool raining = local.precipitationMmPerHour > 0.0f;
if (raining) { ++rainyMinutes; }
if (raining != (v.precipitation > 0.0f) ||
raining != (v.fogDensityPerMeter > 0.0f)) {
++mismatches;
}
if (havePrevious) {
// La BASCULE PLUIE <-> NEIGE est une discontinuite du MODELE, pas
// du rendu : WeatherSample::snowing est un booleen (seuil
// snowThresholdC), et la neige voile x8 plus que la pluie. Le
// premier jet de ce test l'a trouvee : j1 6 h 55 a 1500 m, la
// visibilite passe de 1,6 a 13 km en une minute de jeu. La lisser
// demanderait une phase MIXTE (pluie et neige melees) que Weather
// ne modelise pas - prerequis manquant, documente, pas invente
// ici. Le test l'ISOLE : ces minutes-la sont comptees a part, et
// TOUT AUTRE saut reste un echec.
const bool flip = v.snow != previous.snow;
if (flip) { ++phaseFlips; }
const float fogJump =
std::abs(v.fogDensityPerMeter - previous.fogDensityPerMeter);
if (!flip && fogJump > 2e-4f) { ++unexplainedFogJumps; }
if (!flip) { maxFogJump = std::max(maxFogJump, fogJump); }
maxPrecipJump = std::max(maxPrecipJump,
std::abs(v.precipitation - previous.precipitation));
maxSkyJump = std::max(maxSkyJump,
glm::length(v.light.skyColor - previous.light.skyColor));
}
previous = v;
havePrevious = true;
}
check(rainyMinutes > 0,
"Meteo visible : le calendrier de 30 jours contient de la pluie a montrer");
check(mismatches == 0,
"Meteo visible : pluie et brouillard a l'ecran EXACTEMENT quand la meteo "
"calcule une precipitation, jamais sinon");
// Bornes de continuite : une minute de jeu ne doit pas faire sauter
// l'image. 0,05 de couleur de ciel ~ 13 niveaux sur 255 : c'est le
// crepuscule, deja present depuis la Phase 23, qui fixe le plafond.
//
// Brouillard : 2e-4 /m par minute. La montee d'une averse de NEIGE
// (x8) progresse d'environ 6e-5 /m par minute, lissement ; un saut
// d'un ordre de grandeur au-dessus serait une vraie discontinuite.
check(maxSkyJump < 0.05f && maxPrecipJump < 0.05f && unexplainedFogJumps == 0,
"Meteo visible : continue dans le temps, hors bascule pluie/neige du modele");
std::printf(" [calendrier] %d minutes de pluie sur 30 jours ; sauts max par "
"minute : ciel %.4f, pluie %.4f, brouillard %.2e /m ; %d bascule(s) "
"pluie/neige (discontinuite du modele, voir NOTES-PHASE27.md)\n",
rainyMinutes, maxSkyJump, maxPrecipJump, maxFogJump, phaseFlips);
// Controle negatif sur les deux instants des captures de la phase :
// meme heure, meme lieu, seul le jour change.
const SynopticState rainyDay = weather.synopticAt(8 * 24.0f + 13.0f);
const SynopticState clearDay = weather.synopticAt(12 * 24.0f + 13.0f);
const WeatherVisuals rainy =
weatherVisualsFor(rainyDay, weather.sampleAt(alpage, rainyDay, nullptr), params);
const WeatherVisuals clear =
weatherVisualsFor(clearDay, weather.sampleAt(alpage, clearDay, nullptr), params);
check(rainy.precipitation > 0.0f && clear.precipitation == 0.0f,
"Meteo visible : il pleut a l'ecran le jour 8 a 13 h, pas le jour 12");
check(saturation(rainy.light.skyColor) < saturation(clear.light.skyColor),
"Meteo visible : le ciel du jour 8 est plus gris que celui du jour 12");
}
}
// ===========================================================================
// PHASE 28 : faconnage generique (world/Crafting), foyers, reposer au sol
// ===========================================================================
bool sameGround(const Ground& a, const Ground& b) {
if (a.itemCount() != b.itemCount()) return false;
for (std::size_t i = 0; i < a.itemCount(); ++i) {
const GroundItem& x = a.items()[i];
const GroundItem& y = b.items()[i];
if (x.kind != y.kind || x.position != y.position || x.yaw != y.yaw || x.roll != y.roll) {
return false;
}
}
return true;
}
bool sameInventory(const Inventory& a, const Inventory& b) {
for (uint32_t k = 0; k < kGroundItemKindCount; ++k) {
if (a.count(static_cast<GroundItemKind>(k)) != b.count(static_cast<GroundItemKind>(k))) {
return false;
}
}
return true;
}
int countKind(const Ground& ground, GroundItemKind kind) {
int n = 0;
for (const GroundItem& item : ground.items()) {
if (item.kind == kind) ++n;
}
return n;
}
const GroundItem* firstOfKind(const Ground& ground, GroundItemKind kind) {
for (const GroundItem& item : ground.items()) {
if (item.kind == kind) return &item;
}
return nullptr;
}
void testCraftingRecipeTable() {
section("Phase 28 : table des recettes, nouvelles natures d'objets");
// Unicite des id, sortie absente des ingredients, bornes.
bool idsUnique = true;
bool outNotInput = true;
bool countsSane = true;
for (std::size_t i = 0; i < kRecipes.size(); ++i) {
for (std::size_t j = i + 1; j < kRecipes.size(); ++j) {
if (std::strcmp(kRecipes[i].id, kRecipes[j].id) == 0) idsUnique = false;
}
const Recipe& r = kRecipes[i];
if (r.inCount == 0 || r.inCount > r.in.size()) countsSane = false;
for (uint8_t k = 0; k < r.inCount && k < r.in.size(); ++k) {
if (r.in[k].count == 0) countsSane = false;
if (r.hasOutput && r.in[k].kind == r.out) outNotInput = false;
}
check(findRecipe(r.id) == static_cast<int>(i),
std::string("findRecipe retrouve ") + r.id);
}
check(idsUnique, "Recettes : id uniques");
check(outNotInput, "Recettes : aucune sortie ne figure parmi ses ingredients");
check(countsSane, "Recettes : nombres d'ingredients coherents");
check(findRecipe("inexistante") == -1, "findRecipe : id inconnu -> -1");
// PHASE 28 (Agent 3) : 8 -> 10 (abri, hache renforcee).
check(kRecipes.size() == 10, "Dix recettes dans la table");
check(findRecipe("shelter") == 0, "Priorite : l'abri en tete (la plus complexe)");
check(findRecipe("shelter") < findRecipe("hearth"), "Priorite : abri avant foyer");
check(findRecipe("pitched_axe") < findRecipe("axe"), "Priorite : hache renforcee avant hache");
// Ordre de priorite : le foyer avant la hache, la hache avant la ligature,
// la percussion en DERNIER (la plus simple).
check(findRecipe("hearth") < findRecipe("axe"), "Priorite : foyer avant hache");
check(findRecipe("axe") < findRecipe("cord"), "Priorite : hache avant ligature");
check(findRecipe("pitch") < findRecipe("cord"), "Priorite : poix avant ligature");
check(findRecipe("knap") == static_cast<int>(kRecipes.size()) - 1,
"Priorite : la percussion est la derniere recette");
// Recettes demandees par la conception, a l'unite pres.
{
const Recipe& h = kRecipes[static_cast<std::size_t>(findRecipe("hearth"))];
check(h.out == GroundItemKind::Hearth && h.effect == CraftEffect::LightNewHearth,
"Foyer : produit un foyer allume");
check(h.in[0].kind == GroundItemKind::Stone && h.in[0].count == 3 &&
h.in[0].source == CraftSource::Placed && h.in[0].consumed,
"Foyer : 3 pierres posees consommees");
check(h.in[1].kind == GroundItemKind::Branch && h.in[1].count == 2 &&
h.in[1].source == CraftSource::Placed && h.in[1].consumed,
"Foyer : 2 branches posees consommees");
check(h.in[2].kind == GroundItemKind::Flake && h.in[2].source == CraftSource::Carried &&
!h.in[2].consumed,
"Foyer : eclat porte, outil non consomme");
const Recipe& p = kRecipes[static_cast<std::size_t>(findRecipe("pitch"))];
check(p.station == CraftStation::LitHearth, "Poix : exige un foyer allume");
}
// Toutes les natures ont un rayon, des libelles et (pour les nouvelles) un mesh.
check(kGroundItemKindCount == 15, "15 natures d'objets au sol (Phase 28, Agent 3)");
bool radiiOk = true;
bool labelsOk = true;
for (uint32_t k = 0; k < kGroundItemKindCount; ++k) {
const auto kind = static_cast<GroundItemKind>(k);
if (!(groundItemRestRadius(kind) > 0.0f)) radiiOk = false;
if (std::strcmp(groundItemLabel(kind), "objet") == 0 ||
std::strcmp(groundItemLabelIndefinite(kind), "un objet") == 0 ||
std::strcmp(groundItemLabelPlural(kind), "objets") == 0) {
labelsOk = false;
}
}
check(radiiOk, "Toutes les natures ont un rayon de repos > 0");
check(labelsOk, "Toutes les natures ont leurs trois libelles");
check(!groundItemIsPortable(GroundItemKind::Hearth), "Le foyer n'est pas portable");
check(groundItemIsPortable(GroundItemKind::Axe) && groundItemIsPortable(GroundItemKind::Ash) &&
groundItemIsPortable(GroundItemKind::Stone),
"Hache, cendre, pierre : portables");
check(!groundItemIsPortable(GroundItemKind::Shelter), "L'abri n'est pas portable");
check(groundItemIsPortable(GroundItemKind::PitchedAxe), "La hache renforcee est portable");
const std::array<std::pair<MeshData, float>, 6> meshes = { {
{ pitchedAxeMeshData(), kAxeRadius },
{ cordMeshData(), kCordRadius }, { axeMeshData(), kAxeRadius },
{ hearthMeshData(), kHearthRadius }, { ashMeshData(), kAshRadius },
{ pitchMeshData(), kPitchRadius },
} };
for (const auto& [mesh, radius] : meshes) {
bool indicesValid = !mesh.empty() && mesh.indices.size() % 3 == 0;
bool normalsUnit = true;
bool restsOnGround = true;
bool handSized = true;
float minY = 1e9f;
for (const uint32_t index : mesh.indices) {
if (index >= mesh.vertices.size()) indicesValid = false;
}
for (const Vertex& v : mesh.vertices) {
if (std::abs(glm::length(v.normal) - 1.0f) > 1e-3f) normalsUnit = false;
if (v.pos.y > radius + 1e-4f || v.pos.y < -radius - 1e-4f) restsOnGround = false;
if (std::abs(v.pos.x) > 0.5f || std::abs(v.pos.z) > 0.5f) handSized = false;
minY = std::min(minY, v.pos.y);
}
check(indicesValid, "Mesh valide : " + mesh.name);
check(normalsUnit, "Normales unitaires : " + mesh.name);
check(restsOnGround, "Tient dans sa demi-hauteur : " + mesh.name);
checkNear(minY, -radius, 0.01f, "Touche le sol (bas = -rayon) : " + mesh.name);
check(handSized, "Dimensions plausibles : " + mesh.name);
}
// Resume d'inventaire : matieres toujours listees, objets faconnes seulement
// s'ils sont portes.
Inventory inventory;
check(inventory.summary().find("buches 0") != std::string::npos &&
inventory.summary().find("ligatures") == std::string::npos,
"Resume : matieres a zero listees, objets faconnes a zero masques");
inventory.add(GroundItemKind::Cord);
check(inventory.summary().find("ligatures 1") != std::string::npos,
"Resume : une ligature portee apparait");
}
void testCraftingKnapUnchanged() {
section("Phase 28 : la percussion par la table = knapStones au bit pres");
FlatTerrain flat;
const glm::vec3 player{ 3.0f, 1.7f, -2.0f };
const glm::vec3 facing{ 0.3f, -0.2f, -1.0f };
Ground groundA(flat);
Ground groundB(flat);
Inventory invA;
Inventory invB;
invA.add(GroundItemKind::Stone, 2);
invB.add(GroundItemKind::Stone, 2);
HearthSet hearths;
check(knapStones(invA, groundA, player, facing) == KnapResult::Success,
"knapStones reussit (reference)");
const CraftOutcome outcome = craftAt(invB, groundB, hearths, player, facing, 0.0f);
check(outcome.result == CraftResult::Success && outcome.recipe == findRecipe("knap"),
"craftAt choisit la percussion avec deux pierres portees");
check(outcome.message == knapResultMessage(KnapResult::Success),
"Message de succes identique a la Phase 6");
check(sameInventory(invA, invB) && invB.count(GroundItemKind::Stone) == 1,
"Une seule pierre consommee (le percuteur reste)");
check(sameGround(groundA, groundB), "Eclat depose au meme endroit, meme yaw");
// Refus : message historique, rien ne change.
Inventory one;
one.add(GroundItemKind::Stone);
Ground empty(flat);
const CraftOutcome refused = craftAt(one, empty, hearths, player, facing, 0.0f);
check(refused.result == CraftResult::MissingIngredients, "Une pierre : refus");
check(refused.message == knapResultMessage(KnapResult::NotEnoughStones),
"Refus de percussion : message historique mot pour mot");
check(one.count(GroundItemKind::Stone) == 1 && empty.itemCount() == 0,
"Refus : rien consomme, rien depose");
// Regard vertical : repli sans NaN, eclat a +X.
Inventory two;
two.add(GroundItemKind::Stone, 2);
Ground g(flat);
craftAt(two, g, hearths, player, { 0.0f, -1.0f, 0.0f }, 0.0f);
check(g.itemCount() == 1 && !std::isnan(g.items()[0].position.x) &&
!std::isnan(g.items()[0].position.z),
"Regard vertical : aucun NaN");
checkNear(g.items()[0].position.x, player.x + kCraftDropDistance, 1e-5f,
"Regard vertical : repli sur +X a 1,1 m");
}
void testCraftingCord() {
section("Phase 28 : ligature (3 fibres portees)");
FlatTerrain flat;
Ground ground(flat);
HearthSet hearths;
const glm::vec3 player{ 0.0f, 1.7f, 0.0f };
const glm::vec3 facing{ 0.0f, 0.0f, -1.0f };
Inventory inventory;
inventory.add(GroundItemKind::Fiber, 2);
// Une troisieme fibre AU SOL ne compte pas : la ligature se tord en main.
ground.drop(GroundItemKind::Fiber, 0.5f, 0.0f, 0.0f, 0.0f);
const Ground groundBefore = ground;
const Inventory invBefore = inventory;
const CraftOutcome refused = craftAt(inventory, ground, hearths, player, facing, 0.0f);
check(refused.result == CraftResult::MissingIngredients &&
refused.recipe == findRecipe("cord"),
"Deux fibres portees (+1 posee) : refus, recette la plus proche = ligature");
check(refused.message.find("tige a fibres") != std::string::npos &&
refused.message.find("porter") != std::string::npos,
"Le refus dit qu'il manque une tige a fibres a porter");
check(sameGround(ground, groundBefore) && sameInventory(inventory, invBefore),
"Refus : inventaire et sol identiques");
inventory.add(GroundItemKind::Fiber, 2); // 4 portees
const CraftOutcome ok = craftAt(inventory, ground, hearths, player, facing, 0.0f);
check(ok.result == CraftResult::Success && ok.recipe == findRecipe("cord"),
"Trois fibres portees : ligature");
check(inventory.count(GroundItemKind::Fiber) == 1, "Exactement trois fibres consommees");
check(inventory.count(GroundItemKind::Cord) == 0, "La ligature n'est pas en poche");
check(countKind(ground, GroundItemKind::Fiber) == 1, "La fibre posee n'est pas touchee");
const GroundItem* cord = firstOfKind(ground, GroundItemKind::Cord);
check(cord != nullptr, "La ligature est au sol");
if (cord != nullptr) {
checkNear(cord->position.z, -kCraftDropDistance, 1e-5f, "Ligature a 1,1 m devant");
checkNear(cord->position.y, kCordRadius, 1e-5f, "Ligature posee sur la surface");
}
}
void testCraftingHearth() {
section("Phase 28 : foyer (3 pierres + 2 branches posees, eclat porte)");
FlatTerrain flat;
Ground ground(flat);
HearthSet hearths;
const glm::vec3 player{ 0.0f, 1.7f, 0.0f };
const glm::vec3 facing{ 1.0f, 0.0f, 0.0f };
ground.drop(GroundItemKind::Stone, 1.0f, 0.0f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Stone, 1.0f, 1.0f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Stone, 2.0f, 0.0f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Branch, 2.0f, 1.0f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Branch, 1.5f, 0.5f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Log, 30.0f, 0.0f, 0.0f, 0.0f); // hors portee
// Sans eclat : refus, rien ne bouge.
Inventory inventory;
const Ground before = ground;
const CraftOutcome refused = craftAt(inventory, ground, hearths, player, facing, 10.0f);
check(refused.result == CraftResult::MissingIngredients &&
refused.recipe == findRecipe("hearth"),
"Sans eclat : refus, recette la plus proche = foyer");
check(refused.message.find("eclat") != std::string::npos, "Le refus nomme l'eclat");
check(sameGround(ground, before) && inventory.total() == 0 && hearths.hearths().empty(),
"Refus : sol, inventaire et foyers inchanges");
inventory.add(GroundItemKind::Flake);
const CraftOutcome ok = craftAt(inventory, ground, hearths, player, facing, 10.0f);
check(ok.result == CraftResult::Success && ok.recipe == findRecipe("hearth"),
"Avec l'eclat : foyer construit");
check(inventory.count(GroundItemKind::Flake) == 1, "L'eclat (outil) n'est pas consomme");
check(countKind(ground, GroundItemKind::Stone) == 0 &&
countKind(ground, GroundItemKind::Branch) == 0,
"Les 3 pierres et 2 branches sont consommees");
check(countKind(ground, GroundItemKind::Log) == 1, "La buche hors portee est intacte");
const GroundItem* hearthItem = firstOfKind(ground, GroundItemKind::Hearth);
check(hearthItem != nullptr, "Le foyer existe au sol");
if (hearthItem == nullptr) return;
checkNear(hearthItem->position.x, 1.5f, 1e-4f, "Foyer au barycentre (x)");
checkNear(hearthItem->position.z, 0.5f, 1e-4f, "Foyer au barycentre (z)");
checkNear(hearthItem->position.y, kHearthRadius, 1e-5f, "Foyer pose sur la surface");
check(hearths.hearths().size() == 1 && hearths.hearths()[0].lit, "Le foyer nait allume");
checkNear(hearths.remainingHours(0, 10.0f), 1.0f, 1e-5f, "Combustion : 1 h de jeu");
// Le foyer ne se ramasse pas.
check(ground.findNearest(player, 5.0f) == kNoGroundItem,
"findNearest ignore le foyer (objet fixe)");
// Combustion : allume a mi-parcours, eteint a l'heure dite, UNE cendre.
check(hearths.update(10.5f, ground) == 0 && hearths.hearths()[0].lit,
"A +0,5 h le feu brule encore");
check(countKind(ground, GroundItemKind::Ash) == 0, "Pas de cendre tant qu'il brule");
check(hearths.update(11.0f, ground) == 1 && !hearths.hearths()[0].lit,
"A +1 h le feu s'eteint");
check(countKind(ground, GroundItemKind::Ash) == 1, "Une cendre est deposee");
check(hearths.update(20.0f, ground) == 0 && countKind(ground, GroundItemKind::Ash) == 1,
"Un foyer eteint ne produit pas d'autre cendre");
check(countKind(ground, GroundItemKind::Hearth) == 1, "Le foyer eteint reste en place");
const GroundItem* ash = firstOfKind(ground, GroundItemKind::Ash);
if (ash != nullptr) {
checkNear(ash->position.x, 1.5f, 1e-4f, "Cendre au centre du foyer");
const int nearest = ground.findNearest(player, 5.0f);
check(nearest >= 0 &&
ground.items()[static_cast<std::size_t>(nearest)].kind == GroundItemKind::Ash,
"La cendre, elle, se ramasse");
}
// Rallumer : 2 branches posees + eclat porte, foyer froid a portee.
ground.drop(GroundItemKind::Branch, 0.8f, -0.3f, 0.0f, 0.0f);
const CraftOutcome oneBranch = craftAt(inventory, ground, hearths, player, facing, 20.0f);
check(oneBranch.result == CraftResult::MissingIngredients &&
!hearths.hearths()[0].lit,
"Une seule branche : le foyer froid ne repart pas");
ground.drop(GroundItemKind::Branch, 0.8f, 0.3f, 0.0f, 0.0f);
const CraftOutcome relit = craftAt(inventory, ground, hearths, player, facing, 20.0f);
check(relit.result == CraftResult::Success && relit.recipe == findRecipe("hearth_relight"),
"Deux branches + eclat : le foyer est rallume");
check(hearths.hearths()[0].lit && countKind(ground, GroundItemKind::Branch) == 0 &&
inventory.count(GroundItemKind::Flake) == 1,
"Rallumage : branches consommees, eclat garde");
check(countKind(ground, GroundItemKind::Hearth) == 1, "Rallumage : aucun second foyer");
// Alimenter : une buche posee pres du foyer allume prolonge d'1 h.
ground.drop(GroundItemKind::Log, 0.5f, 0.0f, 0.0f, 0.0f);
const CraftOutcome fed = craftAt(inventory, ground, hearths, player, facing, 20.5f);
check(fed.result == CraftResult::Success && fed.recipe == findRecipe("hearth_feed_log"),
"Buche posee : le foyer est alimente");
checkNear(hearths.remainingHours(0, 20.5f), 1.5f, 1e-4f,
"Alimenter prolonge d'1 h (0,5 h restante -> 1,5 h)");
check(countKind(ground, GroundItemKind::Log) == 1, "Seule la buche proche est consommee");
// POINT D'ACCROCHE (non branche) : chaleur au centre, nulle a 6 m, nulle eteint.
const glm::vec3 center = hearths.hearths()[0].position;
checkNear(hearths.warmthAt(center), 8.0f, 1e-4f, "Chaleur maximale au centre");
checkNear(hearths.warmthAt(center + glm::vec3(3.0f, 0.0f, 0.0f)), 4.0f, 1e-4f,
"Chaleur a mi-rayon : la moitie");
checkNear(hearths.warmthAt(center + glm::vec3(6.0f, 0.0f, 0.0f)), 0.0f, 1e-6f,
"Chaleur nulle a 6 m");
hearths.update(100.0f, ground);
checkNear(hearths.warmthAt(center), 0.0f, 1e-6f, "Foyer eteint : aucune chaleur");
check(countKind(ground, GroundItemKind::Ash) == 2, "Seconde extinction : seconde cendre");
}
void testCraftingAxe() {
section("Phase 28 : hache (eclat + branche + ligature poses)");
FlatTerrain flat;
Ground ground(flat);
HearthSet hearths;
Inventory inventory;
const glm::vec3 player{ 0.0f, 1.7f, 0.0f };
const glm::vec3 facing{ 0.0f, 0.0f, 1.0f };
// Ingredients NON CONTIGUS, entrelaces avec des objets etrangers : la
// consommation ne doit retirer que les bons (pickUp echange avec le dernier).
ground.drop(GroundItemKind::Clay, 0.2f, 0.2f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Flake, 1.0f, 0.0f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Sand, -0.4f, 0.2f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Branch, 0.0f, 1.0f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Resin, 0.3f, -0.6f, 0.0f, 0.0f);
ground.drop(GroundItemKind::Stone, 40.0f, 0.0f, 0.0f, 0.0f);
const Ground before = ground;
const CraftOutcome refused = craftAt(inventory, ground, hearths, player, facing, 0.0f);
check(refused.result == CraftResult::MissingIngredients &&
refused.recipe == findRecipe("axe"),
"Sans ligature : refus, recette la plus proche = hache");
check(refused.message.find("ligature") != std::string::npos, "Le refus nomme la ligature");
check(sameGround(ground, before), "Refus : sol identique octet pour octet");
// Une ligature PORTEE ne suffit pas : l'outil composite s'assemble au sol.
inventory.add(GroundItemKind::Cord);
check(craftAt(inventory, ground, hearths, player, facing, 0.0f).result ==
CraftResult::MissingIngredients,
"Ligature portee (non posee) : refus");
check(inventory.count(GroundItemKind::Cord) == 1 && sameGround(ground, before),
"Refus : la ligature portee n'est pas consommee");
ground.drop(GroundItemKind::Cord, -1.0f, 0.0f, 0.0f, 0.0f);
const CraftOutcome ok = craftAt(inventory, ground, hearths, player, facing, 0.0f);
check(ok.result == CraftResult::Success && ok.recipe == findRecipe("axe"),
"Eclat + branche + ligature poses : hache");
check(countKind(ground, GroundItemKind::Flake) == 0 &&
countKind(ground, GroundItemKind::Branch) == 0 &&
countKind(ground, GroundItemKind::Cord) == 0,
"Les trois ingredients sont consommes");
check(countKind(ground, GroundItemKind::Clay) == 1 &&
countKind(ground, GroundItemKind::Sand) == 1 &&
countKind(ground, GroundItemKind::Resin) == 1 &&
countKind(ground, GroundItemKind::Stone) == 1,
"Les objets etrangers entrelaces sont tous intacts");
check(ground.itemCount() == 5, "Sol : 4 etrangers + la hache");
check(inventory.count(GroundItemKind::Cord) == 1, "La ligature portee est gardee");
const GroundItem* axe = firstOfKind(ground, GroundItemKind::Axe);
check(axe != nullptr, "La hache est au sol");
if (axe != nullptr) {
checkNear(axe->position.x, 0.0f, 1e-5f, "Hache au barycentre (x)");
checkNear(axe->position.z, 1.0f / 3.0f, 1e-5f, "Hache au barycentre (z)");
const int nearest = ground.findNearest({ 0.0f, 1.7f, 0.33f }, 0.1f);
check(nearest >= 0, "La hache se ramasse");
GroundItemKind picked = GroundItemKind::Log;
ground.pickUp(nearest, &picked);
inventory.add(picked);
check(inventory.count(GroundItemKind::Axe) == 1,
"Hache portee (point d'accroche du rendement, Agent 3)");
}
// Un ingredient pose juste hors de portee (2,6 m) ne compte pas.
Ground far(flat);
far.drop(GroundItemKind::Flake, 2.6f, 0.0f, 0.0f, 0.0f);
far.drop(GroundItemKind::Branch, 0.0f, 1.0f, 0.0f, 0.0f);
far.drop(GroundItemKind::Cord, -1.0f, 0.0f, 0.0f, 0.0f);
Inventory none;
check(craftAt(none, far, hearths, player, facing, 0.0f).result ==
CraftResult::MissingIngredients,
"Eclat pose a 2,6 m : hors de portee, refus");
check(far.itemCount() == 3, "Refus : rien consomme");
}
void testPitchNeedsLitHearth() {
section("Phase 28 : poix (2 resines + 1 cendre posees, foyer allume)");
FlatTerrain flat;
const glm::vec3 player{ 0.0f, 1.7f, 0.0f };
const glm::vec3 facing{ 1.0f, 0.0f, 0.0f };
const auto setup = [](Ground& g) {
g.drop(GroundItemKind::Resin, 0.5f, 0.5f, 0.0f, 0.0f);
g.drop(GroundItemKind::Resin, 0.5f, -0.5f, 0.0f, 0.0f);
g.drop(GroundItemKind::Ash, -0.5f, 0.0f, 0.0f, 0.0f);
};
// 1. Aucun foyer.
{
Ground ground(flat);
HearthSet hearths;
Inventory inventory;
setup(ground);
const Ground before = ground;
const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.0f);
check(o.result == CraftResult::MissingIngredients && o.recipe == findRecipe("pitch"),
"Sans foyer : refus, recette la plus proche = poix");
check(o.message.find("chauffer") != std::string::npos,
"Le refus dit qu'il faut chauffer");
check(sameGround(ground, before), "Sans foyer : rien consomme");
}
// 2. Foyer ETEINT a portee.
{
Ground ground(flat);
HearthSet hearths;
Inventory inventory;
ground.drop(GroundItemKind::Hearth, 1.0f, 0.0f, 0.0f, 0.0f);
hearths.addLit(ground.items().back().position, 0.0f);
hearths.update(5.0f, ground); // eteint -> une cendre au centre
check(!hearths.hearths()[0].lit, "Foyer eteint");
setup(ground);
const Ground before = ground;
const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 5.0f);
check(o.result == CraftResult::MissingIngredients,
"Foyer eteint : la poix est refusee");
check(sameGround(ground, before), "Foyer eteint : rien consomme");
}
// 3. Foyer allume trop loin (2,5 m > kStationReach).
{
Ground ground(flat);
HearthSet hearths;
Inventory inventory;
ground.drop(GroundItemKind::Hearth, 2.5f, 0.0f, 0.0f, 0.0f);
hearths.addLit(ground.items().back().position, 0.0f);
setup(ground);
check(craftAt(inventory, ground, hearths, player, facing, 0.1f).result ==
CraftResult::MissingIngredients,
"Foyer allume a 2,5 m : hors de portee du poste, refus");
}
// 4. Foyer allume a portee : succes.
{
Ground ground(flat);
HearthSet hearths;
Inventory inventory;
ground.drop(GroundItemKind::Hearth, 1.5f, 0.0f, 0.0f, 0.0f);
hearths.addLit(ground.items().back().position, 0.0f);
setup(ground);
ground.drop(GroundItemKind::Resin, -1.0f, -1.0f, 0.0f, 0.0f); // une de trop
const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.2f);
check(o.result == CraftResult::Success && o.recipe == findRecipe("pitch"),
"Foyer allume a 1,5 m : poix");
check(countKind(ground, GroundItemKind::Resin) == 1 &&
countKind(ground, GroundItemKind::Ash) == 0,
"Exactement 2 resines et 1 cendre consommees");
check(countKind(ground, GroundItemKind::Hearth) == 1 && hearths.hearths()[0].lit,
"Le foyer (poste) n'est pas consomme");
check(countKind(ground, GroundItemKind::Pitch) == 1, "La poix est au sol");
checkNear(hearths.remainingHours(0, 0.2f), 0.8f, 1e-4f,
"Faire de la poix ne consomme pas de temps de combustion");
}
}
void testPutDown() {
section("Phase 28 : reposer un objet porte (touche P)");
FlatTerrain flat;
Ground ground(flat);
Inventory inventory;
const glm::vec3 player{ 0.0f, 1.7f, 0.0f };
const glm::vec3 facing{ 0.0f, -0.5f, -1.0f };
GroundItemKind kind = GroundItemKind::Log;
check(!chooseKindToPutDown(inventory, GroundItemKind::Stone, &kind),
"Inventaire vide : rien a poser");
check(!putDown(inventory, ground, GroundItemKind::Stone, player, facing) &&
ground.itemCount() == 0,
"putDown sans objet porte : refus, rien depose");
inventory.add(GroundItemKind::Branch, 1);
inventory.add(GroundItemKind::Stone, 3);
check(chooseKindToPutDown(inventory, GroundItemKind::Stone, &kind) &&
kind == GroundItemKind::Stone,
"Le dernier ramasse est pose en priorite");
check(chooseKindToPutDown(inventory, GroundItemKind::Resin, &kind) &&
kind == GroundItemKind::Branch,
"Sinon la premiere nature portee (ordre de l'enum)");
for (int i = 0; i < 3; ++i) {
check(putDown(inventory, ground, GroundItemKind::Stone, player, facing),
"Pierre reposee " + std::to_string(i + 1));
}
check(inventory.count(GroundItemKind::Stone) == 0 && ground.itemCount() == 3,
"Trois pierres passees de l'inventaire au sol");
checkNear(ground.items()[0].position.z, -kPutDownDistance, 1e-5f,
"Premier objet pose a 0,9 m devant");
checkNear(ground.items()[0].position.y, kStoneRadius, 1e-5f, "Pose sur la surface");
bool distinct = true;
bool inReach = true;
for (std::size_t i = 0; i < ground.itemCount(); ++i) {
const glm::vec3 p = ground.items()[i].position;
if (std::sqrt(p.x * p.x + p.z * p.z) > kCraftReach) inReach = false;
for (std::size_t j = i + 1; j < ground.itemCount(); ++j) {
if (glm::length(p - ground.items()[j].position) < 0.2f) distinct = false;
}
}
check(distinct, "Objets reposes decales (pas de superposition exacte)");
check(inReach, "Objets reposes a portee de faconnage");
check(!putDown(inventory, ground, GroundItemKind::Hearth, player, facing),
"Un foyer ne se 'repose' pas");
// Le cycle complet du foyer au clavier : ramasser -> reposer -> C.
inventory.add(GroundItemKind::Branch, 1); // 2 branches
inventory.add(GroundItemKind::Flake, 1);
putDown(inventory, ground, GroundItemKind::Branch, player, facing);
putDown(inventory, ground, GroundItemKind::Branch, player, facing);
HearthSet hearths;
const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.0f);
check(o.result == CraftResult::Success && o.recipe == findRecipe("hearth"),
"Reposer 3 pierres et 2 branches puis C : un foyer");
}
// ===========================================================================
// PHASE 28 (Agent 3) : les EFFETS branches sur les systemes existants
// ===========================================================================
void testHearthWarmthEffect() {
section("Phase 28 : chaleur du foyer -> Needs (ambiante corrigee)");
FlatTerrain flat;
Ground ground(flat);
HearthSet hearths;
const glm::vec3 center{ 0.0f, 0.0f, 0.0f };
checkNear(hearths.warmthAt(center), 0.0f, 1e-6f, "Aucun foyer : +0 degre");
ground.drop(GroundItemKind::Hearth, 0.0f, 0.0f, 0.0f, 0.0f);
hearths.addLit(ground.items().back().position, 0.0f);
checkNear(hearths.warmthAt({ 0.0f, 1.7f, 0.0f }), 8.0f, 1e-4f, "Au centre : +8 degres");
checkNear(hearths.warmthAt({ 1.5f, 1.7f, 0.0f }), 6.0f, 1e-4f, "A 1,5 m : +6 degres");
checkNear(hearths.warmthAt({ 0.0f, 1.7f, 3.0f }), 4.0f, 1e-4f, "A 3 m : +4 degres");
checkNear(hearths.warmthAt({ 6.0f, 1.7f, 0.0f }), 0.0f, 1e-4f, "A 6 m : +0 degre");
checkNear(hearths.warmthAt({ 20.0f, 1.7f, 0.0f }), 0.0f, 1e-6f, "A 20 m : +0 degre (jamais negatif)");
// Meme calcul que main.cpp : ambiante meteo + warmthAt, puis Needs.
const auto feltAfter = [&](float warmth, bool sheltered) {
Needs needs;
NeedsContext ctx;
ctx.ambientTemperatureC = 2.0f + warmth;
ctx.windSpeedMps = 5.0f;
ctx.sheltered = sheltered;
for (int i = 0; i < 600; ++i) needs.update(0.1f, ctx);
return std::make_pair(needs.ambientTemperatureC(), needs.temperature());
};
const auto cold = feltAfter(0.0f, false);
const auto warm = feltAfter(hearths.warmthAt({ 1.5f, 1.7f, 0.0f }), false);
checkNear(warm.first, 8.0f, 1e-4f, "Needs recoit l'ambiante corrigee (2 + 6 degres)");
check(warm.second > cold.second,
"Pres d'un feu allume, la jauge de chaleur baisse moins (60 s a 2 degres, vent 5 m/s)");
// Extinction : le feu ne chauffe plus, la cendre tombe.
hearths.update(1.01f, ground);
check(!hearths.hearths()[0].lit, "Foyer eteint apres 1 h de jeu");
checkNear(hearths.warmthAt({ 0.0f, 1.7f, 0.0f }), 0.0f, 1e-6f, "Foyer eteint : +0 degre");
const auto afterOut = feltAfter(hearths.warmthAt({ 1.5f, 1.7f, 0.0f }), false);
checkNear(afterOut.second, cold.second, 1e-6f, "Foyer eteint : jauge identique au froid sans feu");
hearths.relight(0, 2.0f);
checkNear(hearths.warmthAt({ 0.0f, 1.7f, 0.0f }), 8.0f, 1e-4f, "Rallume : +8 degres de nouveau");
// Deux feux s'additionnent (somme dans warmthAt).
ground.drop(GroundItemKind::Hearth, 2.0f, 0.0f, 0.0f, 0.0f);
hearths.addLit(ground.items().back().position, 2.0f);
checkNear(hearths.warmthAt({ 1.0f, 1.7f, 0.0f }), 2.0f * 8.0f * (1.0f - 1.0f / 6.0f), 1e-4f,
"Entre deux feux a 1 m chacun : chaleurs additionnees");
}
void testAxeYieldEffect() {
section("Phase 28 : rendement de la hache -> Forest::scheduleBucking");
Inventory inventory;
check(axeBonusLogs(inventory) == 0, "Sans hache : bonus 0");
inventory.add(GroundItemKind::Axe);
check(axeBonusLogs(inventory) == kAxeBonusLogs && kAxeBonusLogs == 1, "Hache portee : +1 buche");
inventory.add(GroundItemKind::PitchedAxe);
check(axeBonusLogs(inventory) == kPitchedAxeBonusLogs && kPitchedAxeBonusLogs == 2,
"Hache renforcee portee : +2 (le meilleur outil, pas de cumul)");
inventory.remove(GroundItemKind::Axe, 1);
check(axeBonusLogs(inventory) == 2, "Hache renforcee seule : +2");
check(Forest::buckingLogCount(4.0f, 0) == 2, "Arbre de 4 m : 2 buches (inchange)");
check(Forest::buckingLogCount(7.0f, 0) == 2, "Arbre de 7 m : 2 buches (inchange)");
check(Forest::buckingLogCount(12.0f, 0) == 4, "Arbre de 12 m : 4 buches (plafond inchange)");
check(Forest::buckingLogCount(7.0f, 1) == 3 && Forest::buckingLogCount(12.0f, 1) == 5,
"Hache : 3..5 au lieu de 2..4 (conception P3)");
check(Forest::buckingLogCount(12.0f, 2) == 6, "Hache renforcee : +2");
// Abattage reel, trois fois le meme arbre (meme graine) : 0, 1, 2 de bonus.
const auto fellAndCount = [](int bonus, std::size_t* branchesOut, bool* felledOut) {
FlatTerrain flat;
Ground ground(flat);
ForestParams params;
params.treeCount = 0;
Forest forest(flat, ground, 50.0f, params);
forest.plantTree(0.0f, 0.0f, 12.0f);
forest.setBuckingBonusLogs(bonus);
*felledOut = forest.fell(0);
for (int i = 0; i < 60 * 30 && (forest.trees()[0].state != TreeState::Fallen ||
forest.pendingDropCount() > 0); ++i) {
forest.update(1.0f / 60.0f);
}
*branchesOut = static_cast<std::size_t>(countKind(ground, GroundItemKind::Branch));
return countKind(ground, GroundItemKind::Log);
};
std::size_t b0 = 0, b1 = 0, b2 = 0;
bool f0 = false, f1 = false, f2 = false;
const int l0 = fellAndCount(0, &b0, &f0);
const int l1 = fellAndCount(1, &b1, &f1);
const int l2 = fellAndCount(2, &b2, &f2);
check(f0, "Abattage SANS hache toujours possible (scenario A intact)");
check(l0 == 4 && b0 == 4, "Sans hache : 4 buches + 4 branches (Phase 5, inchange)");
check(l1 == 5 && b1 == 4, "Avec hache : 5 buches, branches inchangees");
check(l2 == 6 && b2 == 4, "Avec hache renforcee : 6 buches");
check(f1 && f2, "Avec hache : l'abattage lui-meme est inchange");
// Negatif borne a 0.
FlatTerrain flat;
Ground ground(flat);
ForestParams params;
params.treeCount = 0;
Forest forest(flat, ground, 50.0f, params);
forest.setBuckingBonusLogs(-3);
check(forest.buckingBonusLogs() == 0, "Bonus negatif ramene a 0");
}
void testShelterEffect() {
section("Phase 28 : abri (4 buches + 6 branches + 2 ligatures) -> NeedsContext::sheltered");
FlatTerrain flat;
Ground ground(flat);
HearthSet hearths;
Inventory inventory;
const glm::vec3 player{ 0.0f, 1.7f, 0.0f };
const glm::vec3 facing{ 1.0f, 0.0f, 0.0f };
check(!shelterNear(ground, player), "Aucun abri : non abrite");
// Ingredients poses en cercle (dans les 2,5 m), sauf UNE ligature.
const auto ring = [&](GroundItemKind kind, int n, float radius, float phase) {
for (int i = 0; i < n; ++i) {
const float a = phase + 6.2831853f * static_cast<float>(i) / static_cast<float>(n);
ground.drop(kind, radius * std::cos(a), radius * std::sin(a), 0.0f, 0.0f);
}
};
ring(GroundItemKind::Log, 4, 1.5f, 0.0f);
ring(GroundItemKind::Branch, 6, 1.0f, 0.3f);
ring(GroundItemKind::Cord, 1, 0.6f, 0.0f);
{
const Ground before = ground;
const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.0f);
check(o.result == CraftResult::MissingIngredients && o.recipe == findRecipe("shelter"),
"Une ligature manque : refus, recette la plus proche = abri");
check(o.message.find("ligature") != std::string::npos, "Le refus nomme la ligature");
check(sameGround(ground, before), "Refus : sol intact");
}
ring(GroundItemKind::Cord, 1, 0.6f, 3.14159265f); // diametralement opposee : barycentre au centre
const CraftOutcome o = craftAt(inventory, ground, hearths, player, facing, 0.0f);
check(o.result == CraftResult::Success && o.recipe == findRecipe("shelter"), "Abri construit");
check(countKind(ground, GroundItemKind::Log) == 0 && countKind(ground, GroundItemKind::Branch) == 0 &&
countKind(ground, GroundItemKind::Cord) == 0,
"4 buches, 6 branches, 2 ligatures consommees (et pas le feu : aucun foyer)");
check(countKind(ground, GroundItemKind::Shelter) == 1, "Un abri au sol");
const GroundItem* shelter = firstOfKind(ground, GroundItemKind::Shelter);
check(shelter != nullptr && std::abs(shelter->position.x) < 1e-3f &&
std::abs(shelter->position.z) < 1e-3f,
"L'abri nait au barycentre des ingredients (ici le centre)");
check(shelter != nullptr && std::abs(shelter->position.y - kShelterRadius) < 1e-4f,
"L'abri repose sur le sol");
check(ground.findNearest(player, 2.5f) == kNoGroundItem, "L'abri ne se ramasse pas");
// L'effet : a portee horizontale et verticale.
check(shelterNear(ground, player), "Sous l'abri : abrite");
check(shelterNear(ground, { 2.4f, 1.7f, 0.0f }), "A 2,4 m : abrite");
check(!shelterNear(ground, { 2.6f, 1.7f, 0.0f }), "A 2,6 m : non abrite");
check(!shelterNear(ground, { 0.0f, 40.0f, 0.0f }), "Survol a 40 m : non abrite");
// Needs : +5 degres ressentis et vent annule (Needs.cpp), rien d'autre.
Needs outside;
Needs inside;
NeedsContext ctx;
ctx.ambientTemperatureC = 0.0f;
ctx.windSpeedMps = 8.0f;
outside.update(0.1f, ctx);
ctx.sheltered = shelterNear(ground, player);
inside.update(0.1f, ctx);
check(inside.feltTemperatureC() > outside.feltTemperatureC() + 5.0f,
"Abrite : ressenti > dehors + 5 degres (abri + vent annule)");
checkNear(inside.ambientTemperatureC(), outside.ambientTemperatureC(), 1e-6f,
"L'abri ne change pas l'ambiante, seulement le ressenti");
// Mesh de l'abri : valide, pose au sol, dans ses demi-dimensions.
const MeshData mesh = shelterMeshData();
bool valid = !mesh.empty() && mesh.indices.size() % 3 == 0;
float minY = 1e9f, maxY = -1e9f;
bool inBox = true;
for (const uint32_t i : mesh.indices) if (i >= mesh.vertices.size()) valid = false;
for (const Vertex& v : mesh.vertices) {
minY = std::min(minY, v.pos.y);
maxY = std::max(maxY, v.pos.y);
if (std::abs(v.pos.x) > kShelterHalfWidth + 1e-3f || std::abs(v.pos.z) > kShelterHalfDepth + 1e-3f)
inBox = false;
if (std::abs(glm::length(v.normal) - 1.0f) > 1e-3f) valid = false;
}
check(valid, "Mesh de l'abri valide (indices, normales)");
checkNear(minY, -kShelterRadius, 0.01f, "Abri : bas du mesh = -rayon (pose au sol)");
check(maxY <= kShelterRadius + 1e-3f, "Abri : tient dans sa demi-hauteur");
check(inBox, "Abri : tient dans son emprise");
// Hache renforcee : hache + poix posees.
Ground g2(flat);
g2.drop(GroundItemKind::Axe, 0.5f, 0.0f, 0.0f, 0.0f);
g2.drop(GroundItemKind::Pitch, -0.5f, 0.0f, 0.0f, 0.0f);
const CraftOutcome pa = craftAt(inventory, g2, hearths, player, facing, 0.0f);
check(pa.result == CraftResult::Success && pa.recipe == findRecipe("pitched_axe"),
"Hache + poix posees : hache renforcee");
check(countKind(g2, GroundItemKind::PitchedAxe) == 1 && countKind(g2, GroundItemKind::Axe) == 0 &&
countKind(g2, GroundItemKind::Pitch) == 0,
"Hache et poix consommees, hache renforcee au sol");
}
// ===========================================================================
// PHASE 29 (Agent 2) : rochers et pierriers
// ===========================================================================
// Versant a pente constante `slope` le long de +X, rendu RUGUEUX par une grille
// d'aleas de +/- `bump` m au pas de 1 m (interpolee bilineairement, comme un DTM).
class RoughSlope : public HeightSampler {
public:
RoughSlope(float slope, float bump) : slope_(slope), bump_(bump) {}
float heightAt(float x, float z) const override {
const float fx = std::floor(x), fz = std::floor(z);
const float tx = x - fx, tz = z - fz;
const auto n = [&](float a, float b) {
uint32_t h = (static_cast<uint32_t>(static_cast<int32_t>(a)) * 0x9E3779B1u) ^
(static_cast<uint32_t>(static_cast<int32_t>(b)) * 0x85EBCA77u);
h ^= h >> 15; h *= 0x2c1b3c6du; h ^= h >> 12; h *= 0x297a2d39u; h ^= h >> 15;
return (static_cast<float>(h >> 8) / 16777216.0f * 2.0f - 1.0f) * bump_;
};
const float v = glm::mix(glm::mix(n(fx, fz), n(fx + 1.0f, fz), tx),
glm::mix(n(fx, fz + 1.0f), n(fx + 1.0f, fz + 1.0f), tx), tz);
return 1500.0f + slope_ * x + v;
}
private:
float slope_, bump_;
};
// Pente qui CROIT avec x (h = k u^2 / 2 -> pente = k u) : le masque 0,60-0,84 y
// est une bande, et tout ce qui en sort doit rester vide.
class RampingSlope : public HeightSampler {
public:
float heightAt(float x, float) const override {
const float u = x + 2000.0f; // pente 0,60 a x = -500, 0,84 a x = +100
return 1200.0f + 0.5f * 0.0004f * u * u;
}
};
void testRockMeshes() {
section("Phase 29 : meshes de rochers (bloc, rocher, pierraille)");
const MeshData meshes[3] = { boulderMeshData(), rockMeshData(), gravelMeshData() };
const char* names[3] = { "gros bloc", "rocher moyen", "pierraille" };
for (int m = 0; m < 3; ++m) {
const MeshData& mesh = meshes[m];
bool ok = !mesh.empty() && mesh.indices.size() % 3 == 0;
glm::vec3 lo(1e9f), hi(-1e9f);
for (uint32_t index : mesh.indices) { ok = ok && index < mesh.vertices.size(); }
for (const Vertex& v : mesh.vertices) {
ok = ok && std::isfinite(v.pos.x) && std::isfinite(v.pos.y) && std::isfinite(v.pos.z);
ok = ok && std::abs(glm::length(v.normal) - 1.0f) < 1e-3f;
lo = glm::min(lo, v.pos);
hi = glm::max(hi, v.pos);
}
std::printf(" (%s : %u triangles, y %.2f..%.2f, emprise %.2f x %.2f)\n", names[m],
mesh.triangleCount(), lo.y, hi.y, hi.x - lo.x, hi.z - lo.z);
check(ok, std::string("Mesh ") + names[m] + " : indices, normales et positions valides");
check(mesh.triangleCount() >= 16 && mesh.triangleCount() <= 1200,
std::string("Mesh ") + names[m] + " : bas-poly (16 a 1200 triangles)");
check(lo.y < 0.0f && hi.y > 0.0f,
std::string("Mesh ") + names[m] + " : en partie ENTERRE sous l'origine (pas de flottement en pente)");
if (m < 2) {
check(hi.y <= kRockVisibleHeight + 1e-3f && hi.y > 0.45f,
std::string("Mesh ") + names[m] + " : hauteur visible sous 0,70 (x echelle)");
check(std::max(hi.x - lo.x, hi.z - lo.z) <= 2.0f * kRockFootprintRadius + 0.05f,
std::string("Mesh ") + names[m] + " : empreinte dans le rayon de collision");
} else {
check(hi.y < 0.15f && std::max(hi.x - lo.x, hi.z - lo.z) <= 1.2f,
"Mesh pierraille : plaque basse d'un metre environ");
}
}
check(meshes[0].triangleCount() > meshes[1].triangleCount(),
"Variantes distinctes : le gros bloc est plus detaille que le rocher moyen");
}
void testRockPlacement() {
section("Phase 29 : semis des pierriers (masque, determinisme, densite, LOD, collision)");
const RockParams defaults;
ConstantMap bare(0.0f);
ConstantMap wooded(0.3f);
// --- Pack / unpack de l'inclinaison ---------------------------------------
{
bool ok = true;
for (float gx = -0.9f; gx <= 0.9f; gx += 0.13f) {
for (float gz = -0.9f; gz <= 0.9f; gz += 0.17f) {
const float packed = packRockVariation(0.37f, { gx, gz });
const glm::vec2 g = unpackRockGradient(packed);
ok = ok && std::abs(g.x - gx) <= 1.0f / 63.0f + 1e-4f &&
std::abs(g.y - gz) <= 1.0f / 63.0f + 1e-4f &&
std::abs(unpackRockTint(packed) - 0.37f) < 2e-3f;
}
}
check(ok, "Inclinaison encodee dans variation : gradient a 1/63 pres, teinte conservee");
}
// --- Masque : chaque critere de la conception, isolement -----------------
{
FlatTerrain flat(1500.0f);
SlopedTerrain gentle(1500.0f, 0.50f), scree(1500.0f, 0.72f), wall(1500.0f, 0.95f);
Rocks onFlat(flat, &bare, 1000.0f), onGentle(gentle, &bare, 1000.0f),
onScree(scree, &bare, 1000.0f), onWall(wall, &bare, 1000.0f),
wooded72(scree, &wooded, 1000.0f), noMap(scree, nullptr, 1000.0f);
check(onScree.maskAt(10.0f, 10.0f), "Masque : pente 0,72 nue -> pierrier");
check(!onFlat.maskAt(10.0f, 10.0f), "Masque : terrain plat -> non");
check(!onGentle.maskAt(10.0f, 10.0f), "Masque : pente 0,50 (< kWalkComfortSlope) -> non");
check(!onWall.maskAt(10.0f, 10.0f), "Masque : pente 0,95 (>= kWalkMaxSlope, paroi) -> non");
check(!wooded72.maskAt(10.0f, 10.0f), "Masque : couvert 0,30 (>= 0,10) -> non");
check(!noMap.enabled() && !noMap.maskAt(10.0f, 10.0f) &&
noMap.blockCellRocks(0, 0).empty() && noMap.gravelCellRocks(0, 0).empty(),
"Sans carte de couvert : AUCUN rocher (pas de semis sans donnee reelle)");
SlopedTerrain edgeMin(1500.0f, kWalkComfortSlope + 0.002f);
SlopedTerrain edgeMax(1500.0f, kWalkMaxSlope + 0.002f);
check(Rocks(edgeMin, &bare, 1000.0f).maskAt(0.0f, 0.0f) &&
!Rocks(edgeMax, &bare, 1000.0f).maskAt(0.0f, 0.0f),
"Masque : bornes [kWalkComfortSlope, kWalkMaxSlope[ respectees");
checkNear(onScree.roughnessAt(3.0f, 7.0f), 0.0f, 1e-2f, "Rugosite d'un plan incline : nulle");
}
// --- Jamais hors masque, sur un relief ou le masque est une bande -------
{
RampingSlope ramp;
HalfCoveredMap half; // boise a l'est de x = 0
Rocks rocks(ramp, &half, 2400.0f);
uint32_t total = 0, outside = 0, badY = 0;
const auto inspect = [&](const std::vector<RockInstance>& list) {
for (const RockInstance& r : list) {
++total;
outside += rocks.maskAt(r.position.x, r.position.z) ? 0u : 1u;
// Bande attendue : pente 0,6..0,84 -> x = -500..100, nue a l'ouest de 0.
outside += (r.position.x < -505.0f || r.position.x > 0.0f) ? 1u : 0u;
badY += std::abs(r.position.y - ramp.heightAt(r.position.x, r.position.z)) > 1e-2f ? 1u : 0u;
}
};
for (int32_t cz = -20; cz <= 20; ++cz) {
for (int32_t cx = -150; cx <= 60; ++cx) { inspect(rocks.blockCellRocks(cx, cz)); }
}
for (int32_t cz = -40; cz <= 40; ++cz) {
for (int32_t cx = -600; cx <= 240; cx += 3) { inspect(rocks.gravelCellRocks(cx, cz)); }
}
std::printf(" (%u rochers semes sur la bande, %u hors masque)\n", total, outside);
check(total > 50, "Bande de pierrier : des rochers sont bien semes");
check(outside == 0, "AUCUN rocher hors masque (pente, couvert) sur toute la bande");
check(badY == 0, "Chaque rocher est pose sur le terrain (y = altitude du sol)");
}
// --- Rugosite -> choix du mesh -------------------------------------------
RoughSlope rough(0.72f, 0.50f);
SlopedTerrain smooth(1500.0f, 0.72f);
{
Rocks onRough(rough, &bare, 1000.0f), onSmooth(smooth, &bare, 1000.0f);
std::printf(" (rugosite du versant bossele : %.3f m)\n", onRough.roughnessAt(5.5f, 5.5f));
check(onRough.roughnessAt(5.5f, 5.5f) >= defaults.roughBlocks,
"Rugosite d'un versant bossele (+/- 0,50 m) : >= 0,10 m");
uint32_t roughBlocks = 0, roughGravel = 0, smoothBlocks = 0, smoothGravel = 0;
for (int32_t cz = -8; cz <= 8; ++cz) {
for (int32_t cx = -8; cx <= 8; ++cx) {
roughBlocks += static_cast<uint32_t>(onRough.blockCellRocks(cx, cz).size());
smoothBlocks += static_cast<uint32_t>(onSmooth.blockCellRocks(cx, cz).size());
roughGravel += static_cast<uint32_t>(onRough.gravelCellRocks(cx, cz).size());
smoothGravel += static_cast<uint32_t>(onSmooth.gravelCellRocks(cx, cz).size());
}
}
std::printf(" (rugueux : %u blocs / %u plaques ; lisse : %u blocs / %u plaques)\n",
roughBlocks, roughGravel, smoothBlocks, smoothGravel);
check(roughBlocks > 0 && smoothBlocks == 0, "Blocs seulement sur le rugueux (>= 0,10 m)");
check(smoothGravel > 0 && roughGravel == 0, "Pierraille seulement sur le lisse (< 0,10 m)");
}
// --- Determinisme, bornes de densite, trainees ---------------------------
{
Rocks a(rough, &bare, 1000.0f), b(rough, &bare, 1000.0f);
RockParams other;
other.seed = 12345u;
Rocks c(rough, &bare, 1000.0f, other);
bool same = true, differs = false, bounded = true;
uint32_t empty = 0, cells = 0;
for (int32_t cz = -12; cz <= 12; ++cz) {
for (int32_t cx = -12; cx <= 12; ++cx) {
const auto ra = a.blockCellRocks(cx, cz);
const auto rb = b.blockCellRocks(cx, cz);
const auto rc = c.blockCellRocks(cx, cz);
same = same && ra.size() == rb.size();
for (std::size_t i = 0; same && i < ra.size(); ++i) {
same = ra[i].position == rb[i].position && ra[i].scale == rb[i].scale &&
ra[i].yaw == rb[i].yaw && ra[i].variation == rb[i].variation;
}
differs = differs || rc.size() != ra.size() ||
(!ra.empty() && ra[0].position != rc[0].position);
bounded = bounded && ra.size() <= defaults.boulderSlots + defaults.stoneSlots;
uint32_t boulders = 0;
for (const RockInstance& r : ra) {
boulders += (r.kind == RockKind::Boulder) ? 1u : 0u;
bounded = bounded && r.scale >= defaults.stoneSizeMin - 1e-4f &&
r.scale <= defaults.boulderSizeMax + 1e-4f;
}
bounded = bounded && boulders <= defaults.boulderSlots;
++cells;
empty += ra.empty() ? 1u : 0u;
}
}
check(same, "Determinisme : meme graine -> memes rochers, au bit pres");
check(differs, "Graine differente -> semis different");
check(bounded, "Densite bornee : <= boulderSlots + stoneSlots par cellule, tailles dans les bornes");
std::printf(" (%u cellules sous masque : %u vides)\n", cells, empty);
check(empty > 0 && empty < cells, "Trainees : le bruit module la densite (cellules vides ET peuplees sous masque)");
const Rocks::Stats st = a.estimate(3);
std::printf(" (estimation : masque %.2f, %.1f blocs/ha, %.1f rochers/ha)\n",
st.maskFraction, st.bouldersPerHa, st.stonesPerHa);
check(st.maskFraction > 0.6, "Estimation : versant bossele majoritairement sous masque");
check(st.bouldersPerHa > 0.0 &&
st.bouldersPerHa <= 1e4 * defaults.boulderSlots / (defaults.blockCell * defaults.blockCell),
"Estimation : densite de gros blocs > 0 et sous le plafond des emplacements");
// Anisotropie : la densite varie moins le long de la pente (x) qu'en travers (z).
double alongVar = 0.0, acrossVar = 0.0;
for (int i = 0; i < 400; ++i) {
const float p = static_cast<float>(i) * 2.0f - 400.0f;
alongVar += std::abs(a.streakDensityAt(p + 2.0f, 37.0f) - a.streakDensityAt(p, 37.0f));
acrossVar += std::abs(a.streakDensityAt(37.0f, p + 2.0f) - a.streakDensityAt(37.0f, p));
}
std::printf(" (variation de densite : le long %.2f, en travers %.2f)\n", alongVar, acrossVar);
check(acrossVar > 1.5 * alongVar, "Trainees allongees dans le sens de la pente");
}
// --- LOD de densite par distance, rendu, inclinaison ---------------------
{
Rocks rocks(rough, &bare, 1000.0f);
std::vector<InstanceData> boulders, stones, gravel;
const glm::vec3 eye(0.0f, rough.heightAt(0.0f, 0.0f) + 1.7f, 0.0f);
for (int i = 0; i < 60; ++i) {
rocks.gather(eye, permissiveFrustum(), boulders, stones, gravel);
}
float maxBoulder = 0.0f, maxStone = 0.0f;
bool faded = true, tilt = true;
for (const InstanceData& inst : boulders) {
maxBoulder = std::max(maxBoulder, glm::length(inst.position - eye));
faded = faded && inst.fade >= 0.0f && inst.fade <= 1.0f;
const glm::vec2 g = unpackRockGradient(inst.variation);
tilt = tilt && std::abs(g.x - 0.72f * defaults.tiltFollow) < 0.25f && std::abs(g.y) < 0.25f;
}
for (const InstanceData& inst : stones) {
maxStone = std::max(maxStone, glm::length(inst.position - eye));
}
std::printf(" (%zu gros blocs jusqu'a %.0f m, %zu rochers jusqu'a %.0f m)\n",
boulders.size(), maxBoulder, stones.size(), maxStone);
check(!boulders.empty() && !stones.empty(), "Rendu : des instances de blocs et de rochers");
check(maxStone < defaults.stoneDistanceFar && maxBoulder < defaults.boulderDistanceFar,
"LOD : aucune instance au-dela de sa portee");
check(maxBoulder > defaults.stoneDistanceFar, "LOD : les gros blocs portent plus loin que les rochers");
check(faded, "LOD : attenuation dans [0,1]");
check(tilt, "Orientation : gradient encode = pente du sol x tiltFollow");
check(gravel.empty(), "Versant rugueux : pas de pierraille rendue");
check(rocks.cachedBlockCount() > 0, "Cache de cellules actif");
Rocks smoothRocks(smooth, &bare, 1000.0f);
const glm::vec3 eye2(0.0f, smooth.heightAt(0.0f, 0.0f) + 1.7f, 0.0f);
for (int i = 0; i < 30; ++i) {
smoothRocks.gather(eye2, permissiveFrustum(), boulders, stones, gravel);
}
float maxGravel = 0.0f;
uint32_t nearCount = 0, farCount = 0;
for (const InstanceData& inst : gravel) {
const float d = glm::length(inst.position - eye2);
maxGravel = std::max(maxGravel, d);
if (d < 30.0f) { ++nearCount; } else { ++farCount; }
}
std::printf(" (pierraille : %zu plaques, %u a < 30 m, %u au-dela, max %.0f m)\n",
gravel.size(), nearCount, farCount, maxGravel);
check(!gravel.empty() && maxGravel < defaults.gravelDistanceFar, "LOD pierraille : portee courte respectee");
const double nearArea = 3.14159 * 30.0 * 30.0;
const double farArea = 3.14159 * (70.0 * 70.0 - 30.0 * 30.0);
check(static_cast<double>(nearCount) / nearArea > static_cast<double>(farCount) / farArea,
"LOD de DENSITE : la pierraille s'eclaircit avec la distance");
}
// --- Collision des gros blocs ---------------------------------------------
{
Rocks rocks(rough, &bare, 1000.0f);
RockParams noCol;
noCol.collide = false;
Rocks ghost(rough, &bare, 1000.0f, noCol);
RockInstance big;
bool haveBig = false;
for (int32_t cz = -8; cz <= 8 && !haveBig; ++cz) {
for (int32_t cx = -8; cx <= 8 && !haveBig; ++cx) {
for (const RockInstance& r : rocks.blockCellRocks(cx, cz)) {
if (r.kind == RockKind::Boulder && r.scale >= defaults.collideMinScale) {
big = r;
haveBig = true;
break;
}
}
}
}
check(haveBig, "Collision : un gros bloc bloquant existe sur le versant rugueux");
if (haveBig) {
BodyCylinder body;
body.position = { big.position.x + 0.1f, big.position.y + 1.7f, big.position.z };
body.feetY = big.position.y;
body.headY = big.position.y + 1.8f;
check(rocks.overlaps(body), "Collision : le joueur dans un gros bloc est detecte");
BodyCylinder pushed = body;
pushed.position = rocks.resolve(body);
check(!rocks.overlaps(pushed), "Collision : resolve() sort le joueur du bloc");
check(!ghost.overlaps(body), "TEMOIN --no-rock-collision : bloc traversable");
BodyCylinder flying = body;
flying.feetY = big.position.y + big.scale + 5.0f;
flying.headY = flying.feetY + 1.8f;
check(!rocks.overlaps(flying), "Collision : un corps au-dessus du bloc (parapente) passe");
CompositeCollisionSolver composite;
composite.add(&rocks);
check(composite.overlaps(body), "Collision : branchee par le CompositeCollisionSolver existant");
}
FlatTerrain flat(1500.0f);
Rocks none(flat, &bare, 1000.0f);
BodyCylinder body;
body.position = { 3.0f, 1501.7f, 3.0f };
body.feetY = 1500.0f;
body.headY = 1501.8f;
check(!none.overlaps(body) && none.resolve(body) == body.position,
"Collision : terrain plat (hors masque) -> aucun obstacle");
}
}
// ===========================================================================
// PHASE 29 (Agent 3) : buissons et petits arbres (classe 3 LiDAR)
// ===========================================================================
// F3 qui croit avec x : 0 a x = -400, 0,40 a x = +400 (le seuil 0,10 tombe a -200).
class LowVegRampX : public HeightSampler {
public:
float heightAt(float x, float) const override {
return glm::clamp((x + 400.0f) / 800.0f * 0.40f, 0.0f, 0.40f);
}
};
// Couvert = F3 + F45, F45 croissant avec z : 0 a z = -400, 0,40 a z = +400
// (le seuil F45 0,20 tombe a z = 0).
class CoverRampXZ : public HeightSampler {
public:
float heightAt(float x, float z) const override {
return LowVegRampX().heightAt(x, z) + glm::clamp((z + 400.0f) / 800.0f * 0.40f, 0.0f, 0.40f);
}
};
void testBushMeshes() {
section("Phase 29 (Agent 3) : meshes de buisson et de petit arbre");
const MeshData meshes[2] = { shrubMeshData(), smallTreeMeshData() };
const char* names[2] = { "buisson", "petit arbre" };
const float radii[2] = { kShrubFootprintRadius, kSmallTreeFootprintRadius };
for (int m = 0; m < 2; ++m) {
const MeshData& mesh = meshes[m];
bool ok = !mesh.empty() && mesh.indices.size() % 3 == 0;
glm::vec3 lo(1e9f), hi(-1e9f);
float radial = 0.0f;
for (uint32_t index : mesh.indices) { ok = ok && index < mesh.vertices.size(); }
for (const Vertex& v : mesh.vertices) {
ok = ok && std::isfinite(v.pos.x) && std::isfinite(v.pos.y) && std::isfinite(v.pos.z);
ok = ok && std::abs(glm::length(v.normal) - 1.0f) < 1e-3f;
lo = glm::min(lo, v.pos);
hi = glm::max(hi, v.pos);
radial = std::max(radial, std::sqrt(v.pos.x * v.pos.x + v.pos.z * v.pos.z));
}
std::printf(" (%s : %u triangles, y %.3f..%.3f, rayon %.2f)\n", names[m],
mesh.triangleCount(), lo.y, hi.y, radial);
check(ok, std::string("Mesh ") + names[m] + " : indices, normales et positions valides");
check(mesh.triangleCount() >= 16 && mesh.triangleCount() <= 400,
std::string("Mesh ") + names[m] + " : bas-poly (16 a 400 triangles)");
checkNear(hi.y, 1.0f, 1e-3f, std::string("Mesh ") + names[m] + " : hauteur unite (echelle = hauteur)");
check(lo.y < 0.0f && lo.y >= -kBushBuriedDepth - 1e-4f,
std::string("Mesh ") + names[m] + " : pied legerement enterre, pas davantage");
check(radial <= radii[m] + 1e-3f,
std::string("Mesh ") + names[m] + " : emprise dans le rayon annonce");
}
check(meshes[0].triangleCount() != meshes[1].triangleCount(), "Deux variantes distinctes");
}
void testBushPlacement() {
section("Phase 29 (Agent 3) : semis des buissons (critere classe 3, determinisme, bornes)");
const BushParams P;
FlatTerrain flat(1500.0f);
ConstantMap h25(2.5f), h0(0.0f), h10(10.0f), h12(1.2f);
// --- Critere, isole -------------------------------------------------------
{
ConstantMap f20(0.20f), f05(0.05f), c30(0.30f), c45(0.45f), c08(0.08f);
Bushes yes(flat, &f20, &h25, &c30, 1000.0f), lowF3(flat, &f05, &h25, &c30, 1000.0f),
wooded(flat, &f20, &h25, &c45, 1000.0f), noF3(flat, nullptr, &h25, &c30, 1000.0f),
noH(flat, &f20, nullptr, &c30, 1000.0f), noCover(flat, &f20, &h25, nullptr, 1000.0f),
rockish(flat, &f20, &h25, &c08, 1000.0f);
check(yes.maskAt(10.0f, 10.0f), "Critere : F3 0,20 et F45 0,10 -> buisson");
check(!lowF3.maskAt(10.0f, 10.0f), "Critere : F3 0,05 (< 0,10) -> non");
check(!wooded.maskAt(10.0f, 10.0f), "Critere : F45 0,25 (>= 0,20, foret) -> non");
check(!rockish.maskAt(10.0f, 10.0f), "Critere : couvert 0,08 < 0,10 (domaine des rochers) -> non");
check(!noF3.enabled() && !noH.enabled() && !noCover.enabled() &&
noF3.cellBushes(0, 0).empty() && noH.cellBushes(0, 0).empty() &&
noCover.cellBushes(0, 0).empty(),
"Sans l'une des trois cartes : AUCUN buisson (pas de substitut)");
check(!yes.maskAt(995.0f, 0.0f), "Critere : bord du terrain exclu");
Bushes zeroH(flat, &f20, &h0, &c30, 1000.0f);
bool none = true;
for (int32_t c = -5; c <= 5; ++c) { none = none && zeroH.cellBushes(c, c).empty(); }
check(none, "Hauteur classe 3 nulle -> aucun sujet (pas de hauteur inventee)");
}
// --- Aucun buisson hors critere, sur un champ qui traverse les seuils ----
LowVegRampX f3;
CoverRampXZ cover;
Bushes field(flat, &f3, &h25, &cover, 1000.0f);
std::vector<BushInstance> all;
{
bool inside = true;
std::size_t perCellMax = 0;
for (int32_t cz = -60; cz <= 60; ++cz) {
for (int32_t cx = -60; cx <= 60; ++cx) {
const auto cell = field.cellBushes(cx, cz);
perCellMax = std::max(perCellMax, cell.size());
for (const BushInstance& b : cell) {
const float vf3 = f3.heightAt(b.position.x, b.position.z);
const float vc = cover.heightAt(b.position.x, b.position.z);
inside = inside && vf3 >= P.lowVegMin && vc - vf3 < P.highVegMax && vc >= P.rockCoverMax;
all.push_back(b);
}
}
}
std::printf(" (%zu buissons semes sur 968 m x 968 m de champ en rampe)\n", all.size());
check(all.size() > 500, "Le champ en rampe porte bien des buissons");
check(inside, "AUCUN buisson hors critere (F3 >= 0,10, F45 < 0,20, couvert >= 0,10)");
check(perCellMax <= P.slots, "Densite bornee : au plus `slots` sujets par cellule de 8 m");
bool xOk = true, zOk = true;
for (const BushInstance& b : all) {
xOk = xOk && b.position.x >= -200.5f;
zOk = zOk && b.position.z < 0.5f;
}
check(xOk && zOk, "Frontieres du champ reproduites (x >= -200, z < 0)");
}
// --- Densite lineaire en F3 ------------------------------------------------
{
ConstantMap c35(0.35f);
ConstantMap f11(0.11f), f30(0.30f), cs11(0.21f);
Bushes sparse(flat, &f11, &h25, &cs11, 1000.0f), dense(flat, &f30, &h25, &c35, 1000.0f);
std::size_t ns = 0, nd = 0;
for (int32_t cz = -20; cz < 20; ++cz) {
for (int32_t cx = -20; cx < 20; ++cx) {
ns += sparse.cellBushes(cx, cz).size();
nd += dense.cellBushes(cx, cz).size();
}
}
const double cells = 1600.0;
std::printf(" (densite : %.2f / cellule a F3 0,11 ; %.2f a F3 0,30)\n", ns / cells, nd / cells);
check(nd == static_cast<std::size_t>(cells) * P.slots, "F3 >= 0,30 : densite pleine, exactement `slots` par cellule");
check(ns > 0 && ns * 2 < nd, "F3 0,11 : clairseme (moins de la moitie de la densite pleine)");
const double perHa = nd / (cells * P.cell * P.cell / 10000.0);
check(perHa <= 940.0, "Densite plafonnee a ~940 sujets / ha");
}
// --- Hauteur bornee et tiree sous la carte ---------------------------------
{
ConstantMap f30(0.30f), c35(0.35f);
Bushes tall(flat, &f30, &h10, &c35, 1000.0f), low(flat, &f30, &h12, &c35, 1000.0f);
bool tallOk = true, lowOk = true, kindOk = true;
std::size_t smallTrees = 0, shrubs = 0;
for (int32_t c = -30; c < 30; ++c) {
for (const BushInstance& b : tall.cellBushes(c, -c)) {
tallOk = tallOk && b.height >= P.heightMin && b.height <= P.heightMax;
kindOk = kindOk && ((b.kind == BushKind::SmallTree) == (b.height >= P.smallTreeFrom));
(b.kind == BushKind::SmallTree ? smallTrees : shrubs) += 1;
}
for (const BushInstance& b : low.cellBushes(c, c)) {
lowOk = lowOk && b.height >= P.heightMin && b.height <= 1.2f + 1e-4f &&
b.kind == BushKind::Shrub;
}
}
check(tallOk, "Hauteur bornee a [0,5 ; 3] m meme sous 10 m de classe 3");
check(lowOk, "Hauteur <= hauteur max classe 3 de la cellule (1,2 m) -> buissons seulement");
check(kindOk && smallTrees > 0, "Petit arbre si et seulement si hauteur >= 1,8 m");
std::printf(" (sous 10 m : %zu petits arbres, %zu buissons)\n", smallTrees, shrubs);
bool sitOk = true;
for (const BushInstance& b : all) { sitOk = sitOk && b.position.y == 1500.0f; }
check(sitOk, "Pied pose sur le terrain");
}
// --- Determinisme -----------------------------------------------------------
{
Bushes again(flat, &f3, &h25, &cover, 1000.0f);
BushParams other;
other.seed = 7u;
Bushes reseeded(flat, &f3, &h25, &cover, 1000.0f, other);
bool same = true, differs = false;
for (int32_t cz = -30; cz <= 30; ++cz) {
for (int32_t cx = -10; cx <= 40; ++cx) {
const auto a = field.cellBushes(cx, cz);
const auto b = again.cellBushes(cx, cz);
const auto r = reseeded.cellBushes(cx, cz);
same = same && a.size() == b.size();
for (std::size_t i = 0; same && i < a.size(); ++i) {
same = std::memcmp(&a[i].position, &b[i].position, sizeof(glm::vec3)) == 0 &&
a[i].height == b[i].height && a[i].yaw == b[i].yaw && a[i].tint == b[i].tint &&
a[i].kind == b[i].kind && a[i].maxDistance == b[i].maxDistance;
}
if (!a.empty() && (r.empty() || r[0].position != a[0].position)) { differs = true; }
}
}
check(same, "Semis deterministe au bit (deux instances, memes cellules)");
check(differs, "La graine change le semis");
}
// --- Disjoint des rochers ---------------------------------------------------
{
// Pente de pierrier (0,72) et couvert en rampe qui traverse 0,10 :
// aucun buisson la ou Rocks seme.
SlopedTerrain scree(1500.0f, 0.72f);
Bushes onScree(scree, &f3, &h25, &cover, 1000.0f);
Rocks rocks(scree, &cover, 1000.0f);
std::size_t n = 0;
bool disjoint = true, rockZone = false;
for (int32_t cz = -50; cz <= 50; cz += 2) {
for (int32_t cx = -50; cx <= 50; cx += 2) {
for (const BushInstance& b : onScree.cellBushes(cx, cz)) {
++n;
disjoint = disjoint && !rocks.maskAt(b.position.x, b.position.z);
}
rockZone = rockZone || rocks.maskAt(cx * 8.0f + 4.0f, cz * 8.0f + 4.0f);
}
}
check(n > 0 && rockZone, "Test des rochers significatif (buissons ET pierrier presents)");
check(disjoint, "Aucun buisson sous le masque des rochers (disjoints par construction)");
}
// --- Emprise des arbres existants --------------------------------------------
{
ConstantMap f30(0.30f), c35(0.35f);
Bushes open(flat, &f30, &h25, &c35, 1000.0f), guarded(flat, &f30, &h25, &c35, 1000.0f);
guarded.setTreeFootprints({ glm::vec3(20.0f, 20.0f, 6.0f), glm::vec3(-100.0f, 40.0f, 4.0f) });
std::size_t before = 0, inside = 0;
for (int32_t cz = -3; cz <= 8; ++cz) {
for (int32_t cx = -16; cx <= 4; ++cx) {
for (const BushInstance& b : open.cellBushes(cx, cz)) {
before += glm::length(glm::vec2(b.position.x - 20.0f, b.position.z - 20.0f)) < 6.0f ? 1 : 0;
}
for (const BushInstance& b : guarded.cellBushes(cx, cz)) {
inside += glm::length(glm::vec2(b.position.x - 20.0f, b.position.z - 20.0f)) < 6.0f ? 1 : 0;
inside += glm::length(glm::vec2(b.position.x + 100.0f, b.position.z - 40.0f)) < 4.0f ? 1 : 0;
}
}
}
check(before > 0 && inside == 0, "Aucun buisson dans l'emprise d'un arbre abattable");
}
// --- gather : LOD, portee, fondu -----------------------------------------------
{
ConstantMap f30(0.30f), c35(0.35f);
Bushes lod(flat, &f30, &h25, &c35, 2000.0f);
std::vector<InstanceData> shrubs, trees;
const glm::vec3 eye(0.0f, 1502.0f, 0.0f);
for (int i = 0; i < 200; ++i) { lod.gather(eye, permissiveFrustum(), shrubs, trees); }
bool inRange = true;
for (const auto* list : { &shrubs, &trees }) {
const float far = (list == &shrubs) ? P.shrubDistanceFar : P.treeDistanceFar;
for (const InstanceData& d : *list) {
const float dist = glm::length(d.position - eye);
inRange = inRange && dist < far && d.fade >= 0.0f && d.fade <= 1.0f &&
d.scale >= P.heightMin && d.scale <= P.heightMax;
}
}
std::size_t ringNear = 0, ringFar = 0;
for (const InstanceData& d : shrubs) {
const float dist = glm::length(glm::vec2(d.position.x, d.position.z));
if (dist < 50.0f) { ++ringNear; }
if (dist >= 100.0f && dist < 140.0f) { ++ringFar; }
}
const double densNear = ringNear / (3.14159 * 50.0 * 50.0);
const double densFar = ringFar / (3.14159 * (140.0 * 140.0 - 100.0 * 100.0));
std::printf(" (gather : %zu buissons, %zu petits arbres ; densite %.4f/m2 a < 50 m, %.4f a 100-140 m)\n",
shrubs.size(), trees.size(), densNear, densFar);
check(!shrubs.empty() && !trees.empty(), "gather : deux listes instanciees remplies");
check(inRange, "gather : portee, fondu et echelle bornes");
check(densFar < 0.6 * densNear, "LOD de densite : eclaircissement avec la distance");
check(lod.lastShrubCount() == shrubs.size() && lod.lastSmallTreeCount() == trees.size(),
"Compteurs de diagnostic coherents");
}
}
// ---------------------------------------------------------------------------
// PHASE 30 : formats GPU compacts et sous-allocation de la geometrie
// ---------------------------------------------------------------------------
// Ce que le GPU lit n'est plus le format de travail `Vertex` (68 octets) mais
// ObjectVertex (44) et TerrainVertex (16), et toute la geometrie vit dans des
// plages de blocs partages. Rien de cela ne se VOIT si c'est faux d'un octet :
// un decalage d'allocateur ecrase la geometrie d'un voisin, une position
// recalculee differemment fait trembler les jointures de tuiles. D'ou ces
// verifications, faites sans GPU.
void testGpuFormatsPhase30() {
section("Phase 30 : formats GPU compacts et pool de geometrie");
check(sizeof(ObjectVertex) == 44 && sizeof(TerrainVertex) == 16 &&
sizeof(DrawItemPush) == 96,
"Phase 30 : 44 / 16 octets par sommet, 96 octets de push constants");
// --- ObjectVertex : conversion EXACTE -----------------------------------
{
Vertex v{};
v.pos = { 1.25f, -3.5f, 1234.567f };
v.color = { 0.42f, 0.13f, 0.99f };
v.normal = { 0.1f, 0.9f, -0.2f };
v.uv = { 0.333f, 0.777f };
v.morphPos = { 9.0f, 9.0f, 9.0f };
const ObjectVertex o = toObjectVertex(v);
check(o.pos == v.pos && o.color == v.color && o.normal == v.normal && o.uv == v.uv,
"ObjectVertex : position, couleur, normale et UV recopiees au bit pres");
}
// --- snorm16 : la convention de VK_FORMAT_R16_SNORM ---------------------
{
float worst = 0.0f;
for (int k = -2000; k <= 2000; ++k) {
const float value = static_cast<float>(k) / 2000.0f;
worst = std::max(worst, std::abs(unpackSnorm16(packSnorm16(value)) - value));
}
check(worst <= 0.5f / 32767.0f + 1e-7f,
"snorm16 : erreur d'aller-retour d'au plus un demi-pas (1,5e-5)");
check(packSnorm16(1.0f) == 32767 && packSnorm16(-1.0f) == -32767 &&
packSnorm16(7.0f) == 32767 && packSnorm16(-7.0f) == -32767 &&
unpackSnorm16(-32768) == -1.0f,
"snorm16 : bornes et ecretage");
// Normales de champ de hauteur, du plat a la paroi (pente 20) : la
// reconstruction de y depuis x et z quantifies reste a 1e-3 pres
// (et a 1e-4 pres jusqu'a une pente de 5, soit 79 degres).
float worstNormal = 0.0f;
float worstNormalModerate = 0.0f;
for (int a = 0; a < 64; ++a) {
for (int b = 0; b < 16; ++b) {
const float slope = 20.0f * static_cast<float>(b) / 15.0f;
const float angle = 6.2831853f * static_cast<float>(a) / 64.0f;
const glm::vec3 n = glm::normalize(
glm::vec3(-slope * std::cos(angle), 1.0f, -slope * std::sin(angle)));
const int16_t packed[2] = { packSnorm16(n.x), packSnorm16(n.z) };
const float error = glm::length(unpackTerrainNormal(packed) - n);
worstNormal = std::max(worstNormal, error);
if (slope <= 5.0f) {
worstNormalModerate = std::max(worstNormalModerate, error);
}
}
}
check(worstNormal < 1e-3f && worstNormalModerate < 1e-4f,
"TerrainVertex : normale reconstruite a 1e-4 pres jusqu'a 79 degres");
}
// --- Tuiles : le format GPU est le format de reference, compacte --------
// writeTerrainNodeVertices (chemin du streamer) doit rendre EXACTEMENT
// toTerrainVertex(terrainNodeMeshData) pour CHAQUE noeud, grilles paire et
// impaire, avec et sans la grille du parent mise en cache.
{
Heightmap::Params even;
even.resolution = 513;
even.worldSize = 512.0f;
even.seed = 3030u;
Heightmap::Params odd;
odd.resolution = 128;
odd.worldSize = 127.0f;
odd.seed = 3031u;
// Assez grande pour que des tuiles de niveau 2 et 3 soient INTERIEURES
// (chemin rapide de writeTerrainNodeVertices a plusieurs pas).
Heightmap::Params large;
large.resolution = 2049;
large.worldSize = 4096.0f;
large.amplitude = 900.0f;
large.seed = 3033u;
TerrainQuadtree::Params qparams;
qparams.nodeCells = 64;
bool identical = true;
bool positionsExact = true;
bool uvExact = true;
uint32_t nodesChecked = 0;
uint32_t fastNodes = 0;
uint32_t fastStrides = 0; // masque des pas couverts par le chemin rapide
for (const Heightmap::Params& hp : { even, odd, large }) {
const Heightmap heightmap(hp);
const TerrainQuadtree quadtree(heightmap, qparams);
const uint32_t verts = qparams.nodeCells + 1;
const uint32_t cells = heightmap.resolution() - 1;
const float origin = heightmap.worldCoord(0);
std::vector<TerrainVertex> written(static_cast<std::size_t>(verts) * verts);
for (uint32_t index = 0; index < quadtree.nodeCount(); ++index) {
if (terrainNodeUsesFastPath(heightmap, quadtree, index)) {
++fastNodes;
fastStrides |= quadtree.node(index).stride;
}
for (const bool cached : { true, false }) {
const MeshData reference =
terrainNodeMeshData(heightmap, quadtree, index, false, cached);
writeTerrainNodeVertices(heightmap, quadtree, index, written.data(), cached);
for (std::size_t v = 0; v < written.size() && identical; ++v) {
const TerrainVertex expected = toTerrainVertex(reference.vertices[v]);
identical = std::memcmp(&expected, &written[v], sizeof(TerrainVertex)) == 0;
}
}
// Ce que terrain.vert recalcule a partir de gl_VertexIndex et de
// DrawItem::grid : memes indices ecretes, memes operations.
const TerrainQuadtree::Node& node = quadtree.node(index);
const MeshData reference = terrainNodeMeshData(heightmap, quadtree, index, false);
for (uint32_t v = 0; v < verts * verts; ++v) {
const uint32_t i = v % verts;
const uint32_t j = v / verts;
const uint32_t gx = std::min(node.ix0 + i * node.stride, cells);
const uint32_t gz = std::min(node.iz0 + j * node.stride, cells);
const uint32_t mx = std::min(node.ix0 + (i & ~1u) * node.stride, cells);
const uint32_t mz = std::min(node.iz0 + (j & ~1u) * node.stride, cells);
const Vertex& r = reference.vertices[v];
positionsExact = positionsExact &&
terrainGridCoord(origin, heightmap.spacing(), gx) == r.pos.x &&
terrainGridCoord(origin, heightmap.spacing(), gz) == r.pos.z &&
terrainGridCoord(origin, heightmap.spacing(), mx) == r.morphPos.x &&
terrainGridCoord(origin, heightmap.spacing(), mz) == r.morphPos.z;
uvExact = uvExact &&
static_cast<float>(gx) / static_cast<float>(cells) == r.uv.x &&
static_cast<float>(gz) / static_cast<float>(cells) == r.uv.y;
}
++nodesChecked;
}
}
check(nodesChecked > 400, "Tuiles : toutes les tuiles des trois grilles verifiees");
check(fastNodes > 0 && fastNodes < nodesChecked && (fastStrides & 0xFu) == 0xFu,
"Tuiles : chemin rapide ET chemin de reference exerces (pas 1, 2, 4 et 8)");
check(identical,
"Tuiles : writeTerrainNodeVertices == toTerrainVertex(reference), au bit pres");
check(positionsExact,
"Tuiles : x/z et cible de morphing recalcules depuis l'indice, au bit pres");
check(uvExact, "Tuiles : UV recalcule depuis l'indice de grille, au bit pres (CPU)");
const std::vector<uint32_t> topology = terrainNodeIndices(qparams.nodeCells);
check(*std::max_element(topology.begin(), topology.end()) <= 0xFFFFu,
"Tuiles : la topologie partagee tient en uint16");
}
// --- Terrain d'un seul bloc (--no-lod) ------------------------------------
{
Heightmap::Params hp;
hp.resolution = 97;
hp.worldSize = 96.0f;
hp.seed = 3032u;
const Heightmap heightmap(hp);
const MeshData reference = terrainMeshData(heightmap);
const TerrainGpuMesh gpu = terrainGpuMeshData(heightmap);
bool same = gpu.vertices.size() == reference.vertices.size() &&
gpu.indices == reference.indices;
for (std::size_t v = 0; v < gpu.vertices.size() && same; ++v) {
TerrainVertex expected = toTerrainVertex(reference.vertices[v]);
// Sans geomorphing, la cible est le sommet lui-meme (elle valait
// zero dans le format de 68 octets, et n'etait jamais lue).
expected.morphHeight = expected.height;
expected.morphNormal[0] = expected.normal[0];
expected.morphNormal[1] = expected.normal[1];
same = std::memcmp(&expected, &gpu.vertices[v], sizeof(TerrainVertex)) == 0;
}
check(same, "Bloc unique : terrainGpuMeshData == reference compactee, memes indices");
}
// --- RangeAllocator : la logique du pool, sans GPU ----------------------
{
RangeAllocator block(1 << 20);
struct Taken { uint64_t offset; uint64_t size; };
std::vector<Taken> taken;
bool aligned = true;
for (uint64_t k = 0; k < 40; ++k) {
const uint64_t size = 1000 + 777 * (k % 7);
const uint64_t offset = block.allocate(size, 256);
if (offset == RangeAllocator::kInvalid) { aligned = false; break; }
aligned = aligned && (offset % 256 == 0);
taken.push_back({ offset, size });
}
bool disjoint = true;
for (std::size_t a = 0; a < taken.size(); ++a) {
for (std::size_t b = a + 1; b < taken.size(); ++b) {
disjoint = disjoint && (taken[a].offset + taken[a].size <= taken[b].offset ||
taken[b].offset + taken[b].size <= taken[a].offset);
}
}
check(aligned && taken.size() == 40, "RangeAllocator : 40 plages alignees sur 256");
check(disjoint, "RangeAllocator : aucune plage n'en chevauche une autre");
// Un trou laisse par une plage liberee est reutilise par une demande de
// meme taille (le cas des tuiles, toutes de la meme taille).
const Taken hole = taken[10];
block.release(hole.offset, hole.size);
check(block.allocate(hole.size, 256) == hole.offset,
"RangeAllocator : un trou est reutilise par une demande de meme taille");
for (const Taken& t : taken) {
block.release(t.offset, t.size);
}
check(block.empty() && block.freeSpanCount() == 1 &&
block.largestFree() == block.capacity(),
"RangeAllocator : tout liberer refusionne le bloc en une seule plage");
check(block.allocate(block.capacity() + 1, 256) == RangeAllocator::kInvalid &&
block.allocate(16, 3) == RangeAllocator::kInvalid,
"RangeAllocator : demande trop grande ou alignement invalide refuses");
}
}
int main() {
std::printf("=== Tests logiques Vercora (headless, sans Vulkan) ===\n");
testExistingBehaviourStillWorks();
testCollision();
testPickup();
testProgressiveFall();
testStoneKnapping();
testDrawListConstruction();
testTerrainFile();
testParaglider();
testBike();
testClimber();
testWalkSlopeLimit();
testTerrainQuadtree();
testQuadtreeAncestry();
testTextureFile();
testGrassMesh();
testGrassPhase18();
testTileMeshingIsThreadSafe();
testGpuFormatsPhase30();
testVegetationPlacement();
testGrassPlacement();
testInstanceLayout();
testEditorAssets();
testAssetCatalog();
testTerrainRaycast();
testEditorScene();
testEditorSceneCollision();
testEditorScenePick();
testSceneFile();
testEditorController();
testNeeds();
testWaterSources();
testHabitatMemory();
testAnimalMesh();
testWildlife();
testEnvironmentalFootprint();
testWildlifeCollision();
testMineralDeposits();
testResin();
testFiberPlants();
testHarvestMeshes();
testWeather();
testWeatherGameplay();
testWeatherVisuals();
testDetailNoise();
// PHASE 28
testCraftingRecipeTable();
testCraftingKnapUnchanged();
testCraftingCord();
testCraftingHearth();
testCraftingAxe();
testPitchNeedsLitHearth();
testPutDown();
// PHASE 28 (Agent 3) : effets branches
testHearthWarmthEffect();
testAxeYieldEffect();
testShelterEffect();
// PHASE 29 (Agent 2) : rochers et pierriers
testRockMeshes();
testRockPlacement();
// PHASE 29 (Agent 3) : buissons et petits arbres
testBushMeshes();
testBushPlacement();
std::printf("\n=====================================================\n");
if (g_failures == 0) {
std::printf("SUCCES : %d verifications passees.\n", g_checks);
return 0;
}
std::printf("ECHEC : %d verifications sur %d ont echoue.\n", g_failures, g_checks);
return 1;
}