Comparer les révisions

...
Auteur SHA1 Message Date

2026-10-19

Theo GastineletClaude Opus 5.5 b2e5189d8a GastinelGarde 0.3.2 : version, CHANGELOG
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:56:31 +02:00
Theo GastineletClaude Opus 5.5 86d4d56a52 GastinelGarde 0.3.2 D3 : no-fall voit le paquet d'etat au sol
Un paquet sans deplacement (dy = 0) qui declare au sol sans bloc dessous est
juge avec la vitesse verticale du dernier paquet qui a bouge pendant la chute
(remise a zero au sol, en milieu special, en exemption et apres un setback).
Avant, NoFall.points exigeait dy <= -0,3 sur le paquet meme : aucune ligne
no-fall contre le NoFall par paquet d'etat (rapport test 19/10, T5).
Test : Garde1015Test.D3_noFallVoitLePaquetDEtatAuSolPendantUneChute

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:55:56 +02:00
Theo GastineletClaude Opus 5.5 2325250fd2 GastinelGarde 0.3.2 D2 : expulsion de combat apres 4 setbacks en 60 s
Un setback portee/hitbox (coups annules) remet le VL de ce controle a zero
et compte pour la regle C5, comme le vol (C2). Avant, le VL de combat
montait a 20 en ~5 s et l'expulsion arrivait sans la regle des 4 setbacks.
Test : Garde1015Test.D2_hitboxEnforceExpulseApresQuatreSetbacksPasAuBoutDe5s

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:55:51 +02:00
Theo GastineletClaude Opus 5.5 963e01fc87 GastinelGarde 0.3.2 D1 : setback vers le point d'arrivee d'une teleportation
Une teleportation externe (/tp, TPA, perle, mod), une reapparition, un
changement de dimension ou une connexion prennent le point d'arrivee comme
position de retour. Avant, un setback avant le premier contact au sol
ramenait a la position d'avant la teleportation (rapport test 19/10, T3).
Test : CablageTest.D1_setbackApresTpRameneAuPointDArriveePasAvantLaTeleportation

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:55:26 +02:00

2026-10-16

gastineltetClaude Sonnet 5.5 288087080f gitignore : livrable/
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 10:15:06 +02:00
gastineltetClaude Sonnet 5.5 9b5273f830 GastinelGarde 0.3.1 : version, CHANGELOG, README
Passe mod_version et neoforge.mods.toml en 0.3.1, ajoute CHANGELOG.md
(resume des correctifs, options nouvelles desactivees par defaut, modes inchanges).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 10:13:26 +02:00
gastineltetClaude Opus 5.5 d90e40c8b9 GastinelGarde tests : cablage NeoForge (evenements, bytecode, options, FAILLE_C4 vehicule)
CablageMinecraftTest (9 tests, sans serveur) : evenements abonnes, gardes
d'expulsion lues dans le bytecode, types d'entites C18/F20, options C7 C8
C10 C15 C18 desactivees par defaut et recopiees par GardeSpec.appliquer
(fichier charge en memoire). FAILLE_C4_apresVehicule... : vert tant que
apresVehicule ignore la marque d'expulsion (non corrige). 291 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
gastineltetClaude Opus 5.5 6e208dccd2 GastinelGarde : couche Cablage testable (Garde, GardeEvents) et ses tests
Decisions du cablage Minecraft sorties sans changement de comportement :
entrees des evenements (C4 expulsion, F01, exemption manuelle), annulation
du coup, exemption contraption de la cible, C7 transition elytres, cache des
detections, position de retour (C3), sanction setback/expulsion (C2, C4)
via une interface Joueur (doublure dans les tests). Evaluation paresseuse
conservee. CablageTest : 16 tests. 266 -> 282 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
gastineltetClaude Opus 5.5 3dc39c8043 GastinelGarde : correctifs C7, C8, C18 derriere options desactivees par defaut
- C7 elytresExemptionStricte : plane declenche moins de elytresAirMinTicks (2)
  ticks apres le dernier sol serveur = pas d exemption de mouvement ;
  portee/hitbox mesurees pendant le plane.
- C8 combatMesureEnVehicule : passager mesure comme a pied (contraption reste exemptee).
- C18 empilementSeulementEnMouvement : minecart contenant immobile non casse, journalise.
266 tests, 0 echec (cornafserver).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:02:09 +02:00
gastineltetClaude Opus 5.5 5eeb916add GastinelGarde tests inverses CORRIGE_C7, C8, C18 (rouges) et ebauches sans effet
Options desactivees par defaut : elytresExemptionStricte, elytresAirMinTicks,
combatMesureEnVehicule, empilementSeulementEnMouvement ; champ
EtatJoueur.elytresDeploiementSuspect ; AntiCrashEntites.empilementACasser.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:32:46 +02:00
gastineltetClaude Opus 5.5 f19fe6444b GastinelGarde tests : FAILLE_C7, FAILLE_C8, FAUX_POSITIF_C18 (verts tant que le defaut existe)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:31:36 +02:00
gastineltetClaude Opus 5.5 9c2814a30e GastinelGarde vol : rafales reseau, ticks dus bornes (AVANCE_MAX = 4)
Un paquet d un tick client recu apres n ticks serveur peut couvrir 1 tick ; les ticks dus
sont couverts par les paquets a 0 tick suivants. Ensemble de ticks candidats = sur-ensemble
de l ancien (jamais plus strict). Actif sans option : c est le correctif d un faux positif.
260 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:16:34 +02:00
gastineltetClaude Opus 5.5 e33225c0d0 GastinelGarde : tests rafales reseau inverses (CORRIGE_...), rouges avant correctif
3 echecs attendus : CORRIGE_lagRafalesDeTrois (ex FAUX_POSITIF_), CORRIGE_rafalesDeTrois, CORRIGE_sautPuisChute.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:15:33 +02:00
gastineltetClaude Opus 5.5 b34a3b3aeb GastinelGarde autotests : rafales reseau (FAUX_POSITIF_ verts tant que le defaut existe)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:14:38 +02:00
gastineltetClaude Opus 5.5 4be81eed65 GastinelGarde config : options C10/C15 (desactivees) et marge de ping dans le toml
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:11:22 +02:00
gastineltetClaude Opus 5.5 4776895371 GastinelGarde : correctif coups-hors-boite (revue 1-4), C13, C10, C15
- revue 1 : ping > seriePingMaxMs n'exempte plus, fenetre bornee
- revue 2 / C13 : oeil suivant borne a un tick de deplacement ; regard suivant > 90 deg refuse
  par coups-hors-boite, serie de coups sauves par le regard suivant comptee en killaura-angle
- revue 3 : table SUIVIES pleine -> eviction de la cible frappee le plus anciennement
- revue 4 : fenetre selon le ping plancher des 2 dernieres minutes + 50 ms (PingPlancher)
- C10 (option volFenetreGlissante, desactivee) : fenetre glissante + sauts en l'air repetes
- C15 (options vitesseMoyenne, timerSoldeMax, desactivees) : vitesse moyenne, solde timer
Temoins modifies (a valider) : Garde92Test ping, revue 4 (cible 4,2), C13 angle en serie.
cornafserver : 254 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:11:21 +02:00
gastineltetClaude Opus 5.5 080415c646 GastinelGarde : tests revue 1-4, C10, C13, C15 inverses (CORRIGE_...), rouges avant correctif
Tests FAILLE_ inverses en CORRIGE_ ; temoins honnetes ajoutes pour C10, C15.
Stubs sans effet pour compiler : options C10/C15 (desactivees), Moteur.pingFenetre.
cornafserver (conteneur jetable) : 254 tests, 11 echecs attendus.
Le test C13 seuils passe deja : reecrit pour verifier coups-hors-boite (a valider).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:05:45 +02:00
35 fichiers modifiés avec 1849 ajouts et 160 suppressions

Aucun fichier ne correspond à votre recherche

+1
Voir le fichier
@@ -7,3 +7,4 @@ run/
# sauvegardes avant modification # sauvegardes avant modification
*.avant-* *.avant-*
livrable/
+56
Voir le fichier
@@ -0,0 +1,56 @@
# Journal des versions
## 0.3.2 (19/10/2026)
Correctifs des défauts D1 à D3 trouvés aux essais en jeu du 19/10 (rapport-garde-test-1019). Modes et options
inchangés. Testé hors jeu seulement (tests unitaires) ; rien n'a été rejoué en jeu.
- D1 : après une téléportation externe (/tp, TPA, perle, mod), une réapparition, un changement de dimension ou une
connexion, le point d'arrivée devient la position de retour. Avant, un setback avant le premier contact au sol
ramenait à la position d'avant la téléportation.
- D2 : un setback `portee` / `hitbox` (coups annulés) remet le VL de ce contrôle à zéro et compte pour C5 : l'expulsion
de combat vient après 4 setbacks en 60 s (avant : ~5 s, VL à 20 sans passer par C5). Les setbacks de combat et de
mouvement sont comptés ensemble pour C5.
- D3 : no-fall voit le NoFall « paquet d'état » : un paquet sans déplacement qui déclare « au sol » sans bloc dessous
est jugé avec la vitesse verticale du dernier paquet de la chute.
## 0.3.1 (16/10/2026)
Version de correctifs. Les modes OBSERVE / ENFORCE de chaque contrôle sont inchangés (aucun défaut de mode modifié).
Toutes les options nouvelles sont désactivées par défaut : sans changement de config, seuls les correctifs « actifs
sans option » ci-dessous changent le comportement. Tout est testé hors jeu seulement ; rien n'a été essayé en jeu.
### Vol et élytres (incident VOL du 15/10, branche fix/vol-elytres)
- C1 : grâce de fin de plané en élytres bornée (`graceFinElytresTicks` = 50 ticks, finit à l'atterrissage).
- C2 : après un setback, vol, vitesse et points VOL / VITESSE remis à zéro.
- C3 : position de retour du setback = dernière position au sol (ou milieu spécial : eau, échelle).
- C4 : expulsion à usage unique (une ligne EXPULSE), contrôles de nouveau actifs après reconnexion. Jamais de bannissement.
- C5 : escalade : expulsion seulement après 4 setbacks en 60 s.
### Coups-hors-boite, portée, C10, C13, C15 (branche fix/hitbox-c10-c13-c15)
- Le ping élevé (> 500 ms) n'exempte plus le coup ; fenêtre bornée à `seriePingMaxMs`.
- Œil / regard suivants bornés (un tick, 90°) ; éviction de la cible non joueur la plus ancienne quand la table est pleine.
- Fenêtre de ping fondée sur le plancher des 2 dernières minutes (`PingPlancher`, `seriePingMargeMs` = 50 ms).
- Options (désactivées par défaut) : `volFenetreGlissante` (C10, sauts en l'air espacés), `vitesseMoyenne` (C15, bhop / sol),
`timerSoldeMax` (C15, timer ; 0 = désactivé, essai conseillé 20).
- Seuils de `portee` / `hitbox` non resserrés.
### Rafales réseau (branche fix/rafales-reseau)
- Faux positif VOL sur chute reçue en rafales (3, 0, 0) corrigé : ticks dus bornés (`AVANCE_MAX` = 4). Actif sans option ;
la chute ralentie par triche reste détectée.
### Constats hauts (branche fix/constats-hauts)
- Options (désactivées par défaut) : `elytresExemptionStricte` (C7), `combatMesureEnVehicule` (C8),
`empilementSeulementEnMouvement` (C18, minecarts à contenu immobiles non cassés).
- C27 (modes vol / portée / hitbox en production) : décision de config, non traitée par le code.
### Tests du câblage Minecraft (branche test/cablage-minecraft)
- Refactoring sans changement de comportement : classe `Cablage` (entrées d'événements, sanctions, C7).
- `CablageTest` et `CablageMinecraftTest` ajoutés.
- Défaut connu non corrigé : `Garde.apresVehicule` ne consulte pas la marque d'expulsion (test `FAILLE_C4_...`).
### Version
- `gradle.properties` et `neoforge.mods.toml` en 0.3.1 ; jar `gastinelgarde-neoforge-1.21.1-0.3.1.jar`.
## 0.3.0
Corrections de l'audit du 14/10/2026 (voir `audit/CORRECTIONS.md`).
+2 -2
Voir le fichier
@@ -1,7 +1,7 @@
# GastinelGarde # GastinelGarde
Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur uniquement). Plan et décisions : Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur uniquement). Plan et décisions :
`../PLAN-GASTINELGARDE.md`. Version **0.3.0** : phases 0, 1 et 2 du plan, plus les corrections de l'audit du `../PLAN-GASTINELGARDE.md`. Version **0.3.1** (voir `CHANGELOG.md`) : phases 0, 1 et 2 du plan, plus les corrections de l'audit du
2026-10-14 (`audit/`). 2026-10-14 (`audit/`).
**État** : compilé, 180 tests JUnit verts (au 16/10) (cœur pur, commandes, configuration, application réelle des mixins, **État** : compilé, 180 tests JUnit verts (au 16/10) (cœur pur, commandes, configuration, application réelle des mixins,
@@ -251,7 +251,7 @@ journaliser et alerter (le coup a déjà eu lieu quand l'aller-retour est vu).
Les traces JSONL se rejouent dans le moteur, sans serveur : Les traces JSONL se rejouent dans le moteur, sans serveur :
``` ```
java -cp build/libs/gastinelgarde-neoforge-1.21.1-0.3.0.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl java -cp build/libs/gastinelgarde-neoforge-1.21.1-0.3.1.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl
``` ```
Sortie : nombre de mouvements et d'attaques, infractions et points maximaux par contrôle, vingt exemples. Méthode : Sortie : nombre de mouvements et d'attaques, infractions et points maximaux par contrôle, vingt exemples. Méthode :
+2
Voir le fichier
@@ -159,6 +159,8 @@
#Minecarts superposés au plus : au-delà, poussée mutuelle coupée et excédentaires (sans passager) cassés. 0 = pas de limite. #Minecarts superposés au plus : au-delà, poussée mutuelle coupée et excédentaires (sans passager) cassés. 0 = pas de limite.
# Range: 0 ~ 64 # Range: 0 ~ 64
minecartsSuperposesMax = 4 minecartsSuperposesMax = 4
#C18 : ne casser que les minecarts empilés en mouvement ou sans contenu (défaut false, décision de Théo)
empilementSeulementEnMouvement = false
alertesOps = true alertesOps = true
#Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs. #Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.
+1 -1
Voir le fichier
@@ -1,7 +1,7 @@
org.gradle.jvmargs=-Xmx2G org.gradle.jvmargs=-Xmx2G
org.gradle.parallel=true org.gradle.parallel=true
mod_version=0.3.0 mod_version=0.3.2
mod_group_id=com.gastinelgarde mod_group_id=com.gastinelgarde
mod_id=gastinelgarde mod_id=gastinelgarde
+169
Voir le fichier
@@ -0,0 +1,169 @@
package com.gastinelgarde;
import com.gastinelgarde.core.DetectionContraption;
import com.gastinelgarde.core.GraceTeleport;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Suivi;
import com.gastinelgarde.core.Verdict;
import java.util.List;
import java.util.UUID;
import java.util.function.BooleanSupplier;
/**
* Décisions du câblage Minecraft (Garde, GardeEvents) sorties sans changement de comportement (16/10, constat C4 ⚠️),
* pour être testées sans serveur. Aucun type Minecraft ici : Garde et GardeEvents lisent le serveur, appellent ces
* méthodes et appliquent le résultat.
*/
final class Cablage {
private Cablage() { }
// --- Entrées des événements ---
/** Ce que fait onAttaque avant toute mesure. */
enum EntreeAttaque {
/** C4 : expulsion en cours, le coup est annulé et rien n'est évalué. */
ANNULER,
/** Exemption manuelle (/garde exempter) : le coup passe sans mesure. */
IGNORER,
EVALUER
}
static EntreeAttaque entreeAttaque(boolean expulse, boolean exempteManuellement) {
if (expulse) return EntreeAttaque.ANNULER;
if (exempteManuellement) return EntreeAttaque.IGNORER;
return EntreeAttaque.EVALUER;
}
/** Fin de onAttaque : le coup est-il annulé ? (portée / hitbox ENFORCE, ou sanction ≥ SETBACK). */
static boolean annulerCoup(boolean coupsBloques, Sanction s) {
return coupsBloques || s.ordinal() >= Sanction.SETBACK.ordinal();
}
/** Fin de onAttaque : seule une EXPULSION est appliquée au joueur (un SETBACK de combat annule seulement le coup). */
static boolean appliquerApresCoup(Sanction s) {
return s == Sanction.EXPULSION;
}
/** avantMouvement : évaluer ce paquet ? (F01 thread serveur, C4 expulsion, exemption manuelle). */
static boolean evaluerAvantMouvement(boolean surThreadServeur, BooleanSupplier expulse,
BooleanSupplier exempteManuellement) {
// Paresseux : hors du thread serveur, l'état du mod n'est pas lu du tout (F01).
return surThreadServeur && !expulse.getAsBoolean() && !exempteManuellement.getAsBoolean();
}
/** apresMouvement : traiter ce paquet (état, position, traces) ? L'exemption manuelle est vue plus loin. */
static boolean traiterApresMouvement(boolean surThreadServeur, BooleanSupplier expulse) {
return surThreadServeur && !expulse.getAsBoolean();
}
/** Sanction de mouvement à appliquer (≥ SETBACK). */
static boolean sanctionDeMouvement(Sanction s) {
return s.ordinal() >= Sanction.SETBACK.ordinal();
}
// --- Exemptions contraption de la cible (portée / hitbox) ---
/**
* Portée et hitbox mesurées ? Non si la cible, ou son véhicule racine, est une contraption ou sur un vaisseau
* Sable. Évaluation paresseuse dans le même ordre que l'ancien code.
*/
static boolean mesurerPorteeHitbox(BooleanSupplier cibleContraption, BooleanSupplier cibleSable,
boolean racineEstCible, BooleanSupplier racineContraption,
BooleanSupplier racineSable) {
return !cibleContraption.getAsBoolean() && !cibleSable.getAsBoolean()
&& (racineEstCible || (!racineContraption.getAsBoolean() && !racineSable.getAsBoolean()));
}
// --- C7 : déploiement des élytres ---
/** Suivi du plané en cours : est-il commencé moins de elytresAirMinTicks après le dernier sol serveur ? */
static final class Elytres {
boolean vues;
boolean suspectes;
/** À chaque construction de l'état : transition isFallFlying. */
void observer(boolean plane, int solServeurTick, int tick, int airMinTicks) {
if (plane) {
if (!vues) {
vues = true;
suspectes = solServeurTick != Integer.MIN_VALUE && tick - solServeurTick < airMinTicks;
}
} else {
vues = false;
suspectes = false;
}
}
}
// --- Détection en cache (contraption, courant d'air) ---
/** Détection refaite au plus toutes les 10 ticks, puis grâce après la dernière détection positive. */
static final class CacheDetection {
int tick = Integer.MIN_VALUE;
int vuTick = Integer.MIN_VALUE;
boolean proche;
boolean lire(int maintenant, BooleanSupplier detecter, int graceTicks) {
if (tick == Integer.MIN_VALUE || maintenant - tick >= 10 || maintenant < tick) {
proche = detecter.getAsBoolean();
tick = maintenant;
if (proche) vuTick = maintenant;
}
return proche || DetectionContraption.dansLaGrace(maintenant, vuTick, graceTicks);
}
}
// --- Position de retour (C3) ---
/** apresMouvement : la position de ce paquet devient-elle la position de retour ? */
static boolean memoriserRetour(Moteur moteur, int dernierVerdictTick, int tick, BooleanSupplier vehiculeControle,
boolean solServeur, boolean milieuSpecial) {
return dernierVerdictTick != tick && !vehiculeControle.getAsBoolean()
&& moteur.positionDeRetourAdmise(solServeur, milieuSpecial);
}
/**
* D1 (0.3.2) : après une téléportation externe (/tp, TPA, perle, réapparition, dimension), le point d'arrivée
* devient la position de retour. Les autres (setback, refus vanilla) ne la changent pas.
*/
static void retourApresTeleport(Suivi sv, boolean externe, double x, double y, double z, float yaw, float pitch,
String dimension) {
if (externe) sv.memoriserPosition(x, y, z, yaw, pitch, dimension);
}
// --- Sanctions (C2, C4) ---
/** Ce que la sanction fait au joueur réel (adaptateur ServerPlayer dans Garde, doublure dans les tests). */
interface Joueur {
UUID id();
String nom();
String dimension();
int tick();
void annoncerTeleport(GraceTeleport.Origine origine);
void teleporter(double x, double y, double z, float yaw, float pitch);
void deconnecter(String message);
void journal(String ligne);
}
/** Expulsion à usage unique (C4) ; setback vers la position de retour de la même dimension, puis remise à zéro (C2). */
static void appliquerSanction(Moteur moteur, Joueur p, Sanction s, List<Verdict> verdicts) {
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
if (s == Sanction.EXPULSION) {
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
if (!moteur.expulser(p.id(), p.tick() * 50L)) return;
p.journal(p.nom() + " EXPULSE (" + raison + ")");
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
} else if (s == Sanction.SETBACK) {
Suivi sv = moteur.suivi(p.id());
if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) {
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
p.teleporter(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
moteur.apresSetback(p.id(), p.tick() * 50L);
p.journal(p.nom() + " SETBACK (" + raison + ")");
}
}
}
}
+79 -47
Voir le fichier
@@ -77,13 +77,12 @@ public final class Garde {
int vehiculeTick = Integer.MIN_VALUE; int vehiculeTick = Integer.MIN_VALUE;
double vehiculeX, vehiculeY, vehiculeZ; double vehiculeX, vehiculeY, vehiculeZ;
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste) // Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
int contraptionTick = Integer.MIN_VALUE; final Cablage.CacheDetection contraption = new Cablage.CacheDetection();
int contraptionVuTick = Integer.MIN_VALUE; // C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
boolean contraptionProche; int solServeurTick = Integer.MIN_VALUE;
final Cablage.Elytres elytres = new Cablage.Elytres();
// Cache de la détection d'un courant d'air (ventilateur Create), même principe // Cache de la détection d'un courant d'air (ventilateur Create), même principe
int courantTick = Integer.MIN_VALUE; final Cablage.CacheDetection courant = new Cablage.CacheDetection();
int courantVuTick = Integer.MIN_VALUE;
boolean courantProche;
// #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux) // #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux)
double[] oeilDernier; double[] oeilDernier;
double[] oeilAvant; double[] oeilAvant;
@@ -198,6 +197,9 @@ public final class Garde {
m.vehiculeId = -1; m.vehiculeId = -1;
m.oeilAvant = null; m.oeilAvant = null;
m.oeilDernier = null; m.oeilDernier = null;
// D1 (0.3.2) : réapparition, changement de dimension, connexion : la position actuelle devient le retour.
Cablage.retourApresTeleport(MOTEUR.suivi(p.getUUID()), true, p.getX(), p.getY(), p.getZ(), p.getYRot(),
p.getXRot(), p.level().dimension().location().toString());
} }
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */ /** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
@@ -210,10 +212,21 @@ public final class Garde {
* Tout teleport() du joueur (mixin) : la grâce ne s'ouvre que pour une origine externe (F05). Le mouvement * Tout teleport() du joueur (mixin) : la grâce ne s'ouvre que pour une origine externe (F05). Le mouvement
* suivant n'est jamais comparé à la position d'avant la téléportation. * suivant n'est jamais comparé à la position d'avant la téléportation.
*/ */
public static void teleportVanilla(ServerPlayer p) { public static void teleportVanilla(ServerPlayer p, double x, double y, double z, float yaw, float pitch,
Set<?> relatifs) {
if (!surThreadServeur(p)) return; if (!surThreadServeur(p)) return;
Marques m = marques(p.getUUID()); Marques m = marques(p.getUUID());
if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount(); boolean externe = m.graceTeleport.teleport();
if (externe) m.teleportTick = p.server.getTickCount();
// D1 (0.3.2) : téléportation externe (/tp, TPA, perle, mod) : le point d'arrivée devient la position de
// retour (avant : un setback ramenait à la position d'avant la téléportation).
Cablage.retourApresTeleport(MOTEUR.suivi(p.getUUID()), externe,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.X) ? p.getX() + x : x,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Y) ? p.getY() + y : y,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Z) ? p.getZ() + z : z,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Y_ROT) ? p.getYRot() + yaw : yaw,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.X_ROT) ? p.getXRot() + pitch : pitch,
p.level().dimension().location().toString());
m.mouvementTick = Integer.MIN_VALUE; m.mouvementTick = Integer.MIN_VALUE;
m.vehiculeId = -1; m.vehiculeId = -1;
m.oeilAvant = null; m.oeilAvant = null;
@@ -240,6 +253,8 @@ public final class Garde {
SUIVIES.put(p.getId(), s); SUIVIES.put(p.getId(), s);
} }
s.jusquaTick = tick + SUIVI_ENTITE_TICKS; s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
// Revue 4 (16/10) : ping noté chaque seconde, hors combat aussi, pour le plancher de ping.
if (tick % 20 == 0) MOTEUR.pingFenetre(p.getUUID(), tick * 50L, p.connection.latency());
} }
java.util.Iterator<Map.Entry<Integer, Suivie>> it = SUIVIES.entrySet().iterator(); java.util.Iterator<Map.Entry<Integer, Suivie>> it = SUIVIES.entrySet().iterator();
while (it.hasNext()) { while (it.hasNext()) {
@@ -273,7 +288,11 @@ public final class Garde {
if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return null; if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return null;
Suivie s = SUIVIES.get(cible.getId()); Suivie s = SUIVIES.get(cible.getId());
if (s == null || s.entite != cible) { if (s == null || s.entite != cible) {
if (!(cible instanceof Player) && SUIVIES.size() < SUIVIES_MAX) { if (!(cible instanceof Player)) {
// Revue 3 (16/10) : table pleine, on évince la cible non joueur frappée il y a le plus longtemps
// (avant : la nouvelle cible n'était jamais suivie, faire frapper beaucoup d'entités aveuglait le
// contrôle). La cible qu'on frappe sans arrêt est la plus récente : jamais évincée.
if (s == null && SUIVIES.size() >= SUIVIES_MAX) evincerPlusAncienne();
s = new Suivie(cible); s = new Suivie(cible);
s.jusquaTick = tick + SUIVI_ENTITE_TICKS; s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
SUIVIES.put(cible.getId(), s); SUIVIES.put(cible.getId(), s);
@@ -282,10 +301,28 @@ public final class Garde {
} }
if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS; if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
if (s.niveau != cible.level()) return null; if (s.niveau != cible.level()) return null;
int fenetre = PorteeHitbox.ticksFenetre(attaquant.connection.latency(), CONFIG); // Revue 4 (16/10) : ping plancher des 2 dernières minutes + marge, pas le ping déclaré du moment.
int fenetre = PorteeHitbox.ticksFenetre(
MOTEUR.pingFenetre(attaquant.getUUID(), tick * 50L, attaquant.connection.latency()), CONFIG);
return s.historique.depuis(tick - fenetre); return s.historique.depuis(tick - fenetre);
} }
/** Revue 3 : retire de la table l'entrée non joueur dont le dernier coup est le plus ancien. */
private static void evincerPlusAncienne() {
Integer cle = null;
int plusTot = Integer.MAX_VALUE;
for (Map.Entry<Integer, Suivie> e : SUIVIES.entrySet()) {
Suivie v = e.getValue();
if (v != null && v.entite instanceof Player) continue;
int t = v == null ? Integer.MIN_VALUE : v.jusquaTick;
if (cle == null || t < plusTot) {
cle = e.getKey();
plusTot = t;
}
}
if (cle != null) SUIVIES.remove(cle);
}
/** Œil de l'attaquant au paquet de mouvement d'avant le dernier (null si inconnu). */ /** Œil de l'attaquant au paquet de mouvement d'avant le dernier (null si inconnu). */
public static double[] oeilAvant(ServerPlayer p) { public static double[] oeilAvant(ServerPlayer p) {
Marques m = MARQUES.get(p.getUUID()); Marques m = MARQUES.get(p.getUUID());
@@ -362,12 +399,16 @@ public final class Garde {
mange = anim == UseAnim.EAT || anim == UseAnim.DRINK; mange = anim == UseAnim.EAT || anim == UseAnim.DRINK;
} }
// C7 : au début du plané, combien de ticks en l'air (sol serveur) ? Moins que elytresAirMinTicks : suspect.
m.elytres.observer(p.isFallFlying(), m.solServeurTick, tick, config().elytresAirMinTicks);
return EtatJoueur.builder() return EtatJoueur.builder()
.creatif(p.isCreative()) .creatif(p.isCreative())
.spectateur(p.isSpectator()) .spectateur(p.isSpectator())
.peutVoler(p.getAbilities().mayfly) .peutVoler(p.getAbilities().mayfly)
.riptide(riptideRecent) .riptide(riptideRecent)
.elytres(p.isFallFlying()) .elytres(p.isFallFlying())
.elytresDeploiementSuspect(m.elytres.suspectes)
.levitation(p.hasEffect(MobEffects.LEVITATION)) .levitation(p.hasEffect(MobEffects.LEVITATION))
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING)) .chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
.enVehicule(p.isPassenger()) .enVehicule(p.isPassenger())
@@ -446,12 +487,7 @@ public final class Garde {
/** La détection est refaite au plus toutes les 10 ticks par joueur ; grâce de 2 s après la dernière détection. */ /** La détection est refaite au plus toutes les 10 ticks par joueur ; grâce de 2 s après la dernière détection. */
private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) { private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) {
if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) { return m.contraption.lire(tick, () -> pocheContraption(p), GRACE_CONTRAPTION_TICKS);
m.contraptionProche = pocheContraption(p);
m.contraptionTick = tick;
if (m.contraptionProche) m.contraptionVuTick = tick;
}
return m.contraptionProche || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS);
} }
/** /**
@@ -546,22 +582,23 @@ public final class Garde {
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */ /** Début du traitement d'un paquet de mouvement : contrôle du débit. */
public static void avantMouvement(ServerPlayer p) { public static void avantMouvement(ServerPlayer p) {
if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà) // F01 : jamais depuis le thread réseau (le mixin l'évite déjà) ; C4 : expulsion en cours, plus rien à évaluer
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 : expulsion en cours, plus rien à évaluer if (!Cablage.evaluerAvantMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()),
if (estExempteManuellement(p.getUUID())) return; () -> estExempteManuellement(p.getUUID()))) return;
EtatJoueur etat = etat(p, false); EtatJoueur etat = etat(p, false);
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat); List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
Sanction s = traiter(p, v); Sanction s = traiter(p, v);
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v); if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
} }
/** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */ /** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */
public static void apresMouvement(ServerPlayer p) { public static void apresMouvement(ServerPlayer p) {
if (!surThreadServeur(p)) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;
int tick = p.server.getTickCount(); int tick = p.server.getTickCount();
Marques m = marques(p.getUUID()); Marques m = marques(p.getUUID());
boolean solServeur = auSolServeur(p, m); boolean solServeur = auSolServeur(p, m);
if (solServeur) m.solServeurTick = tick; // C7
// Phase 2 : no-fall (divergence), vitesse horizontale, vol. // Phase 2 : no-fall (divergence), vitesse horizontale, vol.
boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID()); boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID());
@@ -579,7 +616,7 @@ public final class Garde {
if (controler && em != null) { if (controler && em != null) {
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em); List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
Sanction s = traiter(p, v); Sanction s = traiter(p, v);
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v); if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
} }
// F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup. // F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup.
if (!estExempteManuellement(p.getUUID())) { if (!estExempteManuellement(p.getUUID())) {
@@ -604,8 +641,8 @@ public final class Garde {
// En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée // 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. // qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait.
// C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air. // C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air.
if (m.dernierVerdictTick != tick && !vehiculeControle(p) if (Cablage.memoriserRetour(MOTEUR, m.dernierVerdictTick, tick, () -> vehiculeControle(p), solServeur,
&& MOTEUR.positionDeRetourAdmise(solServeur, em != null && em.milieuSpecial())) { em != null && em.milieuSpecial())) {
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(), MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
p.level().dimension().location().toString()); p.level().dimension().location().toString());
} }
@@ -825,12 +862,7 @@ public final class Garde {
/** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */ /** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */
private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) { private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) {
if (m.courantTick == Integer.MIN_VALUE || tick - m.courantTick >= 10 || tick < m.courantTick) { return m.courant.lire(tick, () -> courantAir(p), GRACE_COURANT_TICKS);
m.courantProche = courantAir(p);
m.courantTick = tick;
if (m.courantProche) m.courantVuTick = tick;
}
return m.courantProche || DetectionContraption.dansLaGrace(tick, m.courantVuTick, GRACE_COURANT_TICKS);
} }
/** /**
@@ -872,22 +904,22 @@ public final class Garde {
} }
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) { public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id(); Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts);
if (s == Sanction.EXPULSION) { }
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
if (!MOTEUR.expulser(p.getUUID(), p.server.getTickCount() * 50L)) return; /** Adaptateur ServerPlayer de Cablage.appliquerSanction. */
ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")"); private static Cablage.Joueur joueur(ServerPlayer p) {
p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ").")); return new Cablage.Joueur() {
} else if (s == Sanction.SETBACK) { @Override public UUID id() { return p.getUUID(); }
Suivi sv = MOTEUR.suivi(p.getUUID()); @Override public String nom() { return p.getGameProfile().getName(); }
String dim = p.level().dimension().location().toString(); @Override public String dimension() { return p.level().dimension().location().toString(); }
if (sv.aPositionValide() && sv.dimension().equals(dim)) { @Override public int tick() { return p.server.getTickCount(); }
annoncerTeleport(p, GraceTeleport.Origine.SETBACK); @Override public void annoncerTeleport(GraceTeleport.Origine origine) { Garde.annoncerTeleport(p, origine); }
p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch()); @Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol. p.connection.teleport(x, y, z, yaw, pitch);
MOTEUR.apresSetback(p.getUUID(), p.server.getTickCount() * 50L);
ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")");
} }
} @Override public void deconnecter(String message) { p.connection.disconnect(Component.literal(message)); }
@Override public void journal(String ligne) { ecrireJournal(ligne); }
};
} }
} }
+11
Voir le fichier
@@ -137,6 +137,17 @@ public final class GardeAntiCrash {
if (!AntiCrashEntites.empilementExcessif(n, r)) return false; if (!AntiCrashEntites.empilementExcessif(n, r)) return false;
if (cart.isVehicle() || Garde.estContraption(cart) || SableAcces.surSousNiveau(cart)) return false; if (cart.isVehicle() || Garde.estContraption(cart) || SableAcces.surSousNiveau(cart)) return false;
Vec3 v = cart.getDeltaMovement(); Vec3 v = cart.getDeltaMovement();
// C18 : avec l'option, un minecart contenant immobile (stockage) n'est pas cassé.
boolean contenant = cart instanceof net.minecraft.world.Container;
if (!AntiCrashEntites.empilementACasser(n, r, v.length(), contenant)) {
if (plafonnementASignaler(cart.getUUID())) {
Garde.journaliser(String.format(java.util.Locale.ROOT,
"anti-crash EMPILEMENT %s immobile garde (%d minecarts superposés > %d), dim=%s pos=(%.1f, %.1f, %.1f)",
BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()), n, r.empilementMax,
cart.level().dimension().location(), cart.getX(), cart.getY(), cart.getZ()));
}
return false;
}
cart.destroy(cart.getPickResult().getItem()); cart.destroy(cart.getPickResult().getItem());
String type = BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()).toString(); String type = BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()).toString();
String ligne = String.format(java.util.Locale.ROOT, String ligne = String.format(java.util.Locale.ROOT,
+15 -11
Voir le fichier
@@ -57,11 +57,16 @@ public final class GardeEvents {
@SubscribeEvent @SubscribeEvent
public static void onAttaque(AttackEntityEvent event) { public static void onAttaque(AttackEntityEvent event) {
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.moteur().estExpulse(p.getUUID())) { // C4 : expulsion en cours switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) {
event.setCanceled(true); case ANNULER -> { // C4 : expulsion en cours
return; event.setCanceled(true);
return;
}
case IGNORER -> {
return;
}
case EVALUER -> { }
} }
if (Garde.estExempteManuellement(p.getUUID())) return;
Entity cible = event.getTarget(); Entity cible = event.getTarget();
int tick = p.server.getTickCount(); int tick = p.server.getTickCount();
@@ -83,8 +88,9 @@ public final class GardeEvents {
// (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere). // (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere).
// L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours. // L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
Entity racine = cible.getRootVehicle(); Entity racine = cible.getRootVehicle();
boolean mesurerPH = !Garde.estContraption(cible) && !SableAcces.surSousNiveau(cible) boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> Garde.estContraption(cible),
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine))); () -> SableAcces.surSousNiveau(cible), racine == cible, () -> Garde.estContraption(racine),
() -> SableAcces.surSousNiveau(racine));
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2) double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
+ Math.pow(cible.getZ() - cible.zo, 2)); + Math.pow(cible.getZ() - cible.zo, 2));
// #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge // #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge
@@ -103,11 +109,9 @@ public final class GardeEvents {
} }
Sanction s = Garde.traiter(p, verdicts); Sanction s = Garde.traiter(p, verdicts);
if (Garde.moteur().coupsBloques(p.getUUID(), tick * 50L)) event.setCanceled(true); // portée / hitbox ENFORCE // portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé
if (s.ordinal() >= Sanction.SETBACK.ordinal()) { if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true);
event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts);
}
} }
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */ /** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
+39 -1
Voir le fichier
@@ -49,6 +49,14 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE; private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
private static final ModConfigSpec.IntValue SERIE_PING_MAX; private static final ModConfigSpec.IntValue SERIE_PING_MAX;
private static final ModConfigSpec.IntValue SERIE_PING_MARGE;
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX;
private static final ModConfigSpec.BooleanValue VOL_FENETRE_GLISSANTE;
private static final ModConfigSpec.BooleanValue VITESSE_MOYENNE;
private static final ModConfigSpec.BooleanValue ELYTRES_STRICTE;
private static final ModConfigSpec.IntValue ELYTRES_AIR_MIN;
private static final ModConfigSpec.BooleanValue COMBAT_VEHICULE;
private static final ModConfigSpec.BooleanValue AC_EMPILEMENT_MOUVEMENT;
private static final ModConfigSpec.DoubleValue SERIE_MANQUE; private static final ModConfigSpec.DoubleValue SERIE_MANQUE;
private static final ModConfigSpec.DoubleValue SERIE_PORTEE; private static final ModConfigSpec.DoubleValue SERIE_PORTEE;
private static final ModConfigSpec.IntValue SERIE_COUPS; private static final ModConfigSpec.IntValue SERIE_COUPS;
@@ -125,8 +133,10 @@ public final class GardeSpec {
"Valeurs de départ prudentes, à régler avec les journaux en OBSERVE avant tout ENFORCE.").push("coupsHorsBoite"); "Valeurs de départ prudentes, à régler avec les journaux en OBSERVE avant tout ENFORCE.").push("coupsHorsBoite");
TICKS_AFFICHAGE = b.comment("Retard d'affichage de base de la cible chez le client (ticks) ; le ping s'ajoute (ping / 50).") TICKS_AFFICHAGE = b.comment("Retard d'affichage de base de la cible chez le client (ticks) ; le ping s'ajoute (ping / 50).")
.defineInRange("ticksAffichageCible", 7, 2, 12); .defineInRange("ticksAffichageCible", 7, 2, 12);
SERIE_PING_MAX = b.comment("Ping (ms) au-delà duquel le coup n'est pas mesuré.") SERIE_PING_MAX = b.comment("Ping (ms) pris en compte au plus dans la fenêtre (au-delà, le coup est mesuré avec cette fenêtre).")
.defineInRange("seriePingMaxMs", 500, 100, 500); .defineInRange("seriePingMaxMs", 500, 100, 500);
SERIE_PING_MARGE = b.comment("Fenêtre selon le ping le plus bas des 2 dernières minutes + cette marge (ms), pas le ping du moment.")
.defineInRange("seriePingMargeMs", 50, 0, 500);
SERIE_MANQUE = b.comment("Coup hors boîte si le regard manque toutes les boîtes vues de plus de cette marge (blocs).") SERIE_MANQUE = b.comment("Coup hors boîte si le regard manque toutes les boîtes vues de plus de cette marge (blocs).")
.defineInRange("serieManqueBlocs", 0.15, 0.05, 2.0); .defineInRange("serieManqueBlocs", 0.15, 0.05, 2.0);
SERIE_PORTEE = b.comment("... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs).") SERIE_PORTEE = b.comment("... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs).")
@@ -140,12 +150,29 @@ public final class GardeSpec {
b.push("timer"); b.push("timer");
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200); PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30); TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
TIMER_SOLDE_MAX = b.comment("C15 : solde de paquets (reçus - ticks écoulés) au-delà duquel le timer compte (timer 1,05-1,10).",
"0 = désactivé (défaut). Essai conseillé : 20, en OBSERVE.")
.defineInRange("timerSoldeMax", 0, 0, 1000);
b.pop(); b.pop();
b.push("mouvement"); b.push("mouvement");
EXCES_VITESSE = b.comment("Total d'excès de vitesse horizontale (blocs) sur 20 ticks avant une infraction.", EXCES_VITESSE = b.comment("Total d'excès de vitesse horizontale (blocs) sur 20 ticks avant une infraction.",
"Valeurs de départ généreuses, à resserrer avec les traces réelles.") "Valeurs de départ généreuses, à resserrer avec les traces réelles.")
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0); .defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
VOL_FENETRE_GLISSANTE = b.comment("C10 : vol, ticks anormaux sur une fenêtre glissante et sauts en l'air répétés.",
"Désactivé par défaut : à essayer en OBSERVE (vol est en ENFORCE en production).")
.define("volFenetreGlissante", false);
VITESSE_MOYENNE = b.comment("C15 : vitesse moyenne sur 40 paquets comparée à la moyenne vanilla (course, sprint-saut).",
"Désactivé par défaut : à essayer en OBSERVE (fausse alerte possible sous un plafond bas, C16).")
.define("vitesseMoyenne", false);
ELYTRES_STRICTE = b.comment("C7 : plané déclenché sans ticks en l'air (sol serveur) = pas d'exemption de mouvement ;",
"portée et hitbox mesurées pendant le plané. Désactivé par défaut : à essayer en OBSERVE.")
.define("elytresExemptionStricte", false);
ELYTRES_AIR_MIN = b.comment("C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres.")
.defineInRange("elytresAirMinTicks", 2, 1, 20);
COMBAT_VEHICULE = b.comment("C8 : le combat d'un passager de véhicule (bateau, cheval, minecart) est mesuré comme à pied.",
"Désactivé par défaut : à essayer en OBSERVE (portée, hitbox, killaura).")
.define("combatMesureEnVehicule", false);
b.pop(); b.pop();
b.push("exemptions"); b.push("exemptions");
@@ -195,6 +222,9 @@ public final class GardeSpec {
AC_EMPILEMENT_MAX = b.comment("Minecarts au plus qui se chevauchent : au-delà, leur poussée mutuelle est coupée et les", AC_EMPILEMENT_MAX = b.comment("Minecarts au plus qui se chevauchent : au-delà, leur poussée mutuelle est coupée et les",
"excédentaires (sans passager) sont cassés et lâchent leur objet. 0 = pas de limite.") "excédentaires (sans passager) sont cassés et lâchent leur objet. 0 = pas de limite.")
.defineInRange("minecartsSuperposesMax", 4, 0, 64); .defineInRange("minecartsSuperposesMax", 4, 0, 64);
AC_EMPILEMENT_MOUVEMENT = b.comment("C18 : ne casser que les minecarts empilés en mouvement ou sans contenu ; un stockage",
"immobile de minecarts à coffre / à trémie n'est plus cassé (poussée coupée, journal seulement). Défaut false.")
.define("empilementSeulementEnMouvement", false);
AC_ALERTES_OPS = b.comment("Message aux ops (5 au plus par 10 s ; tout est dans logs/gastinelgarde.log).") AC_ALERTES_OPS = b.comment("Message aux ops (5 au plus par 10 s ; tout est dans logs/gastinelgarde.log).")
.define("alertesOps", true); .define("alertesOps", true);
b.pop(); b.pop();
@@ -248,6 +278,13 @@ public final class GardeSpec {
c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get(); c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
c.ticksAffichageCible = TICKS_AFFICHAGE.get(); c.ticksAffichageCible = TICKS_AFFICHAGE.get();
c.seriePingMaxMs = SERIE_PING_MAX.get(); c.seriePingMaxMs = SERIE_PING_MAX.get();
c.seriePingMargeMs = SERIE_PING_MARGE.get();
c.timerSoldeMax = TIMER_SOLDE_MAX.get();
c.volFenetreGlissante = VOL_FENETRE_GLISSANTE.get();
c.vitesseMoyenne = VITESSE_MOYENNE.get();
c.elytresExemptionStricte = ELYTRES_STRICTE.get();
c.elytresAirMinTicks = ELYTRES_AIR_MIN.get();
c.combatMesureEnVehicule = COMBAT_VEHICULE.get();
c.serieManqueBlocs = SERIE_MANQUE.get(); c.serieManqueBlocs = SERIE_MANQUE.get();
c.seriePorteeMargeBlocs = SERIE_PORTEE.get(); c.seriePorteeMargeBlocs = SERIE_PORTEE.get();
c.serieCoups = SERIE_COUPS.get(); c.serieCoups = SERIE_COUPS.get();
@@ -322,6 +359,7 @@ public final class GardeSpec {
r.margeBordure = l ? AC_MARGE_BORDURE.get() : AC_MARGE_BORDURE.getDefault(); r.margeBordure = l ? AC_MARGE_BORDURE.get() : AC_MARGE_BORDURE.getDefault();
r.vitesseMaxMinecart = l ? AC_VITESSE_MINECART.get() : AC_VITESSE_MINECART.getDefault(); r.vitesseMaxMinecart = l ? AC_VITESSE_MINECART.get() : AC_VITESSE_MINECART.getDefault();
r.empilementMax = l ? AC_EMPILEMENT_MAX.get() : AC_EMPILEMENT_MAX.getDefault(); r.empilementMax = l ? AC_EMPILEMENT_MAX.get() : AC_EMPILEMENT_MAX.getDefault();
r.empilementSeulementEnMouvement = l ? AC_EMPILEMENT_MOUVEMENT.get() : AC_EMPILEMENT_MOUVEMENT.getDefault();
return r; return r;
} }
+19
Voir le fichier
@@ -48,6 +48,14 @@ public final class AntiCrashEntites {
public double vitesseMaxMinecart = 3.0; public double vitesseMaxMinecart = 3.0;
/** Minecarts au plus qui se chevauchent ; au-delà, la poussée mutuelle est coupée et les excédentaires cassés. */ /** Minecarts au plus qui se chevauchent ; au-delà, la poussée mutuelle est coupée et les excédentaires cassés. */
public int empilementMax = 4; public int empilementMax = 4;
/**
* C18 (16/10) : ne casser que les minecarts en mouvement ou sans contenu (minecart simple). Les minecarts à
* coffre / à trémie immobiles d'un stockage honnête ne sont plus cassés (poussée coupée, journal seulement).
* Désactivé par défaut : décision de Théo.
*/
public boolean empilementSeulementEnMouvement = false;
/** C18 : vitesse (blocs/tick) au-delà de laquelle un minecart empilé est « en mouvement ». */
public double empilementVitesseMin = 0.05;
} }
/** Bordure du monde (rectangle horizontal). */ /** Bordure du monde (rectangle horizontal). */
@@ -136,6 +144,17 @@ public final class AntiCrashEntites {
return r != null && r.actif && r.empilementMax > 0 && minecartsQuiSeChevauchent > r.empilementMax; return r != null && r.actif && r.empilementMax > 0 && minecartsQuiSeChevauchent > r.empilementMax;
} }
/**
* C18 : ce minecart empilé doit-il être cassé ?
* @param vitesse norme de sa vitesse (blocs/tick)
* @param contenant minecart à coffre, à trémie… (casser répand le contenu)
*/
public static boolean empilementACasser(int minecartsQuiSeChevauchent, Reglages r, double vitesse, boolean contenant) {
if (!empilementExcessif(minecartsQuiSeChevauchent, r)) return false;
if (!r.empilementSeulementEnMouvement) return true;
return !contenant || !(vitesse <= r.empilementVitesseMin);
}
/** Position dans la bordure + marge, et dans les limites absolues du jeu. */ /** Position dans la bordure + marge, et dans les limites absolues du jeu. */
public static boolean dansLimites(Bordure b, double marge, double x, double y, double z) { public static boolean dansLimites(Bordure b, double marge, double x, double y, double z) {
if (Math.abs(x) > LIMITE_HORIZONTALE || Math.abs(z) > LIMITE_HORIZONTALE || Math.abs(y) > LIMITE_VERTICALE) { if (Math.abs(x) > LIMITE_HORIZONTALE || Math.abs(z) > LIMITE_HORIZONTALE || Math.abs(y) > LIMITE_VERTICALE) {
+64 -4
Voir le fichier
@@ -15,6 +15,24 @@ final class CoupDiffere {
/** Le paquet de mouvement du même tick arrive normalement juste après ; 2 ticks de marge pour la gigue. */ /** Le paquet de mouvement du même tick arrive normalement juste après ; 2 ticks de marge pour la gigue. */
static final int TICKS_MAX = 2; static final int TICKS_MAX = 2;
/**
* Revue 2 / C13 (16/10) : au-delà de cet angle entre le regard du coup et celui du paquet suivant (rotation
* silencieuse : regard ailleurs au coup, ramené sur la cible juste après), le regard suivant n'est plus pris par
* coups-hors-boite, et le coup est compté comme « sauvé par le regard suivant » pour l'angle killaura (série, voir
* {@link Suivi#regardsSauves}). Un coup isolé garde le bénéfice du doute (demi-tour honnête possible).
* [À VÉRIFIER] en jeu : 90° couvre un « flick » honnête.
*/
static final double REGARD_SUIVANT_MAX_DEGRES = 90.0;
/**
* Revue 2 / C13 : l'œil du paquet suivant est ramené à au plus un tick de déplacement de l'œil du coup :
* déplacement horizontal du tick précédent + cette marge (accélération, élan d'un saut en courant)...
*/
static final double OEIL_SUIVANT_MARGE_H = 0.4;
/** ... déplacement vertical du tick précédent + cette marge (saut : 0,42)... */
static final double OEIL_SUIVANT_MARGE_V = 0.5;
/** ... ou, sans œil précédent connu, ce déplacement (horizontal et vertical). */
static final double OEIL_SUIVANT_DEFAUT = 0.6;
final long nowMs; final long nowMs;
final EtatJoueur etat; final EtatJoueur etat;
final double[] boite; final double[] boite;
@@ -34,6 +52,11 @@ final class CoupDiffere {
/** Regard au coup et au paquet suivant (null si inconnu). */ /** Regard au coup et au paquet suivant (null si inconnu). */
double[] regardCoup, regardSuivant; double[] regardCoup, regardSuivant;
/** Le regard du paquet suivant a été refusé (trop loin du regard du coup). */
boolean regardSuivantRefuse;
/** Excédent d'angle killaura avec le regard du coup seul (avant affinage), -1 si non mesuré. */
double excedentCoup = -1;
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible, CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
double distance, double manque, double excedent, boolean porteeHitbox) { double distance, double manque, double excedent, boolean porteeHitbox) {
this.nowMs = nowMs; this.nowMs = nowMs;
@@ -52,10 +75,18 @@ final class CoupDiffere {
return d >= 0 && d <= TICKS_MAX; return d >= 0 && d <= TICKS_MAX;
} }
/** Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. */ /**
void affiner(double[] oeil, double[] regard) { * Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. Revue 2 / C13 (16/10) : l'œil
oeilSuivant = oeil.clone(); * suivant est borné à un tick de déplacement depuis l'œil du coup, et le regard suivant n'est pris que s'il reste
regardSuivant = regard.clone(); * à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup.
*/
void affiner(double[] oeilRecu, double[] regardRecu) {
double[] oeil = oeilCoup == null ? oeilRecu.clone() : bornerOeil(oeilCoup, oeilPrecedent, oeilRecu);
double[] regard = regardRecu.clone();
regardSuivantRefuse = regardCoup != null && !regardAdmis(regardCoup, regardRecu);
excedentCoup = excedent;
oeilSuivant = oeil;
regardSuivant = regardSuivantRefuse ? null : regard;
double[] b = boite; double[] b = boite;
double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]); double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]);
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2], double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
@@ -68,4 +99,33 @@ final class CoupDiffere {
if (a >= 0) excedent = Math.min(excedent, a); if (a >= 0) excedent = Math.min(excedent, a);
} }
} }
/** Le regard suivant est-il à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup ? */
static boolean regardAdmis(double[] coup, double[] suivant) {
double n1 = Math.sqrt(coup[0] * coup[0] + coup[1] * coup[1] + coup[2] * coup[2]);
double n2 = Math.sqrt(suivant[0] * suivant[0] + suivant[1] * suivant[1] + suivant[2] * suivant[2]);
if (n1 < 1e-9 || n2 < 1e-9) return true;
double c = (coup[0] * suivant[0] + coup[1] * suivant[1] + coup[2] * suivant[2]) / (n1 * n2);
return c >= Math.cos(Math.toRadians(REGARD_SUIVANT_MAX_DEGRES)) - 1e-9;
}
/** Œil suivant ramené à un tick de déplacement de l'œil du coup (horizontal et vertical à part). */
static double[] bornerOeil(double[] coup, double[] precedent, double[] suivant) {
double bornH, bornV;
if (precedent == null) {
bornH = OEIL_SUIVANT_DEFAUT;
bornV = OEIL_SUIVANT_DEFAUT;
} else {
bornH = Math.hypot(coup[0] - precedent[0], coup[2] - precedent[2]) + OEIL_SUIVANT_MARGE_H;
bornV = Math.abs(coup[1] - precedent[1]) + OEIL_SUIVANT_MARGE_V;
}
double dx = suivant[0] - coup[0], dz = suivant[2] - coup[2], dy = suivant[1] - coup[1];
double h = Math.hypot(dx, dz);
if (h > bornH) {
dx *= bornH / h;
dz *= bornH / h;
}
if (Math.abs(dy) > bornV) dy = Math.copySign(bornV, dy);
return new double[] {coup[0] + dx, coup[1] + dy, coup[2] + dz};
}
} }
+5 -2
Voir le fichier
@@ -15,6 +15,7 @@ public record EtatJoueur(
boolean enVehicule, boolean enVehicule,
boolean pocheContraption, boolean pocheContraption,
boolean utiliseObjet, boolean utiliseObjet,
boolean elytresDeploiementSuspect,
int ticksDepuisTeleport, int ticksDepuisTeleport,
int ticksDepuisRecul, int ticksDepuisRecul,
int ticksDepuisGel, int ticksDepuisGel,
@@ -34,7 +35,7 @@ public record EtatJoueur(
public static final class Builder { public static final class Builder {
private boolean creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente; private boolean creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente;
private boolean enVehicule, pocheContraption, utiliseObjet; private boolean enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect;
private int ticksDepuisTeleport = JAMAIS, ticksDepuisRecul = JAMAIS, ticksDepuisGel = JAMAIS; private int ticksDepuisTeleport = JAMAIS, ticksDepuisRecul = JAMAIS, ticksDepuisGel = JAMAIS;
private double tps = 20.0; private double tps = 20.0;
private int pingMs = 30; private int pingMs = 30;
@@ -49,6 +50,8 @@ public record EtatJoueur(
public Builder enVehicule(boolean v) { enVehicule = v; return this; } public Builder enVehicule(boolean v) { enVehicule = v; return this; }
public Builder pocheContraption(boolean v) { pocheContraption = v; return this; } public Builder pocheContraption(boolean v) { pocheContraption = v; return this; }
public Builder utiliseObjet(boolean v) { utiliseObjet = v; return this; } public Builder utiliseObjet(boolean v) { utiliseObjet = v; return this; }
/** C7 : plané déclenché sans assez de ticks en l'air côté serveur (onGround probablement falsifié). */
public Builder elytresDeploiementSuspect(boolean v) { elytresDeploiementSuspect = v; return this; }
public Builder ticksDepuisTeleport(int v) { ticksDepuisTeleport = v; return this; } public Builder ticksDepuisTeleport(int v) { ticksDepuisTeleport = v; return this; }
public Builder ticksDepuisRecul(int v) { ticksDepuisRecul = v; return this; } public Builder ticksDepuisRecul(int v) { ticksDepuisRecul = v; return this; }
public Builder ticksDepuisGel(int v) { ticksDepuisGel = v; return this; } public Builder ticksDepuisGel(int v) { ticksDepuisGel = v; return this; }
@@ -57,7 +60,7 @@ public record EtatJoueur(
public EtatJoueur build() { public EtatJoueur build() {
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente, return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
enVehicule, pocheContraption, utiliseObjet, ticksDepuisTeleport, ticksDepuisRecul, enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect, ticksDepuisTeleport, ticksDepuisRecul,
ticksDepuisGel, tps, pingMs); ticksDepuisGel, tps, pingMs);
} }
} }
+5 -2
Voir le fichier
@@ -28,13 +28,16 @@ public final class Exemptions {
switch (famille) { switch (famille) {
case COMBAT -> { case COMBAT -> {
if (e.enVehicule()) raisons.add("vehicule"); // C8 (16/10) : option combatMesureEnVehicule (défaut false) : le passager est mesuré comme à pied.
if (e.enVehicule() && !cfg.combatMesureEnVehicule) raisons.add("vehicule");
if (e.pocheContraption()) raisons.add("contraption"); if (e.pocheContraption()) raisons.add("contraption");
} }
case MOUVEMENT -> { case MOUVEMENT -> {
if (e.peutVoler()) raisons.add("peut-voler"); if (e.peutVoler()) raisons.add("peut-voler");
if (e.riptide()) raisons.add("riptide"); if (e.riptide()) raisons.add("riptide");
if (e.elytres()) raisons.add("elytres"); // C7 (16/10) : option elytresExemptionStricte (défaut false) : un plané déclenché sans ticks en l'air
// côté serveur (onGround falsifié) n'exempte plus le mouvement.
if (e.elytres() && !(cfg.elytresExemptionStricte && e.elytresDeploiementSuspect())) raisons.add("elytres");
if (e.levitation()) raisons.add("levitation"); if (e.levitation()) raisons.add("levitation");
if (e.chuteLente()) raisons.add("chute-lente"); if (e.chuteLente()) raisons.add("chute-lente");
if (e.enVehicule()) raisons.add("vehicule"); if (e.enVehicule()) raisons.add("vehicule");
+25 -1
Voir le fichier
@@ -72,7 +72,7 @@ public final class GardeConfig {
* 3 ticks (mob), interpolation sur 3 ticks, plus 1 tick de gigue. Le ping s'ajoute (voir seriePingMaxMs). * 3 ticks (mob), interpolation sur 3 ticks, plus 1 tick de gigue. Le ping s'ajoute (voir seriePingMaxMs).
*/ */
public int ticksAffichageCible = 7; public int ticksAffichageCible = 7;
/** Ping (ms) au-delà duquel la mesure compensée n'est pas faite (fenêtre plus large que l'historique fiable). */ /** Ping (ms) pris en compte au plus dans la fenêtre (revue 1, 16/10 : au-delà, mesuré quand même, fenêtre bornée). */
public int seriePingMaxMs = 500; public int seriePingMaxMs = 500;
/** Un coup est « hors boîte » si le regard manque toutes les boîtes vues de plus de cette marge (blocs). */ /** Un coup est « hors boîte » si le regard manque toutes les boîtes vues de plus de cette marge (blocs). */
public double serieManqueBlocs = 0.15; public double serieManqueBlocs = 0.15;
@@ -86,6 +86,30 @@ public final class GardeConfig {
public long serieFenetreMs = 30000; public long serieFenetreMs = 30000;
/** Points par coup hors boîte dans une série suspecte. */ /** Points par coup hors boîte dans une série suspecte. */
public double seriePoints = 2.0; public double seriePoints = 2.0;
/**
* Revue 4 (16/10) : la fenêtre d'historique suit le ping le plus bas vu ces 2 dernières minutes, plus cette marge
* (ms), et non le ping déclaré : gonfler son ping pendant un combat n'élargit plus la fenêtre.
*/
public int seriePingMargeMs = 50;
// --- C10 / C15 (16/10) : détections supplémentaires, DÉSACTIVÉES par défaut (à valider en OBSERVE) ---
/** C10 : vol, ticks anormaux comptés sur une fenêtre glissante et sauts en l'air sans appui. */
public boolean volFenetreGlissante = false;
/** C15 : vitesse moyenne sur 2 s comparée à la moyenne vanilla (course, sprint-saut). */
public boolean vitesseMoyenne = false;
// --- C7 / C8 (16/10, constats hauts) : DÉSACTIVÉS par défaut (à valider en OBSERVE) ---
/**
* C7 : élytres. Pas d'exemption de mouvement si le plané a été déclenché sans au moins
* {@link #elytresAirMinTicks} ticks en l'air (sol serveur), et portée / hitbox mesurées pendant le plané.
*/
public boolean elytresExemptionStricte = false;
/** C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres. */
public int elytresAirMinTicks = 2;
/** C8 : le combat d'un passager de véhicule (bateau, cheval, minecart…) est mesuré comme à pied. */
public boolean combatMesureEnVehicule = false;
/** C15 : solde de paquets de mouvement (reçus - ticks écoulés) au-delà duquel le timer compte ; 0 = désactivé. */
public int timerSoldeMax = 0;
// --- Exemptions --- // --- Exemptions ---
public int graceTeleportTicks = 40; public int graceTeleportTicks = 40;
+42 -10
Voir le fichier
@@ -121,11 +121,20 @@ public final class Moteur {
ajouter(verdicts, s, Controle.HITBOX, PorteeHitbox.pointsHitbox(manque, seuil), nowMs, ex, ajouter(verdicts, s, Controle.HITBOX, PorteeHitbox.pointsHitbox(manque, seuil), nowMs, ex,
String.format(Locale.ROOT, "regard hors boite de %.2f (seuil %.2f)", manque, seuil)); String.format(Locale.ROOT, "regard hors boite de %.2f (seuil %.2f)", manque, seuil));
} }
boolean setback = false;
for (Verdict v : verdicts) { for (Verdict v : verdicts) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) { if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
s.coupsBloquesJusqua = nowMs + DUREE_BLOCAGE_COUPS_MS; s.coupsBloquesJusqua = nowMs + DUREE_BLOCAGE_COUPS_MS;
} }
// D2 (0.3.2) : un setback de combat (coups annulés) compte comme un setback (C5) et remet le VL de ce
// contrôle à zéro, comme pour le vol (C2). Avant, le VL montait à 20 en ~5 s : expulsion directe, sans
// la règle « 4 setbacks en 60 s ».
if (v.applicable() == Sanction.SETBACK) {
s.vl.remettreAZero(v.controle());
setback = true;
}
} }
if (setback) s.noterSetback(nowMs);
return verdicts; return verdicts;
} }
@@ -185,12 +194,11 @@ public final class Moteur {
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2], double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]); porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
CoupDiffere c = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph); CoupDiffere c = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
if (serie) { // Revue 2 / C13 : œil et regard du coup gardés dans tous les cas, pour borner ceux du paquet suivant.
c.boitesVues = boitesVues; c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone(); c.oeilCoup = oeil.clone();
c.oeilCoup = oeil.clone(); c.regardCoup = regard.clone();
c.regardCoup = regard.clone(); if (serie) c.boitesVues = boitesVues;
}
suivi(joueur).coupDiffere = c; suivi(joueur).coupDiffere = c;
return verdicts; return verdicts;
} }
@@ -222,11 +230,23 @@ public final class Moteur {
double pts = s.serie.enregistrer(c.nowMs, hors, cfg); double pts = s.serie.enregistrer(c.nowMs, hors, cfg);
List<Verdict> verdicts = new ArrayList<>(1); List<Verdict> verdicts = new ArrayList<>(1);
ajouter(verdicts, s, Controle.COUPS_HORS_BOITE, pts, c.nowMs, ex, String.format(Locale.ROOT, ajouter(verdicts, s, Controle.COUPS_HORS_BOITE, pts, c.nowMs, ex, String.format(Locale.ROOT,
"manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d", "manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d%s",
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal())); m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal(),
c.regardSuivantRefuse ? ", regard suivant refuse" : ""));
return verdicts; return verdicts;
} }
/**
* Revue 4 (16/10) : ping à utiliser pour la fenêtre d'historique de coups-hors-boite (voir
* {@link PorteeHitbox#ticksFenetre}). Note aussi le ping déclaré.
*/
public int pingFenetre(UUID joueur, long nowMs, int pingDeclare) {
Suivi s = suivi(joueur);
int plancher = s.pingPlancher.noter(nowMs, pingDeclare);
long avecMarge = (long) plancher + Math.max(0, cfg.seriePingMargeMs);
return (int) Math.max(0, Math.min(pingDeclare, avecMarge));
}
/** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */ /** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */
public List<Verdict> regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) { public List<Verdict> regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4 if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
@@ -250,6 +270,12 @@ public final class Moteur {
double seuil = cfg.angleMaxDegres * ex.facteur(); double seuil = cfg.angleMaxDegres * ex.facteur();
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, KillauraAngle.points(c.excedent, seuil), c.nowMs, ex, ajouter(verdicts, s, Controle.KILLAURA_ANGLE, KillauraAngle.points(c.excedent, seuil), c.nowMs, ex,
String.format(Locale.ROOT, "excedent=%.1f deg (seuil %.0f, mesure differee)", c.excedent, seuil)); String.format(Locale.ROOT, "excedent=%.1f deg (seuil %.0f, mesure differee)", c.excedent, seuil));
// C13 : coup « sauvé » seulement par un regard suivant à plus de 90° du regard du coup.
boolean sauve = c.regardSuivantRefuse && c.excedentCoup > seuil && !(c.excedent > seuil);
double ptsSauves = s.regardsSauves.enregistrer(c.nowMs, sauve, cfg);
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, ptsSauves, c.nowMs, ex, String.format(Locale.ROOT,
"regard ramene sur la cible au paquet suivant (excedent au coup %.1f deg), %d coups sur %d",
c.excedentCoup, s.regardsSauves.dernierCompte(), s.regardsSauves.dernierTotal()));
} }
} }
if (c.porteeHitbox) { if (c.porteeHitbox) {
@@ -324,6 +350,7 @@ public final class Moteur {
// 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…). // 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…).
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons())); s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
s.vol.vider(); s.vol.vider();
s.dyChute = 0;
// C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore. // C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore.
if (ex.raisons().contains("elytres")) { if (ex.raisons().contains("elytres")) {
s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L; s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L;
@@ -332,10 +359,13 @@ public final class Moteur {
} }
List<Verdict> verdicts = new ArrayList<>(3); List<Verdict> verdicts = new ArrayList<>(3);
if (noFall) { if (noFall) {
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m), nowMs, ex, ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m, s.dyChute), nowMs, ex,
"au sol declare sans bloc dessous pendant une chute"); NoFall.sansDeplacement(m) ? "au sol declare sans bloc dessous pendant une chute (paquet d'etat)"
: "au sol declare sans bloc dessous pendant une chute");
} }
s.dyChute = NoFall.dyApres(m, s.dyChute);
if (vitesse) { if (vitesse) {
s.vitesse.moyenne = cfg.vitesseMoyenne; // C15, désactivé par défaut
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs); double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
ajouter(verdicts, s, Controle.VITESSE, pts, nowMs, ex, ajouter(verdicts, s, Controle.VITESSE, pts, nowMs, ex,
String.format(Locale.ROOT, "dxz=%.3f max=%.3f ticks=%d base=%.3f", m.dxz(), String.format(Locale.ROOT, "dxz=%.3f max=%.3f ticks=%d base=%.3f", m.dxz(),
@@ -350,6 +380,7 @@ public final class Moteur {
if (vol && graceElytres) { if (vol && graceElytres) {
s.vol.vider(); // le paquet qui suit la grâce sert de référence s.vol.vider(); // le paquet qui suit la grâce sert de référence
} else if (vol) { } else if (vol) {
s.vol.fenetreGlissante = cfg.volFenetreGlissante; // C10, désactivé par défaut
double pts = s.vol.enregistrer(m, false); double pts = s.vol.enregistrer(m, false);
ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy())); ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy()));
} }
@@ -427,6 +458,7 @@ public final class Moteur {
Suivi s = suivi(joueur); Suivi s = suivi(joueur);
s.vol.vider(); s.vol.vider();
s.vitesse.vider(); s.vitesse.vider();
s.dyChute = 0;
s.graceElytresJusquaMs = Long.MIN_VALUE; s.graceElytresJusquaMs = Long.MIN_VALUE;
s.vl.remettreAZero(Controle.VOL); s.vl.remettreAZero(Controle.VOL);
s.vl.remettreAZero(Controle.VITESSE); s.vl.remettreAZero(Controle.VITESSE);
+21 -1
Voir le fichier
@@ -48,7 +48,27 @@ public final class NoFall {
} }
public static double points(EtatMouvement e) { public static double points(EtatMouvement e) {
if (e.auSolClient() && !e.auSolServeur() && e.dy() <= DY_CHUTE && !e.milieuSpecial()) return 0.5; return points(e, 0);
}
/**
* D3 (0.3.2) : idem, mais un paquet sans déplacement (paquet d'état « au sol » ajouté par un NoFall, dy = 0) est
* jugé avec la vitesse verticale du dernier paquet qui a bougé ({@code dyPrecedent}).
*/
public static double points(EtatMouvement e, double dyPrecedent) {
double dy = sansDeplacement(e) ? dyPrecedent : e.dy();
if (e.auSolClient() && !e.auSolServeur() && dy <= DY_CHUTE && !e.milieuSpecial()) return 0.5;
return 0; return 0;
} }
/** Paquet qui ne change pas la position (paquet d'état ou de rotation seule). */
public static boolean sansDeplacement(EtatMouvement e) {
return e.dy() == 0 && e.dxz() == 0;
}
/** Vitesse verticale de chute à retenir après ce paquet : remise à zéro au sol ou en milieu spécial. */
public static double dyApres(EtatMouvement e, double dyPrecedent) {
if (e.auSolServeur() || e.milieuSpecial()) return 0;
return sansDeplacement(e) ? dyPrecedent : e.dy();
}
} }
+43
Voir le fichier
@@ -0,0 +1,43 @@
package com.gastinelgarde.core;
/**
* Revue 4 (16/10/2026) : ping le plus bas vu sur les 2 dernières minutes, par tranches de 10 s.
*
* La fenêtre d'historique de coups-hors-boite suivait le ping déclaré : un client qui gonfle son ping pendant un
* combat (réponses keep-alive retardées) élargissait la fenêtre et cachait un « hitbox » ou un « reach ». Elle suit
* maintenant ce plancher (plus une marge, voir {@link GardeConfig#seriePingMargeMs}) : le ping qui monte d'un coup
* n'élargit plus rien, un ping durablement élevé (plus de 2 minutes) est de nouveau pris en compte.
*
* Coût constant : 12 tranches.
*/
final class PingPlancher {
static final long TRANCHE_MS = 10_000;
static final int TRANCHES = 12;
private final long[] tranche = new long[TRANCHES];
private final int[] min = new int[TRANCHES];
PingPlancher() {
java.util.Arrays.fill(tranche, Long.MIN_VALUE);
}
/** Note le ping déclaré et renvoie le plancher (ce ping s'il n'y a rien d'autre). */
int noter(long nowMs, int ping) {
long t = Math.floorDiv(nowMs, TRANCHE_MS);
int i = (int) Math.floorMod(t, (long) TRANCHES);
if (tranche[i] != t) {
tranche[i] = t;
min[i] = ping;
} else {
min[i] = Math.min(min[i], ping);
}
int plancher = ping;
for (int k = 0; k < TRANCHES; k++) {
if (tranche[k] != Long.MIN_VALUE && t - tranche[k] < TRANCHES && tranche[k] <= t) {
plancher = Math.min(plancher, min[k]);
}
}
return plancher;
}
}
+5 -4
Voir le fichier
@@ -98,7 +98,7 @@ public final class PorteeHitbox {
*/ */
public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) { public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) {
if (e.riptide()) return "riptide"; if (e.riptide()) return "riptide";
if (e.elytres()) return "elytres"; if (e.elytres() && !cfg.elytresExemptionStricte) return "elytres"; // C7 : mesuré avec l'option
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) return "teleportation"; if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) return "teleportation";
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul"; if (e.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul";
if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide"; if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide";
@@ -205,14 +205,15 @@ public final class PorteeHitbox {
/** /**
* Situations où la mesure compensée n'est pas fiable (en plus de {@link #raisonNonMesure}, sans la vitesse * Situations où la mesure compensée n'est pas fiable (en plus de {@link #raisonNonMesure}, sans la vitesse
* instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées), ping au-delà * instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées).
* de {@link GardeConfig#seriePingMaxMs} (la fenêtre ne couvrirait plus le retard d'affichage). *
* Revue 1 (16/10) : un ping au-delà de {@link GardeConfig#seriePingMaxMs} n'exempte plus le coup (le ping est
* falsifiable) ; la fenêtre reste bornée à ce ping par {@link #ticksFenetre}.
*/ */
public static String raisonNonMesureSerie(EtatJoueur e, GardeConfig cfg) { public static String raisonNonMesureSerie(EtatJoueur e, GardeConfig cfg) {
String r = raisonNonMesure(e, 0, cfg); String r = raisonNonMesure(e, 0, cfg);
if (r != null) return r; if (r != null) return r;
if (e.ticksDepuisGel() <= cfg.graceGelTicks) return "gel-serveur"; if (e.ticksDepuisGel() <= cfg.graceGelTicks) return "gel-serveur";
if (e.pingMs() > cfg.seriePingMaxMs) return "ping";
return null; return null;
} }
} }
+9
Voir le fichier
@@ -16,6 +16,13 @@ public final class Suivi {
public final VehiculeMouvement vehicule = new VehiculeMouvement(); public final VehiculeMouvement vehicule = new VehiculeMouvement();
/** #92 : derniers coups mesurés avec l'historique de la cible (contrôle coups-hors-boite). */ /** #92 : derniers coups mesurés avec l'historique de la cible (contrôle coups-hors-boite). */
public final SerieCoups serie = new SerieCoups(); public final SerieCoups serie = new SerieCoups();
/** Revue 4 (16/10) : ping le plus bas des 2 dernières minutes (fenêtre de coups-hors-boite). */
final PingPlancher pingPlancher = new PingPlancher();
/**
* C13 (16/10) : derniers coups dont l'angle killaura n'était bon que grâce à un regard suivant à plus de 90° du
* regard du coup (rotation silencieuse). Mêmes réglages de série que coups-hors-boite.
*/
public final SerieCoups regardsSauves = new SerieCoups();
/** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */ /** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
CoupDiffere coupDiffere; CoupDiffere coupDiffere;
@@ -23,6 +30,8 @@ public final class Suivi {
long coupsBloquesJusqua = Long.MIN_VALUE; long coupsBloquesJusqua = Long.MIN_VALUE;
/** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */ /** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */
long graceElytresJusquaMs = Long.MIN_VALUE; long graceElytresJusquaMs = Long.MIN_VALUE;
/** D3 (0.3.2) : vitesse verticale du dernier paquet qui a bougé pendant une chute (0 au sol). */
double dyChute;
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */ /** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>(); private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
+31
Voir le fichier
@@ -16,7 +16,36 @@ public final class TimerPaquets {
private final CompteurTranches compteur = new CompteurTranches(TRANCHE_MS, SECONDES_MAX * TRANCHES_PAR_SECONDE + 1); private final CompteurTranches compteur = new CompteurTranches(TRANCHE_MS, SECONDES_MAX * TRANCHES_PAR_SECONDE + 1);
/**
* C15 (16/10) : solde de paquets (reçus - ticks écoulés), option {@link GardeConfig#timerSoldeMax} (0 = désactivé).
* Un timer à 1,09 (21,8 paquets/s) restait sous le seuil de 22 paquets/s ; son solde, lui, grandit sans fin. Le
* crédit accumulé pendant un lag (paquets en retard, puis rafale de rattrapage) est borné à {@link #CREDIT_MAX}.
*/
static final double CREDIT_MAX = 40;
private double solde;
private long dernierMs = Long.MIN_VALUE;
private double solde(long nowMs, GardeConfig cfg, double facteur) {
if (cfg.timerSoldeMax <= 0) return 0;
if (dernierMs == Long.MIN_VALUE) {
dernierMs = nowMs;
solde = 0;
return 0;
}
solde += 1.0 - Math.max(0, nowMs - dernierMs) / (double) TRANCHE_MS;
solde = Math.max(-CREDIT_MAX, solde);
dernierMs = Math.max(dernierMs, nowMs);
double max = cfg.timerSoldeMax * facteur;
if (solde <= max) return 0;
return 1.0 + Math.min(3.0, (solde - max) / 20.0);
}
public double enregistrer(long nowMs, GardeConfig cfg, double facteur) { public double enregistrer(long nowMs, GardeConfig cfg, double facteur) {
double ptsSolde = solde(nowMs, cfg, facteur);
return Math.max(ptsSolde, enregistrerDebit(nowMs, cfg, facteur));
}
private double enregistrerDebit(long nowMs, GardeConfig cfg, double facteur) {
compteur.ajouter(nowMs); compteur.ajouter(nowMs);
int max = (int) Math.floor(cfg.paquetsParSecondeMax * facteur); int max = (int) Math.floor(cfg.paquetsParSecondeMax * facteur);
int secondes = Math.min(SECONDES_MAX, Math.max(1, cfg.timerSecondesSoutenues)); int secondes = Math.min(SECONDES_MAX, Math.max(1, cfg.timerSecondesSoutenues));
@@ -31,5 +60,7 @@ public final class TimerPaquets {
public void vider() { public void vider() {
compteur.vider(); compteur.vider();
solde = 0;
dernierMs = Long.MIN_VALUE;
} }
} }
+60 -3
Voir le fichier
@@ -56,6 +56,24 @@ public final class VitesseHorizontale {
private int ticksDepuisSortie = Integer.MAX_VALUE; private int ticksDepuisSortie = Integer.MAX_VALUE;
private double dernierPermis; private double dernierPermis;
// --- C15 (16/10) : vitesse moyenne, option {@link GardeConfig#vitesseMoyenne} désactivée par défaut ---
/** Fenêtre (paquets) sur laquelle la vitesse moyenne est comparée à la moyenne vanilla. */
public static final int MOYENNE_PAQUETS = 40;
/** Moyenne vanilla en course au sol (0,2806 bloc/tick en régime établi) et en sprint-saut (~0,356, 7,13 m/s). */
public static final double MOYENNE_COURSE_SOL = 0.29;
public static final double MOYENNE_COURSE_AIR = 0.36;
/** Marche : au sol 0,216 ; en l'air (saut en marchant) la base actuelle suffit. */
public static final double MOYENNE_MARCHE_SOL = 0.22;
/** Marge sur la moyenne attendue (arrondis, petites accélérations). [À VÉRIFIER] avec des traces réelles. */
public static final double MOYENNE_MARGE = 0.08;
/** Activé par le moteur selon la configuration. */
boolean moyenne;
private final double[] moyDxz = new double[MOYENNE_PAQUETS];
private final double[] moyAttendu = new double[MOYENNE_PAQUETS];
private int moyIndex;
private int moyRemplis;
/** Vitesse maximale attendue (blocs par tick) pour cet état, avant la tolérance du lag. */ /** Vitesse maximale attendue (blocs par tick) pour cet état, avant la tolérance du lag. */
public static double vitesseMax(EtatMouvement e) { public static double vitesseMax(EtatMouvement e) {
double v; double v;
@@ -84,6 +102,7 @@ public final class VitesseHorizontale {
double base = vitesseMax(e) * facteur; double base = vitesseMax(e) * facteur;
if (e.milieuSpecial() || e.frictionAnormale()) { if (e.milieuSpecial() || e.frictionAnormale()) {
// Glace, eau, échelle… : non contrôlé, mais l'élan qui en sort est légitime. // Glace, eau, échelle… : non contrôlé, mais l'élan qui en sort est légitime.
viderMoyenne();
pousser(0); pousser(0);
memoriser(e.dxz(), base, TRAINEE_AIR); memoriser(e.dxz(), base, TRAINEE_AIR);
avancerSortie(ticks); avancerSortie(ticks);
@@ -105,13 +124,49 @@ public final class VitesseHorizontale {
// Un paquet = un tick du client, même arrivé après 2 ticks serveur : l'élan est son déplacement, borné par le // Un paquet = un tick du client, même arrivé après 2 ticks serveur : l'élan est son déplacement, borné par le
// permis d'UN tick (sinon un client qui n'envoie qu'un paquet sur deux se construirait un élan). // permis d'UN tick (sinon un client qui n'envoie qu'un paquet sur deux se construirait un élan).
memoriser(Math.min(e.dxz(), permisParTick), base, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR); memoriser(Math.min(e.dxz(), permisParTick), base, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
boolean sortieRecente = ticksDepuisSortie < MOYENNE_PAQUETS;
avancerSortie(ticks); avancerSortie(ticks);
double ptsMoyenne = moyenne ? moyenne(e, ticks, facteur, sortieRecente) : 0;
if (depasse <= 0) return 0; if (depasse <= 0) return ptsMoyenne;
double total = 0; double total = 0;
for (double v : exces) total += v; for (double v : exces) total += v;
if (total <= seuilBlocs) return 0; if (total <= seuilBlocs) return ptsMoyenne;
return 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0); return Math.max(ptsMoyenne, 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0));
}
/**
* C15 (16/10) : la base en l'air (0,42 dès que le joueur court) et le tampon de 1,5 bloc sur 20 ticks laissaient
* passer un Speed à 0,37-0,40 bloc/tick sans fin. Ici, la moyenne des {@link #MOYENNE_PAQUETS} derniers paquets est
* comparée à la moyenne vanilla du même état (course au sol, sprint-saut). Pas de mesure juste après un état
* exempté (élan hérité) ni dans un milieu non contrôlé (fenêtre vidée).
*/
private double moyenne(EtatMouvement e, int ticks, double facteur, boolean sortieRecente) {
if (sortieRecente) {
viderMoyenne();
return 0;
}
double base = vitesseMax(e);
double brut;
if (e.furtif() || e.ralentiParObjet()) brut = base; // pas de moyenne connue : la borne actuelle
else if (e.sprint()) brut = base * (e.auSolServeur() ? MOYENNE_COURSE_SOL / COURSE : MOYENNE_COURSE_AIR / COURSE_SAUT);
else brut = e.auSolServeur() ? base * MOYENNE_MARCHE_SOL / MARCHE : base;
moyDxz[moyIndex] = e.dxz();
moyAttendu[moyIndex] = brut * facteur * ticks;
moyIndex = (moyIndex + 1) % MOYENNE_PAQUETS;
if (moyRemplis < MOYENNE_PAQUETS) moyRemplis++;
if (moyRemplis < MOYENNE_PAQUETS) return 0;
double d = 0, a = 0;
for (int i = 0; i < MOYENNE_PAQUETS; i++) {
d += moyDxz[i];
a += moyAttendu[i];
}
return d > a * (1.0 + MOYENNE_MARGE) ? 0.5 : 0;
}
private void viderMoyenne() {
moyIndex = 0;
moyRemplis = 0;
} }
/** /**
@@ -125,6 +180,7 @@ public final class VitesseHorizontale {
public void exempter(EtatMouvement e, double facteur, boolean sortieDEtat) { public void exempter(EtatMouvement e, double facteur, boolean sortieDEtat) {
java.util.Arrays.fill(exces, 0); java.util.Arrays.fill(exces, 0);
index = 0; index = 0;
viderMoyenne();
int ticks = Math.max(1, e.ticks()); int ticks = Math.max(1, e.ticks());
memoriser(e.dxz(), vitesseMax(e) * facteur, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR); memoriser(e.dxz(), vitesseMax(e) * facteur, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
if (sortieDEtat) ticksDepuisSortie = 0; if (sortieDEtat) ticksDepuisSortie = 0;
@@ -161,5 +217,6 @@ public final class VitesseHorizontale {
aElan = false; aElan = false;
elan = 0; elan = 0;
ticksDepuisSortie = Integer.MAX_VALUE; ticksDepuisSortie = Integer.MAX_VALUE;
viderMoyenne();
} }
} }
+76 -1
Voir le fichier
@@ -19,6 +19,33 @@ public final class VolVertical {
private boolean etaitEnAir; private boolean etaitEnAir;
private int anormauxConsecutifs; private int anormauxConsecutifs;
/**
* Rafales réseau (16/10) : ticks serveur écoulés moins ticks client couverts par les paquets déjà vus. Un paquet
* d'un tick client reçu après 3 ticks serveur laisse 2 ticks « dus », couverts ensuite par les paquets à 0 tick de
* la même rafale. Borné à {@link #AVANCE_MAX} : au-delà, on revient à la règle stricte (n-1 ou n ticks), donc
* un client qui ralentit durablement sa chute (un tick de gravité toutes les 3 ticks) reste vu.
*/
public static final int AVANCE_MAX = 4;
private int avance;
// --- C10 (16/10) : option {@link GardeConfig#volFenetreGlissante}, désactivée par défaut ---
/** Fenêtre glissante (ticks en l'air évalués) où l'on compte les ticks anormaux. */
public static final int FENETRE_TICKS = 20;
/** Plus de ticks anormaux que ça dans la fenêtre : infraction (alterner 1 anormal / 1 normal en donne 10). */
public static final int FENETRE_ANORMAUX_MAX = 8;
/** Un « saut en l'air » : montée d'au moins ça (blocs) au-dessus de la prévision de gravité, sans appui. */
public static final double SAUT_EN_L_AIR_MIN = 0.2;
/** Deux sauts en l'air à moins de ce nombre de ticks en l'air l'un de l'autre : infraction. */
public static final int SAUTS_FENETRE_TICKS = 60;
/** Activé par le moteur selon la configuration. */
boolean fenetreGlissante;
private final boolean[] fenetre = new boolean[FENETRE_TICKS];
private int fenetreIndex;
private int fenetreAnormaux;
private int ticksEnAir;
private int dernierSautEnAir = Integer.MIN_VALUE;
/** Au-delà, l'écart entre deux paquets est trop grand pour prédire (lag) : on oublie la vitesse. */ /** Au-delà, l'écart entre deux paquets est trop grand pour prédire (lag) : on oublie la vitesse. */
public static final int TICKS_MAX = 40; public static final int TICKS_MAX = 40;
@@ -35,6 +62,7 @@ public final class VolVertical {
int n = e.ticks(); int n = e.ticks();
if (n > TICKS_MAX || n < 0) { if (n > TICKS_MAX || n < 0) {
aVitesse = false; aVitesse = false;
avance = 0;
return 0; return 0;
} }
boolean enAir = !e.auSolServeur(); boolean enAir = !e.auSolServeur();
@@ -44,27 +72,38 @@ public final class VolVertical {
if (exempt || e.milieuSpecial() || !enAir) { if (exempt || e.milieuSpecial() || !enAir) {
anormauxConsecutifs = 0; anormauxConsecutifs = 0;
avance = 0;
viderFenetre();
} else if (etaitEnAir && aVitesse) { } else if (etaitEnAir && aVitesse) {
// Ticks candidats couverts par ce paquet : n exactement à l'heure ; n-1 ou n en retard ; 1 si 0. // Ticks candidats couverts par ce paquet : n exactement à l'heure ; n-1 ou n en retard ; 1 si 0.
int kMin = n <= 1 ? 1 : n - 1; // Rafales : jusqu'à AVANCE_MAX ticks dus peuvent rester en attente ; la règle d'avant reste toujours admise.
int kMin = Math.max(1, Math.min(n <= 1 ? 1 : n - 1, n + avance - AVANCE_MAX));
int kMax = Math.max(1, n); int kMax = Math.max(1, n);
int kRetenu = kMax;
boolean ecart = true; boolean ecart = true;
double v = derniereVitesse; double v = derniereVitesse;
double somme = 0; double somme = 0;
double sommeMax = -Double.MAX_VALUE; // la prévision la plus haute parmi les ticks candidats
for (int k = 1; k <= kMax; k++) { for (int k = 1; k <= kMax; k++) {
v = (v - GRAVITE) * TRAINEE; v = (v - GRAVITE) * TRAINEE;
somme += v; somme += v;
if (k >= kMin) sommeMax = Math.max(sommeMax, somme);
if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) { if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) {
ecart = false; ecart = false;
vitesseFin = n <= 1 ? dy : v; vitesseFin = n <= 1 ? dy : v;
kRetenu = k;
} }
} }
avance = Math.max(0, Math.min(AVANCE_MAX, avance + n - kRetenu));
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08 par tick. // Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08 par tick.
if (ecart) anormauxConsecutifs++; if (ecart) anormauxConsecutifs++;
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1); else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
if (anormauxConsecutifs > TICKS_ANORMAUX) { if (anormauxConsecutifs > TICKS_ANORMAUX) {
points = 1.0 + Math.min(3.0, (anormauxConsecutifs - TICKS_ANORMAUX) / 10.0); points = 1.0 + Math.min(3.0, (anormauxConsecutifs - TICKS_ANORMAUX) / 10.0);
} }
if (fenetreGlissante) {
points = Math.max(points, fenetreGlissante(ecart, dy, sommeMax, Math.max(1, n)));
}
} }
derniereVitesse = vitesseFin; derniereVitesse = vitesseFin;
@@ -73,10 +112,46 @@ public final class VolVertical {
return points; return points;
} }
/**
* C10 (16/10) : le compteur de ticks anormaux consécutifs redescend d'un cran à chaque tick normal ; un saut en
* l'air tous les 10 ticks, ou l'alternance d'un tick plané et d'un tick de gravité, ne l'atteignaient jamais.
* En plus : ticks anormaux comptés sur une fenêtre glissante, et tout gain d'altitude franc en l'air (sans sol,
* hors exemptions : recul, téléportation, milieux spéciaux) compté comme un saut en l'air ; le deuxième à moins
* de {@link #SAUTS_FENETRE_TICKS} ticks en l'air du précédent est une infraction.
*/
private double fenetreGlissante(boolean ecart, double dy, double prevision, int ticks) {
ticksEnAir += ticks;
if (fenetre[fenetreIndex]) fenetreAnormaux--;
fenetre[fenetreIndex] = ecart;
if (ecart) fenetreAnormaux++;
fenetreIndex = (fenetreIndex + 1) % FENETRE_TICKS;
double points = 0;
if (fenetreAnormaux > FENETRE_ANORMAUX_MAX) {
points = 1.0 + Math.min(3.0, (fenetreAnormaux - FENETRE_ANORMAUX_MAX) / 4.0);
}
if (ecart && dy > 0 && dy - prevision >= SAUT_EN_L_AIR_MIN) {
if (dernierSautEnAir != Integer.MIN_VALUE && ticksEnAir - dernierSautEnAir <= SAUTS_FENETRE_TICKS) {
points = Math.max(points, 2.0);
}
dernierSautEnAir = ticksEnAir;
}
return points;
}
private void viderFenetre() {
java.util.Arrays.fill(fenetre, false);
fenetreIndex = 0;
fenetreAnormaux = 0;
ticksEnAir = 0;
dernierSautEnAir = Integer.MIN_VALUE;
}
public void vider() { public void vider() {
derniereVitesse = 0; derniereVitesse = 0;
aVitesse = false; aVitesse = false;
etaitEnAir = false; etaitEnAir = false;
anormauxConsecutifs = 0; anormauxConsecutifs = 0;
avance = 0;
viderFenetre();
} }
} }
+1 -1
Voir le fichier
@@ -67,7 +67,7 @@ public abstract class MovePacketMixin {
@Inject(method = "teleport(DDDFFLjava/util/Set;)V", at = @At("HEAD")) @Inject(method = "teleport(DDDFFLjava/util/Set;)V", at = @At("HEAD"))
private void gastinelgarde$marqueTeleport(double x, double y, double z, float yaw, float pitch, private void gastinelgarde$marqueTeleport(double x, double y, double z, float yaw, float pitch,
java.util.Set<?> relatifs, CallbackInfo ci) { java.util.Set<?> relatifs, CallbackInfo ci) {
if (player != null) Garde.teleportVanilla(player); if (player != null) Garde.teleportVanilla(player, x, y, z, yaw, pitch, relatifs);
} }
// Les 3 teleport() de handleMovePlayer (lit, « moved too quickly », « moved wrongly ») : refus d'un paquet, // Les 3 teleport() de handleMovePlayer (lit, « moved too quickly », « moved wrongly ») : refus d'un paquet,
+1 -1
Voir le fichier
@@ -4,7 +4,7 @@ license="MIT"
[[mods]] [[mods]]
modId="gastinelgarde" modId="gastinelgarde"
version="0.3.0" version="0.3.2"
displayName="GastinelGarde" displayName="GastinelGarde"
authors="Théo Gastinel" authors="Théo Gastinel"
description='''Anti-triche maison : combat, cadence, rotation, timer (phase 1), no-fall, vitesse, vol et véhicules (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.''' description='''Anti-triche maison : combat, cadence, rotation, timer (phase 1), no-fall, vitesse, vol et véhicules (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
+6 -8
Voir le fichier
@@ -16,8 +16,8 @@ import org.junit.jupiter.api.Test;
/** /**
* Autotests du 16/10/2026, nuit : contournement n°3 de la revue de sécurité (table SUIVIES pleine). * Autotests du 16/10/2026, nuit : contournement n°3 de la revue de sécurité (table SUIVIES pleine).
* *
* Garde.boitesVues n'ajoute une cible non joueur à la table que si elle compte moins de SUIVIES_MAX entrées ; sinon * Corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) : quand la table est pleine, la cible non joueur suivie dont le
* elle renvoie null (pas de mesure) et ne la suivra jamais tant que la table reste pleine. La table est commune à * dernier coup est le plus ancien est évincée au profit de la nouvelle (avant : la nouvelle n'était jamais suivie). La table est commune à
* tout le serveur, les joueurs connectés y comptent aussi (sans plafond), une entrée vit 10 s après le dernier coup. * tout le serveur, les joueurs connectés y comptent aussi (sans plafond), une entrée vit 10 s après le dernier coup.
* *
* Le test remplit la table par réflexion avec des identifiants négatifs (jamais attribués) et frappe une entité * Le test remplit la table par réflexion avec des identifiants négatifs (jamais attribués) et frappe une entité
@@ -28,7 +28,7 @@ class AutotestSuiviesTest {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@Test @Test
void FAILLE_revue3_tablePleineLesNouvellesCiblesNeSontJamaisSuivies() throws Exception { void CORRIGE_revue3_tablePleineLaNouvelleCibleEvinceLaPlusAncienne() throws Exception {
Field fTable = Garde.class.getDeclaredField("SUIVIES"); Field fTable = Garde.class.getDeclaredField("SUIVIES");
fTable.setAccessible(true); fTable.setAccessible(true);
Map<Integer, Object> table = (Map<Integer, Object>) fTable.get(null); Map<Integer, Object> table = (Map<Integer, Object>) fTable.get(null);
@@ -52,11 +52,9 @@ class AutotestSuiviesTest {
table.clear(); table.clear();
for (int i = 0; i < max; i++) table.put(-1 - i, null); for (int i = 0; i < max; i++) table.put(-1 - i, null);
for (int k = 0; k < 5; k++) { assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet");
assertNull(Garde.boitesVues(cible, null, 1000 + 20 * k), "coup " + k + " non mesuré"); assertTrue(table.containsKey(cible.getId()), "corrigé : table pleine, la cible est quand même suivie");
} assertEquals(max, table.size(), "une entrée évincée, la table ne grandit pas");
assertFalse(table.containsKey(cible.getId()), "prouvé : table pleine, la cible n'est jamais suivie");
assertEquals(max, table.size(), "aucune éviction");
} finally { } finally {
table.clear(); table.clear();
} }
+336
Voir le fichier
@@ -0,0 +1,336 @@
package com.gastinelgarde;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.GardeConfig;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.Set;
import net.neoforged.neoforge.common.ModConfigSpec;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.InvokeDynamicInsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
/**
* Câblage Minecraft (constat C4 ⚠️), partie qui demande les classes du jeu mais pas de serveur : événements
* NeoForge abonnés, gardes d'expulsion lues dans le bytecode, types d'entités (C18, F20), options (C7, C8, C10, C15,
* C18) du fichier toml jusqu'à la configuration du moteur.
*/
class CablageMinecraftTest {
// --- Bytecode ---
private static ClassNode lire(Class<?> c) throws Exception {
try (InputStream in = c.getResourceAsStream("/" + c.getName().replace('.', '/') + ".class")) {
assertNotNull(in, c.getName());
ClassNode n = new ClassNode();
new ClassReader(in).accept(n, 0);
return n;
}
}
/** Méthodes appelées par une méthode et par ses lambdas (récursivement, dans la même classe). */
private static Set<String> appels(ClassNode classe, String methode) {
Set<String> sortie = new HashSet<>();
Set<String> vues = new HashSet<>();
parcourir(classe, methode, sortie, vues);
return sortie;
}
private static void parcourir(ClassNode classe, String methode, Set<String> sortie, Set<String> vues) {
if (!vues.add(methode)) return;
boolean trouvee = false;
for (MethodNode m : classe.methods) {
if (!m.name.equals(methode)) continue;
trouvee = true;
for (AbstractInsnNode i : m.instructions) {
if (i instanceof MethodInsnNode mi) {
sortie.add(mi.owner.substring(mi.owner.lastIndexOf('/') + 1) + "." + mi.name);
} else if (i instanceof InvokeDynamicInsnNode d) {
for (Object a : d.bsmArgs) {
if (a instanceof org.objectweb.asm.Handle h && h.getOwner().equals(classe.name)) {
parcourir(classe, h.getName(), sortie, vues);
} else if (a instanceof org.objectweb.asm.Handle h) {
sortie.add(h.getOwner().substring(h.getOwner().lastIndexOf('/') + 1) + "." + h.getName());
}
}
}
}
}
assertTrue(trouvee, methode);
}
@Test
void C4_lesPointsDEntreeConsultentLaMarqueDExpulsion() throws Exception {
ClassNode garde = lire(Garde.class);
ClassNode events = lire(GardeEvents.class);
assertTrue(appels(garde, "avantMouvement").contains("Moteur.estExpulse"));
assertTrue(appels(garde, "avantMouvement").contains("Cablage.evaluerAvantMouvement"));
assertTrue(appels(garde, "apresMouvement").contains("Moteur.estExpulse"));
assertTrue(appels(garde, "apresMouvement").contains("Cablage.traiterApresMouvement"));
assertTrue(appels(events, "onAttaque").contains("Moteur.estExpulse"));
assertTrue(appels(events, "onAttaque").contains("Cablage.entreeAttaque"));
assertTrue(appels(events, "onConnexion").contains("Moteur.oublierExpulsion"), "reconnexion : marque effacée");
assertFalse(appels(events, "onDeconnexion").contains("Moteur.oublierExpulsion"),
"la marque survit à la déconnexion (C6)");
assertTrue(appels(garde, "appliquerSanctionMouvement").contains("Cablage.appliquerSanction"));
Set<String> sanction = appels(lire(Cablage.class), "appliquerSanction");
assertTrue(sanction.contains("Moteur.expulser"));
assertTrue(sanction.contains("Moteur.apresSetback"));
assertFalse(appels(garde, "appliquerSanctionMouvement").stream().anyMatch(a -> a.toLowerCase().contains("ban")),
"jamais de bannissement");
}
/**
* FAILLE (16/10, trouvée en écrivant ces tests) : apresVehicule ne regarde pas la marque d'expulsion, à la
* différence de avantMouvement / apresMouvement / onAttaque. Un paquet de véhicule traité après l'expulsion
* (même lot de paquets, avant la fermeture de la connexion) est encore évalué : journal, alerte aux ops,
* stopRiding + setback, et l'état du moteur (Suivi) est recréé. L'expulsion elle-même reste unique
* (Moteur.expulser). Ce test est vert tant que le défaut existe. Proposition : en tête d'apresVehicule,
* {@code if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;}
* (même garde, et idem pour auSolPourChute, qui peut encore appeler le moteur). Non corrigé : décision de Théo.
*/
@Test
void FAILLE_C4_apresVehiculeNeConsultePasLaMarqueDExpulsion() throws Exception {
ClassNode garde = lire(Garde.class);
Set<String> a = appels(garde, "apresVehicule");
assertTrue(a.contains("Moteur.vehicule"), "le paquet de véhicule est bien évalué par le moteur");
assertFalse(a.contains("Moteur.estExpulse"), "défaut corrigé : inverser en CORRIGE_");
assertFalse(appels(garde, "auSolPourChute").contains("Moteur.estExpulse"));
}
// --- Événements NeoForge abonnés ---
@Test
void evenementsAbonnes() {
Set<Class<?>> ev = new HashSet<>();
for (Method m : GardeEvents.class.getDeclaredMethods()) {
if (m.isAnnotationPresent(net.neoforged.bus.api.SubscribeEvent.class)) {
assertEquals(1, m.getParameterCount(), m.getName());
assertTrue(java.lang.reflect.Modifier.isStatic(m.getModifiers()), m.getName());
ev.add(m.getParameterTypes()[0]);
}
}
for (Class<?> c : new Class<?>[] {
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedOutEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerChangedDimensionEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerRespawnEvent.class,
net.neoforged.neoforge.event.tick.ServerTickEvent.Pre.class,
net.neoforged.neoforge.event.tick.ServerTickEvent.Post.class,
net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent.Stop.class,
net.neoforged.neoforge.event.server.ServerStartingEvent.class,
net.neoforged.neoforge.event.server.ServerStoppedEvent.class}) {
assertTrue(ev.contains(c), c.getName());
}
assertTrue(net.neoforged.bus.api.ICancellableEvent.class.isAssignableFrom(
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class), "un coup peut être annulé");
}
@Test
void lesFauxJoueursNeSontJamaisControles() {
// GardeEvents filtre « p instanceof FakePlayer » : un FakePlayer est un ServerPlayer.
assertTrue(net.minecraft.server.level.ServerPlayer.class.isAssignableFrom(
net.neoforged.neoforge.common.util.FakePlayer.class));
}
// --- Types d'entités (C18 GardeAntiCrash, F20 vehiculeControle / etatVehicule) ---
@Test
void C18_seulsLesMinecartsContenantsSontGardesImmobiles() {
Class<?> container = net.minecraft.world.Container.class;
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartChest.class));
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartHopper.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.Minecart.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartTNT.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartFurnace.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartSpawner.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartCommandBlock.class));
}
@Test
void F20_vehiculesControles() {
Class<?> bateau = net.minecraft.world.entity.vehicle.Boat.class;
Class<?> monture = net.minecraft.world.entity.LivingEntity.class;
assertTrue(bateau.isAssignableFrom(net.minecraft.world.entity.vehicle.ChestBoat.class), "bateau à coffre, radeau");
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.horse.Horse.class));
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.Pig.class));
Class<?> minecart = net.minecraft.world.entity.vehicle.AbstractMinecart.class;
assertFalse(bateau.isAssignableFrom(minecart) || monture.isAssignableFrom(minecart),
"minecart : non contrôlé (type AUTRE), la position de retour suit le joueur");
}
// --- Options : du fichier toml au moteur ---
private static Object valeur(String champ) throws Exception {
Field f = GardeSpec.class.getDeclaredField(champ);
f.setAccessible(true);
return f.get(null);
}
@SuppressWarnings("unchecked")
private static <T> T defaut(String champ) throws Exception {
return ((ModConfigSpec.ConfigValue<T>) valeur(champ)).getDefault();
}
@Test
void optionsDesactiveesParDefautDansLeFichierEtLeMoteur() throws Exception {
GardeConfig c = new GardeConfig();
assertEquals(false, defaut("ELYTRES_STRICTE"));
assertEquals(c.elytresExemptionStricte, defaut("ELYTRES_STRICTE"));
assertEquals(2, (int) defaut("ELYTRES_AIR_MIN"));
assertEquals(c.elytresAirMinTicks, (int) defaut("ELYTRES_AIR_MIN"));
assertEquals(false, defaut("COMBAT_VEHICULE"));
assertEquals(c.combatMesureEnVehicule, defaut("COMBAT_VEHICULE"));
assertEquals(false, defaut("VOL_FENETRE_GLISSANTE"));
assertEquals(c.volFenetreGlissante, defaut("VOL_FENETRE_GLISSANTE"));
assertEquals(false, defaut("VITESSE_MOYENNE"));
assertEquals(c.vitesseMoyenne, defaut("VITESSE_MOYENNE"));
assertEquals(0, (int) defaut("TIMER_SOLDE_MAX"));
assertEquals(c.timerSoldeMax, (int) defaut("TIMER_SOLDE_MAX"));
assertEquals(c.seriePingMargeMs, (int) defaut("SERIE_PING_MARGE"));
assertEquals(false, defaut("AC_EMPILEMENT_MOUVEMENT"));
assertFalse(new com.gastinelgarde.core.AntiCrashEntites.Reglages().empilementSeulementEnMouvement);
assertFalse(GardeSpec.antiCrash().empilementSeulementEnMouvement, "fichier non chargé : défaut");
}
@Test
void laConfigProposeeNActivePasLesNouvellesOptions() throws Exception {
// Les tests tournent dans build/minecraft-junit : on remonte jusqu'à la racine du projet.
Path toml = null;
for (Path d = Path.of("").toAbsolutePath(); d != null && toml == null; d = d.getParent()) {
Path f = d.resolve("config-proposee").resolve("gastinelgarde-server.toml");
if (Files.exists(f)) toml = f;
}
Assumptions.assumeTrue(toml != null, "config-proposee introuvable depuis " + Path.of("").toAbsolutePath());
String t = Files.readString(toml, StandardCharsets.UTF_8);
for (String cle : new String[] {"elytresExemptionStricte", "combatMesureEnVehicule", "volFenetreGlissante",
"vitesseMoyenne", "empilementSeulementEnMouvement"}) {
assertFalse(t.matches("(?s).*\\b" + cle + "\\s*=\\s*true.*"), cle);
}
assertFalse(t.matches("(?s).*\\btimerSoldeMax\\s*=\\s*[1-9].*"), "timerSoldeMax");
}
/**
* GardeSpec.appliquer recopie bien chaque option dans GardeConfig. On charge le fichier en mémoire
* (ModConfigSpec.acceptConfig, par réflexion : signature propre à NeoForge 21.1), puis on le décharge.
*/
@Test
void appliquerRecopieLesOptionsDuFichier() throws Exception {
Object charge = chargerEnMemoire();
Assumptions.assumeTrue(charge != null, "[À VÉRIFIER] chargement en mémoire du ModConfigSpec impossible ici");
try {
assertTrue(GardeSpec.SPEC.isLoaded());
GardeConfig vide = new GardeConfig();
GardeSpec.appliquer(vide);
assertFalse(vide.elytresExemptionStricte);
assertFalse(vide.combatMesureEnVehicule);
assertFalse(vide.volFenetreGlissante);
assertFalse(vide.vitesseMoyenne);
assertEquals(0, vide.timerSoldeMax);
for (com.gastinelgarde.core.Controle k : com.gastinelgarde.core.Controle.values()) {
assertEquals(new GardeConfig().mode(k), vide.mode(k), "mode par défaut inchangé : " + k);
}
((ModConfigSpec.BooleanValue) valeur("ELYTRES_STRICTE")).set(true);
((ModConfigSpec.IntValue) valeur("ELYTRES_AIR_MIN")).set(5);
((ModConfigSpec.BooleanValue) valeur("COMBAT_VEHICULE")).set(true);
((ModConfigSpec.BooleanValue) valeur("VOL_FENETRE_GLISSANTE")).set(true);
((ModConfigSpec.BooleanValue) valeur("VITESSE_MOYENNE")).set(true);
((ModConfigSpec.IntValue) valeur("TIMER_SOLDE_MAX")).set(20);
GardeConfig c = new GardeConfig();
GardeSpec.appliquer(c);
assertTrue(c.elytresExemptionStricte, "C7");
assertEquals(5, c.elytresAirMinTicks, "C7");
assertTrue(c.combatMesureEnVehicule, "C8");
assertTrue(c.volFenetreGlissante, "C10");
assertTrue(c.vitesseMoyenne, "C15");
assertEquals(20, c.timerSoldeMax, "C15");
} finally {
dechargerEnMemoire();
}
assertFalse(GardeSpec.SPEC.isLoaded(), "les autres tests attendent un fichier non chargé");
}
/** null si l'API n'est pas celle attendue (le test est alors ignoré, pas faux). */
private static Object chargerEnMemoire() {
try {
Method accept = null;
for (Method m : ModConfigSpec.class.getMethods()) {
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) accept = m;
}
if (accept == null) return null;
Class<?> type = accept.getParameterTypes()[0];
com.electronwill.nightconfig.core.CommentedConfig cc =
com.electronwill.nightconfig.core.CommentedConfig.inMemory();
// Fichier déjà corrigé (valeurs par défaut) : acceptConfig n'a rien à sauvegarder.
for (Method m : ModConfigSpec.class.getMethods()) {
if (m.getName().equals("correct") && m.getParameterCount() == 1
&& m.getParameterTypes()[0].isInstance(cc)) {
m.invoke(GardeSpec.SPEC, cc);
break;
}
}
Object config = null;
if (type.isInstance(cc)) {
config = cc;
} else if (type.isSealed()) {
// NeoForge 21.1 : IConfigSpec.ILoadedConfig est scellée, seule implémentation LoadedConfig.
for (Class<?> impl : type.getPermittedSubclasses()) {
for (java.lang.reflect.Constructor<?> k : impl.getDeclaredConstructors()) {
Class<?>[] p = k.getParameterTypes();
if (p.length == 0 || !p[0].isInstance(cc)) continue;
Object[] args = new Object[p.length];
args[0] = cc;
k.setAccessible(true);
config = k.newInstance(args);
break;
}
if (config != null) break;
}
} else if (type.isInterface()) {
config = Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[] {type}, (o, m, a) -> switch (m.getName()) {
case "config" -> cc;
case "hashCode" -> System.identityHashCode(o);
case "equals" -> o == a[0];
case "toString" -> "config-en-memoire";
default -> null;
});
}
if (config == null) return null;
accept.invoke(GardeSpec.SPEC, config);
return GardeSpec.SPEC.isLoaded() ? config : null;
} catch (ReflectiveOperationException | RuntimeException | LinkageError e) {
System.out.println("[CablageMinecraftTest] chargement en mémoire impossible : " + e);
dechargerEnMemoire();
return null;
}
}
private static void dechargerEnMemoire() {
try {
for (Method m : ModConfigSpec.class.getMethods()) {
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) {
m.invoke(GardeSpec.SPEC, new Object[] {null});
}
}
} catch (ReflectiveOperationException | RuntimeException e) {
System.out.println("[CablageMinecraftTest] déchargement : " + e);
}
}
}
+324
Voir le fichier
@@ -0,0 +1,324 @@
package com.gastinelgarde;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.Exemptions;
import com.gastinelgarde.core.GardeConfig;
import com.gastinelgarde.core.GraceTeleport;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Verdict;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BooleanSupplier;
import org.junit.jupiter.api.Test;
/**
* Câblage Minecraft (constat C4 ⚠️) : décisions de Garde / GardeEvents sorties dans {@link Cablage}, testées sans
* serveur avec une doublure du joueur et un vrai {@link Moteur}.
*/
class CablageTest {
private static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
private static final String MONDE = "minecraft:overworld";
/** Doublure de ServerPlayer : enregistre ce que la sanction lui fait, dans l'ordre. */
static final class FauxJoueur implements Cablage.Joueur {
final List<String> actions = new ArrayList<>();
String dimension = MONDE;
int tick = 1000;
@Override public UUID id() { return ID; }
@Override public String nom() { return "Tricheur"; }
@Override public String dimension() { return dimension; }
@Override public int tick() { return tick; }
@Override public void annoncerTeleport(GraceTeleport.Origine o) { actions.add("annonce " + o); }
@Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
actions.add(String.format(java.util.Locale.ROOT, "teleport %.1f %.1f %.1f %.0f %.0f", x, y, z, yaw, pitch));
}
@Override public void deconnecter(String message) { actions.add("deconnexion " + message); }
@Override public void journal(String ligne) { actions.add("journal " + ligne); }
long compte(String prefixe) {
return actions.stream().filter(a -> a.startsWith(prefixe)).count();
}
}
private static Verdict verdict(Controle c, Sanction s) {
return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of());
}
private static BooleanSupplier compteur(AtomicInteger n, boolean valeur) {
return () -> {
n.incrementAndGet();
return valeur;
};
}
// --- Expulsion unique (C4) ---
@Test
void C4_expulsionUneSeuleFoisPuisDeNouveauApresReconnexion() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.EXPULSION));
for (int i = 0; i < 344; i++) { // incident du 15/10 : 344 disconnect en 18 s
p.tick++;
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
}
assertEquals(1, p.compte("deconnexion"), p.actions.toString());
assertEquals(1, p.compte("journal"));
assertEquals("journal Tricheur EXPULSE (vol)", p.actions.get(0)); // journal avant la déconnexion
assertEquals("deconnexion Expulsé par l'anti-triche (vol).", p.actions.get(1));
assertTrue(moteur.estExpulse(ID));
// GardeEvents.onConnexion : oublierExpulsion, la prochaine expulsion est de nouveau possible.
moteur.oublierExpulsion(ID);
assertFalse(moteur.estExpulse(ID));
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
assertEquals(2, p.compte("deconnexion"));
}
@Test
void C4_apresLExpulsionPlusAucuneEvaluationNiCoup() {
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, false));
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, true)); // l'expulsion passe avant
assertEquals(Cablage.EntreeAttaque.IGNORER, Cablage.entreeAttaque(false, true));
assertEquals(Cablage.EntreeAttaque.EVALUER, Cablage.entreeAttaque(false, false));
AtomicInteger lus = new AtomicInteger();
assertFalse(Cablage.evaluerAvantMouvement(true, () -> true, compteur(lus, false)));
assertEquals(0, lus.get(), "expulsé : l'exemption n'est même pas lue");
assertFalse(Cablage.evaluerAvantMouvement(true, () -> false, () -> true)); // exemption manuelle
assertTrue(Cablage.evaluerAvantMouvement(true, () -> false, () -> false));
assertFalse(Cablage.traiterApresMouvement(true, () -> true));
assertTrue(Cablage.traiterApresMouvement(true, () -> false));
}
@Test
void F01_horsDuThreadServeurLEtatDuModNEstPasLu() {
AtomicInteger lus = new AtomicInteger();
assertFalse(Cablage.evaluerAvantMouvement(false, compteur(lus, false), compteur(lus, false)));
assertFalse(Cablage.traiterApresMouvement(false, compteur(lus, false)));
assertEquals(0, lus.get());
}
@Test
void expulsionSansVerdictRaisonParDefaut() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, List.of());
assertEquals("journal Tricheur EXPULSE (anti-triche)", p.actions.get(0));
}
// --- Setback (C2, C3) ---
@Test
void C2_setbackVersLaPositionAuSolPuisRemiseAZeroDuVol() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
long ms = p.tick * 50L;
moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE);
moteur.suivi(ID).vl.ajouter(Controle.VOL, 30, ms);
moteur.suivi(ID).vl.ajouter(Controle.VITESSE, 20, ms);
moteur.suivi(ID).vl.ajouter(Controle.KILLAURA_CIBLES, 7, ms);
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(List.of("annonce SETBACK", "teleport 10.5 64.0 -3.5 90 10", "journal Tricheur SETBACK (vol)"),
p.actions, "la grâce est annoncée avant le teleport (F05)");
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VOL, ms), 1e-9);
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VITESSE, ms), 1e-9);
assertTrue(moteur.suivi(ID).vl.valeur(Controle.KILLAURA_CIBLES, ms) > 6.9, "les autres VL ne sont pas touchées");
assertFalse(moteur.estExpulse(ID));
}
@Test
void setbackSansPositionOuAutreDimensionNeFaitRien() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.SETBACK));
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
assertTrue(p.actions.isEmpty(), "aucune position de retour : rien");
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
assertTrue(p.actions.isEmpty(), "position dans une autre dimension : jamais de teleport inter-dimension");
}
@Test
void sanctionsInferieuresAuSetbackNeTouchentPasLeJoueur() {
Moteur moteur = new Moteur(new GardeConfig());
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, MONDE);
FauxJoueur p = new FauxJoueur();
for (Sanction s : new Sanction[] {Sanction.AUCUNE, Sanction.JOURNAL, Sanction.ALERTE}) {
Cablage.appliquerSanction(moteur, p, s, List.of(verdict(Controle.VOL, s)));
assertFalse(Cablage.sanctionDeMouvement(s), s.name());
}
assertTrue(p.actions.isEmpty());
assertTrue(Cablage.sanctionDeMouvement(Sanction.SETBACK));
assertTrue(Cablage.sanctionDeMouvement(Sanction.EXPULSION));
}
@Test
void C3_positionDeRetourSeulementAuSolEtSansVerdictNiVehicule() {
Moteur moteur = new Moteur(new GardeConfig());
int tick = 500;
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, true, false));
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, true), "eau, échelle…");
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, false), "en l'air");
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> true, true, false), "véhicule contrôlé");
AtomicInteger lus = new AtomicInteger();
assertFalse(Cablage.memoriserRetour(moteur, tick, tick, compteur(lus, false), true, false), "verdict ce tick");
assertEquals(0, lus.get(), "le véhicule n'est pas lu si un verdict est tombé à ce tick");
}
// --- Coups (GardeEvents.onAttaque) ---
@Test
void coupAnnuleEnEnforceOuSurSanctionEtExpulsionSeuleAppliquee() {
for (Sanction s : Sanction.values()) {
boolean grave = s.ordinal() >= Sanction.SETBACK.ordinal();
assertEquals(grave, Cablage.annulerCoup(false, s), s.name());
assertTrue(Cablage.annulerCoup(true, s), "portée / hitbox ENFORCE : " + s);
assertEquals(s == Sanction.EXPULSION, Cablage.appliquerApresCoup(s), "pas de setback sur un coup : " + s);
}
}
@Test
void cibleSurContraptionOuVaisseauPasDeMesurePorteeHitbox() {
BooleanSupplier oui = () -> true;
BooleanSupplier non = () -> false;
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, non, non));
assertFalse(Cablage.mesurerPorteeHitbox(oui, non, true, non, non), "cible contraption");
assertFalse(Cablage.mesurerPorteeHitbox(non, oui, true, non, non), "cible sur vaisseau Sable");
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, oui, non), "assise sur un siège Create");
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, non, oui), "véhicule sur un vaisseau");
assertTrue(Cablage.mesurerPorteeHitbox(non, non, false, non, non), "cheval, bateau : mesuré");
AtomicInteger lus = new AtomicInteger();
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, compteur(lus, true), compteur(lus, true)));
assertEquals(0, lus.get(), "sans véhicule, la racine n'est pas interrogée");
}
// --- C7 : élytres ---
@Test
void C7_deploiementTropTotApresLeSolEstSuspectPourTouteLaDureeDuPlane() {
Cablage.Elytres e = new Cablage.Elytres();
int sol = 100;
e.observer(false, sol, 100, 2);
e.observer(true, sol, 101, 2); // 1 tick après le sol (onGround falsifié)
assertTrue(e.suspectes);
for (int t = 102; t < 300; t++) e.observer(true, sol, t, 2);
assertTrue(e.suspectes, "reste suspect jusqu'à la fin du plané");
e.observer(false, sol, 300, 2);
assertFalse(e.suspectes);
assertFalse(e.vues);
Cablage.Elytres h = new Cablage.Elytres();
h.observer(true, sol, 102, 2); // 2 ticks en l'air : honnête
assertFalse(h.suspectes);
Cablage.Elytres jamais = new Cablage.Elytres();
jamais.observer(true, Integer.MIN_VALUE, 5, 2); // jamais vu au sol (connexion en plein vol)
assertFalse(jamais.suspectes);
}
@Test
void C7_unSolServeurVuPendantLePlaneNeRendPasSuspectApresCoup() {
Cablage.Elytres e = new Cablage.Elytres();
e.observer(true, 100, 120, 2);
assertFalse(e.suspectes);
e.observer(true, 125, 125, 2); // frôle un bloc en plané
assertFalse(e.suspectes, "seul le début du plané compte");
}
@Test
void C7_cableJusquAuxExemptions_avecEtSansOption() {
Cablage.Elytres e = new Cablage.Elytres();
e.observer(true, 100, 101, 2);
EtatJoueur etat = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(e.suspectes).build();
GardeConfig defaut = new GardeConfig();
assertFalse(defaut.elytresExemptionStricte, "option désactivée par défaut");
assertTrue(Exemptions.evaluer(etat, defaut, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
GardeConfig stricte = new GardeConfig();
stricte.elytresExemptionStricte = true;
assertFalse(Exemptions.evaluer(etat, stricte, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
}
// --- C8 : combat en véhicule ---
@Test
void C8_passagerMesureSeulementAvecLOptionEtContraptionToujoursExemptee() {
EtatJoueur cheval = EtatJoueur.builder().enVehicule(true).build();
EtatJoueur siege = EtatJoueur.builder().enVehicule(true).pocheContraption(true).build();
GardeConfig defaut = new GardeConfig();
assertFalse(defaut.combatMesureEnVehicule);
assertTrue(Exemptions.evaluer(cheval, defaut, Exemptions.Famille.COMBAT).exempt());
GardeConfig option = new GardeConfig();
option.combatMesureEnVehicule = true;
assertFalse(Exemptions.evaluer(cheval, option, Exemptions.Famille.COMBAT).exempt());
assertTrue(Exemptions.evaluer(siege, option, Exemptions.Famille.COMBAT).raisons().contains("contraption"));
assertTrue(Exemptions.evaluer(cheval, option, Exemptions.Famille.MOUVEMENT).raisons().contains("vehicule"),
"l'option ne touche que le combat");
}
// --- Cache des détections (contraption, courant d'air) ---
@Test
void cacheDeDetectionToutesLesDixTicksPuisGrace() {
Cablage.CacheDetection c = new Cablage.CacheDetection();
AtomicInteger appels = new AtomicInteger();
boolean[] present = {true};
BooleanSupplier detecter = () -> {
appels.incrementAndGet();
return present[0];
};
assertTrue(c.lire(100, detecter, 40));
assertEquals(1, appels.get());
present[0] = false; // la contraption s'éloigne
assertTrue(c.lire(109, detecter, 40), "valeur en cache");
assertEquals(1, appels.get());
assertTrue(c.lire(110, detecter, 40), "redétecté (absent) mais dans la grâce");
assertEquals(2, appels.get());
assertTrue(c.lire(140, detecter, 40));
assertFalse(c.lire(150, detecter, 40), "grâce terminée");
assertTrue(c.lire(5, () -> true, 40), "tick qui recule (redémarrage) : redétecté");
}
@Test
void cacheJamaisVuPasDeGrace() {
Cablage.CacheDetection c = new Cablage.CacheDetection();
assertFalse(c.lire(100, () -> false, 40));
}
// --- D1 (0.3.2) : position de retour après une téléportation ---
@Test
void D1_setbackApresTpRameneAuPointDArriveePasAvantLaTeleportation() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
GraceTeleport grace = new GraceTeleport();
moteur.suivi(ID).memoriserPosition(0.5, -60.0, 31.0, 0f, 0f, MONDE); // au sol avant le /tp (rapport T3)
// /tp en l'air (origine externe, aucune annonce)
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 100.5, 80.0, 200.5, 45f, 0f, MONDE);
// vol stationnaire, setback avant tout contact au sol
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertTrue(p.actions.contains("teleport 100.5 80.0 200.5 45 0"), p.actions.toString());
// Le teleport du setback lui-même (et un refus vanilla) ne changent pas le retour.
grace.annoncer(GraceTeleport.Origine.SETBACK);
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 7, 7, 7, 0f, 0f, MONDE);
grace.annoncer(GraceTeleport.Origine.REFUS_VANILLA);
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 8, 8, 8, 0f, 0f, MONDE);
assertEquals(100.5, moteur.suivi(ID).x(), 1e-9);
assertEquals(80.0, moteur.suivi(ID).y(), 1e-9);
}
}
+4 -2
Voir le fichier
@@ -336,12 +336,14 @@ class AutotestCasLimitesTest {
} }
@Test @Test
void FAUX_POSITIF_lagRafalesDeTroisPaquetsPendantUneLongueChute() { void CORRIGE_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
// Inversé le 16/10 (fix/rafales-reseau) : était FAUX_POSITIF_ (88,9 points).
// Ancien commentaire :
// Un paquet d'UN tick client arrivé après 3 ticks serveur n'est comparé qu'à 2 ou 3 ticks de gravité, et la // Un paquet d'UN tick client arrivé après 3 ticks serveur n'est comparé qu'à 2 ou 3 ticks de gravité, et la
// vitesse retenue est alors dy / 3 : le paquet suivant est faux aussi. Motif 3, 0, 0 : +1 anomalie par rafale, // vitesse retenue est alors dy / 3 : le paquet suivant est faux aussi. Motif 3, 0, 0 : +1 anomalie par rafale,
// premier point après ~31 paquets (1,5 s de chute, ~12 blocs). Simulé, à confirmer avec une trace réelle. // premier point après ~31 paquets (1,5 s de chute, ~12 blocs). Simulé, à confirmer avec une trace réelle.
double total = chuteAvecGigue(new int[] {3, 0, 0}); double total = chuteAvecGigue(new int[] {3, 0, 0});
assertTrue(total > 0); assertEquals(0, total, 1e-9);
Mesures.noter("Lag 3,0,0 : " + total + " points de vol sur une chute de 80 paquets"); Mesures.noter("Lag 3,0,0 : " + total + " points de vol sur une chute de 80 paquets");
} }
+91
Voir le fichier
@@ -0,0 +1,91 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.Exemptions.Famille;
import org.junit.jupiter.api.Test;
/**
* Constats de gravité haute restants de l'autocritique du 16/10 (C7, C8, C18).
* Tests inversés (CORRIGE_) : options désactivées par défaut, vérifiées activées ; défaut inchangé vérifié aussi.
*/
class AutotestConstatsHautsTest {
private final GardeConfig cfg = new GardeConfig();
private GardeConfig strict() {
GardeConfig c = new GardeConfig();
c.elytresExemptionStricte = true;
c.combatMesureEnVehicule = true;
return c;
}
// C7 : élytres déployées depuis le sol (onGround falsifié) : plus d'exemption de mouvement avec l'option.
@Test
void CORRIGE_C7_elytresDeployeesAuSolNExemptentPlus() {
EtatJoueur suspect = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(true).build();
assertFalse(Exemptions.evaluer(suspect, strict(), Famille.MOUVEMENT).raisons().contains("elytres"));
// Le mouvement est alors contrôlé : un vol plat soutenu donne des points.
Moteur m = new Moteur(strict());
java.util.UUID j = java.util.UUID.randomUUID();
double pts = 0;
for (int i = 0; i < 60; i++) {
for (Verdict v : m.mouvement(j, i * 50L, suspect,
new EtatMouvement(0.3, 0.0, 1, false, false, true, false, false, 0, 0, false, false))) pts += v.points();
}
assertTrue(pts > 0, "vol plat en élytres suspectes : " + pts);
}
// C7 témoin : plané honnête (déployé en l'air) toujours exempté, avec ou sans l'option ; défaut inchangé.
@Test
void temoin_C7_planeHonneteToujoursExempte() {
EtatJoueur honnete = EtatJoueur.builder().elytres(true).build();
assertTrue(Exemptions.evaluer(honnete, strict(), Famille.MOUVEMENT).raisons().contains("elytres"));
EtatJoueur suspect = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(true).build();
assertTrue(Exemptions.evaluer(suspect, cfg, Famille.MOUVEMENT).raisons().contains("elytres"), "défaut inchangé");
}
// C7 : portée / hitbox mesurées pendant le plané avec l'option.
@Test
void CORRIGE_C7_porteeMesureeEnElytres() {
EtatJoueur e = EtatJoueur.builder().elytres(true).build();
assertNull(PorteeHitbox.raisonNonMesure(e, 0.0, strict()));
assertEquals("elytres", PorteeHitbox.raisonNonMesure(e, 0.0, cfg), "défaut inchangé");
}
// C8 : passager d'un véhicule : combat mesuré avec l'option.
@Test
void CORRIGE_C8_combatMesureEnVehicule() {
EtatJoueur e = EtatJoueur.builder().enVehicule(true).build();
assertFalse(Exemptions.evaluer(e, strict(), Famille.COMBAT).exempt());
Moteur m = new Moteur(strict());
java.util.UUID j = java.util.UUID.randomUUID();
int verdicts = 0;
for (int i = 0; i < 40; i++) verdicts += m.attaque(j, i * 50L, e, 170.0, 1, true).size();
assertTrue(verdicts > 0);
assertTrue(Exemptions.evaluer(e, cfg, Famille.COMBAT).exempt(), "défaut inchangé");
// La contraption reste une exemption (constat : la garder pour le combat sur contraption).
assertTrue(Exemptions.evaluer(EtatJoueur.builder().pocheContraption(true).build(), strict(), Famille.COMBAT).exempt());
}
// C18 : stockage immobile de minecarts à coffre non cassé avec l'option ; empilement en mouvement ou simple cassé.
@Test
void CORRIGE_C18_stockageImmobileNonCasse() {
AntiCrashEntites.Reglages r = new AntiCrashEntites.Reglages();
r.empilementSeulementEnMouvement = true;
assertFalse(AntiCrashEntites.empilementACasser(6, r, 0.0, true));
assertTrue(AntiCrashEntites.empilementACasser(6, r, 0.5, true));
assertTrue(AntiCrashEntites.empilementACasser(6, r, 0.0, false));
assertFalse(AntiCrashEntites.empilementACasser(3, r, 0.5, false));
AntiCrashEntites.Reglages d = new AntiCrashEntites.Reglages();
assertTrue(AntiCrashEntites.empilementACasser(6, d, 0.0, true), "défaut inchangé");
}
@Test
void temoin_portee_mesureeAPiedSansElytres() {
assertNull(PorteeHitbox.raisonNonMesure(EtatJoueur.normal(), 0.0, cfg));
}
}
+115 -46
Voir le fichier
@@ -13,8 +13,9 @@ import org.junit.jupiter.api.Test;
* Autotests du 16/10/2026, nuit : contournements signalés par la revue de sécurité automatique des commits 7a5a1c9 / * Autotests du 16/10/2026, nuit : contournements signalés par la revue de sécurité automatique des commits 7a5a1c9 /
* 937d43d (contrôle coups-hors-boite) et constats C13, C15 de l'autocritique. * 937d43d (contrôle coups-hors-boite) et constats C13, C15 de l'autocritique.
* *
* Un test {@code FAILLE_…} passe tant que le contournement marche ; il échouera quand il sera corrigé (inverser * Corrigés le 16/10 (branche fix/hitbox-c10-c13-c15) : les anciens tests {@code FAILLE_…} ont été inversés et
* alors l'assertion). Chaque faille a un test « témoin » qui montre que, sans le contournement, la triche est vue. * renommés {@code CORRIGE_…}. Chaque faille garde son test « témoin » ; les détections C15 sont des options
* désactivées par défaut, activées ici, avec un témoin honnête qui ne doit rien donner.
* Le contournement n°3 (table SUIVIES pleine) dépend de Minecraft : voir {@code com.gastinelgarde.AutotestSuiviesTest}. * Le contournement n°3 (table SUIVIES pleine) dépend de Minecraft : voir {@code com.gastinelgarde.AutotestSuiviesTest}.
*/ */
class AutotestContournementsTest { class AutotestContournementsTest {
@@ -78,16 +79,16 @@ class AutotestContournementsTest {
} }
@Test @Test
void FAILLE_revue1_pingDeclareAuDessusDe500msExempteTotalementLesCoups() { void CORRIGE_revue1_pingDeclareAuDessusDe500msNExemptePlusLesCoups() {
assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs) > 0, "témoin : à 500 ms, la série est vue"); assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs) > 0, "témoin : à 500 ms, la série est vue");
assertEquals(0, serieHitboxAvecPing(cfg.seriePingMaxMs + 1), 1e-9, assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs + 1) > 0, "corrigé : à 501 ms, la série est encore vue");
"prouvé : à 501 ms (ping falsifiable, F07), aucun coup n'est mesuré"); assertTrue(serieHitboxAvecPing(5000) > 0, "corrigé : à 5 s déclarées aussi (fenêtre bornée)");
} }
// --- Revue n°2 / C13 : regard et œil du paquet SUIVANT acceptés sans borne -------------------------------------- // --- Revue n°2 / C13 : regard et œil du paquet SUIVANT acceptés sans borne --------------------------------------
@Test @Test
void FAILLE_revue2_regardSuivantRameneSurLaCibleEffaceLeCoupHorsBoite() { void CORRIGE_revue2_regardSuivantRameneSurLaCibleNEffacePlusLeCoupHorsBoite() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg); int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double temoin = 0, triche = 0; double temoin = 0, triche = 0;
for (int k = 0; k < 10; k++) { for (int k = 0; k < 10; k++) {
@@ -107,11 +108,11 @@ class AutotestContournementsTest {
Controle.COUPS_HORS_BOITE); Controle.COUPS_HORS_BOITE);
} }
assertTrue(temoin > 0, "témoin : le même regard gardé au paquet suivant est vu"); assertTrue(temoin > 0, "témoin : le même regard gardé au paquet suivant est vu");
assertEquals(0, triche, 1e-9, "prouvé : un demi-tour du regard au paquet suivant efface tout (aucune borne d'angle)"); assertTrue(triche > 0, "corrigé : un demi-tour du regard au paquet suivant n'est plus accepté");
} }
@Test @Test
void FAILLE_revue2_oeilSuivantAvanceDe09BlocEffaceLaPorteeAllongee() { void CORRIGE_revue2_oeilSuivantAvanceDe09BlocNEffacePlusLaPorteeAllongee() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg); int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double temoin = 0, triche = 0; double temoin = 0, triche = 0;
for (int k = 0; k < 10; k++) { for (int k = 0; k < 10; k++) {
@@ -131,11 +132,11 @@ class AutotestContournementsTest {
Controle.COUPS_HORS_BOITE); Controle.COUPS_HORS_BOITE);
} }
assertTrue(temoin > 0); assertTrue(temoin > 0);
assertEquals(0, triche, 1e-9, "prouvé : l'œil suivant n'est pas borné à un déplacement légal"); assertTrue(triche > 0, "corrigé : l'œil suivant est borné à un déplacement d'un tick");
} }
@Test @Test
void FAILLE_C13_porteeEtHitboxGardentLeMinimumAvecLePaquetSuivant() { void CORRIGE_C13_porteeEtAngleNeGardentPlusLeMinimumSansBorne() {
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF); cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
double[] b = boite(0); double[] b = boite(0);
double[] loin = {0, 1.62, -4.3}; // 4,0 blocs de la boîte : refus vanilla à la limite double[] loin = {0, 1.62, -4.3}; // 4,0 blocs de la boîte : refus vanilla à la limite
@@ -151,49 +152,88 @@ class AutotestContournementsTest {
List<Verdict> v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0, List<Verdict> v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0,
true, false)); true, false));
v.addAll(moteur.regardPorteeHitbox(joueur, 50, proche, vers(proche, 0, 1.0, 0))); v.addAll(moteur.regardPorteeHitbox(joueur, 50, proche, vers(proche, 0, 1.0, 0)));
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "prouvé : s'avancer au paquet suivant efface la portée"); assertTrue(points(v, Controle.PORTEE) > 0, "corrigé : s'avancer de 0,8 bloc au paquet suivant n'efface plus la portée");
// Angle killaura : regard à 180° au coup, sur la cible au paquet suivant. // Angle killaura : regard à 180° au coup, sur la cible au paquet suivant. Un coup isolé n'est pas compté (un
// demi-tour honnête existe : Garde1016Test.angleKillauraRegardEnRetardPasDeFauxPositif) ; une série, si.
// [À VÉRIFIER] Théo : le témoin d'origine portait sur un seul coup.
cfg.mode(Controle.PORTEE, Mode.OFF); cfg.mode(Controle.PORTEE, Mode.OFF);
cfg.mode(Controle.HITBOX, Mode.OFF); cfg.mode(Controle.HITBOX, Mode.OFF);
moteur = new Moteur(cfg); moteur = new Moteur(cfg);
double[] oeil = {0, 1.62, -2.5}; double[] oeil = {0, 1.62, -2.5};
List<Verdict> a = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil, new double[] {0, 0, -1}, double serie = 0;
b, 3.0, 0, false, true)); for (int k = 0; k < 10; k++) {
a.addAll(moteur.regardPorteeHitbox(joueur, 50, oeil, vers(oeil, 0, 1.0, 0))); List<Verdict> a = new ArrayList<>(moteur.coupDiffere(joueur, k * 600L, EtatJoueur.normal(), oeil,
assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "prouvé : rotation silencieuse effacée"); new double[] {0, 0, -1}, b, 3.0, 0, false, true));
a.addAll(moteur.regardPorteeHitbox(joueur, k * 600L + 50, oeil, vers(oeil, 0, 1.0, 0)));
if (k == 0) assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "un demi-tour isolé : rien");
serie += points(a, Controle.KILLAURA_ANGLE);
}
assertTrue(serie > 0, "corrigé : rotations silencieuses de 180° répétées vues");
} }
/**
* C13, seuils de {@code portee} (3,3 sur cible immobile, 4,3 sur cible qui sprinte) : {@code portee} et
* {@code hitbox} ne sont pas resserrés (ils peuvent être en ENFORCE en production ; tolérance « vitesse × ticks »
* gardée). C'est {@code coups-hors-boite} (mesure sur l'historique de la cible, marge 0,15) qui doit voir ces
* reach en série. Ancien test : {@code FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee},
* qui mesurait {@code portee} seul. [À VÉRIFIER] Théo : accepter que la correction passe par coups-hors-boite.
*/
@Test @Test
void FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee() { void CORRIGE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteVusParCoupsHorsBoite() {
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF); int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double[] b = boite(0); double immobile = 0, sprint = 0, honnete = 0;
double[] oeil33 = {0, 1.62, -3.59}; // 3,29 blocs for (int k = 0; k < 10; k++) {
List<Verdict> v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil33, double x = 5 * k;
vers(oeil33, 0, 1.0, 0), b, 3.0, 0, true, false)); double[][] fixes = new double[fenetre + 2][];
v.addAll(moteur.terminerCoup(joueur)); for (int i = 0; i < fixes.length; i++) fixes[i] = boite(x);
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,29 blocs sur cible immobile : rien"); double[] oeil33 = {x, 1.62, -3.59}; // 3,29 blocs, cible immobile
immobile += points(coupV(k * 600L, oeil33, vers(oeil33, x, 1.0, 0), x, 0, fixes), Controle.COUPS_HORS_BOITE);
}
moteur = new Moteur(cfg); moteur = new Moteur(cfg);
double[] oeil40 = {0, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte for (int k = 0; k < 10; k++) {
v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil40, vers(oeil40, 0, 1.0, 0), b, 3.0, double x = 5 * k;
V, true, false)); double[] oeil40 = {x, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte
v.addAll(moteur.terminerCoup(joueur)); sprint += points(coupV(k * 600L, oeil40, vers(oeil40, x, 1.0, 0), x, V, vues(x, fenetre)),
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,99 blocs sur cible qui sprinte : rien pour portee"); Controle.COUPS_HORS_BOITE);
}
moteur = new Moteur(cfg);
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.2}; // 2,9 blocs : honnête
honnete += points(coupV(k * 600L, oeil, vers(oeil, x, 1.0, 0), x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
assertTrue(immobile > 0, "3,29 blocs sur cible immobile : vu en série");
assertTrue(sprint > 0, "3,99 blocs sur cible qui sprinte : vu en série");
assertEquals(0, honnete, 1e-9, "témoin : 2,9 blocs, rien");
}
private List<Verdict> coupV(long t, double[] oeil, double[] regard, double xCible, double vCible, double[][] vues) {
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, EtatJoueur.normal(), oeil, regard,
boite(xCible), 3.0, vCible, true, false, oeil, vues));
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeil, regard));
return vs;
} }
// --- Revue n°4 : la fenêtre d'historique grandit avec le ping déclaré ------------------------------------------ // --- Revue n°4 : la fenêtre d'historique grandit avec le ping déclaré ------------------------------------------
private double serieDerriereLaCible(int ping) { /** Le joueur a eu {@code pingAvant} pendant une minute, puis déclare {@code ping} pendant le combat. */
private double serieDerriereLaCible(int pingAvant, int ping) {
moteur = new Moteur(cfg); moteur = new Moteur(cfg);
for (long t = 0; t < 60_000; t += 1000) moteur.pingFenetre(joueur, t, pingAvant);
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build(); EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); // ce que Garde.boitesVues calcule depuis latency() // ce que Garde.boitesVues calcule depuis latency()
int fenetre = PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 60_000, ping), cfg);
double total = 0; double total = 0;
for (int k = 0; k < 10; k++) { for (int k = 0; k < 10; k++) {
double x = 10 * k; double x = 10 * k;
double[] oeil = {x - 1.5, 1.62, -2.5}; double[] oeil = {x - 1.5, 1.62, -2.5};
// Client « hitbox » : touche 3,3 blocs DERRIÈRE le centre de la cible (là où elle était il y a ~12 ticks). // Client « hitbox » : touche loin DERRIÈRE le centre de la cible (là où elle était il y a ~15 ticks).
double[] regard = vers(oeil, x - 3.6, 1.2, 0); // 16/10 (correctif) : 4,2 au lieu de 3,6. Avec la marge de 50 ms sur le plancher (30 + 50 ms : 9 ticks
// au lieu de 8), le point à 3,6 tombait au bord de la fenêtre (manque 0,135 < 0,15) ; à 4,2 il reste
// caché par une fenêtre de 16 ticks (450 ms) et vu avec 8 ou 9. [À VÉRIFIER] Théo : témoin modifié.
double[] regard = vers(oeil, x - 4.2, 1.2, 0);
total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)), total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE); Controle.COUPS_HORS_BOITE);
} }
@@ -201,13 +241,21 @@ class AutotestContournementsTest {
} }
@Test @Test
void FAILLE_revue4_pingDeclareA450msElargitLaFenetreEtCacheLaTriche() { void CORRIGE_revue4_pingGonflePendantLeCombatNElargitPlusLaFenetre() {
assertEquals(8, PorteeHitbox.ticksFenetre(30, cfg)); assertEquals(8, PorteeHitbox.ticksFenetre(30, cfg));
assertEquals(16, PorteeHitbox.ticksFenetre(450, cfg)); assertEquals(16, PorteeHitbox.ticksFenetre(450, cfg));
assertEquals(17, PorteeHitbox.ticksFenetre(500, cfg)); assertEquals(17, PorteeHitbox.ticksFenetre(500, cfg));
assertTrue(serieDerriereLaCible(30) > 0, "témoin : à 30 ms, la série est vue"); assertTrue(serieDerriereLaCible(450, 450) == 0, "témoin : fenêtre de 16 ticks (450 ms durables), cachée");
assertEquals(0, serieDerriereLaCible(450), 1e-9, assertTrue(serieDerriereLaCible(30, 30) > 0, "témoin : à 30 ms, la série est vue");
"prouvé : le même client qui annonce 450 ms de ping n'est plus vu (fenêtre 16 ticks au lieu de 8)"); moteur = new Moteur(cfg);
for (long t = 0; t < 60_000; t += 1000) moteur.pingFenetre(joueur, t, 30);
assertEquals(9, PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 60_000, 450), cfg),
"corrigé : 30 ms puis 450 annoncés : fenêtre de 9 ticks (plancher 30 + marge 50), pas 16");
assertTrue(serieDerriereLaCible(30, 450) > 0,
"corrigé : 30 ms pendant une minute puis 450 ms annoncés en combat : toujours vu");
// Joueur honnête qui a 450 ms depuis le début : fenêtre complète.
moteur = new Moteur(cfg);
assertEquals(16, PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 0, 450), cfg));
} }
// --- C15 : vitesse 0,40 en l'air et Timer 1,09 non vus --------------------------------------------------------- // --- C15 : vitesse 0,40 en l'air et Timer 1,09 non vus ---------------------------------------------------------
@@ -230,16 +278,21 @@ class AutotestContournementsTest {
} }
@Test @Test
void FAILLE_C15_bhopA040BlocParTickNestJamaisVu() { void CORRIGE_C15_bhopA040BlocParTickEstVuAvecLOption() {
// 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (un sprint-saut honnête fait en moyenne ~0,28 à 0,33). // Option désactivée par défaut : comportement inchangé.
assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9); assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9, "option coupée : rien (comme avant)");
cfg.vitesseMoyenne = true;
// 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (sprint-saut vanilla : ~0,356 en moyenne, 7,13 m/s).
assertTrue(vitesse(0.40, 0.40, 12, 400) > 0, "corrigé : bhop à 0,40 vu");
assertEquals(0, vitesse(0.356, 0.356, 12, 400), 1e-9, "témoin : sprint-saut vanilla moyen, rien");
} }
@Test @Test
void FAILLE_C15_speedAuSolA037BlocParTickNestJamaisVu() { void CORRIGE_C15_speedAuSolA037BlocParTickEstVuAvecLOption() {
assertTrue(vitesse(0.45, 0.45, 1, 200) > 0, "témoin : 0,45 au sol (+50 %) est vu"); assertTrue(vitesse(0.45, 0.45, 1, 200) > 0, "témoin : 0,45 au sol (+50 %) est vu");
// 0,37 au sol : +23 % sur le sprint (0,30), l'excès (0,06/tick) reste sous le tampon de 1,5 bloc / 20 ticks. cfg.vitesseMoyenne = true;
assertEquals(0, vitesse(0.37, 0.37, 1, 400), 1e-9); assertTrue(vitesse(0.37, 0.37, 1, 400) > 0, "corrigé : 0,37 au sol vu");
assertEquals(0, vitesse(0.28, 0.28, 1, 400), 1e-9, "témoin : sprint vanilla (0,28), rien");
} }
private double timer(long intervalleMs, int secondes) { private double timer(long intervalleMs, int secondes) {
@@ -252,8 +305,24 @@ class AutotestContournementsTest {
} }
@Test @Test
void FAILLE_C15_timerA109NestJamaisVu() { void CORRIGE_C15_timerA109EstVuAvecLOption() {
assertTrue(timer(40, 10) > 0, "témoin : 25 paquets/s (timer 1,25) est vu"); assertTrue(timer(40, 10) > 0, "témoin : 25 paquets/s (timer 1,25) est vu");
assertEquals(0, timer(46, 30), 1e-9, "prouvé : 21,7 paquets/s (timer 1,09) pendant 30 s, aucun point"); assertEquals(0, timer(46, 30), 1e-9, "option coupée : rien (comme avant)");
cfg.timerSoldeMax = 20;
assertTrue(timer(46, 30) > 0, "corrigé : 21,7 paquets/s (timer 1,09) pendant 30 s vu par le solde");
assertEquals(0, timer(50, 60), 1e-9, "témoin : 20 paquets/s, rien");
// Témoin lag : 1 s sans paquet, puis rafale de 20 paquets d'un coup, à répéter.
moteur = new Moteur(cfg);
double lag = 0;
long t = 10_000;
for (int r = 0; r < 20; r++) {
t += 1000;
for (int i = 0; i < 20; i++) lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
for (int i = 0; i < 40; i++) {
t += 50;
lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
}
}
assertEquals(0, lag, 1e-9, "témoin : rafales de rattrapage après un lag, rien");
} }
} }
+107
Voir le fichier
@@ -0,0 +1,107 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* Autotests du 16/10/2026 : rafales réseau (paquets de mouvement groupés après un lag). Chaque paquet couvre UN tick
* client, mais le serveur voit {@code motif[i]} ticks écoulés avant lui (3, 0, 0 : trois paquets arrivés ensemble).
*
* {@code CORRIGE_…} : anciens FAUX_POSITIF_ (joueur honnête puni), inversés : aucun point attendu.
* {@code temoin_…} : la triche équivalente (chute ralentie) doit rester vue, avant comme après le correctif.
*/
class AutotestRafalesTest {
private Moteur moteur;
private final UUID joueur = UUID.randomUUID();
private long tick;
private boolean sanctionLourde;
@BeforeEach
void init() {
GardeConfig cfg = new GardeConfig();
cfg.mode(Controle.VOL, Mode.ENFORCE);
cfg.mode(Controle.VITESSE, Mode.OFF);
cfg.mode(Controle.NO_FALL, Mode.OBSERVE);
moteur = new Moteur(cfg);
tick = 5000;
sanctionLourde = false;
}
private static EtatMouvement m(double dy, int ticks, boolean sol) {
return new EtatMouvement(0.1, dy, ticks, sol, sol, false, false, false, 0, 0, false, false);
}
private double paquet(EtatMouvement mv) {
tick += mv.ticks();
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, EtatJoueur.normal(), mv);
double p = 0;
for (Verdict v : vs) {
if (v.controle() == Controle.VOL) p += v.points();
if (v.palier() == Sanction.SETBACK || v.palier() == Sanction.EXPULSION) sanctionLourde = true;
}
return p;
}
/** Chute honnête de {@code paquets} ticks client depuis la vitesse v0, avec la gigue donnée. */
private double chute(double v0, int paquets, int[] motif) {
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
double total = 0, v = v0;
for (int p = 0; p < paquets; p++) {
total += paquet(m(v, motif[p % motif.length], false));
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
}
return total;
}
@Test
void CORRIGE_rafalesDeTroisLongueChuteSansPointNiSanction() {
double total = chute(0, 80, new int[] {3, 0, 0});
Mesures.noter("Rafales 3,0,0 chute 80 : " + total + " points, sanction lourde=" + sanctionLourde);
assertEquals(0, total, 1e-9);
assertTrue(!sanctionLourde, "aucun setback ni expulsion pour un joueur honnête");
}
@Test
void CORRIGE_sautPuisChuteEnRafalesDeTrois() {
double total = chute(0.42, 80, new int[] {3, 0, 0});
Mesures.noter("Rafales 3,0,0 saut + chute 80 : " + total + " points");
assertEquals(0, total, 1e-9);
}
@Test
void honnete_gigueIrreguliereApresUnLag() {
// Gigue irrégulière (rafales de 3 et 4 mêlées) : mesurée à 0 point avant le correctif, doit le rester.
double total = chute(0, 90, new int[] {3, 0, 0, 4, 0, 0, 0, 1, 2, 0, 3, 0, 0});
Mesures.noter("Gigue irreguliere chute 90 : " + total + " points");
assertEquals(0, total, 1e-9);
}
@Test
void temoin_chuteRalentieUnPaquetDUnTickToutesLesTroisTicksResteVue() {
// Triche « slow fall / timer lent » : un paquet d'un tick de gravité toutes les 3 ticks serveur, sans rattrapage.
double total = chute(0, 80, new int[] {3});
Mesures.noter("Temoin chute ralentie 1/3 : " + total + " points");
assertTrue(total > 0);
}
@Test
void temoin_planeEnRafalesResteVu() {
// Plané (dy = 0) livré en rafales : doit être vu, quelle que soit la gigue.
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
double total = 0;
int[] motif = {3, 0, 0};
for (int p = 0; p < 60; p++) total += paquet(m(-0.01, motif[p % 3], false));
assertTrue(total > 0);
}
@Test
void honnete_chuteSansGigueReference() {
assertEquals(0, chute(0, 80, new int[] {1}), 1e-9);
}
}
+28 -11
Voir le fichier
@@ -15,8 +15,8 @@ import org.junit.jupiter.api.Test;
* Autotests du 16/10/2026, nuit : incident VOL de Rednixxu (15/10, 17:31) et constats C1 à C5, C10 de l'autocritique. * Autotests du 16/10/2026, nuit : incident VOL de Rednixxu (15/10, 17:31) et constats C1 à C5, C10 de l'autocritique.
* *
* C1 à C5 corrigés le 16/10 (branche fix/vol-elytres) : les anciens tests {@code FAUX_POSITIF_…} / {@code FAILLE_…} * C1 à C5 corrigés le 16/10 (branche fix/vol-elytres) : les anciens tests {@code FAUX_POSITIF_…} / {@code FAILLE_…}
* ont été inversés et renommés {@code CORRIGE_…}. C10 n'est pas corrigé : ses tests {@code FAILLE_…} passent tant que * ont été inversés et renommés {@code CORRIGE_…}. C10 corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) par une option
* le défaut existe. * désactivée par défaut ({@code volFenetreGlissante}) : ses tests l'activent et gardent un témoin honnête.
* *
* Ce qui se passe dans l'adaptateur (Garde.java, qui dépend de Minecraft) est rejoué ici par un petit modèle écrit * Ce qui se passe dans l'adaptateur (Garde.java, qui dépend de Minecraft) est rejoué ici par un petit modèle écrit
* d'après le code : position mémorisée après un paquet sans verdict (Garde.apresMouvement), paquet suivant un * d'après le code : position mémorisée après un paquet sans verdict (Garde.apresMouvement), paquet suivant un
@@ -253,7 +253,8 @@ class AutotestVolIncidentTest {
// --- C10 : sauts en l'air espacés -------------------------------------------------------------------------------- // --- C10 : sauts en l'air espacés --------------------------------------------------------------------------------
@Test @Test
void FAILLE_C10_unSautEnLAirTousLesDixTicksMonteSansFinSansAucunPoint() { void CORRIGE_C10_unSautEnLAirTousLesDixTicksEstVuAvecLOption() {
cfg.volFenetreGlissante = true;
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol()); for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
double total = 0; double total = 0;
double depart = y; double depart = y;
@@ -264,14 +265,32 @@ class AutotestVolIncidentTest {
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE; v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
} }
} }
assertEquals(0, total, 1e-9, "prouvé : aucun point"); assertTrue(total > 0, "corrigé : les sauts en l'air répétés sont vus");
// ~0,5 bloc gagné par cycle de 10 ticks : ~15 blocs en 15 s, sans limite. Mesures.noter(String.format(java.util.Locale.ROOT, "C10 corrige : %.1f points en 300 ticks", total));
assertTrue(y - depart > 10, "et le tricheur a gagné " + (y - depart) + " blocs en 15 s");
Mesures.noter(String.format(java.util.Locale.ROOT, "C10 : +%.1f blocs en 300 ticks, 0 point", y - depart));
} }
@Test @Test
void FAILLE_C10_alternerUnTickAnormalEtUnTickNormalPlaneSansPoint() { void CORRIGE_C10_temoinSautsHonnetesRepetesAvecLOption() {
cfg.volFenetreGlissante = true;
double total = 0;
for (int cycle = 0; cycle < 30; cycle++) {
total += points(paquet(EtatJoueur.normal(), sol()), Controle.VOL);
double v = 0.42; // saut depuis le sol
double h = 0;
for (int i = 0; i < 40; i++) {
if (h + v <= 0) break; // retour au sol
h += v;
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
}
y = Y_SOL;
}
assertEquals(0, total, 1e-9, "témoin : sauts honnêtes répétés, rien");
}
@Test
void CORRIGE_C10_alternerUnTickAnormalEtUnTickNormalEstVuAvecLOption() {
cfg.volFenetreGlissante = true;
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol()); for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
double total = 0; double total = 0;
double depart = y; double depart = y;
@@ -280,8 +299,6 @@ class AutotestVolIncidentTest {
double dy = i % 2 == 0 ? -0.02 : (-0.02 - VolVertical.GRAVITE) * VolVertical.TRAINEE; double dy = i % 2 == 0 ? -0.02 : (-0.02 - VolVertical.GRAVITE) * VolVertical.TRAINEE;
total += points(paquet(EtatJoueur.normal(), air(dy)), Controle.VOL); total += points(paquet(EtatJoueur.normal(), air(dy)), Controle.VOL);
} }
assertEquals(0, total, 1e-9); assertTrue(total > 0, "corrigé : l'alternance plané / gravité est vue");
// 200 ticks de chute vanilla depuis l'arrêt : plus de 200 blocs. Ici : ~6 blocs.
assertTrue(depart - y < 15, "descente de " + (depart - y) + " blocs en 10 s (chute lente illimitée)");
} }
} }
+54
Voir le fichier
@@ -260,4 +260,58 @@ class Garde1015Test {
init(); init();
triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.ENFORCE); triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.ENFORCE);
} }
// --- D2 (0.3.2) : expulsion de combat seulement après 4 setbacks en 60 s (C5) ---
@Test
void D2_hitboxEnforceExpulseApresQuatreSetbacksPasAuBoutDe5s() {
GardeConfig c = new GardeConfig();
c.mode(Controle.HITBOX, Mode.ENFORCE);
Moteur m = new Moteur(c);
UUID j = UUID.randomUUID();
int setbacks = 0;
long expulsionMs = -1;
// Rapport T2 : regard décalé de 30° (manque 0,72 bloc), un coup toutes les 600 ms.
for (int i = 0; i < 200 && expulsionMs < 0; i++) {
long t = i * 600L;
Sanction s = Verdict.pire(m.porteeHitbox(j, t, EtatJoueur.normal(), 2.5, 0.72, 3.0, 0.0));
if (s == Sanction.SETBACK) setbacks++;
if (s == Sanction.EXPULSION) expulsionMs = t;
}
assertEquals(c.setbacksAvantExpulsion, setbacks, "4 setbacks avant l'expulsion");
assertTrue(expulsionMs > 5000, "expulsion trop tôt : " + expulsionMs + " ms");
assertTrue(expulsionMs <= c.fenetreSetbacksMs, "expulsion dans la fenêtre C5 : " + expulsionMs + " ms");
}
// --- D3 (0.3.2) : NoFall par paquet d'état ---
@Test
void D3_noFallVoitLePaquetDEtatAuSolPendantUneChute() {
GardeConfig c = new GardeConfig();
c.mode(Controle.NO_FALL, Mode.OBSERVE);
c.mode(Controle.VOL, Mode.OFF);
c.mode(Controle.VITESSE, Mode.OFF);
Moteur m = new Moteur(c);
UUID j = UUID.randomUUID();
int lignes = 0;
// Rapport T5 : à chaque tick de chute, un paquet de position (en l'air) puis un paquet d'état « au sol ».
double[] dys = {-0.08, -0.16, -0.23, -0.30, -0.38, -0.45, -0.52, -0.58};
for (int i = 0; i < dys.length; i++) {
long t = i * 50L;
lignes += m.mouvement(j, t, EtatJoueur.normal(), new EtatMouvement(0, dys[i], 1, false, false,
false, false, false, 0, 0, false, false)).size();
lignes += m.mouvement(j, t, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, false,
false, false, false, 0, 0, false, false)).size();
}
assertTrue(lignes >= 4, "paquets d'état au sol pendant la chute rapide : " + lignes);
// Honnête : posé au sol, puis paquets d'état « au sol » immobiles (bloc dessous) ; et saut au sommet.
Moteur h = new Moteur(c);
assertTrue(h.mouvement(j, 0, EtatJoueur.normal(), new EtatMouvement(0, -0.5, 1, true, true,
false, false, false, 0, 0, false, false)).isEmpty());
assertTrue(h.mouvement(j, 50, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, true,
false, false, false, 0, 0, false, false)).isEmpty());
assertTrue(h.mouvement(j, 100, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, false,
false, false, false, 0, 0, false, false)).isEmpty(), "après le sol, la chute est oubliée");
}
} }
+2 -1
Voir le fichier
@@ -175,7 +175,8 @@ class Garde92Test {
EtatJoueur.builder().enVehicule(true).build(), EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().elytres(true).build(), EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().riptide(true).build(), EtatJoueur.builder().riptide(true).build(),
EtatJoueur.builder().pingMs(cfg.seriePingMaxMs + 1).build(), // Revue 1 (16/10) : un ping > seriePingMaxMs n'exempte plus (ping falsifiable) ; retiré de la liste,
// voir AutotestContournementsTest.CORRIGE_revue1_… [À VÉRIFIER] Théo.
EtatJoueur.builder().ticksDepuisTeleport(5).build(), EtatJoueur.builder().ticksDepuisTeleport(5).build(),
EtatJoueur.builder().ticksDepuisGel(5).build()); EtatJoueur.builder().ticksDepuisGel(5).build());
for (EtatJoueur etat : etats) { for (EtatJoueur etat : etats) {