diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index 60f980e..72e0a66 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -17,7 +17,7 @@ Base avant corrections : 98 tests verts. | F02 timer inondation | corrigée | `git log --grep F02` | `AuditFaillesTest.F02_*` (2) ; 116 verts | rien (F03, balance de timer, reste une évolution) | | F12 cadence saturée | corrigée | `git log --grep F12` | `AuditFaillesTest.F12_*` (2), `ControlesTest.cadenceFolleSoutenue` (1,8 au lieu de 2,0 : bord de tranche) ; 118 verts | essai en jeu n° 10 (combat honnête contre plusieurs zombies, aucune ligne `cadence`) | | F13 cibles saturées | corrigée | `git log --grep F13` | `AuditFaillesTest.F13_*` (rouge avant) ; 119 verts | essai en jeu n° 10 | -| F20 véhicules | corrigée (bornes [À VÉRIFIER]) | `git log --grep F20` | `AuditFaillesTest.F20_*` (3) ; `MixinsAppliquesTest` couvre la nouvelle injection ; 122 verts | essai en jeu n° 14 + bateau sur glace bleue, cheval rapide, chameau (dash), cochon, arpenteur : aucune fausse alerte ; rejeu des lignes `veh` non écrit | +| F20 véhicules | corrigée (bornes [À VÉRIFIER]) | `git log --grep F20` | `AuditFaillesTest.F20_*` (5) ; `MixinsAppliquesTest` couvre la nouvelle injection ; 126 verts | essai en jeu n° 14 + bateau sur glace bleue, cheval rapide, chameau (dash), cochon, arpenteur : aucune fausse alerte ; rejeu des lignes `veh` non écrit | | F11 rotation silencieuse | corrigée (seuils [À VÉRIFIER]) | `git log --grep F11` | `AuditFaillesTest.F11_*` (2) ; 124 verts | essai en jeu n° 11 ; PvP honnête rapide sans ligne `rotation` | | F19, F22, F25 | essais en jeu seulement | | | `audit/ESSAIS-EN-JEU.md` | | Version 0.3.0, jar, README, script | à faire | | | | @@ -79,3 +79,4 @@ Base avant corrections : 98 tests verts. - Nouveau contrôle `rotation` (OBSERVE, famille d'exemptions COMBAT) : `core/RotationSilencieuse`. Au coup, si le regard s'est écarté d'au moins 45° du regard de la fin du tick t-2, on attend : si dans les 3 ticks il revient à moins de 15° du regard d'avant, c'est un aller-retour (1 point). Les regards viennent de chaque paquet de mouvement accepté (`Garde.apresMouvement` → `Moteur.regard`). - Le coup a déjà eu lieu quand l'aller-retour est vu : journal et VL seulement, aucune sanction directe. - Non fait (audit) : vitesse de rotation avant le coup, deux cibles espacées de plus de 90° en moins de 3 ticks ; une killaura qui revient lentement (plus de 3 ticks) ou ne revient pas passe encore. Reach jamais mesuré (contrôle à ajouter, synthèse n° 3). +- Suite (revue de sécurité du commit F20) : (1) la distance permise se compte en ticks serveur écoulés : un solde (crédit plafonné à 2 ticks, dette au-delà de 1,5 bloc = infraction) remplace le tampon par paquet ; dix paquets dans un tick ne valent plus dix fois la distance (`F20_paquets_multiples_dans_un_tick_vus`, gigue honnête incluse). (2) Sur la glace, borne du type (bateau 4,0 ; monture ×2) au lieu de l'infini, élan plafonné à 4,0 (`F20_elan_de_glace_borne`). (3) En véhicule, la position de retour n'est mémorisée qu'après un paquet de véhicule sans verdict. (4) Changer de véhicule ou remonter ne remet le temps en l'air et le solde à zéro qu'après 2 s sans véhicule. diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index bcdc77a..07c55e9 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -71,7 +71,7 @@ public final class Garde { double mouvementX, mouvementY, mouvementZ; // Véhicule piloté (F20) int vehiculeId = -1; - int vehiculeTick; + int vehiculeTick = Integer.MIN_VALUE; double vehiculeX, vehiculeY, vehiculeZ; // Cache de la détection de contraption (la requête d'entités coûte plus que le reste) int contraptionTick = Integer.MIN_VALUE; @@ -448,7 +448,9 @@ public final class Garde { m.mouvementY = p.getY(); m.mouvementZ = p.getZ(); - if (m.dernierVerdictTick != tick) { + // En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée + // qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait. + if (m.dernierVerdictTick != tick && !p.isPassenger()) { MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(), p.level().dimension().location().toString()); } @@ -485,8 +487,11 @@ public final class Garde { } int tick = p.server.getTickCount(); if (v.getId() != m.vehiculeId) { + // Pas de position de référence pour ce véhicule : rien à mesurer sur ce paquet. Le temps en l'air et le + // solde ne repartent de zéro qu'après 2 s sans véhicule (revue de sécurité de F20 : descendre puis + // remonter en l'air ne doit pas remettre le compteur de vol à zéro). + if (m.vehiculeTick == Integer.MIN_VALUE || tick - m.vehiculeTick > 40) MOTEUR.nouveauVehicule(p.getUUID()); m.vehiculeId = v.getId(); - MOTEUR.nouveauVehicule(p.getUUID()); } else { boolean controler = (CONFIG.mode(Controle.VEHICULE_VITESSE) != Mode.OFF || CONFIG.mode(Controle.VEHICULE_VOL) != Mode.OFF) && !estExempteManuellement(p.getUUID()); @@ -498,12 +503,14 @@ public final class Garde { EtatJoueur etat = etat(p, true); if (controler) { List verdicts = MOTEUR.vehicule(p.getUUID(), tick * 50L, etat, ev); + if (verdicts.isEmpty() && m.dernierVerdictTick != tick) memoriserPositionJoueur(p); Sanction s = traiter(p, verdicts); if (s.ordinal() >= Sanction.SETBACK.ordinal()) { p.stopRiding(); // le retour arrière ramène le joueur, pas le véhicule appliquerSanctionMouvement(p, s, verdicts); } } + else if (m.dernierVerdictTick != tick) memoriserPositionJoueur(p); if (tracesEnCours()) { int f = TraceLigne.masque(etat); if (ev.milieuSpecial()) f |= TraceLigne.F_MILIEU; @@ -520,6 +527,11 @@ public final class Garde { m.vehiculeZ = v.getZ(); } + private static void memoriserPositionJoueur(ServerPlayer p) { + MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(), + p.level().dimension().location().toString()); + } + private static EtatVehicule etatVehicule(Entity v, double dxz, double dy, int ticks) { EtatVehicule.Type type; double attribut = 0; diff --git a/src/main/java/com/gastinelgarde/core/VehiculeMouvement.java b/src/main/java/com/gastinelgarde/core/VehiculeMouvement.java index cd76279..c7cb2ba 100644 --- a/src/main/java/com/gastinelgarde/core/VehiculeMouvement.java +++ b/src/main/java/com/gastinelgarde/core/VehiculeMouvement.java @@ -4,14 +4,17 @@ package com.gastinelgarde.core; * Contrôles des véhicules (F20) : avant, seul vanilla bornait handleMoveVehicle (10 blocs par paquet), et la * famille « véhicule » exemptait le joueur de tout contrôle de mouvement. * - *

Vitesse : borne par type, tampon d'excès sur 20 ticks comme {@link VitesseHorizontale}. L'élan est gardé : - * la borne d'un tick vaut au moins l'élan admis du tick précédent × {@link #DECROISSANCE_ELAN} (un bateau lancé - * sur la glace garde sa vitesse en l'air, × 0,9 par tick en vanilla). Un tricheur ne peut pas se constituer - * d'élan : seul un déplacement admis en compte, et sur la glace (vitesse non bornée) seulement. + *

Vitesse : la distance permise se compte en ticks serveur écoulés, pas en paquets (revue de sécurité de F20 : + * dix paquets dans le même tick ne donnent pas dix fois la distance). Solde : chaque paquet ajoute la distance + * permise sur les ticks écoulés et retire la distance parcourue ; le crédit est plafonné à + * {@link #CREDIT_TICKS} ticks (pas de réserve en restant immobile), la dette au-delà du seuil est une infraction. + * L'élan est gardé : la borne d'un tick vaut au moins l'élan admis du tick précédent × {@link #DECROISSANCE_ELAN} + * (un bateau lancé sur la glace garde sa vitesse en l'air, × 0,9 par tick en vanilla). Sur la glace, la borne est + * celle du type sur glace, jamais infinie. * - *

Vol : en l'air (sans sol ni fluide) plus de {@link #TICKS_EN_AIR_MAX} ticks, un véhicule soumis à la gravité - * tombe à plus de {@link #CHUTE_MIN} bloc par tick (bateau : vitesse limite 0,36 ; cheval : bien plus). Un - * saut de cheval dure environ 25 ticks, un tremplin de glace une trentaine. + *

Vol : en l'air (sans sol ni fluide) plus de {@link #TICKS_EN_AIR_MAX} ticks serveur, un véhicule soumis à la + * gravité tombe à plus de {@link #CHUTE_MIN} bloc par tick (bateau : −0,04 par tick sans frein vertical ; + * cheval : bien plus). Un saut de cheval dure environ 25 ticks, un tremplin de glace une trentaine. * *

Toutes les bornes sont à confirmer avec les traces [À VÉRIFIER] : les montures et véhicules de mods * (Create, Aeronautics) ne sont pas modélisés. @@ -20,69 +23,76 @@ public final class VehiculeMouvement { /** Bateau sur l'eau : vitesse limite vanilla 0,36 bloc par tick (accélération 0,04, frottement 0,9). */ public static final double BATEAU = 0.45; + /** Bateau sur glace bleue : environ 3,6 blocs par tick en vanilla (frottement 0,989). */ + public static final double BATEAU_GLACE = 4.0; /** * Monture au sol : vitesse limite vanilla environ 2,12 × attribut (frottement 0,546) ; cheval le plus rapide * 0,3375 → 0,71 bloc par tick. Marge de 25 %. */ public static final double FACTEUR_MONTURE = 2.12 * 1.25; public static final double MONTURE_MIN = 0.4; + /** Monture sur glace : frottement plus faible, vitesse limite plus haute [À VÉRIFIER]. */ + public static final double FACTEUR_MONTURE_GLACE = 2.0; public static final double DECROISSANCE_ELAN = 0.95; + /** Crédit maximal du solde, en ticks de vitesse permise (gigue réseau : un paquet en retard puis deux d'un coup). */ + public static final int CREDIT_TICKS = 2; public static final int TICKS_EN_AIR_MAX = 40; public static final double CHUTE_MIN = 0.2; - private final double[] exces = new double[VitesseHorizontale.FENETRE_TICKS]; - private int index; + private double solde; private double elan; private int ticksEnAir; - /** Vitesse de base permise (blocs par tick) ; infinie si non bornée. */ + /** Vitesse de base permise (blocs par tick) ; infinie pour un véhicule inconnu. */ public static double vitesseBase(EtatVehicule e) { - if (e.frictionAnormale()) return Double.POSITIVE_INFINITY; return switch (e.type()) { - case BATEAU -> BATEAU; - case MONTURE -> Math.max(MONTURE_MIN, e.vitesseAttribut() * FACTEUR_MONTURE); + case BATEAU -> e.frictionAnormale() ? BATEAU_GLACE : BATEAU; + case MONTURE -> { + double v = Math.max(MONTURE_MIN, e.vitesseAttribut() * FACTEUR_MONTURE); + yield e.frictionAnormale() ? v * FACTEUR_MONTURE_GLACE : v; + } case AUTRE -> Double.POSITIVE_INFINITY; }; } /** @return points de vitesse (0 si rien) */ public double vitesse(EtatVehicule e, double facteur, double seuilBlocs) { - int ticks = Math.max(1, e.ticks()); - double parTick = e.dxz() / ticks; - double permis = Math.max(vitesseBase(e) * facteur, elan * DECROISSANCE_ELAN); - double depasse = Math.max(0, e.dxz() - permis * ticks); + double base = vitesseBase(e); + if (Double.isInfinite(base)) { + solde = 0; + elan = 0; + return 0; + } + int ticks = Math.max(0, e.ticks()); + // Élan borné par le maximum du type sur glace : jamais une réserve infinie. + double permis = Math.max(base * facteur, Math.min(elan, BATEAU_GLACE) * DECROISSANCE_ELAN); + double parTick = ticks == 0 ? e.dxz() : e.dxz() / ticks; elan = Math.min(parTick, permis); - if (Double.isInfinite(permis)) elan = parTick; - exces[index] = depasse; - index = (index + 1) % exces.length; - double total = 0; - for (double v : exces) total += v; - if (total <= seuilBlocs) return 0; - return 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0); + solde = Math.min(solde + permis * ticks - e.dxz(), permis * CREDIT_TICKS); + if (solde >= -seuilBlocs) return 0; + double points = 1.0 + Math.min(3.0, (-solde - seuilBlocs) / 2.0); + solde = -seuilBlocs; // la dette déjà comptée n'est pas recomptée : seul ce qui suit compte + return points; } /** @return points de vol (0 si rien) */ public double vol(EtatVehicule e) { // Véhicule de mod inconnu (dirigeable Aeronautics…) : peut voler légitimement, non contrôlé. - if (e.sansGravite() || e.type() == EtatVehicule.Type.AUTRE) { + if (e.sansGravite() || e.type() == EtatVehicule.Type.AUTRE || e.auSolServeur() || e.milieuSpecial()) { ticksEnAir = 0; return 0; } - if (e.auSolServeur() || e.milieuSpecial()) { - ticksEnAir = 0; - return 0; - } - int ticks = Math.max(1, e.ticks()); + int ticks = Math.max(0, e.ticks()); ticksEnAir += ticks; if (ticksEnAir <= TICKS_EN_AIR_MAX) return 0; - if (e.dy() / ticks <= -CHUTE_MIN) return 0; + if (ticks > 0 && e.dy() / ticks <= -CHUTE_MIN) return 0; + if (ticks == 0 && e.dy() <= -CHUTE_MIN) return 0; return 1.0 + Math.min(3.0, (ticksEnAir - TICKS_EN_AIR_MAX) / 20.0); } public void vider() { - java.util.Arrays.fill(exces, 0); - index = 0; + solde = 0; elan = 0; ticksEnAir = 0; } diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index 3f76014..6b4b6c0 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -454,4 +454,37 @@ class AuditFaillesTest { } assertFalse(vu, "rotations honnêtes : rien"); } + + /** Revue de sécurité de F20 : dix paquets par tick (9 à 0 tick d'écart) ne multiplient plus la distance permise. */ + @Test + void F20_paquets_multiples_dans_un_tick_vus() { + boolean vu = false; + for (int tick = 0; tick < 60; tick++) { + for (int k = 0; k < 10; k++) { + EtatVehicule e = new EtatVehicule(EtatVehicule.Type.BATEAU, 0.4, 0, k == 0 ? 1 : 0, false, true, false, 0, false); + vu |= contient(moteur.vehicule(j, tick * 50L, EtatJoueur.normal(), e), Controle.VEHICULE_VITESSE); + } + } + assertTrue(vu, "4 blocs/tick en dix paquets de 0,4 : vu"); + + UUID gigue = UUID.randomUUID(); + boolean vuGigue = false; + for (int tick = 0; tick < 400; tick += 2) { // gigue : un paquet en retard (2 ticks) puis deux dans le même tick + EtatVehicule a = new EtatVehicule(EtatVehicule.Type.BATEAU, 0.36, 0, 2, false, true, false, 0, false); + EtatVehicule b = new EtatVehicule(EtatVehicule.Type.BATEAU, 0.36, 0, 0, false, true, false, 0, false); + vuGigue |= !moteur.vehicule(gigue, tick * 50L, EtatJoueur.normal(), a).isEmpty(); + vuGigue |= !moteur.vehicule(gigue, tick * 50L, EtatJoueur.normal(), b).isEmpty(); + } + assertFalse(vuGigue, "bateau honnête avec gigue réseau : rien"); + } + + /** Revue de sécurité de F20 : la glace ne donne plus un élan infini. */ + @Test + void F20_elan_de_glace_borne() { + boolean vu = false; + for (int tick = 0; tick < 40; tick++) { + vu |= contient(moteur.vehicule(j, tick * 50L, EtatJoueur.normal(), bateau(8.0, 0, true, false, true)), Controle.VEHICULE_VITESSE); + } + assertTrue(vu, "bateau à 8 blocs/tick sur la glace : vu"); + } }