Fichiers
2026-10-11 01:54:18 +02:00

381 lignes
19 KiB
Markdown

# Phase 13 (2026-08-22) : physique du velo
Premiere version de la troisieme activite. Meme intention que le parapente de la
Phase 8 : un modele **simplifie mais credible**, chiffre et testable, pas une
simulation de dynamique du vehicule.
Fichiers neufs : `src/world/Bike.{hpp,cpp}`. Touches par `src/main.cpp`,
`src/core/Camera.{hpp,cpp}`, `tests/logic_tests.cpp`,
`tools/run_vulkan_check.ps1`, `CMakeLists.txt`, `tools/run_logic_tests.bat`.
---
## 1. Le modele
`Bike` ne connait ni Vulkan ni la `Camera`. Il consomme les deux interfaces qui
existaient deja - `core/HeightSampler` pour l'altitude et la pente,
`core/CollisionSolver` pour les obstacles - et produit une position, un cap, une
vitesse et deux angles d'assiette. **Exactement la meme separation que
`Paraglider`**, ce qui lui vaut d'etre compile ET execute dans les tests
headless, sans GPU.
### Dynamique longitudinale
Une somme d'accelerations, integree a chaque pas. Aucun terme n'agit
instantanement sur la vitesse : ni le pedalage, ni le frein.
```
a = -g.sin(theta) pesanteur le long de la pente
+ pedalAcceleration . (1 - v/pedalSpeedLimit) pedalage (nul si on freine)
- brakeDeceleration . brakeInput frein manuel
- rollingResistance - dragCoefficient.v^2 resistances
```
`sin(theta)` et non `tan(theta)` : sur une paroi LiDAR a 300 % la difference est
un facteur trois, et `tan` divergerait. La zone de jeu contient reellement de
telles parois (voir `NOTES-PHASE9.md`).
### Les valeurs, et pourquoi
| parametre | valeur | justification |
|---|---:|---|
| `pedalAcceleration` | 2,6 m/s² | ~250 W au demarrage sur ~95 kg (velo + cycliste) : un cycliste ordinaire en danseuse |
| `pedalSpeedLimit` | 6,5 m/s | au-dela la cadence s'emballe, l'effort n'est plus utile |
| `rollingResistance` | 0,35 m/s² | coeff. ~0,036 : pneu large basse pression sur terre |
| `dragCoefficient` | 0,014 /m | **terme groupe** : aero (~0,004) + sol irregulier + suspension + le fait qu'un vetetiste ne laisse pas filer sa machine. **C'est lui qui fixe les vitesses de pointe**, et c'est le parametre le plus arbitraire du modele |
| `brakeDeceleration` | 6,0 m/s² | ~0,61 g, la limite avant passage par-dessus le guidon |
| `maxSpeed` | 13,9 m/s (50,0 km/h) | plafond absolu ; ne mord qu'au-dela de ~32 % de pente |
| `maxLateralAccel` | 4,0 m/s² | ~0,41 g, adherence d'un pneu large sur terre seche |
| `maxTurnRateDegPerSec` | 140 °/s | manoeuvre pieds a terre ; sans lui la formule de braquage diverge a l'arret |
| `bodyRadius` | 0,45 m | contre 0,35 m a pied : un guidon est plus large que des epaules |
| `slopeSampleStep` | 2,0 m | demi-base de mesure de la pente ; **voir la section 3**, c'est le reglage qui a demande une mesure sur relief reel |
### Les vitesses obtenues — LE chiffre qui compte
Mesurees sur plans inclines, avec le code du jeu (sonde hors ligne, puis
re-verifiees par les tests headless) :
| pente | pedalage a fond | roue libre |
|---:|---:|---:|
| plat | **16,9 km/h** | 0 |
| +5 % | 13,5 km/h | 0 |
| +10 % | **10,0 km/h** | 0 |
| +15 % | 6,2 km/h | 0 |
| +20 % | 2,4 km/h | 0 |
| +25 % | **0 (cale)** | 0 |
| -5 % | 20,2 km/h | 8,6 km/h |
| -10 % | 23,3 km/h | 22,9 km/h |
| -20 % | 37,4 km/h | **37,4 km/h** |
| -30 % | 47,2 km/h | **47,2 km/h** |
| -40 % | 50,0 km/h (plafond) | 50,0 km/h |
La consigne demandait 30-50 km/h en descente et beaucoup moins en montee : c'est
obtenu entre -20 % et -40 %, et la montee tombe a un cinquieme du plat des 15 %.
**Pente maximale franchissable : 23,6 %.** C'est ou `g.sin(theta)` egale
`pedalAcceleration - rollingResistance`. Au-dela, le velo cale et **ne recule
pas** (la vitesse est ecretee a zero). Voir la section 5 : c'est la limite la
plus visible du modele sur ce massif.
Le velo ne part pas non plus tout seul sur une pente faible : a -2 % en roue
libre la resistance au roulement l'emporte, il reste immobile.
### Direction
Rayon de braquage **fini et croissant avec la vitesse** :
```
omega = min( maxLateralAccel / v , maxTurnRateDegPerSec ) R = v² / maxLateralAccel
```
- a 10 m/s : R = 25 m, soit 23 °/s ;
- a 5 m/s : R = 6,3 m, soit 46 °/s ;
- a l'arret : 140 °/s, le plafond - on replace la machine, on ne "tourne" pas.
Impossible, donc, de pivoter sur place a pleine vitesse. Verifie par la mesure :
le test confronte le rayon OBSERVE a `v²/maxLateralAccel`.
### Contact avec le sol et assiette
La verticale **n'est jamais une variable d'etat** : `position.y` est relue de
`heightAt()` a chaque pas, y compris des `mount()`. Le velo ne decolle donc
jamais d'une bosse, par construction et non par reglage.
L'assiette est **purement visuelle** (elle n'entre dans aucun calcul) :
- tangage = `atan` de la pente le long du cap ;
- roulis = devers (`-atan` de la pente en travers) **+** inclinaison en virage
(`atan(a_lat / g)`, l'angle d'equilibre d'un vrai deux-roues).
Les deux sont ecretes a ±45° : une paroi LiDAR verticale coucherait sinon le
marqueur a plat.
### Obstacles : rien n'a ete reecrit
`Bike::update` construit un `BodyCylinder` et appelle **`moveBody()`**, le point
d'entree unique de la collision du projet - le meme que
`Camera::resolveCollisions`, le meme que les tests de la Phase 6. Meme bande
verticale (`feetY` = pieds, `headY` = un peu au-dessus des yeux), donc une souche
basse arrete le velo comme elle arrete les jambes.
Seul ajout : **le choc coute de la vitesse**, proportionnellement a ce que
l'obstacle a mange du pas voulu. Frotter un tronc en le longeant n'en retire
presque rien ; le percuter de face arrete net. C'est la seule consequence d'un
choc dans cette session - ni degats ni chute, explicitement hors scope.
---
## 2. Integration : touche, camera, exclusions
**Touche B** (`kBikeKey` dans `main.cpp`). B occupe la **meme position physique
en AZERTY et en QWERTY** (rangee du bas W-X-C-V-B contre Z-X-C-V-B), donc le
token GLFW tombe sur la touche gravee B des deux cotes - contrairement a W/A qui
donnent Z/Q. Et elle est juste a cote de V, la touche du parapente.
- **B depuis la marche** : en selle, cap = la direction du regard projetee.
- **B a velo** : pied a terre, la camera revient en mode marche sur la position
du velo.
- Pendant la sortie : **Z** pedale, **S** freine, **Q/D** tournent.
- E/R/C (abattre, ramasser, percuter) sont **desactives** a velo, comme en vol.
- On ne peut pas decoller en parapente a velo, ni enfourcher le velo en vol.
**Camera : nouveau mode `CameraMode::Ride`**, troisieme personne, meme contrat
que `Glide` (la camera est passive, elle recoit sa pose par `setChasePose()`).
Un mode distinct et non un alias de `Glide` : les journaux doivent dire lequel
est actif. Choix de la troisieme personne : la meme raison qu'au parapente, la
lisibilite du mouvement - ici l'assiette du velo sur le relief.
Une contrainte que le parapente n'avait pas : **une garde au sol minimale de
1,2 m pour l'oeil**. En descente la camera recule *dans* la pente qu'on vient de
devaler ; sans ce plancher elle passe sous la surface et on voit l'interieur du
terrain.
Une ligne de telemetrie par seconde tant qu'on roule (vitesse, pente sous les
roues, cap, assiette, altitude). Ce n'est pas du confort : c'est la seule facon
pour le harnais automatise de constater que la physique a travaille sur du vrai
relief - un velo bloque a 0 km/h donnerait autrement un run parfaitement vert.
---
## 3. La mesure qui a change le code : `slopeSampleStep`
Le premier reglage - differences finies a ±1 m, le pas de la heightmap - semblait
evident. **Il ne marche pas**, et c'est le run sur relief reel qui l'a montre :
le velo s'immobilisait definitivement au milieu d'un versant qui descend a 27 %.
Depouillement de ce versant (200 m plein nord depuis E 907172 / N 6439790,
dalle `LHD_0907_6440`, descente moyenne de **26,7 %**) :
| demi-base | ecart-type de la pente | sections en **contre**-pente | pic |
|---:|---:|---:|---:|
| **1 m** | 16,4 % | **8,0 %** | **+22,0 %** |
| 2 m | 15,1 % | 6,1 % | +10,5 % |
| **2 m sur 4 m de base (retenu)** | | **1,6 %** | **+1,1 %** |
| 4 m | 14,0 % | 1,6 % | +1,1 % |
A ±1 m, une descente franche presente **8 % de micro-sections montantes a plus de
20 %** - donc au-dela de la pente maximale franchissable (23,6 %). Le velo calait
en pleine descente.
A ±2 m (base de 4 m), ces sections tombent a 1,6 % avec un pic a +1,1 %, **sans
toucher a la pente moyenne** (-26,9 % contre -26,8 %). Ce n'est pas un artifice :
un DTM LiDAR a 1 m porte du bruit decimetrique, et une machine de 1,1 m
d'empattement lancee a 20 km/h ne "sent" pas un creux d'un metre. Au-dela de 4 m
de base on commencerait a effacer de vraies ruptures de pente.
**Autre defaut trouve par la meme voie** : le seuil d'arret (`kSpeedEpsilon`,
2 cm/s) etait applique inconditionnellement apres chaque integration. Consequence
non voulue : il **empechait tout demarrage** dont l'acceleration etait inferieure
a `kSpeedEpsilon / dt`, soit 1,2 m/s² a 60 images/s. Le velo restait cloue a
0 km/h des 10 % de montee, et ne pouvait meme pas se laisser descendre une pente
de 10 % en roue libre, alors que le bilan des accelerations etait franchement
positif. C'est un seuil d'**arret** : il ne s'applique plus que si le bilan des
accelerations est negatif.
Aucun des deux defauts n'etait visible sur un plan incline synthetique. Les deux
ont ete trouves en roulant sur la dalle LiDAR.
---
## 4. Verification
### Tests headless : 334 assertions (280 avant, **+54**)
`tools\run_logic_tests.bat`, sans GPU ni Vulkan. La section Phase 13 ne
re-derive pas les equations - ca ne prouverait que l'accord du test avec
lui-meme - elle **mesure les vitesses d'equilibre reelles** et les confronte aux
fourchettes annoncees. Couvert :
- contact permanent avec le sol, verifie a chacun des 300 pas d'une descente ;
- lecture de la pente le long du cap (montee, descente, en travers) ;
- inertie : une frame de pedalage ne donne qu'une fraction de m/s ; le frein a
fond ne met pas a l'arret en une frame ; distance d'arret plausible ;
- vitesses d'equilibre sur plat, +10 %, +25 % (cale, **et ne recule pas**),
-20 %, -30 %, et **-200 %** (pente extreme : bornee, aucun NaN, aucune
divergence) ;
- roue libre a -2 % : le velo ne part pas tout seul ;
- rayon de braquage fini, croissant avec la vitesse, egal a `v²/a_lat` mesure ;
plafond a l'arret ; sens de rotation dans les deux sens ;
- assiette : tangage sur la pente, devers en travers, inclinaison en virage
(droite et gauche), ecretage sur une paroi ;
- **collision** : le velo n'entre pas dans un tronc, s'arrete au contact, y perd
sa vitesse - **avec temoin** : sans solveur, le meme trajet traverse. Une
souche basse l'arrete aussi ;
- `update()` sans `mount()`, apres `dismount()`, a `deltaTime` nul : sans effet ;
- ecretage des entrees : passer 50 se comporte comme passer 1.
Le temoin de collision merite d'etre souligne : sans lui, un test ou le velo
n'avance pas du tout passerait pour un test de collision reussi.
### Vulkan reel : `run_vulkan_check.ps1`, **5 scenarios sur 5**
Nouveau **scenario E** : sortie a velo sur la dalle LiDAR reelle, sous couches de
validation. **Zero `[Validation]`, zero `[ERROR]`, zero `[WARN]`, codes de sortie
0/0/0/0/0, fermeture propre 5 fois sur 5.**
**Quatre versions du scenario ont ete necessaires**, et les trois premieres ont
echoue chacune pour une raison differente. C'est le vrai contenu de cette
section : ce qu'il faut pour qu'un scenario automatise PROUVE quelque chose.
1. **Depart quelconque.** Le harnais ne sait pas tourner la camera (GLFW lit le
curseur systeme), donc le velo part forcement au cap initial. Lance n'importe
ou, il roule sur du plat : run vert, rien de montre.
2. **Depart sur un versant a -21 %.** La descente marchait, la remontee non : elle
depassait la pente franchissable (23,6 %) et le velo s'immobilisait pour de
bon. C'est ce run qui a mis au jour le reglage de `slopeSampleStep`
(section 3).
3. **Descendre, puis faire demi-tour et remonter la meme ligne.** Piege double.
D'une part, plus la descente est longue - et il lui faut de la longueur pour
que la vitesse se developpe - plus elle depose le velo bas dans le versant, la
ou la pente depasse le franchissable : 18 s de roue libre donnaient 9,2 m de
denivele (trop peu), 30 s en donnaient 24,4 mais aboutissaient a une remontee
a 0,1 km/h. **Incompatibles dans cet ordre.** D'autre part - l'erreur de
raisonnement de fond - **"faire demi-tour" ne redonne pas la pente inverse** :
le terrain de l'autre cote du point de depart est un AUTRE terrain. Sur la
croupe essayee, le nord descendait a -11 %... et le sud descendait aussi, a
-36 %.
**La version retenue evalue la pente le long de CHAQUE cap** (differences
centrees a ±2 m, exactement comme le fait `Bike`) sur toute la dalle, et retient
un point qui offre les deux a la fois :
> depart `--start=907875,6439450`, altitude 513,2 m
> - **montee cap 220°** : +14,8 % en moyenne sur 90 m, pire section +16,8 %, donc
> **aucune section infranchissable** - le velo monte sans caler ;
> - **descente cap 40°** : -25,0 % en moyenne sur 170 m, pire section -63 %,
> franche mais roulable (les parois a -600 % de la dalle ne testeraient que le
> plafond de vitesse, pas une descente VTT).
La montee se fait en premier : la descente qui suit repasse par le point de
depart et gagne le denivele grimpe en elan supplementaire.
Le **demi-tour est ASSERVI**, pas minute. Un demi-tour "1,4 s a 140 °/s" a ete
essaye et rate : le temps vu par le jeu n'est pas celui du `Start-Sleep`, et sur
ces versants le devers depasse 25 %, donc 18° d'ecart suffisent a sortir de la
fourchette mesuree. Le jeu journalise deja son cap chaque seconde : le script
tourne par courtes rafales, frein tire, en relisant le cap entre chaque, jusqu'a
±8° de la cible.
**Resultats du scenario E**, deux runs consecutifs :
| | run 1 | run 2 |
|---|---:|---:|
| Releves de telemetrie | 66 | 66 |
| Vitesse maximale | **50,0 km/h** | 49,7 km/h |
| En descente (pente <= -8 %) | 50,0 au pic, **31,4 km/h de moyenne** sur 39 releves | 49,7 au pic, 29,4 de moyenne sur 42 |
| En montee (pente >= +8 %) | 6,0 au pic, **5,4 km/h de moyenne** sur **20** releves en mouvement | 6,0 au pic, 5,5 de moyenne sur 20 |
| Releves a l'arret en cote | **2** | **2** |
| Denivele reellement gagne en pedalant | **4,4 m** | **4,4 m** |
| Pente rencontree | -71,0 % a +16,2 % | -69,9 % a +16,4 % |
| Altitude parcourue | 422,5 a 519,3 m, **96,9 m suivis** | 424,0 a 519,4 m, 95,4 m suivis |
Les deux runs sont **reproductibles au dixieme** sur les grandeurs qui comptent
(denivele gagne, nombre de releves en montee, calages) - ce qui n'etait pas le
cas des versions precedentes, ou le denivele gagne oscillait entre 1,9 et 6,3 m
d'un run a l'autre. C'est le signe que le scenario ne fonctionne plus par chance.
Le critere de succes ne se contente pas de constater que les touches ont ete
recues. Il exige une descente ET une montee franches, une vitesse de descente
reelle sous le plafond de 50 km/h, une montee plus lente que la descente **en
moyenne calculee en mouvement**, au moins **2 m d'altitude reellement GAGNES en
pedalant** - une pente positive peut etre "rencontree" a l'arret, et un pic de
vitesse en cote peut n'etre que l'elan emporte depuis la descente - et au moins
12 m de denivele suivi.
Le velo a traverse des pentes locales jusqu'a -71 % sans diverger, sans NaN, sans
jamais depasser son plafond (il l'atteint : 50,0 km/h pile).
---
## 5. Ce qui n'est pas satisfaisant, honnetement
1. **La pente franchissable de 23,6 % est basse pour ce massif.** En dessous, le
velo monte proprement et sans a-coups : sur le versant a +14,8 % du scenario E,
20 releves en mouvement contre **2 calages** seulement. Au-dessus, il
s'immobilise net - et le massif depasse 23,6 % tres souvent (les versants
depouilles ont des devers moyens de 25 a 29 %). Sur une premiere version du
scenario, posee sur un versant a 27 %, le rapport s'inversait : 41 releves a
l'arret contre 3 en mouvement.
Le modele **suppose qu'on zigzague** - il lit la pente LE LONG DU CAP, donc
traverser en biais reduit reellement l'effort, et c'est exactement ce que fait
un vetetiste. C'est jouable, mais un joueur qui pointe droit dans la pente est
bloque sans explication. `pedalAcceleration` est le parametre a revoir, **mais
pas a l'aveugle : il faut d'abord decider si "monter droit dans un versant a
27 %" doit etre possible dans ce jeu.** A pied, ca ne l'est pas non plus.
2. **La vitesse limite demande beaucoup plus de distance sur du relief MESURE que
sur un plan.** Les 47 km/h annonces a -30 % supposent une pente soutenue ; un
vrai versant est fait de terrasses et de ressauts. Le premier essai de
scenario, sur un versant a -21 %, plafonnait a 23 km/h parce qu'une terrasse
coupait la descente au bout de 25 m. Le versant retenu, a -25 %, atteint bien
le plafond de 50,0 km/h - mais la **moyenne** sur toute la descente n'est que
de 31 km/h. C'est un resultat, pas un defaut : le terrain reel est plus
contraignant que le modele.
3. **Le marqueur est un cube.** Comme le pilote de parapente. Il est en revanche
oriente CORRECTEMENT (cap, tangage, roulis), ce qui est le seul moyen de lire
a l'ecran l'assiette calculee - donc de verifier a l'oeil ce que disent les
tests. Un vrai mesh de velo viendra avec l'habillage.
4. **Pas de suspension, pas de transfert de charge, pas de derapage.** Le
`dragCoefficient` groupe tout ca dans un seul terme, ce qui est assume mais
fait de lui le parametre le plus arbitraire du modele.
5. **La collision ne concerne que les arbres de `Forest`** (16, autour de
l'origine). Les dizaines de milliers d'arbres de `Vegetation` se traversent
toujours - limite deja ouverte depuis la Phase 11, que le velo rend plus
voyante puisqu'on couvre du terrain bien plus vite.
6. **Aucun controle d'image** n'a ete fait sur la vue a la troisieme personne du
velo. La garde au sol de la camera est raisonnee et codee, pas mesuree sur une
capture. C'est la meme limite que celle ouverte depuis la Phase 10 : aucun
test automatique ne regarde l'IMAGE.
## 6. Hors scope, assume (conforme a la consigne)
Pas de degats ni de chute en cas de choc ; pas d'usure du velo ; pas de velo
comme objet ramassable ou fabricable. Le velo est disponible en permanence par la
touche B.
---
## 7. Non-regression
- **334 assertions headless** (280 avant, +54), du premier coup.
- **`run_vulkan_check.ps1` : 5 scenarios sur 5, deux runs consecutifs**, zero
`[Validation]`, zero `[ERROR]`, zero `[WARN]`, codes de sortie 0/0/0/0/0,
fermeture propre partout. Scenarios A a D (gameplay synthetique, collision,
dalle LiDAR, parapente) **inchanges et verts** : 2 abattages, 3 debitages,
ramassages, 1 percussion, vol de parapente avec atterrissage naturel.
- **Scenes annexes** relancees une a une (lancement, 6 s, `WM_CLOSE`) : `cube`,
terrain procedural, dalle de Phase 7 en `--no-lod`, et la zone de 25 km2 a
1 m. **Toutes : code de sortie 0, zero `[Validation]`, zero `[ERROR]`, zero
`[WARN]`, fermeture propre.**
- `vercora.exe --dump-world` : **16 lignes AIM sur 16**, inchange.
- Aucun chemin de rendu touche : `Bike` ne parle pas a Vulkan, et le seul ajout
cote rendu est un `DrawItem` de plus (le marqueur), sur le materiau `Object`
qui existait deja.
- `Camera` : une valeur d'enum ajoutee (`Ride`) et deux branches qui la traitent
comme `Glide`. Aucune modification du mode Walk, Free ou Glide.