F20 (suite) : distance permise en ticks serveur, elan de glace borne, position de retour hors vehicule, remontee sans remise a zero
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
e2322fbdf4
révision
ec17ccae5d
4 fichiers modifiés
+93
-37
Aucun fichier ne correspond à votre recherche
@@ -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<Verdict> 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;
|
||||
|
||||
@@ -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.
|
||||
*
|
||||
* <p>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.
|
||||
* <p>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.
|
||||
*
|
||||
* <p>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.
|
||||
* <p>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.
|
||||
*
|
||||
* <p>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;
|
||||
}
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur