- Formats GPU : le format de travail Vertex (68 o) n'est plus televerse. Objets et vegetation : ObjectVertex 44 o (conversion exacte). Terrain : TerrainVertex 16 o (deux altitudes f32 + deux normales snorm16) ; x/z, cible de morphing et UV sont recalcules par terrain.vert depuis gl_VertexIndex et DrawItem::grid, au bit pres (`precise`). - Topologie des tuiles televersee UNE fois, en uint16 (96 Ko de moins par tuile). Indices des maillages d'objets en uint16. - GpuBufferPool + RangeAllocator : toute la geometrie dans des blocs de 4 Mo ; ecriture DIRECTE en memoire unifiee (GPU integre, lavapipe), staging conserve sur GPU discret (--force-staging pour l'eprouver), barriere ecriture-apres-lecture ajoutee devant les copies (validation de synchronisation a zero). - Rendu : terrain dessine apres la vegetation (early-Z) et culling de ses faces arriere. - Tests : +16 verifications (formats, positions recalculees, allocateur). Survol 900 m/s (lavapipe) : pic GPU 286 -> 89 Mo, geometrie terrain 188 -> 33 Mo, ~17 000 -> 21 vkAllocateMemory, streaming 4,5 -> 1,6 ms par image. Foret : 8,3 -> 12,4 images/s. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
10381 lignes
497 KiB
C++
10381 lignes
497 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");
|
|
}
|
|
|
|
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;
|
|
TerrainQuadtree::Params qparams;
|
|
qparams.nodeCells = 64;
|
|
|
|
bool identical = true;
|
|
bool positionsExact = true;
|
|
bool uvExact = true;
|
|
uint32_t nodesChecked = 0;
|
|
for (const Heightmap::Params& hp : { even, odd }) {
|
|
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) {
|
|
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 > 80, "Tuiles : toutes les tuiles des deux grilles verifiees");
|
|
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;
|
|
}
|