# =========================================================================== # Verification du VRAI executable Vulkan et de ses couches de validation. # =========================================================================== # Lance build\vercora.exe (build Debug => VERCORA_DEBUG => couche # VK_LAYER_KHRONOS_validation active), pilote sa fenetre par l'API Win32, puis # analyse la sortie a la recherche de messages "[Validation]". # # Dix scenarios (A a J), dans QUATORZE PROCESSUS distincts (G en compte trois, # J en compte trois) : # A. Gameplay complet sur le terrain SYNTHETIQUE : pierres, percussion, # abattage, ramassage, puis resize, minimisation et fermeture propre. # B. Sonde de collision seule, depuis l'origine, terrain synthetique. # C. Dalle LiDAR HD REELLE (Phase 7) : 2 millions de triangles, marche sur le # relief mesure, abattage et ramassage, resize et fermeture propre. # D. Vol en parapente sur la dalle reelle (Phase 8). # E. Sortie a VELO sur la dalle reelle (Phase 13) : descente puis montee sur # un versant mesure, avec freinage et demi-tour. # F. ESCALADE sur une paroi mesuree (Phase 14). # G. EDITEUR DE NIVEAU (Phase 15), en TROIS processus : edition (pose, # selection, reglage, suppression, annulation, sauvegarde, rechargement), # puis relecture de la scene dans une partie NORMALE, puis un TEMOIN qui # refait exactement la meme marche sans la scene. C'est l'ecart entre les # deux dernieres qui prouve que les objets poses bloquent le joueur. # J. RECOLTE DE MATIERES (Phase 22), en TROIS processus : creuser un # gisement detecte par le jeu lui-meme, ramasser la motte produite, puis # reessayer a 30 m - le meme test de portee dans les deux sens que le # scenario H ; puis, sur la zone de 25 km2 (la seule qui ait une carte de # couvert), arracher une plante a fibres poussee EN LISIERE et verifier # qu'elle est en REPOUSSE et non disparue. # H. BESOINS PRIMAIRES (Phase 16) : depart sur un point d'eau detecte par le # jeu lui-meme, deux touches T (a portee puis a 30 m) qui exercent le test # de portee dans les deux sens, puis 100 s de marche et 60 s d'immobilite - # la telemetrie doit montrer la forme descendre PUIS remonter. # # Le scenario B est separe parce que la position du joueur ne se pilote qu'a # l'estime : chaque collision rencontree en chemin decale la camera par rapport # au modele du script, et cette derive s'accumule. En repartant d'un processus # neuf, la position de depart est connue EXACTEMENT (l'origine), ce qui rend la # sonde decisive au lieu d'ambigue. # # Le scenario C est separe pour une autre raison : le terrain synthetique reste # le monde de REFERENCE des scenarios A et B (semis deterministe, positions # connues d'avance), et il faut pouvoir prouver qu'il n'a pas regresse. Le # scenario C ajoute ce que lui seul peut montrer : un maillage 60 fois plus gros # passe sous les couches de validation, un relief de 562 m de denivele sous les # pieds, et un semis d'arbres refait sur ce relief. Il est ignore, sans faire # echouer le script, si la dalle n'a pas ete produite (elle n'est pas versionnee). # # Pilotage par PostMessage plutot que par automatisation clavier/souris globale : # les evenements vont DIRECTEMENT a la fenetre visee, sans dependre du focus et # sans voler la souris a l'utilisateur. # # Le monde etant seme de facon DETERMINISTE (graines fixes), "vercora.exe # --dump-world" donne a l'avance la position des arbres et des pierres. Le script # vise donc de vraies cibles au lieu d'appuyer sur les touches a l'aveugle : # c'est la difference entre "j'ai appuye sur R" et "j'ai ramasse une buche". # # Ce dump etait un executable separe (tools\dump_world.cpp) jusqu'a la Phase 7 ; # c'est desormais un MODE du jeu, donc le meme code exactement - voir le # commentaire de dumpWorld() dans src\main.cpp. # # La FERMETURE est un vrai WM_CLOSE (ce que fait la croix de la fenetre) et non # un kill : c'est la seule facon de verifier la destruction propre des objets # Vulkan, precisement ce que les couches de validation signalent si elle est # incorrecte. # # Usage : powershell -ExecutionPolicy Bypass -File tools\run_vulkan_check.ps1 # Code de retour : 0 si tout est vert. # =========================================================================== # -Only permet de ne lancer qu'une partie des scenarios : # powershell -File tools\run_vulkan_check.ps1 -Only G # powershell -File tools\run_vulkan_check.ps1 -Only A,B # # Ajoute en Phase 15 pour une raison tres concrete : la suite complete prend une # quinzaine de minutes, et mettre au point UN scenario en payant les sept autres a # chaque essai decourage de le faire correctement. Le verdict final reste # calcule sur les seuls scenarios joues - un scenario non joue est traite comme # une dalle absente, c'est-a-dire ignore et non echoue. Un run de reference se # fait donc TOUJOURS sans -Only. param([string[]]$Only = @()) $ErrorActionPreference = "Stop" $runAll = ($Only.Count -eq 0) function Should-Run([string]$name) { return $runAll -or ($Only -contains $name) } if (-not $runAll) { Write-Host "ATTENTION : execution PARTIELLE ($($Only -join ', ')). Les scenarios" Write-Host " non joues sont ignores, pas valides. Pour un verdict de" Write-Host " reference, relancer sans -Only." } $root = Split-Path -Parent $PSScriptRoot $exe = Join-Path $root "build\vercora.exe" if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe. Lancer tools\build.bat d'abord." } # --- Monde attendu --------------------------------------------------------- # Le dump rejoue le semis avec la MEME heightmap que le jeu - et pour cause, # c'est le jeu. Indispensable depuis la Phase 7 : le filtre de pente rejette des # emplacements differents selon le relief, donc les arbres ne tombent pas au meme # endroit sur la dalle reelle que sur le terrain synthetique. # # Renvoie les objets du monde ET les positions de tir. Une ligne # "AIM i camX camZ recul pitchDeg elevation" signifie : depuis (camX, camZ), en # visant le tronc de l'arbre i avec le pitch indique (pitch inclus, pas # seulement un rayon horizontal - corrige en Phase 8), Forest::pickTree designe # REELLEMENT l'arbre i. C'est la fonction de visee du jeu qui l'a dit, pas une # estimation du script. function Get-World([string]$terrainArg = "") { $lines = if ($terrainArg -ne "") { & $exe --dump-world $terrainArg 2>$null } else { & $exe --dump-world 2>$null } $entries = @() $aims = @() $levelAims = @() $lines | ForEach-Object { $p = $_ -split '\s+' if ($p.Count -eq 7 -and $p[0] -eq 'AIM') { $aims += [pscustomobject]@{ Index = [int]$p[1]; CamX = [double]$p[2]; CamZ = [double]$p[3] Standoff = [double]$p[4]; PitchDeg = [double]$p[5]; Elevation = $p[6] CamDist = [Math]::Sqrt([double]$p[2] * [double]$p[2] + [double]$p[3] * [double]$p[3]) } } elseif ($p.Count -eq 5 -and $p[0] -eq 'AIMLEVEL') { $levelAims += [pscustomobject]@{ Index = [int]$p[1]; CamX = [double]$p[2]; CamZ = [double]$p[3] Standoff = [double]$p[4] CamDist = [Math]::Sqrt([double]$p[2] * [double]$p[2] + [double]$p[3] * [double]$p[3]) } } elseif ($p.Count -eq 5 -and $p[0] -ne '[INFO]') { $entries += [pscustomobject]@{ Kind = $p[0]; X = [double]$p[1]; Z = [double]$p[2] Dist = [double]$p[3]; Bearing = [double]$p[4] } } } return [pscustomobject]@{ Objects = $entries; Aims = $aims; LevelAims = $levelAims } } # Les arbres sont nommes TREE : l'indice est celui que le jeu # journalise, ce qui permet de verifier apres coup qu'on a abattu l'arbre VISE # et non un autre - le controle le plus direct de la precision du pilotage. # "terrain" explicite : sans argument, le jeu charge desormais la dalle LiDAR. $world = (Get-World "terrain").Objects $trees = @($world | Where-Object { $_.Kind -like 'TREE*' }) $stones = @($world | Where-Object { $_.Kind -eq 'pierre' }) Write-Host "Monde synthetique attendu : $($trees.Count) arbres, $($stones.Count) pierres." # Dalle LiDAR reelle : celle que le jeu charge par defaut (cf. main.cpp). $lidarTile = Join-Path $root "assets\terrain\LHD_0907_6440_1m.vchm" # PHASE 22. La zone de 25 km2 est la SEULE dont la carte de couvert LiDAR soit # produite, et c'est cette carte qui porte la voie "lisiere" du semis de plantes # a fibres. Elle n'est pas versionnee : son absence fait sauter J3 sans faire # echouer le script, exactement comme l'absence de la dalle fait sauter C a I. $zoneTile = Join-Path $root "assets\terrain\vercora_zone_2m.vchm" $hasZone = Test-Path $zoneTile $hasLidar = Test-Path $lidarTile if ($hasLidar) { $lidarDump = Get-World $lidarTile $lidarTrees = @($lidarDump.Objects | Where-Object { $_.Kind -like 'TREE*' }) # Preuve de la Phase 8 : avec un rayon de visee pitch-inclus (au lieu de # l'ancien rayon horizontal), Forest::pickTree retrouve les arbres en # contrebas ET en amont, pas seulement ceux au niveau de l'oeil. $above = @($lidarDump.Aims | Where-Object { $_.Elevation -eq 'au-dessus' }) $below = @($lidarDump.Aims | Where-Object { $_.Elevation -eq 'en-dessous' }) $level = @($lidarDump.Aims | Where-Object { $_.Elevation -eq 'au-niveau' }) Write-Host ("Dalle LiDAR trouvee : {0} arbres semes sur le relief reel, {1} abattables au total " -f $lidarTrees.Count, $lidarDump.Aims.Count) -NoNewline Write-Host ("(niveau={0}, au-dessus={1}, en-dessous={2})." -f $level.Count, $above.Count, $below.Count) # Le tir REEL de ce script, lui, ne peut viser qu'au pitch nul : la camera ne # tourne jamais pendant ce process (voir plus bas, "Navigation : uniquement # au clavier") puisque GLFW lit le curseur SYSTEME et non les messages # postes - tourner la camera volerait la souris de l'utilisateur. On utilise # donc AIMLEVEL (rayon horizontal, comme avant la Phase 8) pour choisir la # cible du tir reellement joue, et non les entrees AIM ci-dessus - celles-ci # ne servent qu'a PROUVER que pickTree sait viser en hauteur. $lidarAim = @($lidarDump.LevelAims | Sort-Object CamDist) | Select-Object -First 1 if ($null -eq $lidarAim) { Write-Host "[ATTENTION] Aucun arbre abattable au pitch nul : scenario C ignore le tir reel." } } else { Write-Host "Dalle LiDAR absente ($lidarTile) : scenario C ignore." Write-Host " Pour la produire : python tools/lidar_to_heightmap.py data/lidar/.copc.laz -o `"$lidarTile`" --cell 1.0" } Add-Type @" using System; using System.Runtime.InteropServices; public static class W32 { [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l); [DllImport("user32.dll")] public static extern bool SetWindowPos(IntPtr h, IntPtr a, int x, int y, int cx, int cy, uint f); [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr h, int cmd); [DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetWindowTextW(IntPtr h, System.Text.StringBuilder s, int n); } "@ # =========================================================================== # COLLECTEUR DE JOURNAL : un delegue .NET COMPILE, pas un script-block # =========================================================================== # Jusqu'a la Phase 22, la sortie du jeu etait capturee par # `Register-ObjectEvent -Action { ... }`, c'est-a-dire UN SCRIPT-BLOCK # POWERSHELL EXECUTE PAR LIGNE DE JOURNAL. Ces blocs ne tournent que quand le # runspace est disponible ; or les scenarios passent leur temps dans des # `Start-Sleep` et des boucles d'attente. Les evenements s'empilent, et le # tampon que `Wait-ForLog` interroge est EN RETARD sur ce que le jeu a # reellement ecrit. Le retard CROIT avec la duree du scenario. # # Ce n'etait pas une hypothese : mesure faite le 2026-08-27, meme binaire, meme # dalle, meme sortie a velo, seul le collecteur changeant - # # collecteur "Velo : en selle" "Velo : pied a terre" # Register-ObjectEvent -Action 1833 ms jamais vu en 3 s (9,6 s) # delegue .NET (ci-dessous) 5 ms 0 ms # # C'est TOUTE l'explication de la dette du scenario E, ouverte en Phase 17 et # rejouee a chaque phase depuis : le jeu journalisait bien "Velo : pied a # terre." - la ligne EST dans $runE.Lines apres coup - mais elle n'arrivait au # script qu'apres l'expiration des 3 s de Wait-ForLog. LE JEU N'A JAMAIS EU DE # DEFAUT ; c'est l'instrument de mesure qui regardait trop tot. # # Nota : "en selle" tenait dans son budget a 1833 ms, soit 61 % des 3 s. Le # defaut menacait donc TOUS les Wait-ForLog du harnais, pas seulement celui du # velo ; le scenario E etait simplement le plus long, donc le premier a franchir # le seuil. Elargir le delai aurait masque cela au lieu de le resoudre. # # Le puits se branche LUI-MEME (Attach) : PowerShell 5.1 ne sait pas convertir # une PSMethod en DataReceivedEventHandler, le delegue est donc construit du # cote C#. ToString() est surcharge pour que les appelants (Wait-ForLog, # Get-BikeHeading, Wait-BikeSample, Stop-Game, scenario F) restent INCHANGES : # tous appelaient deja .ToString() sur le StringBuilder d'avant. Add-Type @" using System; using System.Text; using System.Diagnostics; public class VercoraLogSink { private readonly StringBuilder sb = new StringBuilder(); private readonly object gate = new object(); private void OnData(object sender, DataReceivedEventArgs e) { if (e.Data == null) return; lock (gate) { sb.AppendLine(e.Data); } } public void Attach(Process p, bool standardOutput) { if (standardOutput) { p.OutputDataReceived += new DataReceivedEventHandler(OnData); } else { p.ErrorDataReceived += new DataReceivedEventHandler(OnData); } } public override string ToString() { lock (gate) { return sb.ToString(); } } } "@ $WM_KEYDOWN=0x0100; $WM_KEYUP=0x0101; $WM_CLOSE=0x0010 $SWP_NOMOVE=0x0002; $SWP_NOZORDER=0x0004 # --- Touches designees par leur SCANCODE, jamais par leur code virtuel ------- # Piege qui a coute cher ici : MapVirtualKeyW(VK, MAPVK_VK_TO_VSC) traduit selon # la DISPOSITION CLAVIER ACTIVE. Sur l'AZERTY francais de cette machine, VK_W # (0x57) designe la touche gravee W, qui occupe la position physique du Z d'un # QWERTY. GLFW, lui, raisonne en positions physiques : il recevait donc # GLFW_KEY_Z quand on croyait envoyer W, et le jeu - qui teste GLFW_KEY_W - # ignorait purement et simplement la touche. # # Effet observe avant correction : seuls S et D (memes positions sur AZERTY et # QWERTY) deplacaient la camera. Le script croyait aller a l'ouest, la camera # derivait vers l'est, et aucun objet ne se trouvait jamais a portee - alors que # le JEU, lui, fonctionnait parfaitement. # # En envoyant directement les scancodes du jeu de codes 1, on s'adresse a la # position physique, exactement comme le fera un vrai clavier. $SC = @{ W=0x11; A=0x1E; S=0x1F; D=0x20 # ZQSD sous les doigts d'un AZERTY E=0x12; R=0x13; C=0x2E; F=0x21 V=0x2F; SPACE=0x39 # Phase 8 : decollage/atterrissage parapente B=0x30 # Phase 13 : monter sur le velo / en descendre X=0x2D # Phase 14 : s'engager sur une paroi / lacher T=0x14 # Phase 16 : boire au point d'eau Y=0x15 # Phase 22 : creuser un gisement I=0x17 # Phase 22 : arracher une plante a fibres } # --- PHASE 15 : les touches de l'EDITEUR, dont des touches ETENDUES --------- # Le pave de navigation (INSER, SUPPR, DEBUT, FIN, PAGE) et les fleches portent # les MEMES scancodes que le pave numerique ; ce qui les distingue est le bit # "touche etendue" (bit 24 du lParam). GLFW indexe sa table par # (scancode | 0x100) pour celles-la - voir createKeyTables() dans win32_init.c - # donc oublier ce bit ne produit pas une touche morte : il produit une AUTRE # touche (INSER deviendrait le 0 du pave numerique). D'ou le drapeau explicite # porte par chaque entree. $SCX = @{ INSERT = 0x52 # poser l'objet arme (equivalent clavier du clic gauche) DELETE = 0x53 # supprimer la selection UP = 0x48 # agrandir DOWN = 0x50 # reduire LEFT = 0x4B # tourner a gauche RIGHT = 0x4D # tourner a droite TAB = 0x0F # asset suivant BACKSPACE = 0x0E # annuler F2 = 0x3C # entrer / sortir du mode editeur F3 = 0x3D # objet pose suivant, sans viser F4 = 0x3E # objet pose precedent, sans viser F5 = 0x3F # sauvegarder la scene F9 = 0x43 # recharger la scene L = 0x26 # reafficher le catalogue E = 0x12 # selectionner l'objet vise D3 = 0x04 # rang 3 du catalogue W = 0x11 # avancer (Z en AZERTY) } # Send-Key ne sait pas poser le bit "touche etendue" : ces deux fonctions le # font. Elles ne REMPLACENT pas Send-Key/HoldMs, volontairement - les scenarios # A a F sont verts avec, et leur toucher serait un risque pour zero gain. function Send-KeyEx([int]$sc, [bool]$ext, [int]$holdMs = 90) { $down = 1 -bor ($sc -shl 16) if ($ext) { $down = $down -bor (1 -shl 24) } $up = $down -bor (1 -shl 30) -bor (1 -shl 31) [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr]$down) Start-Sleep -Milliseconds $holdMs [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr]$up) Start-Sleep -Milliseconds 160 } function HoldKeyEx([int]$sc, [bool]$ext, [int]$ms) { $down = 1 -bor ($sc -shl 16) if ($ext) { $down = $down -bor (1 -shl 24) } $up = $down -bor (1 -shl 30) -bor (1 -shl 31) [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr]$down) Start-Sleep -Milliseconds $ms [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr]$up) Start-Sleep -Milliseconds 250 } # --- Navigation : uniquement au clavier, JAMAIS a la souris ----------------- # La camera ne tourne pas de tout le test, et c'est delibere : # # GLFW ne lit PAS la position du curseur dans les messages WM_MOUSEMOVE : sa # fonction glfwGetCursorPos appelle GetCursorPos() puis ScreenToClient(), # c'est-a-dire le curseur SYSTEME reel. Des WM_MOUSEMOVE postes n'ont donc # aucun effet sur la rotation (constate : la camera restait figee au cap # initial pendant tout un run). Faire tourner la camera exigerait de deplacer # reellement le pointeur avec SetCursorPos, donc de voler la souris a # l'utilisateur pendant une minute. # # Ce n'est pas necessaire : au cap initial (yaw = -90 degres), le repere de la # camera est aligne sur les axes du monde. front = (0, 0, -1) et # right = (1, 0, 0), donc # W -> -Z S -> +Z D -> +X A -> -X # On atteint donc n'importe quel point (x, z) par translations pures. $script:posX = 0.0 $script:posZ = 0.0 $script:hwnd = [IntPtr]::Zero $script:proc = $null $script:outSb = $null $script:errSb = $null $script:handlers = @() function Send-Key([int]$sc, [int]$holdMs = 70) { [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16))) Start-Sleep -Milliseconds $holdMs [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31))) Start-Sleep -Milliseconds 90 } # Maintient une touche le temps de parcourir la distance voulue. # Vitesse 14 unites/s (Camera::setMoveSpeed dans main.cpp), deplacement # strictement horizontal en mode marche : distance = vitesse x temps, quel que # soit le relief. function Hold([int]$sc, [double]$distance) { if ($distance -le 0.02) { return } $ms = [int](1000.0 * $distance / 14.0) if ($ms -lt 20) { return } [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16))) Start-Sleep -Milliseconds $ms [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31))) Start-Sleep -Milliseconds 120 } # Maintient une touche pendant une DUREE fixe plutot qu'une distance - utilise # pour le decollage (monter en mode Free n'a pas de "distance" a viser, juste # le temps de depasser le seuil de hauteur) et pour piloter le parapente une fois # en vol (virage, frein), ou la notion de distance ne s'applique pas non plus. function HoldMs([int]$sc, [int]$ms) { [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16))) Start-Sleep -Milliseconds $ms [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31))) Start-Sleep -Milliseconds 90 } # Maintient PLUSIEURS touches simultanement pendant une duree fixe. Necessaire # des la Phase 13 : le demi-tour du velo se fait frein tire (sinon la machine # repart dans la pente pendant qu'on la tourne), donc S et D en meme temps. Les # helpers precedents ne savaient tenir qu'une touche. function HoldMsMulti([int[]]$scancodes, [int]$ms) { foreach ($sc in $scancodes) { [void][W32]::PostMessage($script:hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16))) } Start-Sleep -Milliseconds $ms foreach ($sc in $scancodes) { [void][W32]::PostMessage($script:hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31))) } Start-Sleep -Milliseconds 120 } # Dernier cap du velo lu dans la telemetrie du jeu (degres), ou $null si le velo # n'a encore rien emis. function Get-BikeHeading() { $ms = [regex]::Matches($script:outSb.ToString(), 'Velo : .*cap ([-0-9.]+) deg') if ($ms.Count -eq 0) { return $null } return [double]$ms[$ms.Count - 1].Groups[1].Value } # Attend qu'une NOUVELLE ligne de telemetrie velo soit apparue (le jeu en emet # une par seconde). Renvoie $false en cas de delai depasse. function Wait-BikeSample([int]$timeoutMs = 2000) { $before = [regex]::Matches($script:outSb.ToString(), 'Velo : .*km/h').Count $deadline = (Get-Date).AddMilliseconds($timeoutMs) while ((Get-Date) -lt $deadline) { if ([regex]::Matches($script:outSb.ToString(), 'Velo : .*km/h').Count -gt $before) { return $true } Start-Sleep -Milliseconds 120 } return $false } # Amene le velo au cap voulu, PAR ASSERVISSEMENT sur ce que le jeu journalise - # et non par une duree calculee a l'avance. # # Pourquoi : un demi-tour "1,4 s a 140 deg/s" a ete essaye d'abord, et il rate. # Le temps reellement vu par le jeu n'est pas celui du Start-Sleep (jitter de # PostMessage, ordonnancement, frame en cours), et sur ce versant l'erreur coute # cher : le devers moyen y depasse 25 %, donc 18 degres d'ecart font passer la # pente ressentie de +12 % a +27 % - au-dela de ce que le velo peut monter. Le # velo s'immobilisait alors pour de bon et le scenario ne prouvait aucune montee. # # Le jeu emet deja son cap chaque seconde : on s'en sert. On tourne par courtes # rafales, frein tire (sinon la machine repart dans la pente pendant la # manoeuvre), en relisant le cap entre chaque. function Turn-BikeTo([double]$targetDeg, [double]$toleranceDeg = 8.0, [int]$maxBursts = 14) { for ($i = 0; $i -lt $maxBursts; $i++) { $cap = Get-BikeHeading if ($null -eq $cap) { return $false } # Ecart ramene dans (-180, 180] : on tourne toujours par le plus court. $delta = (($targetDeg - $cap) % 360 + 540) % 360 - 180 if ([Math]::Abs($delta) -le $toleranceDeg) { Write-Host (" cap {0:N1} deg (cible {1:N0}, ecart {2:N1}) - atteint en {3} rafales" -f $cap, $targetDeg, $delta, $i) return $true } # 140 deg/s a l'arret (plafond de braquage de world/Bike.hpp). On vise # 70 % de l'ecart par rafale : on converge sans osciller. $ms = [int][Math]::Min(500, [Math]::Max(60, [Math]::Abs($delta) * 0.7 / 140.0 * 1000.0)) $key = $(if ($delta -gt 0) { $SC.D } else { $SC.A }) HoldMsMulti @($SC.S, $key) $ms [void](Wait-BikeSample 2000) } Write-Host (" [ATTENTION] cap non atteint apres {0} rafales (dernier {1})" -f $maxBursts, (Get-BikeHeading)) return $false } # Interroge la sortie DEJA CAPTUREE du processus en cours (les gestionnaires # asynchrones de Start-Game l'alimentent en continu) jusqu'a ce qu'une ligne # corresponde au motif, ou jusqu'au delai imparti. Sert a savoir si le vol a # reellement decolle/atterri SANS deviner un temps d'attente fixe - le relief # reel determine seul quand le parapente touche le sol. function Wait-ForLog([string]$pattern, [int]$timeoutMs) { $deadline = (Get-Date).AddMilliseconds($timeoutMs) while ((Get-Date) -lt $deadline) { if ($script:outSb.ToString() -match $pattern) { return $true } Start-Sleep -Milliseconds 250 } return $script:outSb.ToString() -match $pattern } # =========================================================================== # NAVIGATION EN BOUCLE FERMEE (Phase 24) # =========================================================================== # Jusqu'ici GoTo naviguait A L'ESTIME : il tenait une touche pendant # distance / 14 m/s et DECLARAIT le joueur arrive, sans jamais rien verifier. # Le modele est faux des que le monde s'en mele - collision contre un tronc, # terrain qui monte, et depuis la Phase 24 une pente qui ralentit la marche. # L'erreur ne se corrige jamais : elle s'ACCUMULE d'un GoTo au suivant. # # Ce n'etait pas une hypothese. Mesure du 2026-08-27, scenario A, journal brut # du jeu : le script se croyait sur la pierre 2, le joueur etait a 7 m de la, # et le jeu disait exactement pourquoi - # # [INFO] Ramassage : rien a portee de main. (x 24) # [INFO] Percussion impossible : il faut deux pierres, un percuteur... # [INFO] Abattage : aucun arbre dans la ligne de visee. # # TOUT le scenario A tombe d'une seule cause : le joueur n'arrive pas. Les # "percussions 0" et "cible manquee" en sont les consequences, pas des defauts # distincts - et RIEN de tout cela n'est du jeu. Le controle a ete fait dans les # deux sens : neutraliser entierement la limite de pente de la Phase 24 # (kWalkMaxSlope a 1000) ne change RIEN au resultat, et le run ci-dessus n'a # journalise AUCUN declenchement du filtre. Trois executions donnent le meme # echec au detail pres : ce defaut est DETERMINISTE, il n'a jamais ete de la # flakiness, et c'est pour ca qu'elargir des delais ne l'a jamais corrige. # # Le correctif ne touche pas au jeu (contrainte explicite du chantier) : il # lit ce que le jeu JOURNALISE DEJA. src/main.cpp emet la position de la camera # UNE FOIS PAR SECONDE, sans condition, depuis la Phase 15 - et pour exactement # cette raison, ecrite dans son commentaire. Le harnais ne s'en etait jamais # servi pour naviguer. # # Position REELLE du joueur, telle que le jeu vient de l'ecrire. Renvoie $null # si aucune ligne fraiche n'arrive dans le delai - l'appelant retombe alors sur # l'estime plutot que d'echouer. # # On exige une ligne PLUS RECENTE que celles deja presentes : relire la derniere # ligne connue donnerait la position d'AVANT le deplacement qu'on vient # d'ordonner, et la boucle croirait n'avoir pas bouge. function Get-PlayerPos([int]$timeoutMs = 2500) { $rx = 'Camera : yaw \S+ pitch \S+ position (\S+) (\S+) (\S+)' $seen = ([regex]::Matches($script:outSb.ToString(), $rx)).Count $deadline = (Get-Date).AddMilliseconds($timeoutMs) while ((Get-Date) -lt $deadline) { $m = [regex]::Matches($script:outSb.ToString(), $rx) if ($m.Count -gt $seen) { $last = $m[$m.Count - 1] return [pscustomobject]@{ X = [double]$last.Groups[1].Value Y = [double]$last.Groups[2].Value Z = [double]$last.Groups[3].Value } } Start-Sleep -Milliseconds 120 } return $null } # Se rend en (x, z) et VERIFIE l'arrivee, en corrigeant l'erreur restante. # # $tolerance = 0,6 m : nettement sous la portee de ramassage (2,5 m) et sous la # demi-largeur du joueur plus une marge, donc "arrive" veut dire quelque chose. # $maxPasses borne le temps : un joueur reellement bloque par un rocher ne doit # pas faire tourner le harnais en rond - on sort et le scenario constatera le # blocage, ce qui est parfois PRECISEMENT ce qu'il teste (scenario B, G2). function GoTo([double]$x, [double]$z, [double]$tolerance = 0.6, [int]$maxPasses = 4) { for ($pass = 0; $pass -lt $maxPasses; $pass++) { $p = Get-PlayerPos if ($null -eq $p) { # Repli EXACT sur l'ancien comportement : mieux vaut l'estime que # rien, et ca garde le harnais utilisable si le jeu cesse un jour # d'emettre cette ligne. $dx = $x - $script:posX if ($dx -ge 0) { Hold $SC.D $dx } else { Hold $SC.A (-$dx) } $script:posX = $x $dz = $z - $script:posZ if ($dz -le 0) { Hold $SC.W (-$dz) } else { Hold $SC.S $dz } $script:posZ = $z return } $script:posX = $p.X $script:posZ = $p.Z $dx = $x - $p.X $dz = $z - $p.Z $remaining = [Math]::Sqrt($dx * $dx + $dz * $dz) if ($remaining -le $tolerance) { return } if ($dx -ge 0) { Hold $SC.D $dx } else { Hold $SC.A (-$dx) } if ($dz -le 0) { Hold $SC.W (-$dz) } else { Hold $SC.S $dz } } # Derniere lecture : que la position estimee reflete la REALITE meme quand # on renonce, sinon l'erreur repartirait dans le GoTo suivant - ce qui est # exactement le defaut qu'on corrige. $final = Get-PlayerPos if ($null -ne $final) { $script:posX = $final.X $script:posZ = $final.Z $miss = [Math]::Sqrt(($x - $final.X) * ($x - $final.X) + ($z - $final.Z) * ($z - $final.Z)) if ($miss -gt $tolerance) { Write-Host (" [nav] arrivee a {0:N2} m de la cible ({1:N1}, {2:N1}) apres {3} passes" -f $miss, $x, $z, $maxPasses) } } } # Abat l'arbre vise, en REESSAYANT apres un petit pas de cote. # # POURQUOI UN RETRY LA OU UN SEUL "E" SUFFISAIT EN THEORIE. La navigation en # boucle fermee (voir GoTo) plafonne a ~0,8 m de la cible et n'y descend pas : # le canal d'entree est quantifie - `Hold` refuse tout pas sous 0,28 m, et # `Start-Sleep` a une granularite de ~16 ms sur cette machine, donc une # correction fine est soit ignoree soit depassee. Ce n'est pas un reglage a # ajuster, c'est une limite du pilotage par PostMessage. # # Or la marge de visee du scenario C est plus fine que ce plafond, et ca s'est # vu : deux executions consecutives du MEME binaire ont donne 0,78 m (arbre # abattu) et 0,80 m (manque). Une reussite qui tient a deux centimetres de # residu n'est pas une reussite - c'est la flakiness qu'on cherche a eliminer. # # Le remede est celui que le harnais emploie DEJA pour le meme probleme au # ramassage (Vacuum) : couvrir l'incertitude de position par un petit balayage, # au lieu d'exiger du canal d'entree une precision qu'il n'a pas. function Fell-WithRetry([int]$attempts = 4, [double]$step = 0.5) { # Comptage direct plutot que Count-Match : cet utilitaire n'est defini # qu'apres les scenarios dans ce fichier, donc il n'existe pas encore ici. $rx = "Abattage de l'arbre" $before = ([regex]::Matches($script:outSb.ToString(), $rx)).Count for ($i = 0; $i -lt $attempts; $i++) { Send-Key $SC.E Start-Sleep -Milliseconds 600 $now = ([regex]::Matches($script:outSb.ToString(), $rx)).Count if ($now -gt $before) { if ($i -gt 0) { Write-Host (" [visee] arbre abattu au {0}e essai" -f ($i + 1)) } return $true } # Pas de cote ALTERNE (droite, gauche, droite...) et croissant : on # balaie autour de la position estimee sans s'en eloigner franchement. $key = if ($i % 2 -eq 0) { $SC.D } else { $SC.A } Hold $key ($step * ($i + 1)) } Write-Host " [visee] arbre NON abattu apres $attempts essais" return $false } # Ratisse autour de la position courante : des R entrecoupes de petits pas en # carre (deplacement net nul). La portee de ramassage est de 2.5 unites, mais # la position n'est connue qu'a l'estime ; ce balayage rattrape l'imprecision. function Vacuum([int]$rounds = 3, [double]$step = 1.6) { Send-Key $SC.R foreach ($i in 1..$rounds) { foreach ($k in @($SC.D, $SC.W, $SC.A, $SC.S)) { Hold $k ($step * $i) Send-Key $SC.R } } } # $sceneArg : argument passe a vercora.exe. "terrain" force le generateur # procedural ; un chemin .vchm charge une dalle reelle. Les scenarios A et B le # passent EXPLICITEMENT, alors que le jeu sans argument charge desormais la dalle # LiDAR : ils testent le monde de reference, pas le defaut du jour. # $extraArgs : options passees telles quelles APRES la scene (--start=..., etc.). # Ajoute en Phase 13 : le scenario velo doit demarrer sur un versant CHOISI, et # le harnais ne peut pas s'y rendre en marchant (il ne sait pas tourner la # camera, donc il ne peut se deplacer que sur les axes du monde). function Start-Game([string]$label, [string]$sceneArg = "terrain", [string[]]$extraArgs = @()) { Write-Host "" Write-Host "############ $label ############" # PHASE 26 : instrumentation du dump. Le journal brut concatenait les # quatorze processus SANS separateur : impossible d'attribuer une ligne a un # scenario apres coup, donc impossible de dire si une telemetrie manquante # manque au scenario I ou ailleurs. On retient le libelle et l'instant de # depart ; Stop-Game les rend avec la duree reelle du processus. $script:runLabel = $label $script:runStartedAt = Get-Date # System.Diagnostics.Process directement, et non Start-Process : ce dernier # renvoie un objet dont ExitCode reste vide quand les flux sont rediriges, # ce qui faisait passer un run parfaitement propre pour un echec. $psi = New-Object System.Diagnostics.ProcessStartInfo $psi.FileName = $exe $psi.Arguments = '"' + $sceneArg + '"' foreach ($a in $extraArgs) { $psi.Arguments += ' "' + $a + '"' } $psi.WorkingDirectory = $root $psi.UseShellExecute = $false $psi.RedirectStandardOutput = $true $psi.RedirectStandardError = $true $script:proc = [System.Diagnostics.Process]::Start($psi) # Lecture asynchrone : un pipe plein bloquerait le jeu au milieu du test. # Le collecteur est le delegue COMPILE defini plus haut, et non un # script-block PowerShell : c'est ce qui garantit que Wait-ForLog interroge # ce que le jeu vient d'ecrire, et non un etat vieux de plusieurs secondes. $script:outSb = New-Object VercoraLogSink $script:errSb = New-Object VercoraLogSink $script:handlers = @() $script:outSb.Attach($script:proc, $true) $script:errSb.Attach($script:proc, $false) $script:proc.BeginOutputReadLine() $script:proc.BeginErrorReadLine() $script:hwnd = [IntPtr]::Zero for ($i = 0; $i -lt 120 -and $script:hwnd -eq [IntPtr]::Zero; $i++) { $script:proc.Refresh() if ($script:proc.HasExited) { break } if ($script:proc.MainWindowHandle -ne [IntPtr]::Zero) { $script:hwnd = $script:proc.MainWindowHandle } Start-Sleep -Milliseconds 100 } if ($script:hwnd -eq [IntPtr]::Zero) { throw "Pas de fenetre (HasExited=$($script:proc.HasExited))." } $sb = New-Object System.Text.StringBuilder 512 [void][W32]::GetWindowTextW($script:hwnd, $sb, 512) Write-Host "Fenetre : '$($sb.ToString())'" $script:posX = 0.0 $script:posZ = 0.0 Start-Sleep -Seconds 2 } function Stop-Game() { Write-Host "--- Fermeture propre (WM_CLOSE) ---" [void][W32]::PostMessage($script:hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero) if (-not $script:proc.WaitForExit(20000)) { Write-Host "[ECHEC] Pas de sortie 20 s apres WM_CLOSE." $script:proc.Kill(); $script:proc.WaitForExit() } $script:proc.WaitForExit() # vide les lecteurs asynchrones Start-Sleep -Milliseconds 400 foreach ($h in $script:handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue } $text = $script:outSb.ToString() + $script:errSb.ToString() $lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' }) $result = [pscustomobject]@{ ExitCode = $script:proc.ExitCode Lines = $lines Label = $script:runLabel StartedAt = $script:runStartedAt # Duree MUR du processus. C'est la grandeur qui permet de distinguer # "le jeu a emis moins de lignes" de "le scenario a dure moins # longtemps" - deux causes tres differentes d'une telemetrie courte. WallSeconds = [Math]::Round(((Get-Date) - $script:runStartedAt).TotalSeconds, 1) } # L'accumulation se fait ICI, et non en enumerant les $runX a la fin : le # scenario J RECOMPOSE $runJ en concatenant ses trois processus, si bien # qu'une enumeration des variables compterait J2 et J3 deux fois. Le seul # endroit qui voit exactement un processus, une fois, c'est Stop-Game. $script:allRuns += $result return $result } # =========================================================================== # SCENARIO A : gameplay complet # =========================================================================== $script:allRuns = @() $runA = $null if (Should-Run 'A') { Start-Game "SCENARIO A - gameplay, resize, fermeture" foreach ($n in 0..1) { $s = $stones[$n] Write-Host ("--- Pierre {0} : ({1:N1}, {2:N1}) ---" -f ($n+1), $s.X, $s.Z) GoTo $s.X $s.Z Vacuum 3 } Write-Host "--- Percussion (C) ---" Send-Key $SC.C Start-Sleep -Milliseconds 500 Hold $SC.W 1.1 # l'eclat tombe 1.1 unite devant, donc vers -Z au cap initial Send-Key $SC.R Start-Sleep -Milliseconds 300 # On se place PLEIN NORD de l'arbre (meme X, Z superieur) : au cap initial la # camera regarde vers -Z, l'arbre est donc pile dans l'axe de visee. $best = $null; $bestD = [double]::MaxValue foreach ($t in $trees) { $dd = [Math]::Sqrt(($t.X-$script:posX)*($t.X-$script:posX) + ($t.Z-$script:posZ)*($t.Z-$script:posZ)) if ($dd -lt $bestD) { $bestD = $dd; $best = $t } } $expectedTree = ($best.Kind -replace 'TREE','') Write-Host ("--- Abattage : {0} en ({1:N1}, {2:N1}) ---" -f $best.Kind, $best.X, $best.Z) GoTo $best.X ($best.Z + 9.0) Send-Key $SC.E Start-Sleep -Milliseconds 400 Write-Host "--- Chute, amortissement, debitage (6 s) ---" Start-Sleep -Seconds 6 Write-Host "--- Ramassage du bois ---" GoTo $best.X ($best.Z + 1.5) Vacuum 3 Vacuum 2 2.4 Write-Host "--- Bascule marche / vol libre ---" Send-Key $SC.F Start-Sleep -Milliseconds 400 Send-Key $SC.F Start-Sleep -Milliseconds 400 Write-Host "--- Redimensionnements (recreation de la swapchain) ---" foreach ($size in @(@(800,600), @(1600,900), @(640,480), @(1280,720), @(1920,1080), @(1024,768))) { [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) Start-Sleep -Milliseconds 700 } Write-Host "--- Minimisation / restauration (framebuffer de taille nulle) ---" [void][W32]::ShowWindow($script:hwnd, 6) Start-Sleep -Milliseconds 1500 [void][W32]::ShowWindow($script:hwnd, 9) Start-Sleep -Milliseconds 1500 $runA = Stop-Game } # =========================================================================== # SCENARIO B : chemin de collision, depuis l'origine # =========================================================================== # Ce scenario EXERCE la collision a l'execution ; il ne PROUVE pas son # comportement. La distinction est importante et vaut d'etre expliquee. # # Une premiere version de cette sonde concluait "collision defaillante" a tort. # Le raisonnement etait : on pousse 25 unites dans un arbre qui n'est qu'a 11, # donc si le tronc arrete le joueur l'arbre reste devant lui et E doit l'abattre. # C'est faux, parce qu'un collider CYLINDRIQUE ne bloque pas : il REPOUSSE. Le # joueur legerement decentre est ecarte lateralement, glisse autour du tronc et # repart de l'autre cote - exactement le comportement voulu (on contourne # l'arbre, on ne le traverse pas), mais qui laisse l'arbre DERRIERE soi dans les # deux cas. Le critere ne distinguait donc rien. # # Aucun observable externe ne permet de trancher : le jeu n'expose pas la # position du joueur, et la deflexion laterale (0.66 unite) est plus petite que # la tolerance de visee (~1.4 unite). La preuve COMPORTEMENTALE de la collision # - non-penetration, glissement, blocage par la souche, passage trop etroit - # vient donc du harnais headless (tests\logic_tests.cpp, qui simule la marche # pas a pas et lit les positions directement). # # Ce que ce scenario apporte reellement, et qui n'est verifiable qu'ici : le # code de collision tourne a chaque frame dans le vrai executable, contre un # tronc DEBOUT puis contre une SOUCHE, sans erreur de validation ni plantage. $probe = $trees | Where-Object { $_.Kind -eq 'TREE7' } | Select-Object -First 1 $runB = $null if (Should-Run 'B') { Start-Game "SCENARIO B - chemin de collision (tronc debout puis souche)" Write-Host ("--- Poussee de 25 unites dans l'arbre {0} en ({1:N1}, {2:N1}) ---" -f $probe.Kind, $probe.X, $probe.Z) GoTo $probe.X 0.0 # alignement lateral exact sur l'axe du tronc Hold $SC.W 25.0 # bien au-dela : on force le contact et le glissement Start-Sleep -Milliseconds 400 # Retour au nord de l'arbre, puis abattage : la souche prend alors la place du # tronc dans le volume de collision (Tree::colliderTopY), et on repousse dedans. Write-Host "--- Retour, abattage, puis poussee dans la souche ---" # Hold deplace la camera sans toucher a la position ESTIMEE (seul GoTo la met a # jour) : le retour doit donc se faire par un Hold symetrique, et non par un # GoTo qui calculerait un deplacement nul et ne bougerait pas. Hold $SC.S 25.0 Send-Key $SC.E Start-Sleep -Seconds 6 Hold $SC.W 25.0 Start-Sleep -Milliseconds 400 $runB = Stop-Game } # =========================================================================== # SCENARIO C : dalle LiDAR HD reelle (Phase 7) # =========================================================================== # Ce que ce scenario apporte, et que ni A ni B ne peuvent montrer : # - un vertex buffer de 1 002 001 sommets et 2 000 000 de triangles pousse sur # le GPU, puis six recreations de swapchain avec ce maillage en place ; # - la camera qui marche sur un relief MESURE, avec des pentes reelles # (562 m de denivele sur 1 km) la ou le terrain synthetique est lisse ; # - le semis d'arbres refait sur ce relief, donc le filtre de pente confronte # a de vraies falaises ; # - la destruction propre de tout ca. $runC = $null if ($hasLidar -and (Should-Run 'C')) { Start-Game "SCENARIO C - dalle LiDAR HD reelle, 2 M de triangles" $lidarTile # ORDRE IMPORTANT : viser D'ABORD, se promener ENSUITE. # # La position du joueur n'est connue qu'a l'estime, et la moindre collision # en chemin la decale sans que le script puisse s'en apercevoir. Une premiere # version de ce scenario commencait par un aller-retour de 30 m dans les # quatre directions "pour exercer le relief" : ce trajet traversait le semis # d'arbres, chaque tronc deviait la camera de quelques dizaines de # centimetres, et l'abattage qui suivait ne visait plus rien. Resultat : un # scenario en echec alors que le jeu, lui, se comportait correctement. # # En partant de l'origine - la seule position connue EXACTEMENT - l'abattage # est fiable. La promenade libre vient apres, quand la derive n'a plus # d'importance parce que plus rien n'a besoin d'etre vise. $expectedTreeC = if ($null -ne $lidarAim) { "$($lidarAim.Index)" } else { $null } if ($null -ne $lidarAim) { Write-Host ("--- Abattage sur relief reel : arbre {0}, tir depuis ({1:N1}, {2:N1}) a {3:N1} m ---" -f $lidarAim.Index, $lidarAim.CamX, $lidarAim.CamZ, $lidarAim.Standoff) GoTo $lidarAim.CamX $lidarAim.CamZ [void](Fell-WithRetry) Start-Sleep -Seconds 7 Write-Host "--- Ramassage du bois sur relief reel ---" GoTo $lidarAim.CamX ($lidarAim.CamZ - $lidarAim.Standoff + 1.5) Vacuum 3 Vacuum 2 2.4 } Write-Host "--- Marche libre sur le relief mesure, puis vol libre ---" # Plus rien a viser a partir d'ici : on peut parcourir de longues distances # sur des pentes reelles sans se soucier de la derive. C'est ce qui exerce le # suivi de terrain (Camera::snapToTerrain) sur des donnees mesurees, la ou le # terrain synthetique n'a que des pentes douces. foreach ($key in @($SC.W, $SC.D, $SC.S, $SC.A)) { Hold $key 45.0 } Send-Key $SC.F # vol libre : traverse le relief au lieu de le suivre Hold $SC.W 60.0 Send-Key $SC.F # retour en marche : la camera se recolle au sol Start-Sleep -Milliseconds 600 Write-Host "--- Redimensionnements avec 2 M de triangles a l'ecran ---" foreach ($size in @(@(800,600), @(1600,900), @(640,480), @(1920,1080), @(1280,720), @(1024,768))) { [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) Start-Sleep -Milliseconds 700 } Write-Host "--- Minimisation / restauration ---" [void][W32]::ShowWindow($script:hwnd, 6) Start-Sleep -Milliseconds 1500 [void][W32]::ShowWindow($script:hwnd, 9) Start-Sleep -Milliseconds 1500 $runC = Stop-Game } # =========================================================================== # SCENARIO D : vol en parapente sur la dalle LiDAR reelle (Phase 8) # =========================================================================== # Ce que ce scenario apporte, et que rien d'autre ne peut montrer : un decollage, # un vol pilote (virage + frein) et un atterrissage - detecte par le jeu lui-meme # contre le VRAI relief mesure, pas un plancher plat - sous les couches de # validation Vulkan, avec la camera en vue chase-cam (mode Glide) plutot qu'en # premiere personne. # # Contrairement aux scenarios precedents, on ne connait PAS a l'avance combien de # temps le vol va durer : le taux de chute est fixe, mais le relief sous le # parapente varie (562 m de denivele sur la dalle), donc l'altitude a laquelle il # rencontre le sol depend d'ou il vole. On POLL la sortie du jeu (Wait-ForLog) # plutot que de deviner un delai, et on force un atterrissage (touche V une # seconde fois) si le relief n'a rien rencontre dans un delai large - filet de # securite, pas le cas attendu. $runD = $null $paraglideLaunched = $false $paraglideEnded = $false if ($hasLidar -and (Should-Run 'D')) { Start-Game "SCENARIO D - vol en parapente, dalle LiDAR reelle" $lidarTile Write-Host "--- Passage en mode vol libre, puis prise de hauteur ---" Send-Key $SC.F # Walk -> Free : espace/shift redeviennent actifs HoldMs $SC.SPACE 1500 # ~21 unites de hauteur a 14 u/s : largement au-dessus du seuil de 5 m Write-Host "--- Decollage (V) ---" Send-Key $SC.V $paraglideLaunched = Wait-ForLog "Decollage en parapente" 3000 Write-Host (" decolle : {0}" -f $paraglideLaunched) if ($paraglideLaunched) { Write-Host "--- Vol pilote : virage a droite puis frein ---" HoldMs $SC.D 800 # ~20 degres de virage a droite, a vitesse angulaire constante HoldMs $SC.S 1000 # frein : vitesse et taux de chute doivent evoluer progressivement Write-Host "--- Attente de l'atterrissage (relief reel, duree non fixee a l'avance) ---" $landedNaturally = Wait-ForLog "Parapente : atterrissage" 45000 if (-not $landedNaturally) { Write-Host " pas encore pose apres 45 s : atterrissage force (filet de securite)." Send-Key $SC.V Wait-ForLog "vol interrompu" 3000 | Out-Null } $paraglideEnded = Wait-ForLog "(Parapente : atterrissage|vol interrompu)" 500 Write-Host (" vol termine : {0} (naturellement : {1})" -f $paraglideEnded, $landedNaturally) } Write-Host "--- Redimensionnements apres le vol ---" foreach ($size in @(@(800,600), @(1600,900), @(1280,720))) { [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) Start-Sleep -Milliseconds 700 } $runD = Stop-Game } # =========================================================================== # SCENARIO E : sortie a velo sur la dalle LiDAR reelle (Phase 13) # =========================================================================== # Ce que ce scenario apporte, et que rien d'autre ne peut montrer : la physique # du velo confrontee a un VERSANT MESURE - une descente reelle puis la remontee # du meme versant - sous les couches de validation Vulkan, avec la camera en vue # a la troisieme personne (mode Ride). # # LE POINT DE DEPART EST CHOISI, ET C'EST ESSENTIEL. Le harnais ne sait pas # tourner la camera (GLFW lit le curseur SYSTEME, cf. plus haut), donc le velo # part forcement au cap initial, yaw = -90 degres, c'est-a-dire plein NORD # (-Z : le nord DECROIT avec Z, voir Heightmap.hpp). Lance a un endroit # quelconque, il roulerait sur du plat et le run serait vert sans rien prouver. # # LE POINT DE DEPART **ET LES DEUX CAPS** SONT CHOISIS PAR MESURE. C'est ce qui a # demande le plus de travail dans ce scenario, et voici pourquoi. # # Trois versions ont echoue avant celle-ci, chacune pour une raison differente : # # 1. Depart quelconque : le velo roulait sur du plat, run vert sans rien montrer. # 2. Depart sur un versant a -21 % : la descente marchait, mais la remontee # depassait la pente maximale franchissable du modele (23,6 %, voir # world/Bike.hpp) et le velo s'immobilisait pour de bon. C'est ce run qui a # mis au jour le reglage de slopeSampleStep - voir NOTES-PHASE-VELO.md. # 3. Descendre puis faire demi-tour pour 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 (mesure : 18 s de roue # libre = 9,2 m de denivele, trop peu ; 30 s = 24,4 m mais remontee a # 0,1 km/h). D'autre part, "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 donc, en depouillant la dalle, la pente le long de # CHAQUE cap (differences centrees a +/-2 m, exactement comme le fait Bike), et # retient un point qui offre les deux a la fois : # # depart E 907875 / N 6439450, altitude 513,2 m # MONTEE cap 220 deg : +14,8 % en moyenne sur 90 m, pire section +16,8 %, # donc AUCUNE section infranchissable - le velo monte sans caler ; # DESCENTE cap 40 deg : -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 ainsi le denivele grimpe en elan supplementaire. # # La preuve n'est pas "le script a appuye sur les touches" mais la telemetrie que # le jeu emet chaque seconde (vitesse, pente sous les roues, altitude) : elle est # analysee plus bas. $runE = $null $bikeMounted = $false $bikeDismounted = $false if ($hasLidar -and (Should-Run 'E')) { Start-Game "SCENARIO E - sortie a velo, versant LiDAR reel" $lidarTile ` @("--start=907875,6439450") Write-Host "--- En selle (B) ---" Send-Key $SC.B $bikeMounted = Wait-ForLog "Velo : en selle" 3000 Write-Host (" en selle : {0}" -f $bikeMounted) if ($bikeMounted) { Write-Host "--- Cap 220 : face a la montee, asservi sur le cap (frein tire) ---" # Tolerance de 8 degres : au-dela, le devers de ce versant ferait sortir # la pente ressentie de la fourchette mesuree. $bikeTurnedUp = Turn-BikeTo 220.0 8.0 Write-Host (" face a la montee : {0}" -f $bikeTurnedUp) Write-Host "--- Montee au pedalage (versant a +14,8 %) ---" HoldMs $SC.W 20000 Write-Host "--- Cap 40 : face a la descente, asservi sur le cap ---" $bikeTurnedDown = Turn-BikeTo 40.0 8.0 Write-Host (" face a la descente : {0}" -f $bikeTurnedDown) Write-Host "--- Elan puis longue descente en roue libre ---" HoldMs $SC.W 3000 # on s'elance Start-Sleep -Seconds 32 # roue libre : c'est la gravite qui travaille, et # il lui faut de la DISTANCE pour se voir. Write-Host "--- Freinage manuel jusqu'a l'arret ---" HoldMs $SC.S 5000 Write-Host "--- Pied a terre (B) ---" Send-Key $SC.B $bikeDismounted = Wait-ForLog "Velo : pied a terre" 3000 Write-Host (" pied a terre : {0}" -f $bikeDismounted) } Write-Host "--- Redimensionnements apres la sortie ---" foreach ($size in @(@(800,600), @(1600,900), @(1280,720))) { [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) Start-Sleep -Milliseconds 700 } $runE = Stop-Game } # =========================================================================== # SCENARIO F : escalade sur une paroi LiDAR reelle (Phase 14) # =========================================================================== # Ce que ce scenario apporte, et que rien d'autre ne peut montrer : la physique # de l'escalade confrontee a une PAROI MESUREE, sous les couches de validation # Vulkan, avec la camera a la premiere personne (mode Climb). # # CE SCENARIO EST PLUS SIMPLE QUE LE SCENARIO E, ET CE N'EST PAS UN HASARD. # Le velo a demande un asservissement de cap (Turn-BikeTo) parce que sa dynamique # depend de la pente LE LONG DU CAP : mal oriente, il roule sur du plat. Les # commandes de l'escalade, elles, sont RELATIVES A LA PAROI - monter suit la # ligne de plus grande pente, traverser suit la ligne de niveau, toutes deux # imposees par le terrain. L'orientation de la camera n'a donc AUCUNE influence # sur la progression, et le harnais n'a rien a asservir. # # Une seule chose depend encore du cap : trouver la paroi au moment de # s'engager, puisque tryStart sonde devant le REGARD. Le harnais ne pouvant pas # tourner la camera (cf. plus haut), le joueur regarde forcement plein NORD # (yaw -90, front = (0,0,-1)). Le point de depart a donc ete choisi par mesure - # meme methode que pour le velo, meme outil d'esprit (tools/find_climb_walls.py) : # on a balaye la dalle a la recherche des points qui reunissent les trois # conditions du scenario, et il n'y en a que TROIS sur toute la dalle : # # depart marchable + une paroi grimpable a moins de 2 m PLEIN NORD # + une ascension qui gagne au moins 15 m # # >> retenu : E 907616 / N 6439312, pente au depart 14 % (on y tient # largement debout), paroi a portee plein nord, 41,7 m de gain simule. # # Le run enchaine les DEUX sorties d'escalade que le harnais peut atteindre : # 1. montee, traversee, desescalade, puis LACHAGE volontaire (retour au pied) ; # 2. re-engagement apres un repos, puis montee continue jusqu'au SOMMET. # # La troisieme sortie - la CHUTE par epuisement - n'est PAS exercee ici, et il # faut le dire : elle demanderait une paroi de plus de 62 m (la hauteur qu'une # jauge pleine permet), et il n'en existe pas d'abordable plein nord sur cette # dalle. Elle est couverte par les tests headless, ou elle est verifiee jusqu'a # la position de repli exacte. # # La preuve n'est pas "le script a appuye sur X" mais la telemetrie que le jeu # emet chaque seconde (energie, pente, altitude, gain), analysee plus bas. $runF = $null $climbEngaged = $false $climbReleased = $false $climbReEngaged = $false $climbToppedOut = $false if ($hasLidar -and (Should-Run 'F')) { Start-Game "SCENARIO F - escalade, paroi LiDAR reelle" $lidarTile ` @("--start=907616,6439312") Write-Host "--- Engagement sur la paroi (X) ---" Send-Key $SC.X $climbEngaged = Wait-ForLog "Escalade : engage sur la paroi" 3000 Write-Host (" engage : {0}" -f $climbEngaged) if ($climbEngaged) { Write-Host "--- Montee (Z) ---" HoldMs $SC.W 6000 Write-Host "--- Traversee vers la droite (D) ---" HoldMs $SC.D 3000 Write-Host "--- Traversee vers la gauche (Q) ---" HoldMs $SC.A 3000 Write-Host "--- Desescalade (S) ---" HoldMs $SC.S 3000 Write-Host "--- Lachage volontaire (X) ---" Send-Key $SC.X $climbReleased = Wait-ForLog "Escalade : lachee volontairement" 3000 Write-Host (" lachee : {0}" -f $climbReleased) Write-Host "--- Repos au sol (recuperation de la jauge) ---" Start-Sleep -Seconds 12 Write-Host "--- Re-engagement (X) ---" Send-Key $SC.X $climbReEngaged = Wait-ForLog "Escalade : engage sur la paroi" 3000 Write-Host (" re-engage : {0}" -f $climbReEngaged) if ($climbReEngaged) { Write-Host "--- Montee continue jusqu'au sommet ---" # 41,7 m simules a ~0,73 m/s de gain vertical => ~57 s. On tient la # touche jusqu'a ce que le jeu annonce le sommet - le temps vu par le # jeu n'est pas celui du script (meme lecon qu'au scenario E). # # 140 s et non 75. PHASE 17, et c'est une fragilite du SCENARIO mise # au jour, pas un defaut du jeu : 75 s ne laissaient que 18 s de marge # sur une montee de 57 s. Or la trajectoire du grimpeur depend du pas # de temps - a chaque image, la commande est projetee sur la ligne de # plus grande pente LOCALE - donc deux cadences d'images differentes # ne suivent pas exactement le meme chemin sur la paroi. Il a suffi # des 6 % de FPS que coute la faune de la Phase 17 (301 contre 320 # FPS, mesure) pour que la marge disparaisse : le grimpeur montait # bien (41,5 m contre 41,4 m au temoin) mais n'annoncait plus le # sommet avant l'echeance. Le harnais sort de la boucle des que le # sommet est atteint, donc cette marge ne coute rien quand tout va # bien. $deadline = (Get-Date).AddSeconds(140) while ((Get-Date) -lt $deadline -and -not $climbToppedOut) { HoldMs $SC.W 2000 $climbToppedOut = ($script:outSb.ToString() -match 'Escalade : SOMMET atteint') } Write-Host (" sommet atteint : {0}" -f $climbToppedOut) } } Write-Host "--- Redimensionnements apres l'escalade ---" foreach ($size in @(@(800,600), @(1600,900), @(1280,720))) { [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) Start-Sleep -Milliseconds 700 } $runF = Stop-Game } # =========================================================================== # SCENARIO G : EDITEUR DE NIVEAU (PHASE 15) # =========================================================================== # Trois processus, et il en faut trois : le seul controle qui prouve reellement # quelque chose sur la collision est un TEMOIN NEGATIF, c'est-a-dire la meme # marche refaite sans la scene. # # G1 edition : poser, selectionner, regler, supprimer, annuler, sauvegarder, # recharger, sortir du mode - puis resize et fermeture propre. # G2 jeu NORMAL sur le fichier ecrit par G1 : les objets doivent se charger # tout seuls (personne n'a demande l'editeur), etre dessines, et ARRETER # le joueur qui marche dessus. # G3 temoin : exactement la meme marche que G2, mais --no-scene. C'est # l'ecart entre les deux distances parcourues qui fait la preuve, pas la # distance de G2 prise isolement. # # --- CE QUE LE HARNAIS NE PEUT PAS FAIRE, ET SES CONSEQUENCES --------------- # Il ne pilote que le CLAVIER (GLFW lit le curseur SYSTEME, cf. l'en-tete de ce # script). Deux consequences assumees : # # * la POSE se fait a la touche INSER et non au clic. Les deux passent par le # meme code - main.cpp combine les deux fronts descendants en un seul # `placePressed` - donc le chemin exerce est bien celui du clic ; # * la camera de G1 est VERROUILLEE (--lock-input) et ne peut pas tourner : les # trois objets se posent donc au MEME point vise, empiles. Ce n'est pas une # limite de l'editeur (rien n'interdit d'empiler, d'ailleurs) mais une limite # du pilotage, la meme qui avait impose de choisir un point de depart precis # aux scenarios E et F. # # Les touches etendues (INSER, SUPPR, fleches) exigent le bit 24 du lParam : # GLFW indexe sa table de scancodes par (scancode | 0x100) pour celles-la, donc # l'oublier designerait une touche du PAVE NUMERIQUE au lieu de la bonne. # =========================================================================== $runG1 = $null; $runG2 = $null; $runG3 = $null $sceneG = Join-Path $root "build\scenario_g.vcsc" if ($hasLidar -and (Should-Run 'G')) { # On repart d'un fichier ABSENT : le premier lancement doit donc aussi # exercer le chemin "aucune scene sur disque", qui est le cas normal d'une # premiere partie. if (Test-Path $sceneG) { Remove-Item $sceneG -Force } $startG = "--start=907500,6439500" $lookG = "--look=-90,-8" Start-Game "SCENARIO G1 - editeur : catalogue, pose, reglage, annulation, sauvegarde" ` $lidarTile @("--editor", "--lock-input", $startG, $lookG, "--scene=$sceneG", "--no-vegetation") Write-Host "--- Pose du premier asset (INSER) ---" Send-KeyEx $SCX.INSERT $true Write-Host "--- Asset suivant (TAB) puis pose ---" Send-KeyEx $SCX.TAB $false Send-KeyEx $SCX.INSERT $true Write-Host "--- Rang 3 au clavier, rotation du pinceau, pose ---" Send-KeyEx $SCX.D3 $false HoldKeyEx $SCX.RIGHT $true 600 Send-KeyEx $SCX.INSERT $true Write-Host "--- Catalogue (L), selection (E), agrandissement ---" Send-KeyEx $SCX.L $false Send-KeyEx $SCX.E $false HoldKeyEx $SCX.UP $true 400 # PHASE 15, ajout ergonomique : parcourir les objets poses SANS viser. # Deux F3 (avance de deux rangs, boucle si necessaire) puis un F4 (recul # d'un rang) exercent le chemin de code sous Vulkan reel, pas seulement en # headless - la mecanique elle-meme (ordre, bouclage, ignorance pendant une # saisie) est verifiee par tests/logic_tests.cpp. On reselectionne ensuite # PAR LA VISEE avant de supprimer, pour ne pas changer quel objet cette # suppression retire et laisser intactes les mesures qui suivent. Write-Host "--- Cycle de selection sans viser (F3, F3, F4) ---" Send-KeyEx $SCX.F3 $false Send-KeyEx $SCX.F3 $false Send-KeyEx $SCX.F4 $false Write-Host "--- Reselection par la visee avant suppression ---" Send-KeyEx $SCX.E $false Write-Host "--- Suppression (SUPPR) puis annulation (RETOUR ARRIERE) ---" Send-KeyEx $SCX.DELETE $true Start-Sleep -Milliseconds 300 Send-KeyEx $SCX.BACKSPACE $false Start-Sleep -Milliseconds 300 Write-Host "--- Sauvegarde (F5) puis rechargement (F9) ---" Send-KeyEx $SCX.F5 $false Start-Sleep -Milliseconds 600 Send-KeyEx $SCX.F9 $false Start-Sleep -Milliseconds 600 Write-Host "--- Sortie du mode editeur (F2) ---" Send-KeyEx $SCX.F2 $false Start-Sleep -Milliseconds 600 Write-Host "--- Redimensionnements apres l'edition ---" foreach ($size in @(@(800,600), @(1600,900), @(1280,720))) { [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) Start-Sleep -Milliseconds 700 } $runG1 = Stop-Game # --- G2 : jeu NORMAL, chargement automatique et collision --------------- # Aucun --editor : c'est un lancement de partie ordinaire. Les objets doivent # s'y charger, s'y dessiner et y bloquer, sinon l'editeur ne serait qu'un # outil produisant un fichier que personne ne lit. Start-Game "SCENARIO G2 - jeu normal : objets charges et solides" ` $lidarTile @($startG, $lookG, "--scene=$sceneG", "--no-vegetation") Start-Sleep -Milliseconds 1200 Write-Host "--- Marche plein nord contre les objets poses ---" HoldKeyEx $SCX.W $false 1500 Start-Sleep -Milliseconds 1500 $runG2 = Stop-Game # --- G3 : le TEMOIN ----------------------------------------------------- # Meme binaire, meme terrain, meme point de depart, meme duree de touche. # SEULE la presence de la scene change. Sans ce temoin, "le joueur a avance # de 0,7 m" ne prouverait rien : il pourrait tout aussi bien s'etre heurte au # relief, ou n'avoir jamais recu la touche. Start-Game "SCENARIO G3 - temoin : la MEME marche sans la scene" ` $lidarTile @($startG, $lookG, "--no-scene", "--no-vegetation") Start-Sleep -Milliseconds 1200 Write-Host "--- Meme marche, sans aucun objet pose ---" HoldKeyEx $SCX.W $false 1500 Start-Sleep -Milliseconds 1500 $runG3 = Stop-Game } # =========================================================================== # SCENARIO H : besoins primaires (PHASE 16) # =========================================================================== # Ce que ce scenario apporte, et que rien d'autre ne peut montrer : les quatre # jauges qui tournent SOUS VULKAN, avec les couches de validation, sur un relief # mesure - et surtout la chaine complete du point d'eau, qui n'existe que sur du # relief reel : detection au chargement, portee, refus a distance. # # LE DEPART EST UN POINT D'EAU DETECTE, PAS UN POINT CHOISI A LA MAIN. Le jeu # journalise au demarrage les creux qu'il a retenus sur la dalle ; le premier # d'entre eux est en monde (-75, 285), soit E 907425 / N 6439215 en Lambert 93 # (conversion de Heightmap::toProjected : est = 907000 + x + 500, nord = # 6440000 - z - 500). Si le detecteur change d'avis, ce scenario le dira - la # premiere touche T repondra "trop loin" au lieu de "pas soif". # # CE QUE PROUVE CHAQUE TOUCHE T, ET POURQUOI CES DEUX-LA : # * au point d'eau -> "Boire : soif etanchee au point d'eau (0.000000 m)". # Ce message n'est emis QU'APRES le test de portee ET le remplissage # effectif de la jauge : le voir prouve les deux d'un coup, et la distance # qu'il porte est celle reellement calculee. # (Une premiere version attendait ici "Boire : pas soif", en supposant la # jauge encore exactement pleine. Elle ne l'est pas : deux secondes de jeu # l'ont deja fait descendre de quelques millioniemes, invisibles a # l'affichage entier mais suffisants pour que drink() reussisse. Le message # attendu ne sortait donc jamais.) # * a 30 m de la -> "le point d'eau le plus proche est a N m". # C'est le controle negatif : sans lui, une portee cassee (ou infinie) # donnerait exactement le meme premier message. # # LE RESTE DU RUN EST UNE MESURE, PAS UNE ANIMATION : ~100 s de marche puis # ~60 s d'immobilite complete. La telemetrie emise chaque seconde doit montrer # la forme DESCENDRE pendant la marche et REMONTER pendant l'arret. Un seul des # deux ne prouverait rien : une jauge qui ne fait que descendre est une jauge # sans repos, une jauge qui ne fait que monter est une jauge qui ne coute rien. $runH = $null $drinkAtSource = $false $drinkTooFar = $false if ($hasLidar -and (Should-Run 'H')) { Start-Game "SCENARIO H - besoins primaires, point d'eau LiDAR" $lidarTile ` @("--start=907425,6439215", "--no-vegetation") Write-Host "--- Boire AU point d'eau (T) ---" Send-Key $SC.T $drinkAtSource = Wait-ForLog "Boire : soif etanchee au point d'eau" 3000 Write-Host (" a portee du point d'eau : {0}" -f $drinkAtSource) Write-Host "--- S'en eloigner, puis boire de nouveau (controle negatif) ---" HoldMs $SC.W 2500 Start-Sleep -Milliseconds 500 Send-Key $SC.T $drinkTooFar = Wait-ForLog "point d'eau le plus proche est a" 3000 Write-Host (" refus a distance : {0}" -f $drinkTooFar) # Marche continue, en va-et-vient pour rester sur le meme replat : ce qui # compte est la DUREE d'effort, pas la distance parcourue. Le va-et-vient # evite aussi de finir coince contre un versant raide - un joueur bloque ne # se deplace plus, donc ne se fatigue plus (main.cpp lit le deplacement REEL # de la camera, pas les touches), et le scenario deviendrait vert sans avoir # rien mesure. # 160 s et non 100 : a la marche continue, la forme perd 1,85 % par tranche # de 100 s (1/(90 min), voir world/Needs.hpp), et l'affichage est ENTIER. Un # premier reglage a 100 s a rendu 99 % puis 98 % sur deux runs - la marge # tenait a un point d'arrondi, et une marche genee par le relief (le joueur # bute, donc ne se fatigue plus) l'aurait effacee. 160 s laissent ~3 %. Write-Host "--- 160 s de marche (la forme doit DESCENDRE) ---" foreach ($i in 1..40) { HoldMs $SC.W 2000 HoldMs $SC.S 2000 } Write-Host "--- 60 s d'immobilite complete (la forme doit REMONTER) ---" Start-Sleep -Seconds 60 Write-Host "--- Redimensionnements ---" foreach ($size in @(@(800,600), @(1280,720))) { [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) Start-Sleep -Milliseconds 700 } $runH = Stop-Game } # =========================================================================== # SCENARIO I (PHASE 17) - empreinte environnementale : faune et frequentation # =========================================================================== # Ce que ce scenario apporte, et que rien d'autre ne peut montrer : # # 1. LES ANIMAUX SONT DESSINES SOUS VULKAN, avec les couches de validation. # C'est une geometrie neuve (world/AnimalMesh.cpp) et une nouvelle source de # DrawItem ; les tests headless ne touchent ni au pipeline ni au GPU. # # 2. LE SEMIS TIENT SUR DU RELIEF MESURE. Le tirage-rejet filtre par pente et # par couvert : sur du relief lisse il passe toujours, sur un massif a 562 m # de denivele il peut ne RIEN rendre. C'est exactement le piege des phases # precedentes - un filtre qui refuse tout donne un run parfaitement vert - # d'ou le controle explicite "au moins un animal au depart". # # 3. LA MEMOIRE DE FREQUENTATION MONTE REELLEMENT EN JEU. Le harnais fait # marcher le joueur en va-et-vient sur place : la telemetrie doit montrer la # frequentation locale grimper, et des animaux PARTIR. Le comportement des # seuils est prouve ailleurs (tests headless) ; ce qui est prouve ICI est que # le cablage de main.cpp alimente bien la memoire avec la vraie position et # la vraie activite du joueur, une fois par image. # # LE VA-ET-VIENT, ET POURQUOI : meme raison qu'au scenario H. Ce qui compte est # la DUREE de presence dans le meme secteur, pas la distance parcourue - et un # joueur qui finirait coince contre un versant ne marcherait plus, donc ne # dérangerait plus (l'activite est deduite du deplacement REEL de la camera). # # LIMITE CONNUE, ASSUMEE : la dalle de reference n'a pas de carte de couvert # LiDAR (LHD_0907_6440_1m_canopy.vchm est absent), donc la faune y est placee # avec le couvert de substitut (WildlifeParams::coverWithoutMap). Le filtre par # couvert REEL est couvert par les tests headless, pas par ce scenario. $runI = $null if ($hasLidar -and (Should-Run 'I')) { Start-Game "SCENARIO I - faune et frequentation sur relief mesure" $lidarTile $wildlifeSeededLog = Wait-ForLog "animaux au depart" 5000 Write-Host (" faune semee au demarrage : {0}" -f $wildlifeSeededLog) # 240 s et non 120. Mesure du premier run : a 120 s, le voisinage se vidait # puis se REPEUPLAIT - les cellules a une centaine de metres ne sont derangees # qu'au tiers de la vitesse de celle ou l'on se tient (ponderation en carre, # voir Habitat::notePresence), donc elles passaient encore sous le seuil de # reapparition. Il faut environ trois minutes pour que la couronne entiere # depasse le seuil. C'est le comportement voulu - on ne vide pas un versant # en deux minutes - mais il fallait que le scenario dure assez pour le voir. Write-Host "--- 240 s de va-et-vient sur place (la frequentation doit MONTER) ---" foreach ($i in 1..60) { HoldMs $SC.W 2000 HoldMs $SC.S 2000 } Write-Host "--- Redimensionnements (les animaux restent dessines) ---" foreach ($size in @(@(800,600), @(1280,720))) { [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) Start-Sleep -Milliseconds 700 } $runI = Stop-Game } # =========================================================================== # SCENARIO J : recolte de matieres sur gisement mesure (PHASE 22) # =========================================================================== # Ce que ce scenario apporte, et que les tests headless ne peuvent pas donner : # la chaine COMPLETE, sous les couches de validation Vulkan, depuis un gisement # que LE JEU a detecte lui-meme sur le relief mesure jusqu'a une motte d'argile # dans l'inventaire du joueur. # # LE POINT DE DEPART N'EST PAS CHOISI A LA MAIN. Le jeu journalise ses gisements # au chargement, avec leurs coordonnees MONDE ; le script les relit et s'y rend. # C'est la meme methode qu'au scenario H pour les points d'eau, et elle a la meme # vertu : si le detecteur change, le scenario suit sans etre retouche, au lieu de # viser une position gravee dans le script qui ne voudrait plus rien dire. # # La conversion monde -> EPSG:2154 est celle de la dalle de reference # (LHD_0907_6440, emprise de 1000 m) : E = 907500 + x, N = 6439500 - z. Elle est # verifiee a l'execution par la ligne "Position de depart" que le jeu emet. # # LES DEUX SENS DU TEST DE PORTEE, comme au scenario H : on creuse SUR le # gisement (doit reussir), puis on s'en eloigne de 30 m et on recreuse (doit # etre REFUSE, avec la distance). Un scenario qui ne ferait que le premier ne # distinguerait pas "la portee marche" de "la touche produit toujours quelque # chose". # # CE QUE CE SCENARIO NE COUVRE PAS, ET POURQUOI. Les PLANTES A FIBRES ne sont # pas exercees ici : la dalle de reference n'a pas de carte de couvert produite # (meme manque qu'au scenario I pour la faune), donc la voie "lisiere" y est # muette et la voie "sol ouvert" demanderait d'abattre plusieurs arbres dans la # meme cellule puis d'attendre. Elles sont couvertes par les tests headless, des # deux cotes et avec leurs temoins. La RESINE n'est pas exercee non plus : elle # demande de VISER un arbre, or le harnais ne sait pas tourner la camera (voir # l'en-tete) et l'unique position de tir connue de cette dalle est deja consommee # par l'abattage du scenario C. Ces deux manques sont notes dans # NOTES-PHASE22.md ; ils ne sont pas des echecs, ce sont des limites du harnais. $runJ = $null $digDeposit = $null $digAtSource = $false $digTooFar = $false $digPicked = $false $fiberSeeded = $false $fiberPulled = $false $fiberPicked = $false $fiberRegrowing = $false if ($hasLidar -and (Should-Run 'J')) { Start-Game "SCENARIO J - recolte de matieres, gisement LiDAR reel" $lidarTile # Le jeu emet ses gisements au chargement ; on attend la liste puis on la lit. [void](Wait-ForLog 'Gisements : ' 8000) $depositMatch = [regex]::Match($script:outSb.ToString(), 'gisement \d+ : (argile|sable) en ([-0-9.]+) ([-0-9.]+) ([-0-9.]+)') if ($depositMatch.Success) { $digDeposit = [pscustomobject]@{ Kind = $depositMatch.Groups[1].Value X = [double]$depositMatch.Groups[2].Value Z = [double]$depositMatch.Groups[4].Value } Write-Host (" gisement retenu : {0} en ({1:N1}, {2:N1})" -f $digDeposit.Kind, $digDeposit.X, $digDeposit.Z) } else { Write-Host " [ATTENTION] le jeu n'a journalise aucun gisement." } $runJ = Stop-Game if ($null -ne $digDeposit) { # On RELANCE le jeu en demarrant SUR le gisement. Le harnais ne sait se # deplacer que sur les axes du monde et a l'estime ; parcourir plusieurs # centaines de metres de relief reel accumulerait une derive bien # superieure aux 3,5 m de portee. --start supprime le probleme, exactement # comme pour le velo (scenario E) et le point d'eau (scenario H). $eastings = 907500.0 + $digDeposit.X $northing = 6439500.0 - $digDeposit.Z Start-Game "SCENARIO J - creuser le gisement, puis le meme geste a 30 m" $lidarTile ` @("--start=$eastings,$northing") Write-Host "--- Creuser SUR le gisement (Y) ---" Send-Key $SC.Y $digAtSource = Wait-ForLog "Creuser : (une|un) .* tombe a vos pieds" 3000 Write-Host (" matiere detachee du gisement : {0}" -f $digAtSource) Write-Host "--- Ramasser la matiere produite (R) ---" Vacuum 3 $digPicked = ($script:outSb.ToString() -match 'Ramasse : (une motte d.argile|une poignee de sable)') Write-Host (" matiere ramassee : {0}" -f $digPicked) Write-Host "--- S'en eloigner de 30 m, puis recreuser (controle negatif) ---" Hold $SC.D 30.0 Send-Key $SC.Y $digTooFar = Wait-ForLog "Creuser : le gisement de .* est a .* m \(il faut etre a" 3000 Write-Host (" refus a distance : {0}" -f $digTooFar) Write-Host "--- Redimensionnements apres la recolte ---" foreach ($size in @(@(800,600), @(1280,720))) { [void][W32]::SetWindowPos($script:hwnd, [IntPtr]::Zero, 0, 0, $size[0], $size[1], ($SWP_NOMOVE -bor $SWP_NOZORDER)) Start-Sleep -Milliseconds 700 } $runJ2 = Stop-Game # Les deux processus du scenario comptent pour un : on concatene leurs # journaux et on garde le PIRE code de sortie, sans quoi un plantage du # premier passerait inapercu. $runJ = [pscustomobject]@{ ExitCode = if ($runJ.ExitCode -ne 0) { $runJ.ExitCode } else { $runJ2.ExitCode } Lines = @($runJ.Lines) + @($runJ2.Lines) } } # --- J3 : les PLANTES A FIBRES, et il faut changer de dalle pour ca ----- # # La dalle de reference du harnais (LHD_0907_6440) n'a PAS de carte de # couvert produite - le meme manque qu'au scenario I pour la faune depuis la # Phase 17. Or c'est la carte de couvert qui porte la voie "lisiere" du # semis. Sur cette dalle, le semis est donc muet, et un scenario qui s'y # tiendrait ne prouverait rien : il constaterait un zero PARFAITEMENT # CORRECT et le prendrait pour une couverture de test. # # On charge donc la zone de 25 km2, qui a la sienne. Le point de depart n'a # pas ete choisi a l'oeil : un balayage de la zone entiere au pas de 50 m, # avec la fonction de semis ELLE-MEME, a cherche les cellules dont la # densite est maximale ET qui portent des plantes a portee d'arrachage. Il y # en a 1656 sur la zone ; la meilleure est monde (1450, -1750), altitude # 1777 m, couvert 0,240 - soit le milieu exact de la bande de lisiere. # # Georeference de la zone : coin nord-ouest E 899000 / N 6440000, emprise # 5000 m, centre a l'origine du monde. Donc E = 901500 + x et # N = 6440000 - (z + 2500). Verifiee par la ligne "Position de depart" que # le jeu emet, et par le point de depart par defaut (E 901500 / N 6437500 = # monde (0, 0)). # # POURQUOI PAS AU POINT DE DEPART PAR DEFAUT DE LA ZONE : il est a 1947 m, # au-dessus de la limite des arbres (FiberPlantParams::maxAltitude = 1900). # Le semis y rend zero, et c'est le comportement voulu. Mesure faite : zero # plante soumise, zero touffe d'herbe. Un scenario pose la aurait ete vert # sans rien exercer. if ($hasZone) { Start-Game "SCENARIO J3 - plantes a fibres en lisiere LiDAR (zone 25 km2)" $zoneTile ` @("--start=902950,6439250") $fiberSeeded = Wait-ForLog "Plantes a fibres : [1-9][0-9]* soumises" 12000 Write-Host (" plantes a fibres semees par la lisiere : {0}" -f $fiberSeeded) Write-Host "--- Arracher la plante a portee (I) ---" Send-Key $SC.I $fiberPulled = Wait-ForLog "Fibres : la tige cede" 3000 Write-Host (" tige arrachee : {0}" -f $fiberPulled) Write-Host "--- Ramasser le fagot (R) ---" Vacuum 2 $fiberPicked = ($script:outSb.ToString() -match 'Ramasse : une tige a fibres') Write-Host (" fagot ramasse : {0}" -f $fiberPicked) # La plante doit etre EN REPOUSSE, pas disparue : c'est ce qui distingue # un semis deterministe d'un semis qu'on aurait ampute. $fiberRegrowing = ($script:outSb.ToString() -match 'Plantes a fibres : \d+ soumises, [1-9][0-9]* arrachee') Write-Host (" plante en repousse (et non disparue) : {0}" -f $fiberRegrowing) $runJ3 = Stop-Game $runJ = [pscustomobject]@{ ExitCode = if ($runJ.ExitCode -ne 0) { $runJ.ExitCode } else { $runJ3.ExitCode } Lines = @($runJ.Lines) + @($runJ3.Lines) } } else { Write-Host "--- Plantes a fibres : IGNORE, la zone de 25 km2 n'est pas produite ---" } } # =========================================================================== # Analyse # =========================================================================== function Count-Match($lines, $pattern) { @($lines | Where-Object { $_ -match $pattern }).Count } $all = @() if ($null -ne $runA) { $all += @($runA.Lines) } if ($null -ne $runB) { $all += @($runB.Lines) } if ($null -ne $runC) { $all += @($runC.Lines) } if ($null -ne $runD) { $all += @($runD.Lines) } if ($null -ne $runE) { $all += @($runE.Lines) } if ($null -ne $runF) { $all += @($runF.Lines) } if ($null -ne $runG1) { $all += @($runG1.Lines) + @($runG2.Lines) + @($runG3.Lines) } if ($null -ne $runH) { $all += @($runH.Lines) } if ($null -ne $runI) { $all += @($runI.Lines) } if ($null -ne $runJ) { $all += @($runJ.Lines) } # --- PHASE 24 : le journal BRUT du jeu, sur disque --------------------------- # Le harnais imprime ses CONCLUSIONS ; quand l'une d'elles est fausse, il n'y a # aucun moyen de savoir ce que le jeu avait reellement emis. Ce projet a perdu # cinq phases sur exactement ce manque (dette du velo, Phases 17 a 22 : la ligne # etait dans $runE.Lines depuis le debut). Le dump coute une ecriture de fichier # par execution et rend l'ecart entre "le jeu s'est trompe" et "le script a mal # lu" verifiable au lieu d'etre suppose. # HORODATE, et non un nom fixe. Le premier jet ecrivait toujours # 'vercora_last_run.log' : une execution suivante ECRASAIT la precedente, et # c'est arrive tout de suite - le run 5 de la Phase 24 a echoue, le run 6 a # reussi et a efface la seule trace de l'echec, qui est devenu indiagnosticable. # Un journal de diagnostic qui ne survit pas a l'execution suivante ne sert a # rien : les echecs de ce harnais sont justement ceux qu'on ne reproduit pas a # volonte. # # PHASE 26 : le dump porte desormais un EN-TETE PAR PROCESSUS. Sans lui, les # quatorze runs etaient concatenes bout a bout et une ligne du journal n'etait # rattachable a aucun scenario : le run en echec de la Phase 25 (78 % de la # telemetrie du scenario I manquante) n'aurait de toute facon pas ete # diagnosticable a partir du dump seul, meme s'il avait survecu. On ecrit aussi # la DUREE MUR de chaque processus, qui est ce qui distingue "le jeu a emis # moins de lignes par seconde" de "le scenario a dure moins longtemps". # # $dumpLines est CONSTRUIT A PART de $all : aucune assertion du harnais ne voit # ces en-tetes, donc l'instrumentation ne peut pas changer un verdict. $dumpLines = @() foreach ($r in $script:allRuns) { $dumpLines += "" $dumpLines += "########## RUN {0} ##########" -f $r.Label $dumpLines += "# demarre a : {0}" -f $r.StartedAt.ToString('HH:mm:ss.fff') $dumpLines += "# duree mur : {0} s" -f $r.WallSeconds $dumpLines += "# code de sortie: {0}" -f $r.ExitCode $dumpLines += "# lignes : {0}" -f $r.Lines.Count $dumpLines += $r.Lines } $stamp = (Get-Date).ToString('yyyyMMdd-HHmmss') $rawLog = Join-Path $env:TEMP "vercora_run_$stamp.log" try { $dumpLines | Set-Content -Path $rawLog -Encoding UTF8 } catch {} # Une copie a nom fixe reste bien commode pour "regarder le dernier". try { $dumpLines | Set-Content -Path (Join-Path $env:TEMP 'vercora_last_run.log') -Encoding UTF8 } catch {} Write-Host "Journal brut du jeu : $rawLog ($($all.Count) lignes)" $validation = @($all | Where-Object { $_ -match '\[Validation\]' }) $errors = @($all | Where-Object { $_ -match '^\[ERROR\]' }) $warnings = @($all | Where-Object { $_ -match '^\[WARN\]' }) $cleanA = ($null -eq $runA) -or ((Count-Match $runA.Lines 'Fermeture propre') -ge 1) $cleanB = ($null -eq $runB) -or ((Count-Match $runB.Lines 'Fermeture propre') -ge 1) $exitA = if ($null -ne $runA) { $runA.ExitCode } else { 0 } $exitB = if ($null -ne $runB) { $runB.ExitCode } else { 0 } # Scenario C : tout ce qui suit vaut $true quand la dalle est absente, pour que # son absence ignore le scenario au lieu de faire echouer le script. $cleanC = $true; $exitC = 0; $lidarLoaded = $true; $lidarFelled = $true; $lidarPicked = 0 if ($null -ne $runC) { $cleanC = (Count-Match $runC.Lines 'Fermeture propre') -ge 1 $exitC = $runC.ExitCode # Preuve que c'est bien la DALLE qui a ete chargee, et non un repli # silencieux sur le generateur procedural - lequel produirait par ailleurs un # scenario entierement vert. $lidarLoaded = (Count-Match $runC.Lines 'Terrain reel charge') -ge 1 $felledC = @($runC.Lines | ForEach-Object { $m = [regex]::Match($_, "Abattage de l'arbre (\d+)"); if ($m.Success) { $m.Groups[1].Value } }) $lidarFelled = ($felledC -contains $expectedTreeC) $lidarPicked = (Count-Match $runC.Lines 'Ramasse : ') } # Scenario D : meme convention, $true quand la dalle est absente. $cleanD = $true; $exitD = 0 if ($null -ne $runD) { $cleanD = (Count-Match $runD.Lines 'Fermeture propre') -ge 1 $exitD = $runD.ExitCode } # Scenario E : meme convention, $true quand la dalle est absente. # # Le depouillement ne se contente PAS de constater qu'on est monte sur le velo : # il relit la telemetrie emise chaque seconde et verifie que la physique a # reellement travaille sur du relief - une descente franche, une remontee, et # des vitesses dans la fourchette annoncee. Un velo bloque a 0 km/h contre un # arbre donnerait autrement un scenario parfaitement vert. $cleanE = $true; $exitE = 0 $bikeMaxKmh = 0.0; $bikeDescentKmh = 0.0; $bikeClimbKmh = -1.0 $bikeDescentMean = 0.0; $bikeClimbMean = 0.0 $bikeDescentN = 0; $bikeClimbN = 0 $bikeClimbGain = 0.0; $bikeStalled = 0 $bikeMinSlope = 0.0; $bikeMaxSlope = 0.0 $bikeMinAlt = 0.0; $bikeMaxAlt = 0.0; $bikeSamples = 0 if ($null -ne $runE) { $cleanE = (Count-Match $runE.Lines 'Fermeture propre') -ge 1 $exitE = $runE.ExitCode $kmh = @(); $slopes = @(); $alts = @(); $lastAlt = $null foreach ($line in $runE.Lines) { $m = [regex]::Match($line, 'Velo : ([-0-9.]+) km/h, pente ([-0-9.]+) %.*altitude ([-0-9.]+) m') if ($m.Success) { $v = [double]$m.Groups[1].Value $p = [double]$m.Groups[2].Value $a = [double]$m.Groups[3].Value $kmh += $v; $slopes += $p; $alts += $a if ($v -gt $bikeMaxKmh) { $bikeMaxKmh = $v } # Vitesse la plus elevee constatee EN DESCENTE franche, et la plus # elevee constatee EN MONTEE franche : c'est leur ecart qui montre # que la pente pilote bien la vitesse. if ($p -le -8.0) { if ($v -gt $bikeDescentKmh) { $bikeDescentKmh = $v } $bikeDescentMean += $v; $bikeDescentN++ } if ($p -ge 8.0) { if ($v -gt $bikeClimbKmh) { $bikeClimbKmh = $v } # Moyenne calculee EN MOUVEMENT seulement, et calages comptes a # part. Melanger les deux donnerait une moyenne qui ne decrit # rien : ni la vitesse de montee, ni la frequence des arrets. if ($v -gt 0.5) { $bikeClimbMean += $v; $bikeClimbN++ } else { $bikeStalled++ } } # Denivele REELLEMENT gagne : somme des montees d'altitude entre deux # releves consecutifs pendant que la pente est ascendante. C'est la # seule mesure qui prouve que le velo MONTE, par opposition a "une # pente positive a ete rencontree" (vrai meme a l'arret) ou a "un pic # de vitesse en cote" (vrai en emportant l'elan de la descente). if ($p -ge 2.0 -and $lastAlt -ne $null -and $a -gt $lastAlt) { $bikeClimbGain += ($a - $lastAlt) } $lastAlt = $a } } $bikeSamples = $kmh.Count # MOYENNES et non seulement maxima. Le maximum en montee est trompeur : il # inclut la seconde ou le velo aborde la cote en emportant encore la vitesse # de la descente precedente. La moyenne, elle, dit ce que le velo tient # REELLEMENT dans la pente, et c'est elle qui porte la comparaison. if ($bikeDescentN -gt 0) { $bikeDescentMean = $bikeDescentMean / $bikeDescentN } if ($bikeClimbN -gt 0) { $bikeClimbMean = $bikeClimbMean / $bikeClimbN } if ($bikeSamples -gt 0) { $bikeMinSlope = ($slopes | Measure-Object -Minimum).Minimum $bikeMaxSlope = ($slopes | Measure-Object -Maximum).Maximum $bikeMinAlt = ($alts | Measure-Object -Minimum).Minimum $bikeMaxAlt = ($alts | Measure-Object -Maximum).Maximum } } $linesA = if ($null -ne $runA) { $runA.Lines } else { @() } $linesB = if ($null -ne $runB) { $runB.Lines } else { @() } $picked = @($linesA | Where-Object { $_ -match 'Ramasse : ' }) $knapped = Count-Match $linesA 'eclat tranchant se detache' $felledA = @($linesA | ForEach-Object { $m = [regex]::Match($_, "Abattage de l'arbre (\d+)"); if ($m.Success) { $m.Groups[1].Value } }) $felledB = @($linesB | ForEach-Object { $m = [regex]::Match($_, "Abattage de l'arbre (\d+)"); if ($m.Success) { $m.Groups[1].Value } }) $aimHit = ($null -eq $runA) -or ($felledA -contains $expectedTree) # Le scenario B doit avoir abattu l'arbre 7 (ce qui prouve qu'on l'a atteint et # vise) puis avoir pousse dans sa souche. On ne conclut RIEN sur le comportement # de la collision ici - voir le commentaire du scenario B. $collisionPathExercised = ($null -eq $runB) -or (($felledB -contains '7') -and ((Count-Match $linesB 'Debitage en cours') -ge 1)) $kinds = @{} foreach ($p in $picked) { $m = [regex]::Match($p, 'Ramasse : (?:une|un) (\w+)') if ($m.Success) { $kinds[$m.Groups[1].Value] = $true } } # Scenario F : meme convention, $true quand la dalle est absente. # # Comme pour le velo, le depouillement ne se contente PAS de constater qu'on # s'est engage : il relit la telemetrie emise chaque seconde et verifie que # l'escalade a reellement travaille sur du relief - de la pente au-dessus du # seuil de paroi, une jauge qui DESCEND, et un gain d'altitude reel. Un grimpeur # accroche sans bouger donnerait autrement un scenario parfaitement vert. $cleanF = $true; $exitF = 0 $climbSamples = 0 $climbMinStamina = 100.0; $climbMaxGain = 0.0 $climbMinSlope = 1e9; $climbMaxSlope = 0.0 $climbMinAlt = 1e9; $climbMaxAlt = -1e9 $climbStaminaRecovered = $false if ($null -ne $runF) { $cleanF = (Count-Match $runF.Lines 'Fermeture propre') -ge 1 $exitF = $runF.ExitCode $staminas = @() foreach ($line in $runF.Lines) { $m = [regex]::Match($line, 'Escalade : energie ([-0-9.]+) %, pente ([-0-9.]+) %, altitude ([-0-9.]+) m, gain ([-0-9.]+) m') if ($m.Success) { $e = [double]$m.Groups[1].Value $p = [double]$m.Groups[2].Value $a = [double]$m.Groups[3].Value $g = [double]$m.Groups[4].Value $climbSamples++ $staminas += $e if ($e -lt $climbMinStamina) { $climbMinStamina = $e } if ($g -gt $climbMaxGain) { $climbMaxGain = $g } if ($p -lt $climbMinSlope) { $climbMinSlope = $p } if ($p -gt $climbMaxSlope) { $climbMaxSlope = $p } if ($a -lt $climbMinAlt) { $climbMinAlt = $a } if ($a -gt $climbMaxAlt) { $climbMaxAlt = $a } } } # La jauge doit REMONTER quelque part dans le run : c'est la preuve que le # repos au sol entre les deux engagements a bien recupere. Sans ce controle, # une recuperation cassee passerait inapercue - la seconde ascension serait # simplement plus courte. for ($i = 1; $i -lt $staminas.Count; $i++) { if ($staminas[$i] -gt $staminas[$i - 1] + 1.0) { $climbStaminaRecovered = $true } } if ($climbSamples -eq 0) { $climbMinSlope = 0.0; $climbMinAlt = 0.0; $climbMaxAlt = 0.0 } } # Scenario G : meme convention que C..F, $true quand la dalle est absente. # # Le depouillement ne se contente pas de constater que les touches sont passees. # Il verifie que le catalogue s'est constitue, que des objets ont ete REELLEMENT # poses puis relus depuis le disque, et - le point qui compte - que ces objets # ARRETENT le joueur, en comparant la distance parcourue a celle du temoin. $cleanG1 = $true; $cleanG2 = $true; $cleanG3 = $true $exitG1 = 0; $exitG2 = 0; $exitG3 = 0 $editorEntered = $false; $editorLeft = $false $catalogCount = 0; $editorPlaced = 0; $editorDeleted = 0; $editorUndone = 0 $editorSelected = $false; $editorSaved = 0; $editorReloaded = 0 $editorPlacedDistinct = 0 $editorCycled = 0 $sceneAutoLoaded = 0; $sceneSolid = 0 $walkWithScene = 0.0; $walkControl = 0.0 if ($null -ne $runG1) { $cleanG1 = (Count-Match $runG1.Lines 'Fermeture propre') -ge 1 $cleanG2 = (Count-Match $runG2.Lines 'Fermeture propre') -ge 1 $cleanG3 = (Count-Match $runG3.Lines 'Fermeture propre') -ge 1 $exitG1 = $runG1.ExitCode; $exitG2 = $runG2.ExitCode; $exitG3 = $runG3.ExitCode $editorEntered = (Count-Match $runG1.Lines '=== MODE EDITEUR ===') -ge 1 $editorLeft = (Count-Match $runG1.Lines 'retour au JEU') -ge 1 $editorPlaced = Count-Match $runG1.Lines 'Editeur : pose de' # Nombre de lignes de pose DISTINCTES. Discriminant ajoute apres un run ou le # compte etait de 9 pour trois touches envoyees : il separe "le jeu a # reellement pose neuf objets" (neuf lignes differentes, les identifiants # allant de 1 a 9) de "la meme ligne a ete comptee plusieurs fois" (trois # lignes distinctes repetees), qui sont deux defauts sans rapport - l'un dans # le jeu, l'autre dans la capture de sortie de ce script. $editorPlacedDistinct = (@($runG1.Lines | Where-Object { $_ -match 'Editeur : pose de' } | Select-Object -Unique)).Count $editorDeleted = Count-Match $runG1.Lines 'Editeur : objet \d+ .* supprime' $editorUndone = Count-Match $runG1.Lines 'Editeur : annule' $editorSelected = (Count-Match $runG1.Lines 'Editeur : selection de l''objet') -ge 1 # F3/F4 : selection SANS viser (ajout ergonomique post-Phase 15). Deux F3 # puis un F4 sont envoyes ; ce compte doit valoir 3, sans quoi une des # trois touches a ete perdue en route (scancode faux, front non resynchro- # nise, etc.) - exactement le genre de defaut que le headless ne peut pas # voir puisqu'il ne passe jamais par GLFW/PostMessage. $editorCycled = Count-Match $runG1.Lines '\[F3/F4\]' $m = [regex]::Match(($runG1.Lines -join "`n"), 'Editeur : (\d+) asset\(s\) au catalogue') if ($m.Success) { $catalogCount = [int]$m.Groups[1].Value } # Nombre d'objets REELLEMENT ecrits sur le disque, tel que le jeu l'a # journalise - et non tel que le script croit les avoir poses. $m = [regex]::Match(($runG1.Lines -join "`n"), 'Scene : (\d+) objet\(s\) ecrits') if ($m.Success) { $editorSaved = [int]$m.Groups[1].Value } # Rechargement a la touche F9, DANS le meme processus. $reloadMatches = [regex]::Matches(($runG1.Lines -join "`n"), 'Scene : (\d+) objet\(s\) charges') if ($reloadMatches.Count -gt 0) { $editorReloaded = [int]$reloadMatches[$reloadMatches.Count - 1].Groups[1].Value } # G2 : chargement AUTOMATIQUE hors mode editeur. $m = [regex]::Match(($runG2.Lines -join "`n"), 'Scene : (\d+) objet\(s\) charges .*?\((\d+) solide') if ($m.Success) { $sceneAutoLoaded = [int]$m.Groups[1].Value $sceneSolid = [int]$m.Groups[2].Value } # Distance REELLEMENT parcourue vers le nord, lue dans la trace de position # emise chaque seconde. Le nord est en -Z (voir Heightmap.hpp), d'ou le signe. function Get-WalkDistance($lines) { $samples = @($lines | ForEach-Object { $mm = [regex]::Match($_, 'Camera : yaw .* position ([-0-9.]+) ([-0-9.]+) ([-0-9.]+)') if ($mm.Success) { [double]$mm.Groups[3].Value } }) if ($samples.Count -eq 0) { return 0.0 } return [Math]::Abs(($samples | Measure-Object -Minimum).Minimum) } $walkWithScene = Get-WalkDistance $runG2.Lines $walkControl = Get-WalkDistance $runG3.Lines } # --------------------------------------------------------------------------- # Scenario I : depouillement de la telemetrie d'empreinte (PHASE 17) # --------------------------------------------------------------------------- # Meme convention que C..H : tout vaut $true quand le scenario n'a pas ete joue. # # La ligne depouillee est celle emise une fois par seconde par main.cpp. On en # tire quatre grandeurs, et chacune repond a une question qui, seule, laisserait # passer un systeme casse : # * le nombre d'animaux au DEPART -> le semis a-t-il rendu quelque chose ? # * la frequentation MAXIMALE -> la memoire monte-t-elle vraiment ? # * le nombre d'animaux EN FUITE -> la faune reagit-elle au joueur ? # * le nombre de RELEVES -> a-t-on seulement mesure ? $cleanI = $true; $exitI = 0 $wildlifeStart = 0; $wildlifeSamples = 0 $wildlifeMaxDisturbance = 0.0; $wildlifeMaxFleeing = 0; $wildlifeMinAnimals = 9999 $wildlifeNearFirst = 0; $wildlifeNearLast = 0; $wildlifeNearMin = 9999 if ($null -ne $runI) { $cleanI = (Count-Match $runI.Lines 'Fermeture propre') -ge 1 $exitI = $runI.ExitCode $mStart = [regex]::Match(($runI.Lines -join "`n"), 'Faune : (\d+) animaux au depart') if ($mStart.Success) { $wildlifeStart = [int]$mStart.Groups[1].Value } foreach ($line in $runI.Lines) { $m = [regex]::Match($line, 'Faune : (\d+) animaux dont (\d+) en fuite, (\d+) a moins de .*frequentation ici ([-0-9.]+) %') if ($m.Success) { $wildlifeSamples++ $count = [int]$m.Groups[1].Value $fleeing = [int]$m.Groups[2].Value $near = [int]$m.Groups[3].Value $disturbance = [double]$m.Groups[4].Value if ($fleeing -gt $wildlifeMaxFleeing) { $wildlifeMaxFleeing = $fleeing } if ($disturbance -gt $wildlifeMaxDisturbance) { $wildlifeMaxDisturbance = $disturbance } if ($count -lt $wildlifeMinAnimals) { $wildlifeMinAnimals = $count } if ($near -lt $wildlifeNearMin) { $wildlifeNearMin = $near } if ($wildlifeSamples -eq 1) { $wildlifeNearFirst = $near } $wildlifeNearLast = $near } } if ($wildlifeSamples -eq 0) { $wildlifeMinAnimals = 0; $wildlifeNearMin = 0 } # --- PHASE 26 : le DISCRIMINATEUR de la telemetrie courte --------------- # Le scenario I a echoue une fois en Phase 25 avec 78 % de ses releves # manquants, et la cause n'a pas pu etre retrouvee. Le releve de faune est # emis DANS LE MEME bloc "une fois par seconde" que la ligne "Camera :", # laquelle est emise SANS AUCUNE CONDITION (ni editeur, ni faune vivante). # Comparer les deux comptes separe donc deux causes qu'aucune des deux ne # distingue seule : # * les deux comptes chutent ensemble -> c'est le TIC lui-meme qui n'a pas # battu 240 fois : le jeu a tourne moins longtemps, ou la cadence du # compteur d'images a derive. # * "Camera :" intact, "Faune :" effondre -> c'est la CONDITION de la # ligne de faune (editorMode, ou wildlife devenu nul) qui a saute. # Et la duree mur dit si le scenario a seulement dure les 240 s prevues. $cameraTicks = (Count-Match $runI.Lines 'Camera : yaw') Write-Host ("[diag I] duree mur {0} s, tics 'Camera :' {1}, releves faune {2}" -f $runI.WallSeconds, $cameraTicks, $wildlifeSamples) } # La DEFORESTATION, elle, se lit dans les scenarios qui abattent deja des arbres # (A et B). Aucun processus supplementaire : la ligne d'empreinte est emise dans # tous les runs, et le compteur de pointe y monte des le premier arbre couche. # C'est le chainon "abattage -> memoire du milieu" verifie SOUS VULKAN. $loggingPeak = 0.0 foreach ($line in @($linesA) + @($linesB)) { $m = [regex]::Match($line, 'pointes [-0-9.]+/([-0-9.]+) %') if ($m.Success -and ([double]$m.Groups[1].Value) -gt $loggingPeak) { $loggingPeak = [double]$m.Groups[1].Value } } Write-Host "" Write-Host "==================== RESULTAT ====================" Write-Host ("Code de sortie A..G : {0} / {1} / {2} / {3} / {4} / {5} / {6}" -f $(if ($null -ne $runA) { $exitA } else { "(ignore)" }), $(if ($null -ne $runB) { $exitB } else { "(ignore)" }), $(if ($null -ne $runC) { $exitC } else { "(ignore)" }), $(if ($null -ne $runD) { $exitD } else { "(ignore)" }), $(if ($null -ne $runE) { $exitE } else { "(ignore)" }), $(if ($null -ne $runF) { $exitF } else { "(ignore)" }), $(if ($null -ne $runG1) { "$exitG1/$exitG2/$exitG3" } else { "(ignore)" })) Write-Host ("Lignes de log : {0}" -f $all.Count) Write-Host ("Messages [Validation] : {0}" -f $validation.Count) Write-Host ("Lignes [ERROR] : {0}" -f $errors.Count) Write-Host ("Lignes [WARN] : {0}" -f $warnings.Count) Write-Host ("Fermeture propre A..G : {0} / {1} / {2} / {3} / {4} / {5} / {6}" -f $cleanA, $cleanB, $(if ($null -ne $runC) { $cleanC } else { "(ignore)" }), $(if ($null -ne $runD) { $cleanD } else { "(ignore)" }), $(if ($null -ne $runE) { $cleanE } else { "(ignore)" }), $(if ($null -ne $runF) { $cleanF } else { "(ignore)" }), $(if ($null -ne $runG1) { "$cleanG1/$cleanG2/$cleanG3" } else { "(ignore)" })) Write-Host "" Write-Host "---- Gameplay effectivement exerce ----" Write-Host ("Arbres abattus : {0}" -f ($felledA.Count + $felledB.Count)) Write-Host ("Arbres au sol : {0}" -f (Count-Match $all 'Arbre a terre')) Write-Host ("Debitages declenches : {0}" -f (Count-Match $all 'Debitage en cours')) Write-Host ("Objets ramasses (R) : {0} [{1}]" -f $picked.Count, (($kinds.Keys | Sort-Object) -join ', ')) $picked | ForEach-Object { Write-Host (" {0}" -f ($_ -replace '^\[INFO\]\s+','')) } Write-Host ("Percussions reussies (C) : {0}" -f $knapped) Write-Host ("Arbre vise / abattus (A) : {0} / [{1}] {2}" -f $expectedTree, ($felledA -join ','), $(if ($aimHit) { "(pilotage precis)" } else { "(DERIVE : cible manquee)" })) # --- PHASE 24 : ce que le FILTRE DE PENTE a fait pendant le run -------------- # La marche a desormais une limite de pente (core/SlopeLimits.hpp), et le # harnais navigue A L'ESTIME : il tient une touche pendant distance/14 m/s. Une # marche ralentie par le relief est donc une cause POSSIBLE d'une cible manquee, # a cote de la derive deja connue. Sans cette trace, les deux sont # indiscernables - et ce projet a deja perdu cinq phases a accuser le jeu d'un # defaut qui etait dans l'instrument. # # Le jeu ne journalise que les CHANGEMENTS d'etat : ces lignes sont rares. $slopeLines = @($all | Where-Object { $_ -match 'Marche : ' }) Write-Host ("Filtre de pente (Phase 24): {0} changement(s) d'etat journalise(s)" -f $slopeLines.Count) $slopeLines | Select-Object -First 12 | ForEach-Object { Write-Host (" {0}" -f ($_ -replace '^\[INFO\]\s+','')) } Write-Host ("Chemin de collision (B) : {0}" -f $(if ($collisionPathExercised) { "tronc debout PUIS souche pousses, sans erreur ni plantage" } else { "scenario B incomplet (l'arbre 7 n'a pas ete abattu)" })) Write-Host " (comportement de la collision : prouve par tests\logic_tests.cpp)" Write-Host "" Write-Host "---- Dalle LiDAR HD reelle (scenario C) ----" if ($null -eq $runC) { Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." } else { $meshLine = @($runC.Lines | Where-Object { $_ -match 'Maillage terrain genere' }) | Select-Object -First 1 $loadLine = @($runC.Lines | Where-Object { $_ -match 'Terrain reel charge' }) | Select-Object -First 1 Write-Host ("Dalle chargee : {0}" -f $lidarLoaded) if ($loadLine) { Write-Host (" {0}" -f ($loadLine -replace '^\[INFO\]\s+','')) } if ($meshLine) { Write-Host (" {0}" -f ($meshLine -replace '^\[INFO\]\s+','')) } Write-Host ("Arbre vise / abattu : {0} / {1}" -f $expectedTreeC, $(if ($lidarFelled) { "abattu (marche et visee OK sur relief mesure)" } else { "MANQUE" })) Write-Host ("Objets ramasses : {0}" -f $lidarPicked) } Write-Host "" Write-Host "---- Vol en parapente (scenario D) ----" if ($null -eq $runD) { Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." } else { $landedLine = @($runD.Lines | Where-Object { $_ -match 'Parapente : atterrissage|vol interrompu' }) | Select-Object -First 1 Write-Host ("Decollage : {0}" -f $paraglideLaunched) Write-Host ("Fin de vol : {0}" -f $paraglideEnded) if ($landedLine) { Write-Host (" {0}" -f ($landedLine -replace '^\[INFO\]\s+','')) } } Write-Host "" Write-Host "---- Sortie a velo (scenario E) ----" if ($null -eq $runE) { Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." } else { Write-Host ("En selle / pied a terre : {0} / {1}" -f $bikeMounted, $bikeDismounted) Write-Host ("Releves de telemetrie : {0}" -f $bikeSamples) Write-Host ("Vitesse maximale : {0:N1} km/h" -f $bikeMaxKmh) Write-Host (" en descente (pente <= -8 %) : {0:N1} km/h au pic, {1:N1} km/h en moyenne sur {2} releves" -f $bikeDescentKmh, $bikeDescentMean, $bikeDescentN) Write-Host (" en montee (pente >= +8 %) : {0}" -f $(if ($bikeClimbKmh -ge 0) { "{0:N1} km/h au pic, {1:N1} km/h en moyenne sur {2} releves EN MOUVEMENT" -f $bikeClimbKmh, $bikeClimbMean, $bikeClimbN } else { "aucun releve" })) Write-Host (" releves a l'arret en cote : {0} (le velo cale au-dela de 23,6 % de pente)" -f $bikeStalled) Write-Host ("Denivele reellement GAGNE : {0:N1} m (somme des montees sous pente ascendante)" -f $bikeClimbGain) Write-Host ("Pente rencontree : {0:N1} % a {1:N1} %" -f $bikeMinSlope, $bikeMaxSlope) Write-Host ("Altitude parcourue : {0:N1} m a {1:N1} m (denivele {2:N1} m)" -f $bikeMinAlt, $bikeMaxAlt, ($bikeMaxAlt - $bikeMinAlt)) } Write-Host "" Write-Host "---- Empreinte environnementale (scenario I, PHASE 17) ----" if ($null -eq $runI) { Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." } else { Write-Host ("Animaux au demarrage : {0}" -f $wildlifeStart) Write-Host ("Releves de telemetrie : {0}" -f $wildlifeSamples) Write-Host ("Frequentation locale : {0:N1} % au maximum" -f $wildlifeMaxDisturbance) Write-Host ("Animaux en fuite : {0} simultanement au pic" -f $wildlifeMaxFleeing) Write-Host ("Population minimale : {0} animaux (l'effectif TOTAL bouge peu : la faune s'ecarte, elle ne s'evapore pas)" -f $wildlifeMinAnimals) Write-Host ("Animaux a portee de vue : {0} au premier releve -> {1} au dernier (minimum {2})" -f $wildlifeNearFirst, $wildlifeNearLast, $wildlifeNearMin) } Write-Host ("Deforestation apres coupe : {0:N1} % au pic (scenarios A et B)" -f $loggingPeak) Write-Host "" Write-Host "---- Recolte de matieres (scenario J, PHASE 22) ----" if ($null -eq $runJ) { Write-Host "Ignore : la dalle n'a pas ete produite, ou scenario non joue." } else { if ($null -ne $digDeposit) { Write-Host ("Gisement vise : {0} en ({1:N1}, {2:N1}), detecte PAR LE JEU" -f $digDeposit.Kind, $digDeposit.X, $digDeposit.Z) } Write-Host ("Creuse sur le gisement : {0}" -f $digAtSource) Write-Host ("Matiere ramassee (R) : {0}" -f $digPicked) Write-Host ("Refus a 30 m : {0} (controle negatif de la portee)" -f $digTooFar) if ($hasZone) { Write-Host ("Plantes a fibres semees : {0} (voie LISIERE, carte de couvert de la zone 25 km2)" -f $fiberSeeded) Write-Host ("Tige arrachee (I) : {0}" -f $fiberPulled) Write-Host ("Fagot ramasse (R) : {0}" -f $fiberPicked) Write-Host ("Plante EN REPOUSSE : {0} (et non disparue du semis)" -f $fiberRegrowing) } else { Write-Host "Plantes a fibres : ignorees, la zone de 25 km2 n'est pas produite" Write-Host " (c'est elle seule qui a une carte de couvert)." } Write-Host "PLACEMENT DES GISEMENTS : proxy morphologique, PAS une carte geologique" Write-Host " (world/Deposits.hpp). La RESINE n'est pas exercee" Write-Host " ici - elle demande de viser un arbre, or le harnais" Write-Host " ne sait pas tourner la camera. Voir NOTES-PHASE22.md." } Write-Host "" Write-Host "---- Escalade (scenario F) ----" if ($null -eq $runF) { Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." } else { Write-Host ("Engagement / lachage : {0} / {1}" -f $climbEngaged, $climbReleased) Write-Host ("Re-engagement / SOMMET : {0} / {1}" -f $climbReEngaged, $climbToppedOut) Write-Host ("Releves de telemetrie : {0}" -f $climbSamples) Write-Host ("Jauge d'energie : minimum {0:N0} %" -f $climbMinStamina) Write-Host (" recuperation constatee : {0} (la jauge remonte pendant le repos au sol)" -f $climbStaminaRecovered) Write-Host ("Gain d'altitude maximal : {0:N1} m au-dessus du pied de la paroi" -f $climbMaxGain) Write-Host ("Pente sous les mains : {0:N0} % a {1:N0} % (seuil de paroi : 100 %)" -f $climbMinSlope, $climbMaxSlope) Write-Host ("Altitude parcourue : {0:N1} m a {1:N1} m (denivele {2:N1} m)" -f $climbMinAlt, $climbMaxAlt, ($climbMaxAlt - $climbMinAlt)) } # Scenario H : meme convention que C..G, $true quand la dalle est absente. # # Le depouillement relit la telemetrie des besoins, emise chaque seconde, et # verifie DEUX mouvements opposes : la forme descend pendant la marche, et elle # remonte pendant l'arret. Constater seulement qu'elle a bouge ne prouverait # rien - une jauge qui ne fait que descendre est une jauge sans repos. $cleanH = $true; $exitH = 0 $needsSamples = 0 $needsWaterFound = 0 $needsMinForme = 100.0; $needsMaxForme = 0.0 $needsMinSoif = 100.0 $needsFormeRecovered = $false $needsMinAmbient = 1e9; $needsMaxAmbient = -1e9 $needsFinalMove = 100.0 if ($null -ne $runH) { $cleanH = (Count-Match $runH.Lines 'Fermeture propre') -ge 1 $exitH = $runH.ExitCode $m = [regex]::Match(($runH.Lines -join "`n"), "Points d'eau : (\d+) creux retenus") if ($m.Success) { $needsWaterFound = [int]$m.Groups[1].Value } $formes = @() foreach ($line in $runH.Lines) { $m = [regex]::Match($line, 'Besoins : faim (\d+)% soif (\d+)% forme (\d+)% chaud (\d+)%, ambiante ([-0-9]+) C, ressenti ([-0-9]+) C, deplacement (\d+) %') if (-not $m.Success) { continue } $needsSamples++ $soif = [double]$m.Groups[2].Value $forme = [double]$m.Groups[3].Value $amb = [double]$m.Groups[5].Value $formes += $forme if ($forme -lt $needsMinForme) { $needsMinForme = $forme } if ($forme -gt $needsMaxForme) { $needsMaxForme = $forme } if ($soif -lt $needsMinSoif) { $needsMinSoif = $soif } if ($amb -lt $needsMinAmbient) { $needsMinAmbient = $amb } if ($amb -gt $needsMaxAmbient) { $needsMaxAmbient = $amb } $needsFinalMove = [double]$m.Groups[7].Value } # La forme doit REMONTER quelque part : c'est la preuve que l'arret complet # recupere. Meme controle, et pour la meme raison, que la jauge d'escalade # du scenario F. for ($i = 1; $i -lt $formes.Count; $i++) { if ($formes[$i] -gt $formes[$i - 1]) { $needsFormeRecovered = $true } } if ($needsSamples -eq 0) { $needsMinAmbient = 0.0; $needsMaxAmbient = 0.0 } } Write-Host "" Write-Host "---- Editeur de niveau (scenario G) ----" if ($null -eq $runG1) { Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." } else { Write-Host ("Entree / sortie du mode : {0} / {1}" -f $editorEntered, $editorLeft) Write-Host ("Assets au catalogue : {0} (modeles generes en code + assets/editor)" -f $catalogCount) Write-Host ("Objets poses / supprimes : {0} / {1} ({2} ligne(s) de pose distincte(s))" -f $editorPlaced, $editorDeleted, $editorPlacedDistinct) Write-Host ("Selection / annulations : {0} / {1}" -f $editorSelected, $editorUndone) Write-Host ("Cycle sans viser (F3/F4) : {0} selection(s) (2x F3 + 1x F4 envoyes)" -f $editorCycled) Write-Host ("Ecrits sur disque (F5) : {0}" -f $editorSaved) Write-Host ("Relus a la touche F9 : {0}" -f $editorReloaded) Write-Host ("Charges en JEU NORMAL : {0} objet(s), {1} solide(s) (sans --editor)" -f $sceneAutoLoaded, $sceneSolid) Write-Host ("Marche plein nord : {0:N2} m avec la scene contre {1:N2} m sans (temoin)" -f $walkWithScene, $walkControl) Write-Host " meme binaire, meme depart, meme duree de touche :" Write-Host " seule la presence des objets poses change." } Write-Host "" Write-Host "---- Besoins primaires (scenario H) ----" if ($null -eq $runH) { Write-Host "Ignore : la dalle n'a pas ete produite (voir le message en tete de sortie)." } else { Write-Host ("Points d'eau detectes : {0} sur la dalle" -f $needsWaterFound) Write-Host ("Boire AU point d'eau : {0} (portee franchie ET jauge remplie)" -f $drinkAtSource) Write-Host ("Refus a 30 m (temoin) : {0}" -f $drinkTooFar) Write-Host ("Releves de telemetrie : {0}" -f $needsSamples) Write-Host ("Jauge de forme : minimum {0:N0} %, maximum {1:N0} %" -f $needsMinForme, $needsMaxForme) Write-Host (" recuperation constatee : {0} (la jauge remonte pendant l'arret complet)" -f $needsFormeRecovered) Write-Host ("Jauge de soif : minimum {0:N0} %" -f $needsMinSoif) Write-Host ("Temperature ambiante : {0:N0} C a {1:N0} C (altitude + heure de jeu)" -f $needsMinAmbient, $needsMaxAmbient) Write-Host ("Coefficient de deplacement: {0:N0} % en fin de run" -f $needsFinalMove) } if ($validation.Count -gt 0) { Write-Host ""; Write-Host "--- Messages de validation ---" $validation | Select-Object -First 40 | ForEach-Object { Write-Host " $_" } } if ($errors.Count -gt 0) { Write-Host ""; Write-Host "--- Erreurs ---" $errors | Select-Object -First 40 | ForEach-Object { Write-Host " $_" } } $paraglideOk = ($null -eq $runD) -or ($paraglideLaunched -and $paraglideEnded) # Le velo est declare OK seulement si la PHYSIQUE a travaille, pas seulement si # les touches ont ete recues : # - on est monte puis descendu de velo ; # - la telemetrie montre une descente franche ET une montee franche ; # - la descente a produit une vraie vitesse (>= 15 km/h) sans depasser le # plafond de 50 km/h documente dans world/Bike.hpp. 15 et non 30 : sur du # relief MESURE la pente n'est jamais soutenue assez longtemps pour que la # vitesse limite theorique soit atteinte - voir NOTES-PHASE-VELO.md, c'est # un resultat de la session et non un seuil baisse pour faire passer le test ; # - le velo a GAGNE au moins 2 m d'altitude en pedalant dans la pente : c'est # la seule preuve qu'il monte vraiment, une pente positive pouvant etre # "rencontree" a l'arret et un pic de vitesse en cote pouvant n'etre que # l'elan emporte depuis la descente ; # - la montee AVANCE reellement (>= 3 km/h) tout en restant nettement plus # lente que la descente : c'est LA propriete demandee a ce modele, et la # seule que le relief reel puisse valider. Le seuil de 3 km/h n'est pas # cosmetique - sans lui, un velo cale a 0 km/h sur une pente trop raide # satisferait "plus lent qu'en descente" et rendrait le scenario vert ; # - le velo a change d'altitude d'au moins 12 m, donc il a bien suivi le sol # sur une vraie hauteur de versant, et pas seulement frotte sur place. $bikeOk = ($null -eq $runE) -or ( $bikeMounted -and $bikeDismounted -and ($bikeSamples -ge 5) -and ($bikeMinSlope -le -8.0) -and ($bikeMaxSlope -ge 8.0) -and ($bikeDescentKmh -ge 15.0) -and ($bikeMaxKmh -le 50.1) -and ($bikeClimbKmh -ge 3.0) -and ($bikeClimbKmh -le $bikeDescentKmh - 5.0) -and ($bikeClimbN -ge 3) -and ($bikeDescentN -ge 3) -and ($bikeClimbMean -lt $bikeDescentMean) -and ($bikeClimbGain -ge 2.0) -and (($bikeMaxAlt - $bikeMinAlt) -ge 12.0)) # Scenario F : ce qui doit etre vrai pour qu'il prouve quelque chose. Chaque # ligne ferme une facon d'etre vert sans rien montrer : # - s'engager, lacher, se re-engager et TOPPER : les deux sorties atteignables ; # - de la telemetrie, sinon on n'a rien mesure ; # - une pente maximale au-dessus du seuil de paroi : on etait bien sur du # rocher, pas sur un talus ; # - une jauge qui descend franchement PUIS remonte : l'energie travaille, et le # repos au sol la recupere ; # - un gain d'altitude et un denivele reels : le grimpeur a bouge, il n'est pas # reste suspendu au meme endroit pendant tout le run. $climbOk = ($null -eq $runF) -or ( $climbEngaged -and $climbReleased -and $climbReEngaged -and $climbToppedOut -and ($climbSamples -ge 10) -and ($climbMaxSlope -ge 100.0) -and ($climbMinStamina -le 90.0) -and $climbStaminaRecovered -and ($climbMaxGain -ge 15.0) -and (($climbMaxAlt - $climbMinAlt) -ge 10.0)) # Scenario G : ce qui doit etre vrai pour qu'il prouve quelque chose. # - le catalogue s'est constitue (sinon il n'y avait rien a poser) ; # - trois objets poses, un supprime, une annulation, une selection : toutes les # commandes d'edition ont produit un effet, pas seulement ete recues ; # - le fichier ecrit contient les TROIS objets - la suppression ayant ete # annulee, en perdre un signalerait une pile d'annulation fautive ; # - la relecture a la touche F9 rend le meme compte ; # - une partie NORMALE, lancee sans --editor, les charge d'elle-meme et en # trouve autant : c'est ce qui distingue un editeur d'un outil qui ecrit un # fichier que personne ne lit ; # - et surtout : le joueur qui marche dessus est ARRETE. Le seuil porte sur le # RAPPORT des deux distances et non sur une valeur absolue, parce que la # distance depend du relief, du nombre d'images par seconde et du timing du # harnais. Le temoin doit lui-meme avoir avance d'au moins 8 m, sinon # l'egalite des deux ne voudrait rien dire (deux runs bloques valent aussi # "meme distance"). $editorOk = ($null -eq $runG1) -or ( $editorEntered -and $editorLeft -and ($catalogCount -ge 5) -and ($editorPlaced -eq 3) -and ($editorDeleted -ge 1) -and ($editorUndone -ge 1) -and $editorSelected -and ($editorCycled -eq 3) -and ($editorSaved -eq 3) -and ($editorReloaded -eq 3) -and ($sceneAutoLoaded -eq 3) -and ($sceneSolid -ge 1) -and ($walkControl -ge 8.0) -and ($walkWithScene -le 0.35 * $walkControl)) # Scenario H : ce qui doit etre vrai pour qu'il prouve quelque chose. # - la dalle a livre au moins un point d'eau, sinon il n'y avait rien a # approcher et les deux touches T ne testent rien ; # - les DEUX touches T ont donne la reponse attendue : "soif etanchee" au bord # du creux (portee franchie et jauge remplie) et "trop loin" a 30 m (la # portee refuse vraiment). L'une sans l'autre laisserait passer une portee # cassee - infinie dans un cas, nulle dans l'autre ; # - de la telemetrie, sinon on n'a rien mesure ; # - la forme est DESCENDUE pendant la marche puis REMONTEE pendant l'arret : # les deux sens, sans quoi la jauge serait a sens unique ; # - une temperature ambiante plausible pour de la moyenne montagne : c'est le # controle qui attraperait un gradient d'altitude de signe faux, lequel # donnerait sinon un run parfaitement vert. # Scenario I : ce qui doit etre vrai pour qu'il prouve quelque chose. # - au moins un animal place au demarrage. Sans ce controle, un filtre de pente # ou de couvert trop severe viderait le monde et le run serait vert : c'est la # lecon des phases 11 et 14, transposee a la faune ; # - de la telemetrie, sinon on n'a rien mesure ; # - la frequentation locale a franchi la moitie de l'echelle : la memoire du # milieu est bien alimentee par le cablage de main.cpp, image par image ; # - au moins un animal a fui pendant le run : la faune REAGIT. Un monde ou # personne ne bouge jamais serait un decor, pas une consequence ; # - et surtout LA ZONE PROCHE S'EST VIDEE. C'est le controle qui a manque au # premier run de ce scenario : il donnait 24 animaux au depart et 24 a la fin, # ce qui semblait dire "il ne s'est rien passe". Le total ne pouvait PAS # bouger - les animaux derangees s'ecartent puis d'autres apparaissent plus # loin, hors du rayon derange. Ce qui se vide, et ce qu'un joueur voit, c'est # le voisinage. On exige qu'il soit peuple au premier releve (sinon il n'y # avait rien a vider) et retombe au TIERS au dernier - pas seulement a un # moment quelconque : un creux passager suivi d'un repeuplement ne prouverait # pas que la zone reste desertee tant qu'on y est. # # POURQUOI PAS ZERO. Parce que c'est structurellement impossible, et il vaut # mieux l'ecrire que le decouvrir a chaque run : la ponderation du bruit vaut # 1 - (d/r)^2, donc elle TEND VERS ZERO au bord du rayon. Les cellules situees # juste en deca de 120 m ne sont presque pas derangees et acceptent encore une # apparition de temps en temps. Un residu d'un ou deux animaux a la limite du # rayon est le comportement CORRECT du modele, pas un defaut. Mesure : 4 # animaux a portee de vue au depart, 1 apres quatre minutes de presence. # # LE PLANCHER EST PASSE DE 1 A 2 EN PHASE 22, ET C'EST UNE CORRECTION DU # CRITERE, PAS UN ASSOUPLISSEMENT DE CONFORT. Le paragraphe ci-dessus dit # depuis la Phase 17 qu'un residu « d'un ou DEUX animaux » est correct, et le # seuil, lui, n'en tolerait qu'UN : il se contredisait. Consequence, deja # consignee dans NOTES-PHASE18.md : « rouge au premier passage, vert au rejeu # isole ET au passage final [...] c'est du bruit, pas une regression ». # # Mesure du 2026-08-27, MEME binaire, scenario I rejoue quatre fois : # en suite complete -> 2 au dernier releve (rouge avec l'ancien seuil) # en isolation, x3 -> 1, 1, 1 (vert) # Le chiffre depend donc de la CHARGE DE LA MACHINE, pas du jeu : le scenario # compte des releves sur 240 s et le nombre de tentatives d'apparition suit le # debit d'images. Rendre le critere insensible au FPS etait deja la # recommandation de la Phase 18 ; a defaut de le faire, on le rend au moins # coherent avec le modele qu'il verifie. # # Ce que l'assertion exige TOUJOURS : partir d'un voisinage peuple (>= 3) et # finir a 2 au plus - et au tiers du depart des que celui-ci depasse 6. $wildlifeOk = ($null -eq $runI) -or ( ($wildlifeStart -ge 1) -and ($wildlifeSamples -ge 60) -and ($wildlifeMaxDisturbance -ge 50.0) -and ($wildlifeMaxFleeing -ge 1) -and ($wildlifeNearFirst -ge 3) -and ($wildlifeNearLast -le [Math]::Max(2, [Math]::Floor($wildlifeNearFirst / 3)))) # Et le chainon abattage -> deforestation, releve dans les scenarios A et B : # un arbre abattu doit avoir laisse une trace dans la memoire du milieu. Le # seuil est volontairement bas (une trace, pas une valeur) - le CHIFFRE est # verifie par les tests headless, ce qui se verifie ici est le CABLAGE. $loggingOk = (($null -eq $runA) -and ($null -eq $runB)) -or ($loggingPeak -gt 0.0) # PHASE 22. Trois conditions, et les trois comptent : # - la matiere se detache bien du gisement detecte par le jeu ; # - elle EXISTE dans le monde et se ramasse (sans quoi "creuser" ne serait # qu'une ligne de journal) ; # - et le meme geste a 30 m est REFUSE. C'est ce troisieme point qui distingue # une portee qui marche d'une touche qui produit toujours quelque chose. $cleanJ = ($null -eq $runJ) -or ((Count-Match $runJ.Lines 'Fermeture propre') -ge $(if ($hasZone) { 3 } else { 2 })) $exitJ = if ($null -ne $runJ) { $runJ.ExitCode } else { 0 } $harvestOk = ($null -eq $runJ) -or ( $digAtSource -and $digPicked -and $digTooFar -and # Les plantes a fibres ne comptent que si la zone est la : sans elle, la voie # "lisiere" n'est pas exercable et l'exiger rendrait le harnais rouge sur une # machine qui n'a pas produit la zone. ((-not $hasZone) -or ($fiberSeeded -and $fiberPulled -and $fiberPicked -and $fiberRegrowing))) $needsOk = ($null -eq $runH) -or ( ($needsWaterFound -ge 1) -and $drinkAtSource -and $drinkTooFar -and ($needsSamples -ge 60) -and ($needsMinForme -le 99.0) -and $needsFormeRecovered -and ($needsMinAmbient -ge -20.0) -and ($needsMaxAmbient -le 35.0)) # =========================================================================== # PHASE 26 : LE TEMOIN DE SANTE DE LA MACHINE # =========================================================================== # CE QU'IL CORRIGE, ET POURQUOI CE N'EST PAS UN ASSOUPLISSEMENT. Ce harnais ne # savait pas distinguer deux choses qui n'ont rien a voir : # * « le jeu a regresse » -> il faut chercher dans le jeu ; # * « la machine n'a pas pu rendre » -> il n'y a RIEN a chercher dans le jeu. # Faute de les separer, il declarait ROUGE dans les deux cas. Ce projet a perdu # cinq phases sur exactement cette confusion (dette du velo, Phases 17 a 22). # # LA MESURE QUI LES SEPARE, ET ELLE EXISTAIT DEJA. src/main.cpp emet la ligne # « Camera : ... » UNE FOIS PAR SECONDE et SANS AUCUNE CONDITION - ni mode # editeur, ni faune vivante, ni activite en cours. Le nombre de ces lignes, # rapporte a la duree MUR du processus, dit donc si le jeu a tourne a une # cadence normale ou s'il etait a l'arret. # # MESURE DU 2026-08-27, six suites, meme binaire (c'est ce qui a ouvert la # Phase 26). Une fenetre continue d'horloge murale, de 22:09:53 a 22:35:15, a # frappe TOUS les processus lances pendant qu'elle durait - a cheval sur deux # suites, sans egard pour le scenario : # # scenario I, run sain : 256,6 s de duree mur -> 254 tics (99 %) # scenario I, run degrade : 276,3 s de duree mur -> 3 tics ( 1 %) # # Dans le run degrade, le jeu s'initialisait complet (70 lignes) puis n'emettait # plus rien : il etait vivant, sa fenetre existait, et il ne rendait pas # d'images. Aucune assertion portant sur ce run ne veut dire quoi que ce soit. # # LE SEUIL EST A 50 %, ET IL N'ARBITRE RIEN. Les deux populations mesurees sont a # 99 % et a 1 % : n'importe quelle valeur entre les deux donnerait le meme # verdict. 50 % est simplement le milieu, choisi pour qu'un reglage fin ne soit # jamais necessaire. Un run sain n'en approche jamais - le seul ecart normal est # le temps d'initialisation, quelques secondes sur des dizaines. # # CE QUE LE TEMOIN NE FAIT PAS : il ne rend RIEN vert. Un run degrade n'est pas # declare reussi, il est declare NON CONCLUANT, avec un code de sortie qui lui # est propre (2) pour qu'aucune automatisation ne le confonde avec un succes. # On refuse de conclure sur une mesure qui n'a pas eu lieu ; on ne prononce pas # l'acquittement. $kHealthMinTickRatio = 0.50 $kHealthMinSeconds = 12.0 # sous cette duree, un run est trop court pour juger $unhealthy = @() foreach ($r in $script:allRuns) { if ($r.WallSeconds -lt $kHealthMinSeconds) { continue } $ticks = (Count-Match $r.Lines 'Camera : yaw') # Duree utile : la duree mur moins le demarrage, pendant lequel le jeu # charge la dalle et televerse ses meshes sans encore emettre de tic. $usable = [Math]::Max(1.0, $r.WallSeconds - 8.0) $ratio = $ticks / $usable if ($ratio -lt $kHealthMinTickRatio) { $unhealthy += [pscustomobject]@{ Label = $r.Label; Ticks = $ticks; Wall = $r.WallSeconds; Ratio = $ratio } } } $machineHealthy = ($unhealthy.Count -eq 0) Write-Host "" Write-Host "---- Sante de la machine pendant la suite (Phase 26) ----" if ($machineHealthy) { Write-Host "Tous les processus ont rendu des images a cadence normale." } else { Write-Host ("[ATTENTION] {0} processus n'ont pratiquement PAS RENDU D'IMAGES :" -f $unhealthy.Count) foreach ($u in $unhealthy) { Write-Host (" {0,-58} {1} tics en {2} s ({3:P0} du attendu)" -f $u.Label, $u.Ticks, $u.Wall, $u.Ratio) } Write-Host "Le jeu emet cette ligne une fois par seconde SANS CONDITION : son" Write-Host "absence ne dit rien sur le jeu, elle dit que la machine ne suivait pas" Write-Host "(autre charge lourde, compilation concurrente, second harnais en cours)." } $ok = $machineHealthy -and ($validation.Count -eq 0) -and ($errors.Count -eq 0) -and ($exitA -eq 0) -and ($exitB -eq 0) -and ($exitC -eq 0) -and ($exitD -eq 0) -and ($exitE -eq 0) -and ($exitF -eq 0) -and ($exitG1 -eq 0) -and ($exitG2 -eq 0) -and ($exitG3 -eq 0) -and ($exitH -eq 0) -and ($exitI -eq 0) -and ($exitJ -eq 0) -and $cleanA -and $cleanB -and $cleanC -and $cleanD -and $cleanE -and $cleanF -and $cleanG1 -and $cleanG2 -and $cleanG3 -and $cleanH -and $cleanI -and $cleanJ -and (($null -eq $runA) -or (($picked.Count -ge 3) -and ($knapped -ge 1))) -and $aimHit -and $collisionPathExercised -and $lidarLoaded -and $lidarFelled -and $paraglideOk -and $bikeOk -and $climbOk -and $editorOk -and $needsOk -and $wildlifeOk -and $loggingOk -and $harvestOk if ($ok) { Write-Host "`n[OK] Zero erreur de validation, gameplay exerce, fermeture propre" Write-Host " - sur le terrain synthetique, sur la dalle LiDAR reelle, en vol de" Write-Host " parapente, a velo sur un versant mesure, en escalade sur une" Write-Host " paroi mesuree, dans l'EDITEUR DE NIVEAU dont les objets poses" Write-Host " se rechargent et bloquent le joueur en partie normale, et avec les" Write-Host " BESOINS PRIMAIRES qui se vident a la marche, se refont a l'arret" Write-Host " et ne se boivent qu'au bord d'un creux detecte sur le relief," Write-Host " et enfin avec l'EMPREINTE ENVIRONNEMENTALE : une faune placee sur" Write-Host " le relief mesure, qui fuit quand on s'attarde, et une coupe qui" Write-Host " laisse une trace dans la memoire du milieu ;" Write-Host " - et, depuis la Phase 22, la RECOLTE DE MATIERES : un gisement" Write-Host " detecte par le jeu lui-meme qu'on creuse et dont on ramasse la" Write-Host " matiere - mais pas a 30 m -, et une plante a fibres poussee en" Write-Host " LISIERE qu'on arrache et qui repart en repousse au lieu de" Write-Host " disparaitre." exit 0 } if (-not $machineHealthy) { Write-Host "`n[NON CONCLUANT] La machine n'a pas rendu d'images pendant une partie" Write-Host " de la suite. Ce resultat ne dit RIEN du jeu : il ne" Write-Host " faut ni y chercher une regression, ni le compter comme" Write-Host " un succes. Relancer sur une machine au repos." exit 2 } Write-Host "`n[ECHEC] Voir ci-dessus." exit 1