From c92ebb055af75a63d5c2384e5011a439d94904cb Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Fri, 23 Oct 2026 16:10:28 +0200 Subject: [PATCH] Plane : fusees enchainees cumulees, reference de vitesse hors grace et reinitialisee Co-Authored-By: Claude Sonnet 5.5 --- .../com/gastinelgarde/core/PlaneElytres.java | 24 +++++++++++---- .../core/NouveauxControlesTest.java | 29 ++++++++++++++----- 2 files changed, 39 insertions(+), 14 deletions(-) diff --git a/src/main/java/com/gastinelgarde/core/PlaneElytres.java b/src/main/java/com/gastinelgarde/core/PlaneElytres.java index 52c241b..1b4a93e 100644 --- a/src/main/java/com/gastinelgarde/core/PlaneElytres.java +++ b/src/main/java/com/gastinelgarde/core/PlaneElytres.java @@ -41,7 +41,9 @@ public final class PlaneElytres { private int graceTicks; private int fenetreGrace; private double vitesseGrace; + /** Dernière vitesse mesurée HORS grâce de fusée ; invalide tant que {@link #vitesseConnue} est faux. */ private double derniereVitesse; + private boolean vitesseConnue; private final double[] fenetre = new double[GAIN_TICKS]; private int monteeTicks; private double vitesseDebut; @@ -65,12 +67,13 @@ public final class PlaneElytres { if (n >= 1 && n <= TICKS_MAX) { double vh = m.dxz() / n; if (graceTicks == 0) { - vitesseGrace = derniereVitesse; // vitesse vue par le serveur juste avant la fusée + // référence = dernière vitesse mesurée hors grâce ; inconnue (atterrissage, milieu spécial, + // première mesure) : la vitesse courante, donc le gain exigé part de ce qu'on voit (pessimiste) + vitesseGrace = vitesseConnue ? derniereVitesse : vh; fenetreGrace = 0; } graceTicks += n; fenetre[fenetreGrace++ % GAIN_TICKS] = vh; - derniereVitesse = vh; if (!graceTenue()) { // la fusée ne pousse pas (ou un pic isolé a masqué une vitesse plate) : contrôle comme sans fusée return mesurer(m, n, cfg); @@ -81,14 +84,22 @@ public final class PlaneElytres { } else { graceTicks = 0; fenetreGrace = 0; + if (n >= 1 && n <= TICKS_MAX) { + derniereVitesse = m.dxz() / n; // seulement hors grâce + vitesseConnue = true; + } } return mesurer(m, n, cfg); } - /** Nouvelle fusée : la mesure du gain repart de zéro (vitesse de référence = celle d'avant la fusée). */ + /** + * Nouvelle fusée tirée en plané. Ne remet RIEN à zéro : des fusées enchaînées cumulent leurs ticks de grâce dans la + * même fenêtre (sinon un tricheur ne sortirait jamais de la grâce et le test de gain ne serait jamais évalué) et la + * référence de vitesse reste celle d'avant la première fusée. La fenêtre ne se ferme que quand le drapeau de + * propulsion tombe (paquet hors grâce). Gardée pour le journal d'appel et les tests. + */ public void nouvelleFusee() { - graceTicks = 0; - fenetreGrace = 0; + // volontairement vide } /** @@ -107,7 +118,6 @@ public final class PlaneElytres { } private double mesurer(EtatMouvement m, int n, GardeConfig cfg) { - derniereVitesse = n >= 1 && n <= TICKS_MAX ? m.dxz() / n : derniereVitesse; if (n < 1 || n > TICKS_MAX) return 0; // neutre : ni remise à zéro ni ajout double vh = m.dxz() / n; double vy = m.dy() / n; @@ -133,6 +143,8 @@ public final class PlaneElytres { public void vider() { graceTicks = 0; fenetreGrace = 0; + derniereVitesse = 0; + vitesseConnue = false; monteeTicks = 0; vitesseDebut = 0; stationnaireTicks = 0; diff --git a/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java b/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java index 226d875..b102c08 100644 --- a/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java +++ b/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java @@ -274,16 +274,29 @@ class NouveauxControlesTest { } @Test - void elytresNouvelleFuseeRepartDeZero() { + void elytresDixFuseesEnchaineesSansGainReelSontRetirees() { EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build(); - for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); - moteur.nouvelleFusee(j); + for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); // vitesse d'avant : 1,0 double total = 0; - double v = 1.0; - for (int i = 0; i < 12; i++) total += plane(fusee, v += 0.05, 0.4, 1); // première fusée : gain - moteur.nouvelleFusee(j); - for (int i = 0; i < 9; i++) total += plane(fusee, 1.6, 0.4, 1); // seconde : mesure repartie, moins de 10 ticks - assertEquals(0, total); + for (int f = 0; f < 10; f++) { + moteur.nouvelleFusee(j); // ne remet rien à zéro + for (int i = 0; i < 6; i++) total += plane(fusee, 1.0, 0.4, 1); // le drapeau ne tombe jamais + } + assertTrue(total > 0, "60 ticks de grâce cumulés sans gain : le test de gain est évalué et retire la grâce"); + } + + @Test + void elytresAtterrissagePuisDecollageAvecFuseePasDeVieilleReference() { + // vitesse élevée en plané, puis atterrissage (sol serveur) : la référence est effacée + for (int i = 0; i < 10; i++) plane(enPlane(), 2.5, -0.1, 1); + now += 50; + moteur.mouvement(j, now, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, true, false, false, false, 0, 0, false, false)); + // décollage lent avec fusée : sans vieille référence de 2,5, un vrai gain (0,6 -> 1,2) garde la grâce + EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build(); + double total = 0; + double v = 0.6; + for (int i = 0; i < 40; i++) total += plane(fusee, v = Math.min(1.5, v + 0.05), 0.4, 1); + assertEquals(0, total, "gain réel mesuré contre une référence inconnue, pas contre l'ancienne vitesse de 2,5"); } @Test