diff --git a/.gitignore b/.gitignore
index cb3b3a9..b66b6de 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,6 @@ build-out/
run/
*.jar
!gradle/wrapper/gradle-wrapper.jar
+
+# sauvegardes avant modification
+*.avant-*
diff --git a/README.md b/README.md
index f3a4adb..e03b41f 100644
--- a/README.md
+++ b/README.md
@@ -4,10 +4,112 @@ Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur
`../PLAN-GASTINELGARDE.md`. Version **0.3.0** : phases 0, 1 et 2 du plan, plus les corrections de l'audit du
2026-10-14 (`audit/`).
-**État** : compilé, 128 tests JUnit verts (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,
preuves de l'audit). **Jamais testé en jeu.** Tous les contrôles démarrent en `OBSERVE` (journal et message aux
ops, aucune sanction). Il n'y a jamais de bannissement automatique.
+## Anti-crash des entités (16/10/2026, non commité, version toujours 0.3.0)
+
+**Incident** (journaux réels, `latest.log` du 15/10 13:43–13:46, joueur `totoche10`) : des œufs lancés depuis
+(3483, 108, -2412) avec une vitesse de 2,0e6 puis 1,5e7, 3,7e9, 5,2e8 et enfin 7,1e53 blocs/tick (boîtes relevées
+par Sable « Aborting entity get for abnormally large AABB »). Au tick de l'œuf, `ThrowableProjectile.tick` →
+`ProjectileUtil.getHitResultOnMoveVector` → `BlockGetter.clip` trace un rayon sur toute la vitesse ;
+chaque `Level.getBlockState` charge ou GÉNÈRE le chunk traversé. Coordonnées bornées à ±2^31 → chunk
+(207, 134217720) : `Aquifer$NoiseBasedAquifer.getAquiferStatus` → `ArrayIndexOutOfBoundsException: Index -402651290`
+→ « Exception generating new chunk » (crash). Sur une vitesse plus faible : génération de milliers de chunks dans un
+seul tick → watchdog (60 s). Les erreurs Sable (`checkLeftOwner`) sont un symptôme, pas la cause. La vitesse vient du
+lanceur : un projectile hérite de la vitesse connue du joueur (`shootFromRotation`), elle-même celle du minecart
+qu'il conduit.
+
+**Parade** (`GardeAntiCrash`, logique pure `core/AntiCrashEntites`) : à l'arrivée d'une entité non joueur dans le
+monde et au début de chacun de ses ticks (`EntityTickEvent.Pre`, avant le rayon) :
+- position ou vitesse NaN / infinie, entité hors bordure + `margeBordureBlocs` (ou hors ±30 M / ±20 M), trajectoire
+ du tick (position + vitesse) qui sort de la bordure + marge, ou vitesse > `vitesseMax × facteurSuppression`
+ (1 000 b/t) : **suppression** (passagers joueurs descendus avant) ;
+- vitesse > `vitesseMaxBlocsParTick` (100) : **ramenée à 100** dans la même direction ;
+- contraption Create, entité sur un vaisseau Sable, véhicule qui porte un joueur : jamais supprimés, **arrêtés** ;
+- joueurs : jamais concernés (riptide, élytres).
+Journal `logs/gastinelgarde.log` (action, type, motif, propriétaire, dimension, position, vitesse) ; message aux ops
+(5 max / 10 s). Section `[antiCrash]` de la config (`actif = false` pour couper).
+
+Seuil 100 b/t : 25 × la flèche d'arbalète (~3,2), 50 × un bateau sur glace bleue, au-dessus des canons à TNT courants
+et des trains Create ; un rayon de 100 blocs touche au plus ~8 chunks. Bordure du vrai serveur : vanilla
+(59 999 968, relevé dans level.dat) ; les plots Sable sont vers 20,5 M blocs (`SubLevelContainer.DEFAULT_ORIGIN`
+= 10000 plots de 2^7 chunks), dans la bordure.
+
+**Reproduction locale** (serveur-test-totoche, sans Sable) : `/summon egg … {Motion:[0d,0d,1.0e8d]}` ne reproduit
+PAS (vanilla remet à 0 toute composante de Motion > 10 au chargement NBT). Reproduit avec
+`/summon fireball 8 120 8 {Motion:[0d,0d,1d],acceleration_power:1.0e8d,ExplosionPower:0b}` : sans GastinelGarde,
+watchdog 60 s (même pile : clip → getBlockState → génération de chunk) ; avec, boule de feu supprimée au 1er tick.
+
+**Empilement de minecarts (« Minecart Velocity Exploit », précision du 16/10).** 6 à 15 minecarts superposés se
+poussent à chaque tick (`AbstractMinecart.push(Entity)` : chacun reprend 0,2 × sa vitesse + la moyenne des deux
++ 0,05, une fois par voisin) : croissance exponentielle. `moveAlongTrack` ramène la vitesse à 2,0 au tick suivant,
+mais les poussées ont lieu APRÈS ; entre deux ticks, le joueur assis lance un œuf qui hérite de cette vitesse
+(`Projectile.shootFromRotation` → `ServerPlayer.getKnownMovement` → vitesse du minecart). Parade :
+- `MinecartPushMixin` : avant chaque poussée minecart-minecart, plus de `minecartsSuperposesMax` (4) minecarts
+ qui se chevauchent → poussée coupée ; après chaque poussée, les deux minecarts ramenés sous
+ `vitesseMaxMinecartBlocsParTick` (3,0 ; vanilla : 0,4 sur rail, 2,0 au plus après moveAlongTrack) ;
+- toutes les 10 ticks, un minecart dans une pile > 4 (sans passager, hors contraption / Sable) est cassé et lâche
+ son objet (et son contenu) ; journal + alerte ops ;
+- projectile lancé depuis un véhicule : plafonds projectile inchangés (100 / suppression à 1 000).
+Reproduit en local (15 `/summon minecart` décalés de 0,03 sur un rail est-ouest) : sans GastinelGarde, Motion
+1,5e29 puis 1,4e94 b/t en 6 s ; avec, 11 minecarts cassés, Motion plafonnée à 3,0 puis retombée à ~0,01.
+
+## Modifications du 15/10/2026 (non commitées, version toujours 0.3.0)
+
+**Contraptions.** Noms relevés par `javap` dans les jars du serveur (`~/server-infra/stacks/minecraft-neoforge/data/mods`,
+md5 identiques à `_CODE/2-minecraft/dist_mods/mods`) :
+
+| Classe | Jar (chemin dans le jar) | Hérite de |
+|---|---|---|
+| `com.simibubi.create.content.contraptions.AbstractContraptionEntity` | create-1.21.1-6.0.10.jar | `Entity` (classe mère de toutes) |
+| `com.simibubi.create.content.contraptions.ControlledContraptionEntity` | idem | AbstractContraptionEntity |
+| `com.simibubi.create.content.contraptions.OrientedContraptionEntity` | idem | AbstractContraptionEntity |
+| `com.simibubi.create.content.contraptions.gantry.GantryContraptionEntity` | idem | AbstractContraptionEntity |
+| `com.simibubi.create.content.trains.entity.CarriageContraptionEntity` | idem | OrientedContraptionEntity |
+| `dev.eriksonn.aeronautics.content.blocks.propeller.bearing.contraption.PropellerBearingContraptionEntity` | create-aeronautics-bundled-1.21.1-1.3.2.jar → META-INF/jarjar/dev.eriksonn.aeronautics.aeronautics-neoforge-1.21.1-1.3.2.jar | ControlledContraptionEntity |
+| `dev.ryanhcode.offroad.content.entities.BoreheadContraptionEntity` | idem → META-INF/jarjar/dev.ryanhcode.offroad.offroad-neoforge-1.21.1-1.3.2.jar | ControlledContraptionEntity |
+
+Réglage par défaut : `AbstractContraptionEntity` seul ; la détection remonte la chaîne des classes, donc toutes les
+classes ci-dessus sont couvertes. Écartées volontairement (immobiles, ou ne déplacent pas le joueur) : `SuperGlueEntity`,
+`SeatEntity` (déjà « véhicule »), `GustEntity` (aucune requête d'entités dans son code), `HoneyGlueEntity`, `DiagramEntity`,
+`LaunchedPlungerEntity`. L'ancien préfixe `com.simibubi.create.content.contraptions` ratait les trains et exemptait près
+de la colle.
+
+**Vaisseaux Aeronautics** : ce ne sont pas des entités mais des sous-niveaux de Sable 2.0.6. Détection par
+`SableCompanion.INSTANCE.getTrackingOrVehicleSubLevel(Entity)` (sable-neoforge-1.21.1-2.0.6.jar →
+META-INF/jarjar/sable-companion-common-1.21.1-1.6.0.jar), appelé par réflexion (`SableAcces`). Grâce de 2 s après.
+
+**Portée / hitbox** (contrôles `portee` et `hitbox`, OBSERVE) : distance œil – boîte réelle au-delà de
+portée d'interaction + 0,3 ; regard qui manque la boîte réelle de plus de 0,25 bloc. Les deux marges s'élargissent de
+la vitesse de la cible × 3 ticks (plafond 1 bloc) et × 1,5 sous 18 TPS. Vanilla refuse déjà au-delà de portée + 1,0.
+
+**Déploiement (relevé en SSH lecture seule le 16/10/2026).** GastinelGarde n'est PAS encore sur le vrai serveur
+(aucun jar, aucun `gastinelgarde-server.toml`) ; GastinelClaims y est en 1.1.6 (ancien mixin riptide). Déployer
+GastinelClaims 1.1.7 et GastinelGarde ensemble. Config proposée : `config-proposee/gastinelgarde-server.toml`
+(tous les contrôles en OBSERVE), à copier dans `data/config/`.
+
+**Modes (corrigé le 16/10/2026).** ENFORCE reste possible pour TOUS les contrôles (config et `/garde mode`), comme
+dans d0c001d, y compris la correction no-fall (drapeau « au sol » du serveur en ENFORCE). no-fall, vitesse, vol,
+portée et hitbox sont en OBSERVE par défaut (comme tous les contrôles) et à garder ainsi tant qu'ils ne sont pas validés
+en jeu. L'interdiction d'ENFORCE du 15/10 était une erreur et est retirée.
+
+**Vanilla vérifié (javap / sources NeoForge 21.1.234).** `handleInteract` appelle `canInteractWithEntity(aabb, 1.0)` :
+distance² œil – boîte de la cible < (entityInteractionRange + 1,0)². L'hypothèse « portée + 1,0 » est exacte.
+
+**Faux positifs portée / hitbox (16/10).**
+- Le client envoie son coup AVANT la position et la rotation du même tick : la mesure est refaite au paquet de
+ mouvement suivant (au plus 2 ticks), on garde la plus petite (`core/CoupDiffere`). Couvre souris rapide, sprint,
+ potions de vitesse / saut, glace. Sans paquet dans les 2 ticks, le regard n'a pas changé : la mesure du coup reste.
+- Ping : la cible affichée a ping/50 ticks de retard en plus (ping borné à `pingLatenceMaxMs` = 300, tolérance totale
+ plafonnée à `latenceCibleMaxBlocs`).
+- Non mesuré : riptide (coup au contact de la vrille), élytres, téléportation récente (/tpa, réapparition, dimension,
+ connexion), recul récent, cible à plus de `vitesseCibleMaxMesure` = 1 bloc/tick, cible assise sur une contraption.
+- L'angle killaura est mesuré de la même façon (différé, plus petit des deux), et pas pendant une vrille riptide.
+- En ENFORCE, la mesure étant différée, le coup fautif n'est plus annulé lui-même : après une sanction (setback ou
+ plus), les coups suivants sont annulés 2 s.
+
## Nouveautés 0.3.0 (corrections de l'audit)
Détail faille par faille : `audit/CORRECTIONS.md`. Essais en jeu à faire : `audit/ESSAIS-EN-JEU.md`.
diff --git a/config-proposee/gastinelgarde-server.toml b/config-proposee/gastinelgarde-server.toml
new file mode 100644
index 0000000..ef378ab
--- /dev/null
+++ b/config-proposee/gastinelgarde-server.toml
@@ -0,0 +1,173 @@
+#Mode de chaque contrôle : OFF (coupé), OBSERVE (journal et message aux ops, aucune sanction),
+#ENFORCE (sanctions appliquées). Tout démarre en OBSERVE ; ne passer en ENFORCE qu'après
+#plusieurs jours sans fausse alerte sur des joueurs honnêtes.
+#no-fall, vitesse, vol, portee et hitbox : OBSERVE conseillé tant qu'ils n'ont pas été validés en jeu.
+[modes]
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ killaura-angle = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ killaura-cibles = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ cadence = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ regularite = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ attaque-impossible = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ rotation = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ portee = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ hitbox = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ timer = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ no-fall = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ vitesse = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ vol = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ vehicule-vitesse = "OBSERVE"
+ #Allowed Values: OFF, OBSERVE, ENFORCE
+ vehicule-vol = "OBSERVE"
+
+[sanctions]
+ #Points d'infraction perdus par seconde (par contrôle). S'applique aux joueurs qui se connectent après le rechargement.
+ # Default: 0.5
+ # Range: 0.0 ~ 100.0
+ decroissanceParSeconde = 0.5
+ # Default: 5.0
+ # Range: 0.1 ~ 1000.0
+ seuilAlerte = 5.0
+ # Default: 10.0
+ # Range: 0.1 ~ 1000.0
+ seuilSetback = 10.0
+ # Default: 20.0
+ # Range: 0.1 ~ 1000.0
+ seuilExpulsion = 20.0
+ #Sanction la plus forte autorisée : JOURNAL, ALERTE, SETBACK ou EXPULSION. Il n'y a jamais de bannissement automatique.
+ #Allowed Values: AUCUNE, JOURNAL, ALERTE, SETBACK, EXPULSION
+ sanctionMax = "EXPULSION"
+
+[combat]
+ #Excédent d'angle maximal entre le regard et la silhouette de la cible (degrés).
+ # Default: 60.0
+ # Range: 5.0 ~ 180.0
+ angleMaxDegres = 60.0
+ # Default: 3
+ # Range: 1 ~ 20
+ ciblesMax = 3
+ # Default: 1000
+ # Range: 100 ~ 10000
+ fenetreCiblesMs = 1000
+ #Coups par seconde, soutenus 2 s, au-delà desquels on lève une infraction.
+ # Default: 20
+ # Range: 5 ~ 100
+ cpsMax = 20
+ # Default: 12.0
+ # Range: 0.0 ~ 100.0
+ ecartTypeMinMs = 12.0
+ # Default: 150.0
+ # Range: 20.0 ~ 1000.0
+ intervalleMoyenMaxMs = 150.0
+ #Portée : marge (blocs) au-delà de la portée d'interaction du joueur (3,0 en survie).
+ #Vanilla refuse déjà tout coup à plus de portée + 1,0 bloc : ce contrôle couvre la bande intermédiaire.
+ # Default: 0.3
+ # Range: 0.0 ~ 2.0
+ porteeToleranceBlocs = 0.3
+ #Hitbox : de combien (blocs) la boîte réelle de la cible peut manquer le regard.
+ # Default: 0.25
+ # Range: 0.0 ~ 2.0
+ hitboxMargeBlocs = 0.25
+ #Retard d'affichage de la cible chez le client (ticks), multiplié par sa vitesse.
+ # Default: 3
+ # Range: 0 ~ 20
+ ticksLatenceCible = 3
+ # Default: 1.0
+ # Range: 0.0 ~ 4.0
+ latenceCibleMaxBlocs = 1.0
+ #Ping (ms) au plus ajouté au retard d affichage de la cible (ping / 50 ticks), plafonné par latenceCibleMaxBlocs.
+ # Default: 300
+ # Range: 0 ~ 1000
+ pingLatenceMaxMs = 300
+ #Cible plus rapide (blocs/tick) : portée et hitbox ne mesurent pas (élytres, recul, téléportation).
+ # Default: 1.0
+ # Range: 0.1 ~ 10.0
+ vitesseCibleMaxMesure = 1.0
+
+[timer]
+ # Default: 22
+ # Range: 20 ~ 200
+ paquetsParSecondeMax = 22
+ # Default: 3
+ # Range: 1 ~ 30
+ secondesSoutenues = 3
+
+[mouvement]
+ #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.
+ # Default: 1.5
+ # Range: 0.1 ~ 100.0
+ excesVitesseBlocs = 1.5
+
+[exemptions]
+ # Default: 40
+ # Range: 0 ~ 600
+ graceTeleportTicks = 40
+ # Default: 20
+ # Range: 0 ~ 600
+ graceReculTicks = 20
+ # Default: 100
+ # Range: 0 ~ 1200
+ graceGelTicks = 100
+ # Default: 18.0
+ # Range: 1.0 ~ 20.0
+ tpsLag = 18.0
+ #Ignoré depuis 0.3.0 : le ping est falsifiable par le client (PingSpoof). Gardé pour compatibilité.
+ # Default: 250
+ # Range: 50 ~ 5000
+ pingLagMs = 250
+ #Multiplicateur des seuils quand le serveur tire (TPS sous tpsLag, mesuré par le serveur).
+ # Default: 1.5
+ # Range: 1.0 ~ 5.0
+ facteurLag = 1.5
+ #Classes (séparées par des virgules) des entités de contraption ; les sous-classes sont couvertes.
+ #Un nom finissant par une minuscule, « . » ou « * » est un préfixe de paquet. Un joueur près d'une telle entité est exempté.
+ #Les vaisseaux Aeronautics ne sont pas des entités : ils sont détectés par Sable, indépendamment de ce réglage (voir README).
+ prefixesContraption = "com.simibubi.create.content.contraptions.AbstractContraptionEntity"
+ # Default: 3
+ # Range: 0 ~ 16
+ distanceContraptionBlocs = 3
+
+#Anti-crash des entités non joueurs (incident du 16/10/2026). Pas un contrôle de triche : agit dès qu'il est actif.
+#Joueurs jamais concernés ; contraptions Create, entités sur vaisseau Sable, véhicules portant un joueur : jamais supprimés (arrêtés).
+[antiCrash]
+ actif = true
+ #Vitesse max (blocs/tick) d'une entité non joueur, ramenée à cette valeur au-delà.
+ # Range: 4.0 ~ 10000.0
+ vitesseMaxBlocsParTick = 100.0
+ #Au-delà de vitesseMax × facteur (1 000 b/t), suppression.
+ # Range: 1.0 ~ 1000.0
+ facteurSuppression = 10.0
+ #Marge (blocs) au-delà de la bordure du monde.
+ # Range: 0.0 ~ 1000000.0
+ margeBordureBlocs = 64.0
+ #Vitesse max d'un minecart (blocs/tick) : vanilla 0,4 sur rail, ramenée à 2,0 par moveAlongTrack ; 3,0 = marge Create / canons.
+ # Range: 0.5 ~ 100.0
+ vitesseMaxMinecartBlocsParTick = 3.0
+ #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
+ minecartsSuperposesMax = 4
+ alertesOps = true
+
+#Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.
+[traces]
+ #Enregistrement continu pour tous les joueurs (décision T7 de Théo, 13/10/2026).
+ actives = true
+ # Default: 7
+ # Range: 1 ~ 90
+ joursConservation = 7
+ # Default: 1024
+ # Range: 16 ~ 102400
+ tailleMaxMo = 1024
diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java
index f5885ae..7b51d00 100644
--- a/src/main/java/com/gastinelgarde/Garde.java
+++ b/src/main/java/com/gastinelgarde/Garde.java
@@ -1,6 +1,7 @@
package com.gastinelgarde;
import com.gastinelgarde.core.Controle;
+import com.gastinelgarde.core.DetectionContraption;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.EtatMouvement;
import com.gastinelgarde.core.EtatVehicule;
@@ -75,6 +76,7 @@ public final class Garde {
double vehiculeX, vehiculeY, vehiculeZ;
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
int contraptionTick = Integer.MIN_VALUE;
+ int contraptionVuTick = Integer.MIN_VALUE;
boolean contraptionProche;
}
@@ -321,29 +323,45 @@ public final class Garde {
return r.actif(tick);
}
- /** La détection est refaite au plus toutes les 10 ticks par joueur. */
+ /** Ticks pendant lesquels un joueur reste exempté après avoir quitté une contraption ou un vaisseau Sable. */
+ private static final int GRACE_CONTRAPTION_TICKS = 40;
+
+ /** 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) {
if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) {
m.contraptionProche = pocheContraption(p);
m.contraptionTick = tick;
+ if (m.contraptionProche) m.contraptionVuTick = tick;
}
- return m.contraptionProche;
+ return m.contraptionProche || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS);
}
- /** Une entité de contraption (Create, Aeronautics…) est-elle toute proche ? Détection par nom de classe. */
+ /**
+ * Le joueur est-il sur ou près d'une contraption ? Deux sources :
+ *
+ * - Create (et les contraptions d'Aeronautics / Offroad, qui en héritent) : entités proches dont une classe de
+ * la chaîne correspond au réglage prefixesContraption ;
+ * - Aeronautics 1.3.2 : les vaisseaux ne sont PAS des entités, ce sont des « sous-niveaux » de Sable 2.0.6.
+ * On demande à Sable (par réflexion, sans dépendance de compilation) si le joueur est suivi par un
+ * sous-niveau, ou s'il est dans un véhicule posé sur un sous-niveau.
+ *
+ */
private static boolean pocheContraption(Player p) {
+ if (SableAcces.surSousNiveau(p)) return true;
int dist = GardeSpec.distanceContraption();
if (dist <= 0) return false;
- String[] prefixes = GardeSpec.prefixesContraption().split(",");
- List proches = p.level().getEntities(p, p.getBoundingBox().inflate(dist), e -> {
- String nom = e.getClass().getName();
- for (String pre : prefixes) {
- String t = pre.trim();
- if (!t.isEmpty() && nom.startsWith(t)) return true;
- }
- return false;
- });
- return !proches.isEmpty();
+ return !p.level().getEntities(p, p.getBoundingBox().inflate(dist), Garde::estContraption).isEmpty();
+ }
+
+ /** L'entité est-elle une contraption (classe ou classe parente dans le réglage) ? */
+ public static boolean estContraption(Entity e) {
+ List motifs = DetectionContraption.motifs(GardeSpec.prefixesContraption());
+ if (motifs.isEmpty()) return false;
+ List chaine = new java.util.ArrayList<>(6);
+ for (Class> c = e.getClass(); c != null && c != Entity.class && c != Object.class; c = c.getSuperclass()) {
+ chaine.add(c.getName());
+ }
+ return DetectionContraption.correspond(chaine, motifs);
}
// --- Réaction aux verdicts ---
@@ -378,6 +396,11 @@ public final class Garde {
}
}
+ /** Ligne dans logs/gastinelgarde.log et le journal du serveur (anti-crash, 16/10). */
+ public static void journaliser(String ligne) {
+ ecrireJournal(ligne);
+ }
+
private static synchronized void ecrireJournal(String ligne) {
GastinelGarde.LOGGER.warn("[GastinelGarde] {}", ligne);
if (journal == null) return;
@@ -442,6 +465,13 @@ public final class Garde {
if (!estExempteManuellement(p.getUUID())) {
List v = MOTEUR.regard(p.getUUID(), tick * 50L, () -> etat(p, true), p.getYRot(), p.getXRot());
traiter(p, v); // le coup a déjà eu lieu : journal et VL seulement
+ // Portée / hitbox : mesure du dernier coup refaite avec l'œil et le regard de ce paquet (core.CoupDiffere).
+ net.minecraft.world.phys.Vec3 oeil = p.getEyePosition();
+ net.minecraft.world.phys.Vec3 regard = p.getLookAngle();
+ List vh = MOTEUR.regardPorteeHitbox(p.getUUID(), tick * 50L,
+ new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z});
+ Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques)
+ if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh);
}
m.mouvementTick = tick;
m.mouvementX = p.getX();
diff --git a/src/main/java/com/gastinelgarde/GardeAntiCrash.java b/src/main/java/com/gastinelgarde/GardeAntiCrash.java
new file mode 100644
index 0000000..36cf99d
--- /dev/null
+++ b/src/main/java/com/gastinelgarde/GardeAntiCrash.java
@@ -0,0 +1,215 @@
+package com.gastinelgarde;
+
+import com.gastinelgarde.core.AntiCrashEntites;
+import com.gastinelgarde.core.AntiCrashEntites.Action;
+import com.gastinelgarde.core.AntiCrashEntites.Bordure;
+import com.gastinelgarde.core.AntiCrashEntites.Decision;
+import net.minecraft.ChatFormatting;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.TraceableEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.vehicle.AbstractMinecart;
+import net.minecraft.world.level.border.WorldBorder;
+import net.minecraft.world.phys.Vec3;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.neoforge.event.entity.EntityJoinLevelEvent;
+import net.neoforged.neoforge.event.tick.EntityTickEvent;
+
+/**
+ * Anti-crash des entités non joueurs (incident du 16/10/2026, voir {@link AntiCrashEntites}). Toujours actif
+ * (désactivable dans la config, section antiCrash), indépendant des modes OBSERVE / ENFORCE des contrôles de triche.
+ *
+ * Vérifié à l'arrivée de l'entité dans le monde (lancer, /summon, chargement d'un chunk) et au début de chacun de
+ * ses ticks (avant que son tick ne trace son rayon ou ne la déplace). Les joueurs ne sont jamais concernés
+ * (riptide, élytres) ; leurs véhicules et projectiles le sont.
+ */
+public final class GardeAntiCrash {
+
+ private static final AntiCrashEntites.LimiteurAlertes LIMITEUR = new AntiCrashEntites.LimiteurAlertes(5, 10_000);
+
+ private GardeAntiCrash() { }
+
+ @SubscribeEvent(priority = EventPriority.HIGHEST)
+ public static void onArrivee(EntityJoinLevelEvent event) {
+ if (!(event.getLevel() instanceof ServerLevel)) return;
+ if (verifier(event.getEntity(), "arrivee")) event.setCanceled(true);
+ }
+
+ @SubscribeEvent(priority = EventPriority.HIGHEST)
+ public static void onTick(EntityTickEvent.Pre event) {
+ Entity e = event.getEntity();
+ if (e.level().isClientSide()) return;
+ if (verifier(e, "tick")) event.setCanceled(true);
+ }
+
+ /** @return vrai si l'entité a été supprimée (l'événement doit être annulé). */
+ static boolean verifier(Entity e, String moment) {
+ if (e == null || e instanceof Player || e.isRemoved()) return false;
+ AntiCrashEntites.Reglages r = GardeSpec.antiCrash();
+ if (!r.actif) return false;
+
+ Vec3 v = e.getDeltaMovement();
+ WorldBorder wb = e.level().getWorldBorder();
+ Bordure b = new Bordure(wb.getMinX(), wb.getMinZ(), wb.getMaxX(), wb.getMaxZ());
+
+ // Chemin rapide (chaque entité, chaque tick) : rien d'anormal sans protection à calculer.
+ // Minecarts : plafond propre, bien plus bas (exploit d'empilement, 16/10).
+ double plafond = e instanceof AbstractMinecart ? r.vitesseMaxMinecart : r.vitesseMax;
+ if (e instanceof AbstractMinecart cart && "tick".equals(moment) && empilementTraite(cart, r)) return true;
+ Decision d = AntiCrashEntites.evaluer(r, b, e.getX(), e.getY(), e.getZ(), v.x, v.y, v.z, false, plafond);
+ if (d.action() == Action.RIEN) return false;
+ if (d.action() == Action.SUPPRIMER && estProtegee(e)) {
+ d = AntiCrashEntites.evaluer(r, b, e.getX(), e.getY(), e.getZ(), v.x, v.y, v.z, true, plafond);
+ }
+
+ // Entité protégée déjà immobile hors limites : rien à refaire, pas de journal à chaque tick.
+ if (d.action() == Action.ARRETER && v.equals(Vec3.ZERO)) return false;
+
+ switch (d.action()) {
+ case PLAFONNER -> e.setDeltaMovement(d.vx(), d.vy(), d.vz());
+ case ARRETER -> e.setDeltaMovement(Vec3.ZERO);
+ case SUPPRIMER -> {
+ // Les passagers (non joueurs) partent avec le véhicule ; un joueur passager est seulement descendu.
+ e.ejectPassengers();
+ e.discard();
+ }
+ default -> { }
+ }
+ // Une entité qui ré-accélère d'elle-même (boule de feu) serait plafonnée à chaque tick : 1 ligne / 5 s.
+ if (d.action() != Action.PLAFONNER || plafonnementASignaler(e.getUUID())) signaler(e, d, moment, v);
+ return d.action() == Action.SUPPRIMER;
+ }
+
+ // --- Empilement de minecarts (« Minecart Velocity Exploit », précision de Théo du 16/10) ---------------------
+ // 6 à 15 minecarts superposés se poussent mutuellement à chaque tick (AbstractMinecart.push(Entity) : chacun
+ // reçoit la moyenne des deux vitesses + 0,05, une fois par voisin) : la vitesse croît exponentiellement.
+ // moveAlongTrack la ramène à 2,0 au tick suivant, mais les poussées ont lieu APRÈS : entre deux ticks la
+ // vitesse est énorme, et un œuf lancé par le joueur assis en hérite (Projectile.shootFromRotation →
+ // ServerPlayer.getKnownMovement → vitesse du minecart).
+
+ /** Nombre de minecarts dont la boîte chevauche celle de ce minecart (lui compris). */
+ public static int minecartsEmpiles(AbstractMinecart cart) {
+ return cart.level().getEntitiesOfClass(AbstractMinecart.class, cart.getBoundingBox()).size();
+ }
+
+ /** Appelé par MinecartPushMixin avant chaque poussée minecart-minecart : vrai = poussée coupée. */
+ public static boolean couperPoussee(AbstractMinecart cart, Entity autre) {
+ AntiCrashEntites.Reglages r = GardeSpec.antiCrash();
+ if (!r.actif || !(autre instanceof AbstractMinecart) || cart.level().isClientSide()) return false;
+ return AntiCrashEntites.empilementExcessif(minecartsEmpiles(cart), r);
+ }
+
+ /** Appelé par MinecartPushMixin après chaque poussée : les deux minecarts restent sous leur plafond. */
+ public static void apresPoussee(AbstractMinecart cart, Entity autre) {
+ AntiCrashEntites.Reglages r = GardeSpec.antiCrash();
+ if (!r.actif || cart.level().isClientSide()) return;
+ plafonnerMinecart(cart, r);
+ if (autre instanceof AbstractMinecart m) plafonnerMinecart(m, r);
+ }
+
+ private static void plafonnerMinecart(AbstractMinecart m, AntiCrashEntites.Reglages r) {
+ Vec3 v = m.getDeltaMovement();
+ double[] n = AntiCrashEntites.plafonner(v.x, v.y, v.z, r.vitesseMaxMinecart);
+ if (n == null) return;
+ m.setDeltaMovement(n[0], n[1], n[2]);
+ // Une poussée vanilla ne dépasse guère 2,5 : au-delà de 2 × le plafond, c'est l'exploit, on le journalise.
+ double vitesse = v.length();
+ if (!(vitesse <= r.vitesseMaxMinecart * 2) && plafonnementASignaler(m.getUUID())) {
+ signaler(m, new Decision(Action.PLAFONNER, AntiCrashEntites.Motif.VITESSE_EXCESSIVE, n[0], n[1], n[2],
+ vitesse), "poussee", v);
+ }
+ }
+
+ /**
+ * Toutes les 10 ticks : au-delà de empilementMax minecarts superposés, ce minecart (s'il ne porte personne et
+ * n'est pas une contraption) est cassé et lâche son objet (et son contenu, pour un minecart à coffre).
+ * @return vrai s'il a été cassé
+ */
+ private static boolean empilementTraite(AbstractMinecart cart, AntiCrashEntites.Reglages r) {
+ if ((cart.tickCount + cart.getId()) % 10 != 0 || r.empilementMax <= 0) return false;
+ int n = minecartsEmpiles(cart);
+ if (!AntiCrashEntites.empilementExcessif(n, r)) return false;
+ if (cart.isVehicle() || Garde.estContraption(cart) || SableAcces.surSousNiveau(cart)) return false;
+ Vec3 v = cart.getDeltaMovement();
+ cart.destroy(cart.getPickResult().getItem());
+ String type = BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()).toString();
+ String ligne = String.format(java.util.Locale.ROOT,
+ "anti-crash EMPILEMENT %s cassé (%d minecarts superposés > %d), dim=%s pos=(%.1f, %.1f, %.1f) vitesse=%.4g b/t",
+ type, n, r.empilementMax, cart.level().dimension().location(), cart.getX(), cart.getY(), cart.getZ(),
+ v.length());
+ Garde.journaliser(ligne);
+ alerterOps(cart.level().getServer(), String.format(java.util.Locale.ROOT,
+ "[Garde] Anti-crash : empilement de %d minecarts à %.0f %.0f %.0f, un minecart cassé", n,
+ cart.getX(), cart.getY(), cart.getZ()));
+ return true;
+ }
+
+ private static void alerterOps(MinecraftServer server, String texte) {
+ if (server == null || !GardeSpec.antiCrashAlertesOps()) return;
+ if (!LIMITEUR.autoriser(System.currentTimeMillis())) return;
+ int masquees = LIMITEUR.masqueesDepuis();
+ Component msg = Component.literal(texte + (masquees > 0 ? " (+" + masquees + " masqués, voir gastinelgarde.log)" : ""))
+ .withStyle(ChatFormatting.RED);
+ for (ServerPlayer op : server.getPlayerList().getPlayers()) {
+ if (op.hasPermissions(2) && Garde.alertesActivesPour(op.getUUID())) op.sendSystemMessage(msg);
+ }
+ }
+
+ private static final java.util.Map DERNIER_PLAFOND = new java.util.HashMap<>();
+
+ private static boolean plafonnementASignaler(java.util.UUID id) {
+ long t = System.currentTimeMillis();
+ if (DERNIER_PLAFOND.size() > 1000) DERNIER_PLAFOND.values().removeIf(x -> t - x > 5000);
+ Long avant = DERNIER_PLAFOND.get(id);
+ if (avant != null && t - avant < 5000) return false;
+ DERNIER_PLAFOND.put(id, t);
+ return true;
+ }
+
+ /** Contraption Create, entité portée par un vaisseau Sable, ou véhicule qui porte un joueur. */
+ private static boolean estProtegee(Entity e) {
+ if (Garde.estContraption(e) || SableAcces.surSousNiveau(e)) return true;
+ for (Entity p : e.getIndirectPassengers()) {
+ if (p instanceof Player) return true;
+ }
+ return false;
+ }
+
+ private static void signaler(Entity e, Decision d, String moment, Vec3 avant) {
+ String proprio = "inconnu";
+ Entity owner = e instanceof TraceableEntity t ? t.getOwner() : null;
+ if (owner == null) owner = e.getControllingPassenger();
+ if (owner == null && e.getVehicle() != null) owner = e.getVehicle().getControllingPassenger();
+ if (owner instanceof ServerPlayer sp) proprio = sp.getGameProfile().getName();
+ else if (owner != null) proprio = BuiltInRegistries.ENTITY_TYPE.getKey(owner.getType()).toString();
+
+ String type = BuiltInRegistries.ENTITY_TYPE.getKey(e.getType()).toString();
+ String ligne = String.format(java.util.Locale.ROOT,
+ "anti-crash %s %s (%s) : %s, proprietaire=%s, dim=%s pos=(%.1f, %.1f, %.1f) vitesse=%.4g b/t (%.4g, %.4g, %.4g)%s",
+ d.action(), type, moment, d.motif(), proprio, e.level().dimension().location(),
+ e.getX(), e.getY(), e.getZ(), d.vitesse(), avant.x, avant.y, avant.z,
+ d.action() == Action.PLAFONNER ? String.format(java.util.Locale.ROOT, " -> %.1f b/t",
+ Math.sqrt(d.vx() * d.vx() + d.vy() * d.vy() + d.vz() * d.vz())) : "");
+ Garde.journaliser(ligne);
+
+ MinecraftServer server = e.level().getServer();
+ if (server == null || !GardeSpec.antiCrashAlertesOps()) return;
+ if (!LIMITEUR.autoriser(System.currentTimeMillis())) return;
+ int masquees = LIMITEUR.masqueesDepuis();
+ Component msg = Component.literal(String.format(java.util.Locale.ROOT,
+ "[Garde] Anti-crash : %s %s (%s) par %s à %.0f %.0f %.0f, %.3g b/t%s",
+ d.action() == Action.SUPPRIMER ? "supprimé" : d.action() == Action.ARRETER ? "arrêté" : "ralenti",
+ type, d.motif(), proprio, e.getX(), e.getY(), e.getZ(), d.vitesse(),
+ masquees > 0 ? " (+" + masquees + " masqués, voir gastinelgarde.log)" : ""))
+ .withStyle(ChatFormatting.RED);
+ for (ServerPlayer op : server.getPlayerList().getPlayers()) {
+ if (op.hasPermissions(2) && Garde.alertesActivesPour(op.getUUID())) op.sendSystemMessage(msg);
+ }
+ }
+}
diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java
index 79d817b..2a7ef1c 100644
--- a/src/main/java/com/gastinelgarde/GardeEvents.java
+++ b/src/main/java/com/gastinelgarde/GardeEvents.java
@@ -2,9 +2,11 @@ package com.gastinelgarde;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.KillauraAngle;
+import com.gastinelgarde.core.PorteeHitbox;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.TraceLigne;
import com.gastinelgarde.core.Verdict;
+import java.util.ArrayList;
import java.util.List;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.entity.Entity;
@@ -67,7 +69,23 @@ public final class GardeEvents {
bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ);
boolean visible = p.hasLineOfSight(cible);
- List verdicts = Garde.moteur().attaque(p.getUUID(), tick * 50L, etat, excedent, cible.getId(), visible);
+ List verdicts = new ArrayList<>(
+ Garde.moteur().attaque(p.getUUID(), tick * 50L, etat, -1, cible.getId(), visible)); // angle : différé
+
+ // Portée et hitbox (test de Rednixxu, 14/10). Cible sur une contraption ou un vaisseau Sable : ses
+ // coordonnées et sa boîte ne sont pas fiables pour cette géométrie, on ne mesure pas.
+ // 16/10 : cible assise sur une contraption (siège Create) ; mesure terminée au paquet de mouvement suivant
+ // (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.
+ Entity racine = cible.getRootVehicle();
+ boolean mesurerPH = !Garde.estContraption(cible) && !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)
+ + Math.pow(cible.getZ() - cible.zo, 2));
+ verdicts.addAll(Garde.moteur().coupDiffere(p.getUUID(), tick * 50L, etat,
+ new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z},
+ new double[] {bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ}, p.entityInteractionRange(),
+ vitesseCible, mesurerPH, true));
if (Garde.tracesEnCours()) {
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
@@ -76,6 +94,7 @@ public final class GardeEvents {
}
Sanction s = Garde.traiter(p, verdicts);
+ if (Garde.moteur().coupsBloques(p.getUUID(), tick * 50L)) event.setCanceled(true); // portée / hitbox ENFORCE
if (s.ordinal() >= Sanction.SETBACK.ordinal()) {
event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé
if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts);
diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java
index b777bfb..d9e9f29 100644
--- a/src/main/java/com/gastinelgarde/GardeSpec.java
+++ b/src/main/java/com/gastinelgarde/GardeSpec.java
@@ -40,9 +40,24 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue PING_LAG;
private static final ModConfigSpec.DoubleValue FACTEUR_LAG;
+ private static final ModConfigSpec.DoubleValue PORTEE_TOLERANCE;
+ private static final ModConfigSpec.DoubleValue HITBOX_MARGE;
+ private static final ModConfigSpec.IntValue TICKS_LATENCE_CIBLE;
+ private static final ModConfigSpec.DoubleValue LATENCE_CIBLE_MAX;
+ private static final ModConfigSpec.IntValue PING_LATENCE_MAX;
+ private static final ModConfigSpec.DoubleValue VITESSE_CIBLE_MAX;
+
private static final ModConfigSpec.ConfigValue PREFIXES_CONTRAPTION;
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
+ private static final ModConfigSpec.BooleanValue AC_ACTIF;
+ private static final ModConfigSpec.DoubleValue AC_VITESSE_MAX;
+ private static final ModConfigSpec.DoubleValue AC_FACTEUR_SUPPRESSION;
+ private static final ModConfigSpec.DoubleValue AC_MARGE_BORDURE;
+ private static final ModConfigSpec.BooleanValue AC_ALERTES_OPS;
+ private static final ModConfigSpec.DoubleValue AC_VITESSE_MINECART;
+ private static final ModConfigSpec.IntValue AC_EMPILEMENT_MAX;
+
private static final ModConfigSpec.BooleanValue TRACES_ACTIVES;
private static final ModConfigSpec.IntValue TRACES_JOURS;
private static final ModConfigSpec.IntValue TRACES_TAILLE_MO;
@@ -52,7 +67,8 @@ public final class GardeSpec {
b.comment("Mode de chaque contrôle : OFF (coupé), OBSERVE (journal et message aux ops, aucune sanction),",
"ENFORCE (sanctions appliquées). Tout démarre en OBSERVE ; ne passer en ENFORCE qu'après",
- "plusieurs jours sans fausse alerte sur des joueurs honnêtes.").push("modes");
+ "plusieurs jours sans fausse alerte sur des joueurs honnêtes.",
+ "no-fall, vitesse, vol, portee et hitbox : OBSERVE conseillé tant qu'ils n'ont pas été validés en jeu.").push("modes");
for (Controle c : Controle.values()) {
MODES.put(c, b.defineEnum(c.id(), Mode.OBSERVE));
}
@@ -77,6 +93,18 @@ public final class GardeSpec {
.defineInRange("cpsMax", 20, 5, 100);
ECART_TYPE_MIN = b.defineInRange("ecartTypeMinMs", 12.0, 0.0, 100.0);
INTERVALLE_MOYEN_MAX = b.defineInRange("intervalleMoyenMaxMs", 150.0, 20.0, 1000.0);
+ PORTEE_TOLERANCE = b.comment("Portée : marge (blocs) au-delà de la portée d'interaction du joueur (3,0 en survie).",
+ "Vanilla refuse déjà tout coup à plus de portée + 1,0 bloc : ce contrôle couvre la bande intermédiaire.")
+ .defineInRange("porteeToleranceBlocs", 0.3, 0.0, 2.0);
+ HITBOX_MARGE = b.comment("Hitbox : de combien (blocs) la boîte réelle de la cible peut manquer le regard.")
+ .defineInRange("hitboxMargeBlocs", 0.25, 0.0, 2.0);
+ TICKS_LATENCE_CIBLE = b.comment("Retard d'affichage de la cible chez le client (ticks), multiplié par sa vitesse.")
+ .defineInRange("ticksLatenceCible", 3, 0, 20);
+ LATENCE_CIBLE_MAX = b.defineInRange("latenceCibleMaxBlocs", 1.0, 0.0, 4.0);
+ PING_LATENCE_MAX = b.comment("Ping (ms) au plus ajouté au retard d affichage de la cible (ping / 50 ticks), plafonné par latenceCibleMaxBlocs.")
+ .defineInRange("pingLatenceMaxMs", 300, 0, 1000);
+ VITESSE_CIBLE_MAX = b.comment("Cible plus rapide (blocs/tick) : portée et hitbox ne mesurent pas (élytres, recul, téléportation).")
+ .defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
b.pop();
b.push("timer");
@@ -99,12 +127,40 @@ public final class GardeSpec {
.defineInRange("pingLagMs", 250, 50, 5000);
FACTEUR_LAG = b.comment("Multiplicateur des seuils quand le serveur tire (TPS sous tpsLag, mesuré par le serveur).")
.defineInRange("facteurLag", 1.5, 1.0, 5.0);
- PREFIXES_CONTRAPTION = b.comment("Préfixes de classes (séparés par des virgules) des entités de contraptions Create / Aeronautics.",
- "Un joueur près d'une telle entité est exempté. À valider sur le serveur réel (voir README).")
- .define("prefixesContraption", "com.simibubi.create.content.contraptions,dev.simulated_team,dev.ryanhcode");
+ PREFIXES_CONTRAPTION = b.comment("Classes (séparées par des virgules) des entités de contraption ; les sous-classes sont couvertes.",
+ "Un nom finissant par une minuscule, « . » ou « * » est un préfixe de paquet. Un joueur près d'une telle entité est exempté.",
+ "Les vaisseaux Aeronautics ne sont pas des entités : ils sont détectés par Sable, indépendamment de ce réglage (voir README).")
+ .define("prefixesContraption", com.gastinelgarde.core.DetectionContraption.MOTIFS_DEFAUT);
DISTANCE_CONTRAPTION = b.defineInRange("distanceContraptionBlocs", 3, 0, 16);
b.pop();
+ b.comment("Anti-crash des entités non joueurs (incident du 16/10/2026 : œuf lancé à ~1e53 blocs/tick, génération",
+ "de chunks à Z = 2 147 483 500, serveur planté). Ce n'est pas un contrôle de triche : pas de mode OBSERVE,",
+ "il agit dès qu'il est actif. Les joueurs ne sont jamais concernés (riptide, élytres) ; les contraptions",
+ "Create, les entités sur un vaisseau Sable et les véhicules qui portent un joueur ne sont jamais supprimés",
+ "(seulement arrêtés).").push("antiCrash");
+ AC_ACTIF = b.define("actif", true);
+ AC_VITESSE_MAX = b.comment("Vitesse maximale (blocs/tick) d'une entité non joueur ; au-delà elle est ramenée à cette valeur.",
+ "100 = 2 000 blocs/s : plus de 25 fois le projectile vanilla le plus rapide (flèche d'arbalète ~3,2),",
+ "50 fois un bateau sur glace bleue (~2), largement au-dessus des canons à TNT courants et des trains Create.",
+ "Un rayon de 100 blocs touche au plus ~8 chunks par tick.")
+ .defineInRange("vitesseMaxBlocsParTick", 100.0, 4.0, 10000.0);
+ AC_FACTEUR_SUPPRESSION = b.comment("Au-delà de vitesseMax × ce facteur (1 000 blocs/tick par défaut), l'entité est supprimée au lieu d'être ralentie.")
+ .defineInRange("facteurSuppression", 10.0, 1.0, 1000.0);
+ AC_MARGE_BORDURE = b.comment("Marge (blocs) au-delà de la bordure du monde : une entité (ou sa trajectoire du tick) plus loin est supprimée.",
+ "Les limites absolues du jeu (±30 000 000 horizontal, ±20 000 000 vertical) s'appliquent toujours.")
+ .defineInRange("margeBordureBlocs", 64.0, 0.0, 1000000.0);
+ AC_VITESSE_MINECART = b.comment("Vitesse maximale d'un minecart (blocs/tick). Vanilla 1.21.1 : 0,4 sur rail (NeoForge jusqu'à 1,2),",
+ "vitesse ramenée à 2,0 au plus sur rail, 0,4 hors rail. 3,0 laisse de la marge (Create, canons). Exploit",
+ "d'empilement : la vitesse des minecarts superposés croît exponentiellement et passe à leurs projectiles.")
+ .defineInRange("vitesseMaxMinecartBlocsParTick", 3.0, 0.5, 100.0);
+ 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.")
+ .defineInRange("minecartsSuperposesMax", 4, 0, 64);
+ AC_ALERTES_OPS = b.comment("Message aux ops (5 au plus par 10 s ; tout est dans logs/gastinelgarde.log).")
+ .define("alertesOps", true);
+ b.pop();
+
b.comment("Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.")
.push("traces");
TRACES_ACTIVES = b.comment("Enregistrement continu pour tous les joueurs (décision T7 de Théo, 13/10/2026).")
@@ -120,6 +176,7 @@ public final class GardeSpec {
public static void onConfig(ModConfigEvent event) {
if (event.getConfig().getSpec() == SPEC) {
+ acCache = null;
appliquer(Garde.config());
Garde.surConfigChargee();
}
@@ -145,6 +202,12 @@ public final class GardeSpec {
c.paquetsParSecondeMax = PAQUETS_PAR_SECONDE.get();
c.timerSecondesSoutenues = TIMER_SECONDES.get();
c.excesVitesseBlocs = EXCES_VITESSE.get();
+ c.porteeToleranceBlocs = PORTEE_TOLERANCE.get();
+ c.hitboxMargeBlocs = HITBOX_MARGE.get();
+ c.ticksLatenceCible = TICKS_LATENCE_CIBLE.get();
+ c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
+ c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
+ c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
c.graceTeleportTicks = GRACE_TELEPORT.get();
c.graceReculTicks = GRACE_RECUL.get();
c.graceGelTicks = GRACE_GEL.get();
@@ -163,6 +226,33 @@ public final class GardeSpec {
return SPEC.isLoaded() ? DISTANCE_CONTRAPTION.get() : DISTANCE_CONTRAPTION.getDefault();
}
+ /** Réglages anti-crash courants (valeurs par défaut si le fichier n'est pas chargé). */
+ public static com.gastinelgarde.core.AntiCrashEntites.Reglages antiCrash() {
+ com.gastinelgarde.core.AntiCrashEntites.Reglages r = acCache;
+ if (r != null) return r; // appelé pour chaque entité à chaque tick : relu seulement au (re)chargement
+ r = lireAntiCrash();
+ if (SPEC.isLoaded()) acCache = r;
+ return r;
+ }
+
+ private static volatile com.gastinelgarde.core.AntiCrashEntites.Reglages acCache;
+
+ private static com.gastinelgarde.core.AntiCrashEntites.Reglages lireAntiCrash() {
+ com.gastinelgarde.core.AntiCrashEntites.Reglages r = new com.gastinelgarde.core.AntiCrashEntites.Reglages();
+ boolean l = SPEC.isLoaded();
+ r.actif = l ? AC_ACTIF.get() : AC_ACTIF.getDefault();
+ r.vitesseMax = l ? AC_VITESSE_MAX.get() : AC_VITESSE_MAX.getDefault();
+ r.facteurSuppression = l ? AC_FACTEUR_SUPPRESSION.get() : AC_FACTEUR_SUPPRESSION.getDefault();
+ r.margeBordure = l ? AC_MARGE_BORDURE.get() : AC_MARGE_BORDURE.getDefault();
+ r.vitesseMaxMinecart = l ? AC_VITESSE_MINECART.get() : AC_VITESSE_MINECART.getDefault();
+ r.empilementMax = l ? AC_EMPILEMENT_MAX.get() : AC_EMPILEMENT_MAX.getDefault();
+ return r;
+ }
+
+ public static boolean antiCrashAlertesOps() {
+ return SPEC.isLoaded() ? AC_ALERTES_OPS.get() : AC_ALERTES_OPS.getDefault();
+ }
+
public static boolean tracesActives() {
return SPEC.isLoaded() ? TRACES_ACTIVES.get() : TRACES_ACTIVES.getDefault();
}
diff --git a/src/main/java/com/gastinelgarde/GastinelGarde.java b/src/main/java/com/gastinelgarde/GastinelGarde.java
index 53b62a0..f980d84 100644
--- a/src/main/java/com/gastinelgarde/GastinelGarde.java
+++ b/src/main/java/com/gastinelgarde/GastinelGarde.java
@@ -23,6 +23,7 @@ public class GastinelGarde {
NeoForge.EVENT_BUS.register(GardeEvents.class);
NeoForge.EVENT_BUS.register(GardeCommands.class);
+ NeoForge.EVENT_BUS.register(GardeAntiCrash.class); // anti-crash entités (16/10), toujours actif
LOGGER.info("[GastinelGarde] Anti-triche chargé (tous les contrôles démarrent en observe).");
}
diff --git a/src/main/java/com/gastinelgarde/SableAcces.java b/src/main/java/com/gastinelgarde/SableAcces.java
new file mode 100644
index 0000000..fe4c253
--- /dev/null
+++ b/src/main/java/com/gastinelgarde/SableAcces.java
@@ -0,0 +1,51 @@
+package com.gastinelgarde;
+
+import java.lang.reflect.Method;
+import net.minecraft.world.entity.Entity;
+
+/**
+ * Accès facultatif à Sable (moteur physique des vaisseaux de Create Aeronautics), par réflexion : GastinelGarde
+ * se charge et fonctionne sans Sable.
+ *
+ * API utilisée (relevée dans sable-neoforge-1.21.1-2.0.6.jar, jar inclus
+ * META-INF/jarjar/sable-companion-common-1.21.1-1.6.0.jar) :
+ * {@code dev.ryanhcode.sable.companion.SableCompanion.INSTANCE.getTrackingOrVehicleSubLevel(Entity)}, qui renvoie
+ * le sous-niveau (vaisseau) qui porte l'entité, ou celui de son véhicule, sinon null.
+ */
+final class SableAcces {
+
+ private static final String CLASSE = "dev.ryanhcode.sable.companion.SableCompanion";
+
+ private static boolean essaye;
+ private static Object instance;
+ private static Method suivi;
+
+ private SableAcces() { }
+
+ private static synchronized void charger() {
+ if (essaye) return;
+ essaye = true;
+ try {
+ Class> c = Class.forName(CLASSE);
+ instance = c.getField("INSTANCE").get(null);
+ suivi = c.getMethod("getTrackingOrVehicleSubLevel", Entity.class);
+ GastinelGarde.LOGGER.info("[GastinelGarde] Sable détecté : les joueurs sur un vaisseau sont exemptés.");
+ } catch (ReflectiveOperationException | LinkageError e) {
+ instance = null;
+ suivi = null;
+ GastinelGarde.LOGGER.info("[GastinelGarde] Sable absent ou API différente ({}) : vaisseaux non détectés.",
+ e.getClass().getSimpleName());
+ }
+ }
+
+ /** Vrai si Sable dit que l'entité est portée par un vaisseau (ou que son véhicule l'est). */
+ static boolean surSousNiveau(Entity e) {
+ if (!essaye) charger();
+ if (suivi == null) return false;
+ try {
+ return suivi.invoke(instance, e) != null;
+ } catch (ReflectiveOperationException | RuntimeException ex) {
+ return false;
+ }
+ }
+}
diff --git a/src/main/java/com/gastinelgarde/core/AntiCrashEntites.java b/src/main/java/com/gastinelgarde/core/AntiCrashEntites.java
new file mode 100644
index 0000000..d264982
--- /dev/null
+++ b/src/main/java/com/gastinelgarde/core/AntiCrashEntites.java
@@ -0,0 +1,183 @@
+package com.gastinelgarde.core;
+
+/**
+ * Protection anti-crash des entités non joueurs (incident du 16/10/2026, « Minecart Velocity Exploit »).
+ *
+ * Un œuf lancé à ~7e53 blocs/tick : à son tick, {@code ProjectileUtil.getHitResultOnMoveVector} trace un rayon
+ * (BlockGetter.clip) le long de toute sa vitesse ; chaque {@code getBlockState} charge ou GÉNÈRE le chunk traversé.
+ * Les coordonnées, bornées à ±2^31, tombent sur des chunks (~134 217 720) où la génération déborde
+ * (Aquifer : ArrayIndexOutOfBoundsException) : « Exception generating new chunk », serveur planté ou figé.
+ *
+ * Parade, avant que l'entité ne bouge (arrivée dans le monde et début de chaque tick) :
+ *
+ * - position non finie, ou hors bordure + marge (ou hors des limites absolues du jeu) : suppression ;
+ * - vitesse non finie : suppression ;
+ * - vitesse au-delà de {@code vitesseMax × facteurSuppression} : suppression ;
+ * - vitesse au-delà de {@code vitesseMax} : ramenée à {@code vitesseMax} (même direction) ;
+ * - position après ce tick (position + vitesse) hors bordure + marge : suppression.
+ *
+ * Une entité « protégée » (contraption Create, entité portée par un vaisseau Sable, véhicule qui porte un joueur)
+ * n'est jamais supprimée : sa vitesse est mise à zéro à la place (ARRETER).
+ *
+ * Logique pure, sans Minecraft.
+ */
+public final class AntiCrashEntites {
+
+ /** Limite horizontale absolue de Minecraft (Level.MAX_LEVEL_SIZE). */
+ public static final double LIMITE_HORIZONTALE = 30_000_000.0;
+ /** Limite verticale absolue des positions acceptées par Minecraft (Level.isInSpawnableBounds : ±20 000 000). */
+ public static final double LIMITE_VERTICALE = 20_000_000.0;
+
+ public enum Action { RIEN, PLAFONNER, ARRETER, SUPPRIMER }
+
+ public enum Motif { AUCUN, POSITION_NON_FINIE, VITESSE_NON_FINIE, HORS_BORDURE, VITESSE_EXTREME, VITESSE_EXCESSIVE, TRAJECTOIRE_HORS_BORDURE }
+
+ /** Réglages (recopiés du fichier de configuration). */
+ public static final class Reglages {
+ public boolean actif = true;
+ /** Vitesse maximale d'une entité non joueur (blocs/tick). */
+ public double vitesseMax = 100.0;
+ /** Au-delà de vitesseMax × ce facteur, l'entité est supprimée au lieu d'être ralentie. */
+ public double facteurSuppression = 10.0;
+ /** Marge (blocs) tolérée au-delà de la bordure du monde. */
+ public double margeBordure = 64.0;
+ /**
+ * Vitesse maximale d'un minecart (blocs/tick). Vanilla 1.21.1 : déplacement sur rail borné à 0,4 (NeoForge
+ * jusqu'à 1,2), vitesse ramenée à 2,0 au plus par moveAlongTrack, 0,4 hors rail (comeOffTrack).
+ */
+ 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. */
+ public int empilementMax = 4;
+ }
+
+ /** Bordure du monde (rectangle horizontal). */
+ public record Bordure(double minX, double minZ, double maxX, double maxZ) {
+ public static final Bordure VANILLA = new Bordure(-29_999_984, -29_999_984, 29_999_984, 29_999_984);
+ }
+
+ /** Décision : action, motif, et la nouvelle vitesse si PLAFONNER / ARRETER. */
+ public record Decision(Action action, Motif motif, double vx, double vy, double vz, double vitesse) {
+ static final Decision RIEN = new Decision(Action.RIEN, Motif.AUCUN, 0, 0, 0, 0);
+ }
+
+ private AntiCrashEntites() { }
+
+ /**
+ * @param protege contraption, entité sur un vaisseau Sable, véhicule portant un joueur : jamais supprimée
+ */
+ public static Decision evaluer(Reglages r, Bordure b, double x, double y, double z,
+ double vx, double vy, double vz, boolean protege) {
+ return evaluer(r, b, x, y, z, vx, vy, vz, protege, r == null ? 0 : r.vitesseMax);
+ }
+
+ /**
+ * Comme {@link #evaluer(Reglages, Bordure, double, double, double, double, double, double, boolean)} avec un
+ * plafond propre (minecarts : {@code vitesseMaxMinecart}). Le seuil de suppression reste
+ * {@code vitesseMax × facteurSuppression}.
+ */
+ public static Decision evaluer(Reglages r, Bordure b, double x, double y, double z,
+ double vx, double vy, double vz, boolean protege, double plafond) {
+ if (r == null || !r.actif) return Decision.RIEN;
+
+ if (!Double.isFinite(x) || !Double.isFinite(y) || !Double.isFinite(z)) {
+ return grave(Motif.POSITION_NON_FINIE, protege, Double.NaN);
+ }
+ boolean vitesseFinie = Double.isFinite(vx) && Double.isFinite(vy) && Double.isFinite(vz);
+ double v = vitesseFinie ? Math.sqrt(vx * vx + vy * vy + vz * vz) : Double.NaN;
+ if (vitesseFinie && Double.isInfinite(v)) vitesseFinie = false; // composantes finies mais carré infini
+ if (!vitesseFinie) return grave(Motif.VITESSE_NON_FINIE, protege, v);
+
+ if (!dansLimites(b, r.margeBordure, x, y, z)) {
+ // Une entité protégée hors limites est seulement arrêtée (elle ne génère plus rien en bougeant).
+ return grave(Motif.HORS_BORDURE, protege, v);
+ }
+
+ if (v > Math.max(r.vitesseMax, 0.0) * Math.max(r.facteurSuppression, 1.0)) {
+ return grave(Motif.VITESSE_EXTREME, protege, v);
+ }
+ double max = Math.max(Math.min(plafond, r.vitesseMax), 0.0);
+
+ double nx = vx, ny = vy, nz = vz;
+ Action action = Action.RIEN;
+ Motif motif = Motif.AUCUN;
+ if (v > max) {
+ double k = v > 0 ? max / v : 0;
+ nx = vx * k;
+ ny = vy * k;
+ nz = vz * k;
+ action = Action.PLAFONNER;
+ motif = Motif.VITESSE_EXCESSIVE;
+ }
+ // Le rayon de ce tick va de la position à position + vitesse : il ne doit pas sortir de la bordure + marge.
+ if (!dansLimites(b, r.margeBordure, x + nx, y + ny, z + nz)) {
+ return grave(Motif.TRAJECTOIRE_HORS_BORDURE, protege, v);
+ }
+ return action == Action.RIEN ? Decision.RIEN : new Decision(action, motif, nx, ny, nz, v);
+ }
+
+ private static Decision grave(Motif m, boolean protege, double v) {
+ return new Decision(protege ? Action.ARRETER : Action.SUPPRIMER, m, 0, 0, 0, v);
+ }
+
+ /**
+ * Vecteur ramené à la norme {@code max} (même direction) ; NaN / infini → zéro. Renvoie null si rien à changer.
+ */
+ public static double[] plafonner(double vx, double vy, double vz, double max) {
+ if (!Double.isFinite(vx) || !Double.isFinite(vy) || !Double.isFinite(vz)) return new double[] {0, 0, 0};
+ double v = Math.sqrt(vx * vx + vy * vy + vz * vz);
+ if (!Double.isFinite(v)) return new double[] {0, 0, 0};
+ if (v <= max) return null;
+ double k = max / v;
+ return new double[] {vx * k, vy * k, vz * k};
+ }
+
+ /** Empilement : y a-t-il trop de minecarts qui se chevauchent (lui compris) ? */
+ public static boolean empilementExcessif(int minecartsQuiSeChevauchent, Reglages r) {
+ return r != null && r.actif && r.empilementMax > 0 && minecartsQuiSeChevauchent > r.empilementMax;
+ }
+
+ /** 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) {
+ if (Math.abs(x) > LIMITE_HORIZONTALE || Math.abs(z) > LIMITE_HORIZONTALE || Math.abs(y) > LIMITE_VERTICALE) {
+ return false;
+ }
+ if (b == null) return true;
+ double m = Math.max(marge, 0.0);
+ return x >= b.minX() - m && x <= b.maxX() + m && z >= b.minZ() - m && z <= b.maxZ() + m;
+ }
+
+ /** Limiteur des messages aux ops : au plus {@code max} par fenêtre de {@code fenetreMs} (le journal garde tout). */
+ public static final class LimiteurAlertes {
+ private final int max;
+ private final long fenetreMs;
+ private long debut = Long.MIN_VALUE;
+ private int compte;
+ private int masquees;
+
+ public LimiteurAlertes(int max, long fenetreMs) {
+ this.max = max;
+ this.fenetreMs = fenetreMs;
+ }
+
+ /** Vrai si le message peut partir ; sinon il est compté comme masqué. */
+ public synchronized boolean autoriser(long maintenantMs) {
+ if (debut == Long.MIN_VALUE || maintenantMs - debut >= fenetreMs) {
+ debut = maintenantMs;
+ compte = 0;
+ }
+ if (compte < max) {
+ compte++;
+ return true;
+ }
+ masquees++;
+ return false;
+ }
+
+ /** Nombre de messages masqués depuis le dernier appel (remis à zéro). */
+ public synchronized int masqueesDepuis() {
+ int m = masquees;
+ masquees = 0;
+ return m;
+ }
+ }
+}
diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java
index 08b2830..3d32b15 100644
--- a/src/main/java/com/gastinelgarde/core/Controle.java
+++ b/src/main/java/com/gastinelgarde/core/Controle.java
@@ -8,6 +8,8 @@ public enum Controle {
REGULARITE("regularite"),
ATTAQUE_IMPOSSIBLE("attaque-impossible"),
ROTATION("rotation"),
+ PORTEE("portee"),
+ HITBOX("hitbox"),
TIMER("timer"),
NO_FALL("no-fall"),
VITESSE("vitesse"),
@@ -25,6 +27,15 @@ public enum Controle {
return id;
}
+ /**
+ * Contrôles nouveaux ou à risque de fausse alerte (no-fall, vitesse horizontale, vol, portée, hitbox) :
+ * OBSERVE par défaut. ENFORCE reste possible par la configuration ou {@code /garde mode} (16/10/2026 :
+ * correction de l'interdiction du 15/10, qui empêchait aussi la correction no-fall de d0c001d).
+ */
+ public boolean observeParDefaut() {
+ return this == NO_FALL || this == VITESSE || this == VOL || this == PORTEE || this == HITBOX;
+ }
+
public static Controle parse(String texte) {
if (texte == null) return null;
for (Controle c : values()) {
diff --git a/src/main/java/com/gastinelgarde/core/CoupDiffere.java b/src/main/java/com/gastinelgarde/core/CoupDiffere.java
new file mode 100644
index 0000000..2b901dc
--- /dev/null
+++ b/src/main/java/com/gastinelgarde/core/CoupDiffere.java
@@ -0,0 +1,62 @@
+package com.gastinelgarde.core;
+
+/**
+ * Mesure portée / hitbox d'un coup, terminée au paquet de mouvement suivant (16/10/2026).
+ *
+ * Le client 1.21.1 traite les touches (donc envoie le coup) AVANT d'envoyer, dans le même tick, sa position et sa
+ * rotation (Minecraft.tick : handleKeybinds puis tickEntities / LocalPlayer.sendPosition). Au moment du coup, le
+ * serveur connaît donc l'œil et le regard du tick précédent : un joueur qui tourne vite la souris, sprinte, saute
+ * (potions de vitesse ou de saut, glace) serait vu « à côté » de sa cible. On garde la plus petite des deux mesures :
+ * celle du coup et celle refaite avec l'œil et le regard du premier paquet qui suit (au plus {@link #TICKS_MAX}
+ * ticks plus tard ; au-delà, ou sans paquet, le regard n'a pas changé et la mesure du coup est la bonne).
+ */
+final class CoupDiffere {
+
+ /** 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;
+
+ final long nowMs;
+ final EtatJoueur etat;
+ final double[] boite;
+ final double porteeJoueur;
+ final double vitesseCible;
+ /** Faux : cible sur contraption, seul l'angle killaura est mesuré. */
+ final boolean porteeHitbox;
+ double distance;
+ double manque;
+ /** Excédent d'angle killaura (degrés), -1 si non mesuré. */
+ double excedent;
+
+ CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
+ double distance, double manque, double excedent, boolean porteeHitbox) {
+ this.nowMs = nowMs;
+ this.etat = etat;
+ this.boite = boite;
+ this.porteeJoueur = porteeJoueur;
+ this.vitesseCible = vitesseCible;
+ this.distance = distance;
+ this.manque = manque;
+ this.excedent = excedent;
+ this.porteeHitbox = porteeHitbox;
+ }
+
+ boolean encoreValable(long maintenantMs) {
+ long d = maintenantMs / 50 - nowMs / 50;
+ 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) {
+ 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 m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
+ porteeJoueur + 1.0, b[0], b[1], b[2], b[3], b[4], b[5]);
+ distance = Math.min(distance, d);
+ manque = Math.min(manque, m);
+ if (excedent >= 0) {
+ double a = KillauraAngle.excedentDegres(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
+ b[0], b[1], b[2], b[3], b[4], b[5]);
+ if (a >= 0) excedent = Math.min(excedent, a);
+ }
+ }
+}
diff --git a/src/main/java/com/gastinelgarde/core/DetectionContraption.java b/src/main/java/com/gastinelgarde/core/DetectionContraption.java
new file mode 100644
index 0000000..f6beff2
--- /dev/null
+++ b/src/main/java/com/gastinelgarde/core/DetectionContraption.java
@@ -0,0 +1,67 @@
+package com.gastinelgarde.core;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Reconnaît une entité de contraption à partir de la chaîne de ses classes (la sienne, puis ses parents).
+ *
+ * Un motif est soit un nom de classe exact (« com.simibubi.create.content.contraptions.AbstractContraptionEntity »),
+ * qui couvre aussi toutes ses sous-classes puisque toute la chaîne est examinée, soit un paquet (dernier segment en
+ * minuscule, ou motif terminé par « . » ou « * ») : ancienne forme du réglage, gardée pour les fichiers existants.
+ *
+ * Noms relevés le 15/10/2026 dans les jars du serveur (identiques au bit près à ceux de dist_mods) :
+ * voir README, section « Contraptions ».
+ */
+public final class DetectionContraption {
+
+ /** Valeur par défaut du réglage prefixesContraption (noms exacts, voir README). */
+ public static final String MOTIFS_DEFAUT =
+ "com.simibubi.create.content.contraptions.AbstractContraptionEntity";
+
+ private DetectionContraption() { }
+
+ public static List motifs(String reglage) {
+ List l = new ArrayList<>();
+ if (reglage == null) return l;
+ for (String m : reglage.split(",")) {
+ String t = m.trim();
+ if (!t.isEmpty()) l.add(t);
+ }
+ return l;
+ }
+
+ /** Un nom de la chaîne de classes correspond-il à un motif ? */
+ public static boolean correspond(Iterable chaineClasses, List motifs) {
+ for (String nom : chaineClasses) {
+ for (String m : motifs) {
+ if (m.endsWith("*")) {
+ if (nom.startsWith(m.substring(0, m.length() - 1))) return true;
+ } else if (estPaquet(m)) {
+ if (nom.startsWith(m.endsWith(".") ? m : m + ".")) return true;
+ } else if (nom.equals(m) || nom.startsWith(m + "$")) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /** Paquet si le dernier segment commence par une minuscule (convention Java : classes en majuscule). */
+ static boolean estPaquet(String m) {
+ String t = m.endsWith(".") ? m.substring(0, m.length() - 1) : m;
+ if (m.endsWith(".")) return true;
+ int i = t.lastIndexOf('.');
+ String dernier = i < 0 ? t : t.substring(i + 1);
+ return !dernier.isEmpty() && Character.isLowerCase(dernier.charAt(0));
+ }
+
+ /**
+ * Grâce après avoir quitté une contraption ou un vaisseau Sable : le joueur garde l'élan du vaisseau quelques
+ * ticks. Vrai si la contraption a été vue il y a au plus {@code graceTicks} ticks.
+ */
+ public static boolean dansLaGrace(int tick, int dernierVuTick, int graceTicks) {
+ if (dernierVuTick == Integer.MIN_VALUE || tick < dernierVuTick) return false;
+ return tick - dernierVuTick <= graceTicks;
+ }
+}
diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java
index 2b33495..804fe76 100644
--- a/src/main/java/com/gastinelgarde/core/GardeConfig.java
+++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java
@@ -41,6 +41,23 @@ public final class GardeConfig {
/** Total d'excès de vitesse horizontale (blocs) sur 20 ticks au-delà duquel on lève une infraction. */
public double excesVitesseBlocs = 1.5;
+ // --- Portée et hitbox (après le test de Rednixxu, 14/10) ---
+ /** Marge (blocs) ajoutée à la portée d'interaction du joueur (3,0 en survie) avant une infraction. */
+ public double porteeToleranceBlocs = 0.3;
+ /** Marge (blocs) dont la boîte réelle de la cible peut manquer le regard avant une infraction. */
+ public double hitboxMargeBlocs = 0.25;
+ /** Ticks de retard d'affichage de la cible pris en compte (son déplacement par tick × ce nombre). */
+ public int ticksLatenceCible = 3;
+ /** Plafond de la tolérance due au déplacement de la cible (blocs). */
+ public double latenceCibleMaxBlocs = 1.0;
+ /**
+ * Ping (ms) au plus pris en compte dans le retard d'affichage de la cible (ping / 50 ticks en plus). Le ping est
+ * falsifiable (F07) : il ne joue qu'ici, borné, et la tolérance totale reste plafonnée par latenceCibleMaxBlocs.
+ */
+ public int pingLatenceMaxMs = 300;
+ /** Cible plus rapide que ça (blocs/tick : élytres, riptide, téléportation, recul fort) : pas de mesure. */
+ public double vitesseCibleMaxMesure = 1.0;
+
// --- Exemptions ---
public int graceTeleportTicks = 40;
public int graceReculTicks = 20;
diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java
index 0145247..8fbd5f2 100644
--- a/src/main/java/com/gastinelgarde/core/Moteur.java
+++ b/src/main/java/com/gastinelgarde/core/Moteur.java
@@ -86,6 +86,126 @@ public final class Moteur {
return verdicts;
}
+ /**
+ * Portée et hitbox d'un coup (voir {@link PorteeHitbox}). Appelé à part de {@link #attaque} pour garder sa
+ * signature (rejeu des traces).
+ *
+ * @param distance distance œil – boîte réelle de la cible, -1 si non mesurée
+ * @param manque gonflement nécessaire de la boîte pour que le regard la touche, -1 si non mesuré
+ * @param porteeJoueur portée d'interaction du joueur (attribut, 3,0 en survie)
+ * @param vitesseCible déplacement de la cible au dernier tick (blocs)
+ */
+ public List porteeHitbox(UUID joueur, long nowMs, EtatJoueur etat, double distance, double manque,
+ double porteeJoueur, double vitesseCible) {
+ boolean portee = cfg.mode(Controle.PORTEE) != Mode.OFF;
+ boolean hitbox = cfg.mode(Controle.HITBOX) != Mode.OFF;
+ if (!portee && !hitbox) return List.of();
+ Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
+ if (ex.exempt()) return List.of();
+ if (PorteeHitbox.raisonNonMesure(etat, vitesseCible, cfg) != null) return List.of();
+
+ Suivi s = suivi(joueur);
+ List verdicts = new ArrayList<>(2);
+ double lat = PorteeHitbox.toleranceLatence(vitesseCible, etat.pingMs(), cfg);
+ if (portee && distance >= 0) {
+ double seuil = PorteeHitbox.seuilPortee(porteeJoueur, lat, cfg, ex.facteur());
+ ajouter(verdicts, s, Controle.PORTEE, PorteeHitbox.pointsPortee(distance, seuil), nowMs, ex,
+ String.format(Locale.ROOT, "distance=%.2f (seuil %.2f, portee %.1f)", distance, seuil, porteeJoueur));
+ }
+ if (hitbox && manque >= 0) {
+ double seuil = PorteeHitbox.seuilHitbox(lat, cfg, ex.facteur());
+ ajouter(verdicts, s, Controle.HITBOX, PorteeHitbox.pointsHitbox(manque, seuil), nowMs, ex,
+ String.format(Locale.ROOT, "regard hors boite de %.2f (seuil %.2f)", manque, seuil));
+ }
+ for (Verdict v : verdicts) {
+ if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
+ s.coupsBloquesJusqua = nowMs + DUREE_BLOCAGE_COUPS_MS;
+ }
+ }
+ return verdicts;
+ }
+
+ /** Après une sanction portée / hitbox (ENFORCE), les coups sont annulés pendant cette durée. */
+ public static final long DUREE_BLOCAGE_COUPS_MS = 2000;
+
+ /**
+ * Mesure différée d'un coup (voir {@link CoupDiffere}) : la mesure est mise de côté et terminée au paquet de
+ * mouvement suivant ({@link #regardPorteeHitbox}). Un coup encore en attente est terminé ici.
+ *
+ * @param oeil position de l'œil vue par le serveur (x, y, z)
+ * @param regard direction du regard vue par le serveur
+ * @param boite boîte réelle de la cible (minX, minY, minZ, maxX, maxY, maxZ)
+ * @return les verdicts du coup précédent s'il était encore en attente
+ */
+ public List coupPorteeHitbox(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
+ double[] boite, double porteeJoueur, double vitesseCible) {
+ return coupDiffere(joueur, nowMs, etat, oeil, regard, boite, porteeJoueur, vitesseCible, true, false);
+ }
+
+ /**
+ * Mesure différée générale (16/10/2026) : portée / hitbox si {@code porteeHitbox}, angle killaura si
+ * {@code angle} (dans ce cas, {@link #attaque} doit recevoir -1 comme excédent pour ne pas le compter deux fois).
+ */
+ public List coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
+ double[] boite, double porteeJoueur, double vitesseCible,
+ boolean porteeHitbox, boolean angle) {
+ List verdicts = terminerCoup(joueur);
+ boolean ph = porteeHitbox
+ && (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
+ boolean an = angle && cfg.mode(Controle.KILLAURA_ANGLE) != Mode.OFF;
+ if (!ph && !an) return verdicts;
+ double ex = an ? KillauraAngle.excedentDegres(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
+ boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]) : -1;
+ if (an && ex < 0) ex = -1;
+ double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2],
+ boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
+ 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]);
+ suivi(joueur).coupDiffere = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
+ return verdicts;
+ }
+
+ /** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */
+ public List regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) {
+ Suivi s = suivis.get(joueur);
+ if (s == null || s.coupDiffere == null) return List.of();
+ if (s.coupDiffere.encoreValable(nowMs)) s.coupDiffere.affiner(oeil, regard);
+ return terminerCoup(joueur);
+ }
+
+ /** Termine le coup en attente (paquet suivant, coup suivant). */
+ public List terminerCoup(UUID joueur) {
+ Suivi s = suivis.get(joueur);
+ if (s == null || s.coupDiffere == null) return new ArrayList<>(0);
+ CoupDiffere c = s.coupDiffere;
+ s.coupDiffere = null;
+ List verdicts = new ArrayList<>(3);
+ // Vrille riptide : le coup part au contact (Player.doAutoAttackOnTouch), sans viser.
+ if (c.excedent >= 0 && !c.etat.riptide() && cfg.mode(Controle.KILLAURA_ANGLE) != Mode.OFF) {
+ Exemptions.Resultat ex = Exemptions.evaluer(c.etat, cfg, Exemptions.Famille.COMBAT);
+ if (!ex.exempt()) {
+ double seuil = cfg.angleMaxDegres * ex.facteur();
+ 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));
+ }
+ }
+ if (c.porteeHitbox) {
+ verdicts.addAll(porteeHitbox(joueur, c.nowMs, c.etat, c.distance, c.manque, c.porteeJoueur, c.vitesseCible));
+ }
+ for (Verdict v : verdicts) { // le coup est déjà passé : en ENFORCE, on annule les suivants
+ if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
+ s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS);
+ }
+ }
+ return verdicts;
+ }
+
+ /** Les coups de ce joueur sont-ils annulés (sanction portée / hitbox récente en ENFORCE) ? */
+ public boolean coupsBloques(UUID joueur, long nowMs) {
+ Suivi s = suivis.get(joueur);
+ return s != null && nowMs < s.coupsBloquesJusqua;
+ }
+
/**
* Un regard accepté (paquet de mouvement) : termine éventuellement un aller-retour de rotation autour d'un
* coup (F11). L'état du joueur n'est construit que si un aller-retour est vu.
@@ -196,8 +316,8 @@ public final class Moteur {
}
/**
- * Drapeau « au sol » à donner aux dégâts de chute : celui du serveur en ENFORCE (sauf exemption), celui du
- * client sinon.
+ * Drapeau « au sol » à donner aux dégâts de chute. Celui du serveur en ENFORCE (sauf exemption), celui du
+ * client sinon (OBSERVE, le défaut).
*/
public boolean auSolPourDegatsDeChute(EtatJoueur etat, boolean auSolClient, boolean auSolServeur) {
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
diff --git a/src/main/java/com/gastinelgarde/core/NoFall.java b/src/main/java/com/gastinelgarde/core/NoFall.java
index 63f67e3..771a6dd 100644
--- a/src/main/java/com/gastinelgarde/core/NoFall.java
+++ b/src/main/java/com/gastinelgarde/core/NoFall.java
@@ -5,7 +5,8 @@ package com.gastinelgarde.core;
* calcule lui-même s'il y a un bloc sous le joueur.
*
* Principe du plan : on corrige, on ne punit pas. En {@code ENFORCE}, le drapeau transmis aux dégâts de chute est
- * remplacé par celui du serveur ; en {@code OBSERVE}, rien n'est modifié et la divergence est seulement journalisée.
+ * remplacé par celui du serveur ; en {@code OBSERVE} (défaut), rien n'est modifié et la divergence est seulement
+ * journalisée.
*/
public final class NoFall {
diff --git a/src/main/java/com/gastinelgarde/core/PorteeHitbox.java b/src/main/java/com/gastinelgarde/core/PorteeHitbox.java
new file mode 100644
index 0000000..938c602
--- /dev/null
+++ b/src/main/java/com/gastinelgarde/core/PorteeHitbox.java
@@ -0,0 +1,129 @@
+package com.gastinelgarde.core;
+
+/**
+ * Contrôles portée et hitbox (géométrie pure), ajoutés après le test de Rednixxu (14/10/2026) : un cheat « hitbox »
+ * grossit côté client la boîte des cibles, ce qui permet de toucher sans viser la vraie boîte, et souvent de plus loin.
+ *
+ * Ce que vanilla fait déjà (1.21.1, ServerGamePacketListenerImpl.handleInteract) : un coup est refusé si la boîte
+ * de la cible est à plus de « portée d'interaction + 1,0 » de l'œil (3,0 + 1,0 = 4,0 blocs en survie). Le serveur
+ * laisse donc passer toute la bande 3,0 à 4,0 blocs, et ne regarde jamais si le regard touche la boîte.
+ *
+ * Ici, deux mesures sur les positions vues par le serveur :
+ *
+ * - portée : distance de l'œil au point le plus proche de la boîte réelle de la cible ;
+ * - hitbox : de combien il faudrait gonfler la boîte réelle pour que le rayon du regard la touche.
+ *
+ * La cible affichée chez le client a quelques ticks de retard : sa vitesse par tick, multipliée par ce retard,
+ * s'ajoute aux deux tolérances.
+ */
+public final class PorteeHitbox {
+
+ /** Gonflement maximal recherché (blocs) : au-delà, le manque est plafonné à cette valeur. */
+ public static final double MANQUE_MAX = 4.0;
+
+ private PorteeHitbox() { }
+
+ /** Distance de l'œil au point le plus proche de la boîte (0 si l'œil est dedans). */
+ public static double distanceOeilBoite(double ex, double ey, double ez,
+ double minX, double minY, double minZ,
+ double maxX, double maxY, double maxZ) {
+ double dx = ex < minX ? minX - ex : (ex > maxX ? ex - maxX : 0);
+ double dy = ey < minY ? minY - ey : (ey > maxY ? ey - maxY : 0);
+ double dz = ez < minZ ? minZ - ez : (ez > maxZ ? ez - maxZ : 0);
+ return Math.sqrt(dx * dx + dy * dy + dz * dz);
+ }
+
+ /**
+ * Gonflement minimal (blocs) de la boîte pour que le segment [œil, œil + regard × longueur] la touche.
+ * 0 si le regard touche déjà la boîte ; {@link #MANQUE_MAX} au plus.
+ */
+ public static double manqueRegard(double ex, double ey, double ez,
+ double lx, double ly, double lz, double longueur,
+ double minX, double minY, double minZ,
+ double maxX, double maxY, double maxZ) {
+ double n = Math.sqrt(lx * lx + ly * ly + lz * lz);
+ if (n < 1e-9) return 0;
+ double dx = lx / n * longueur, dy = ly / n * longueur, dz = lz / n * longueur;
+ if (touche(ex, ey, ez, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, 0)) return 0;
+ if (!touche(ex, ey, ez, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, MANQUE_MAX)) return MANQUE_MAX;
+ double bas = 0, haut = MANQUE_MAX;
+ for (int i = 0; i < 30; i++) { // précision ~4e-9 bloc
+ double mil = (bas + haut) / 2;
+ if (touche(ex, ey, ez, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, mil)) haut = mil;
+ else bas = mil;
+ }
+ return haut;
+ }
+
+ /** Test des plans (slabs) : le segment origine + t·d, t dans [0, 1], coupe-t-il la boîte gonflée de g ? */
+ static boolean touche(double ox, double oy, double oz, double dx, double dy, double dz,
+ double minX, double minY, double minZ, double maxX, double maxY, double maxZ, double g) {
+ double[] t = {0.0, 1.0};
+ return plan(ox, dx, minX - g, maxX + g, t) && plan(oy, dy, minY - g, maxY + g, t)
+ && plan(oz, dz, minZ - g, maxZ + g, t);
+ }
+
+ private static boolean plan(double o, double d, double min, double max, double[] t) {
+ if (Math.abs(d) < 1e-12) return o >= min && o <= max;
+ double t1 = (min - o) / d, t2 = (max - o) / d;
+ if (t1 > t2) { double x = t1; t1 = t2; t2 = x; }
+ t[0] = Math.max(t[0], t1);
+ t[1] = Math.min(t[1], t2);
+ return t[0] <= t[1];
+ }
+
+ /** Tolérance due au retard d'affichage de la cible : vitesse (blocs/tick) × ticks, plafonnée. */
+ public static double toleranceLatence(double vitesseCibleParTick, GardeConfig cfg) {
+ return toleranceLatence(vitesseCibleParTick, 0, cfg);
+ }
+
+ /**
+ * Idem avec le ping de l'attaquant : la cible qu'il voit a ping / 50 ticks de retard de plus (16/10/2026, ping
+ * élevé). Ping borné par {@link GardeConfig#pingLatenceMaxMs}, total plafonné : falsifier son ping ne donne
+ * jamais plus de {@link GardeConfig#latenceCibleMaxBlocs}, et vanilla refuse de toute façon au-delà de portée + 1.
+ */
+ public static double toleranceLatence(double vitesseCibleParTick, int pingMs, GardeConfig cfg) {
+ double ticks = Math.max(0, cfg.ticksLatenceCible)
+ + Math.min(Math.max(0, pingMs), Math.max(0, cfg.pingLatenceMaxMs)) / 50.0;
+ double v = Math.max(0, vitesseCibleParTick) * ticks;
+ return Math.min(v, cfg.latenceCibleMaxBlocs);
+ }
+
+ /**
+ * Situations où la géométrie du coup n'est pas fiable (16/10/2026) : vrille riptide (le coup part au contact,
+ * sans viser), élytres, téléportation récente (/tpa, réapparition, dimension, connexion), recul récent, cible
+ * trop rapide (le client l'affiche ailleurs). On ne mesure pas : ni point, ni sanction.
+ *
+ * @return la raison, ou null si la mesure est fiable
+ */
+ public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) {
+ if (e.riptide()) return "riptide";
+ if (e.elytres()) return "elytres";
+ if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) return "teleportation";
+ if (e.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul";
+ if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide";
+ return null;
+ }
+
+ /** Seuil de portée (blocs) : portée d'interaction du joueur + marge + latence, le tout × facteur de lag. */
+ public static double seuilPortee(double porteeJoueur, double latence, GardeConfig cfg, double facteur) {
+ return porteeJoueur + (cfg.porteeToleranceBlocs + latence) * facteur;
+ }
+
+ /** Seuil de hitbox (blocs). */
+ public static double seuilHitbox(double latence, GardeConfig cfg, double facteur) {
+ return (cfg.hitboxMargeBlocs + latence) * facteur;
+ }
+
+ /** Points de portée : 0 sous le seuil, puis 1 + 1 par demi-bloc d'excès, au plus 4. */
+ public static double pointsPortee(double distance, double seuil) {
+ if (!(distance > seuil)) return 0;
+ return 1.0 + Math.min(3.0, (distance - seuil) / 0.5);
+ }
+
+ /** Points de hitbox : 0 sous le seuil, puis 1 + 1 par 0,3 bloc d'excès, au plus 3. */
+ public static double pointsHitbox(double manque, double seuil) {
+ if (!(manque > seuil)) return 0;
+ return 1.0 + Math.min(2.0, (manque - seuil) / 0.3);
+ }
+}
diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java
index 586d03e..ffde619 100644
--- a/src/main/java/com/gastinelgarde/core/Suivi.java
+++ b/src/main/java/com/gastinelgarde/core/Suivi.java
@@ -15,6 +15,11 @@ public final class Suivi {
public final VolVertical vol = new VolVertical();
public final VehiculeMouvement vehicule = new VehiculeMouvement();
+ /** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
+ CoupDiffere coupDiffere;
+ /** Jusqu'à quand (ms) les coups sont annulés après une sanction portée / hitbox en ENFORCE. */
+ long coupsBloquesJusqua = Long.MIN_VALUE;
+
// Dernière position jugée valide (retour en arrière).
private boolean positionValide;
private double x, y, z;
diff --git a/src/main/java/com/gastinelgarde/mixin/MinecartPushMixin.java b/src/main/java/com/gastinelgarde/mixin/MinecartPushMixin.java
new file mode 100644
index 0000000..3607c89
--- /dev/null
+++ b/src/main/java/com/gastinelgarde/mixin/MinecartPushMixin.java
@@ -0,0 +1,29 @@
+package com.gastinelgarde.mixin;
+
+import com.gastinelgarde.GardeAntiCrash;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.vehicle.AbstractMinecart;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/**
+ * « Minecart Velocity Exploit » (16/10/2026) : des minecarts superposés se poussent mutuellement à chaque tick et
+ * leur vitesse croît exponentiellement (AbstractMinecart.push(Entity), vanilla 1.21.1 / NeoForge 21.1.234).
+ * Au-delà de empilementMax minecarts superposés, la poussée minecart-minecart est coupée ; après chaque poussée,
+ * les deux minecarts sont ramenés sous vitesseMaxMinecart (avant qu'un passager ne lance un projectile).
+ */
+@Mixin(AbstractMinecart.class)
+public abstract class MinecartPushMixin {
+
+ @Inject(method = "push(Lnet/minecraft/world/entity/Entity;)V", at = @At("HEAD"), cancellable = true)
+ private void gastinelgarde$couperEmpilement(Entity autre, CallbackInfo ci) {
+ if (GardeAntiCrash.couperPoussee((AbstractMinecart) (Object) this, autre)) ci.cancel();
+ }
+
+ @Inject(method = "push(Lnet/minecraft/world/entity/Entity;)V", at = @At("RETURN"))
+ private void gastinelgarde$plafonnerApresPoussee(Entity autre, CallbackInfo ci) {
+ GardeAntiCrash.apresPoussee((AbstractMinecart) (Object) this, autre);
+ }
+}
diff --git a/src/main/resources/gastinelgarde.mixins.json b/src/main/resources/gastinelgarde.mixins.json
index 5e51266..7896db0 100644
--- a/src/main/resources/gastinelgarde.mixins.json
+++ b/src/main/resources/gastinelgarde.mixins.json
@@ -3,6 +3,6 @@
"minVersion": "0.8",
"package": "com.gastinelgarde.mixin",
"compatibilityLevel": "JAVA_21",
- "mixins": ["MovePacketMixin", "RiptideMoveMixin"],
+ "mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin"],
"injectors": {"defaultRequire": 1}
}
diff --git a/src/test/java/com/gastinelgarde/MixinsAppliquesTest.java b/src/test/java/com/gastinelgarde/MixinsAppliquesTest.java
index 4ad287b..2549255 100644
--- a/src/test/java/com/gastinelgarde/MixinsAppliquesTest.java
+++ b/src/test/java/com/gastinelgarde/MixinsAppliquesTest.java
@@ -19,4 +19,12 @@ class MixinsAppliquesTest {
// Force le chargement complet (liaison) de la classe transformée.
c.getDeclaredMethods();
}
+
+ @Test
+ void leMixinDesMinecartsSApplique() throws Exception {
+ // MinecartPushMixin (16/10) : push(Entity) doit exister avec ce descripteur, sinon erreur ici.
+ Class> c = Class.forName("net.minecraft.world.entity.vehicle.AbstractMinecart", false, getClass().getClassLoader());
+ assertNotNull(c);
+ c.getDeclaredMethods();
+ }
}
diff --git a/src/test/java/com/gastinelgarde/core/AntiCrashEntitesTest.java b/src/test/java/com/gastinelgarde/core/AntiCrashEntitesTest.java
new file mode 100644
index 0000000..f3afce3
--- /dev/null
+++ b/src/test/java/com/gastinelgarde/core/AntiCrashEntitesTest.java
@@ -0,0 +1,217 @@
+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.assertTrue;
+
+import com.gastinelgarde.core.AntiCrashEntites.Action;
+import com.gastinelgarde.core.AntiCrashEntites.Bordure;
+import com.gastinelgarde.core.AntiCrashEntites.Decision;
+import com.gastinelgarde.core.AntiCrashEntites.Motif;
+import com.gastinelgarde.core.AntiCrashEntites.Reglages;
+import org.junit.jupiter.api.Test;
+
+/** Incident du 16/10/2026 : œuf à ~7e53 blocs/tick, génération de chunks à Z ≈ 2^31, serveur planté. */
+class AntiCrashEntitesTest {
+
+ private final Reglages r = new Reglages();
+ private final Bordure b = Bordure.VANILLA;
+
+ private Decision eval(double x, double y, double z, double vx, double vy, double vz, boolean protege) {
+ return AntiCrashEntites.evaluer(r, b, x, y, z, vx, vy, vz, protege);
+ }
+
+ @Test
+ void lesVitessesVanillaPassentSansRien() {
+ assertEquals(Action.RIEN, eval(3483, 108, -2412, 0, 0, 1.5, false).action()); // œuf / perle
+ assertEquals(Action.RIEN, eval(3483, 108, -2412, 0.4, -0.1, 3.15, false).action()); // flèche d'arbalète
+ assertEquals(Action.RIEN, eval(0, 64, 0, 2.0, 0, 0, false).action()); // bateau glace bleue
+ assertEquals(Action.RIEN, eval(0, 64, 0, 60, 20, 0, false).action()); // canon à TNT
+ assertEquals(Action.RIEN, eval(0, 64, 0, 0, 0, 0, false).action());
+ }
+
+ @Test
+ void lesOeufsDeLIncidentSontSupprimes() {
+ // Valeurs relevées dans latest.log (AABB de Sable) : 2,03e6 puis 1,5e7, 3,7e9, 5,2e8, 7,1e53 blocs/tick.
+ for (double vz : new double[] {2.03e6, 1.5e7, 3.67e9, 5.2e8, 7.1e53}) {
+ Decision d = eval(3483, 108, -2412, 0, 0, vz, false);
+ assertEquals(Action.SUPPRIMER, d.action(), "vz=" + vz);
+ assertEquals(Motif.VITESSE_EXTREME, d.motif());
+ }
+ // La commande de reproduction : /summon egg ~ ~ ~ {Motion:[0d,0d,1.0e8d]}
+ assertEquals(Action.SUPPRIMER, eval(0, 80, 0, 0, 0, 1.0e8, false).action());
+ }
+
+ @Test
+ void auDessusDuPlafondLaVitesseEstRameneeSansChangerDeDirection() {
+ Decision d = eval(0, 64, 0, 300, 0, 400, false); // 500 b/t : entre 100 et 1 000
+ assertEquals(Action.PLAFONNER, d.action());
+ assertEquals(Motif.VITESSE_EXCESSIVE, d.motif());
+ assertEquals(60, d.vx(), 1e-9);
+ assertEquals(80, d.vz(), 1e-9);
+ assertEquals(100, Math.sqrt(d.vx() * d.vx() + d.vy() * d.vy() + d.vz() * d.vz()), 1e-9);
+ assertEquals(500, d.vitesse(), 1e-9);
+ }
+
+ @Test
+ void nanEtInfiniSontSupprimes() {
+ assertEquals(Motif.VITESSE_NON_FINIE, eval(0, 64, 0, Double.NaN, 0, 0, false).motif());
+ assertEquals(Action.SUPPRIMER, eval(0, 64, 0, 0, Double.POSITIVE_INFINITY, 0, false).action());
+ assertEquals(Action.SUPPRIMER, eval(0, 64, 0, 0, 0, Double.NEGATIVE_INFINITY, false).action());
+ // Composantes finies dont la norme déborde (1e200² = infini).
+ assertEquals(Motif.VITESSE_NON_FINIE, eval(0, 64, 0, 1e200, 1e200, 0, false).motif());
+ assertEquals(Motif.POSITION_NON_FINIE, eval(Double.NaN, 64, 0, 0, 0, 0, false).motif());
+ assertEquals(Action.SUPPRIMER, eval(0, Double.POSITIVE_INFINITY, 0, 0, 0, 0, false).action());
+ }
+
+ @Test
+ void horsBordureOuTrajectoireHorsBordureSupprimee() {
+ // Le chunk qui a planté : (207, 134217720) → Z ≈ 2 147 483 520.
+ assertEquals(Motif.HORS_BORDURE, eval(3312, 108, 2_147_483_520.0, 0, 0, 0, false).motif());
+ assertEquals(Action.SUPPRIMER, eval(29_999_984 + 65, 64, 0, 0, 0, 0, false).action());
+ assertEquals(Action.RIEN, eval(29_999_984 + 10, 64, 0, 0, 0, 0, false).action()); // dans la marge (et sous 30 000 000)
+ assertEquals(Action.SUPPRIMER, eval(0, 25_000_000, 0, 0, 0, 0, false).action()); // limite verticale
+ // Dans la bordure mais le rayon de ce tick sort de bordure + marge.
+ Decision d = eval(29_999_950, 64, 0, 99, 0, 0, false);
+ assertEquals(Motif.TRAJECTOIRE_HORS_BORDURE, d.motif());
+ assertEquals(Action.SUPPRIMER, d.action());
+ // Après plafonnement aussi : 500 b/t ramené à 100, depuis 29 999 950 → 30 000 050 > bordure + 64.
+ assertEquals(Motif.TRAJECTOIRE_HORS_BORDURE, eval(29_999_950, 64, 0, 500, 0, 0, false).motif());
+ }
+
+ @Test
+ void bordureReduiteEtMargeConfigurable() {
+ Bordure petite = new Bordure(-5000, -5000, 5000, 5000);
+ assertEquals(Action.SUPPRIMER, AntiCrashEntites.evaluer(r, petite, 5100, 64, 0, 0, 0, 0, false).action());
+ r.margeBordure = 200;
+ assertEquals(Action.RIEN, AntiCrashEntites.evaluer(r, petite, 5100, 64, 0, 0, 0, 0, false).action());
+ // Pas de bordure fournie : seules les limites absolues comptent.
+ assertTrue(AntiCrashEntites.dansLimites(null, 0, 29_999_999, 0, 0));
+ assertFalse(AntiCrashEntites.dansLimites(null, 0, 30_000_001, 0, 0));
+ }
+
+ @Test
+ void entiteProtegeeJamaisSupprimeeSeulementArretee() {
+ // Contraption Create, entité sur un vaisseau Sable, minecart qui porte un joueur.
+ Decision d = eval(0, 64, 0, 0, 0, 1.0e8, true);
+ assertEquals(Action.ARRETER, d.action());
+ assertEquals(0, d.vz(), 0);
+ assertEquals(Action.ARRETER, eval(0, 64, 2.0e9, 0, 0, 0, true).action());
+ assertEquals(Action.ARRETER, eval(0, 64, 0, Double.NaN, 0, 0, true).action());
+ // Simplement trop rapide : plafonnée comme les autres (pas arrêtée).
+ assertEquals(Action.PLAFONNER, eval(0, 64, 0, 0, 0, 150, true).action());
+ // Un train Create à pleine vitesse (~1-2 b/t) : rien.
+ assertEquals(Action.RIEN, eval(1000, 70, 1000, 1.6, 0, 0.5, true).action());
+ }
+
+ @Test
+ void minecartRapidePuisProjectileLanceDepuisLui() {
+ // Minecart à 1e8 b/t (Motion forcée) : supprimé avant de bouger ; avec un joueur dedans : arrêté.
+ assertEquals(Action.SUPPRIMER, eval(0, 64, 0, 1.0e8, 0, 0, false).action());
+ assertEquals(Action.ARRETER, eval(0, 64, 0, 1.0e8, 0, 0, true).action());
+ // L'œuf hérite de la vitesse connue du lanceur (Projectile.shootFromRotation) : 1,5 + 2e6.
+ assertEquals(Action.SUPPRIMER, eval(0, 65, 0, 2.0e6 + 1.5, 0, 0, false).action());
+ // Héritage modéré (minecart vanilla 0,4 b/t, ou même 8 b/t sur rails modés) : rien.
+ assertEquals(Action.RIEN, eval(0, 65, 0, 8 + 1.5, 0, 0, false).action());
+ }
+
+ @Test
+ void desactivableEtReglable() {
+ r.actif = false;
+ assertEquals(Action.RIEN, eval(0, 64, 0, 0, 0, 1.0e53, false).action());
+ assertEquals(Action.RIEN, AntiCrashEntites.evaluer(null, b, 0, 64, 0, 0, 0, 1.0e53, false).action());
+ r.actif = true;
+ r.vitesseMax = 10;
+ r.facteurSuppression = 1; // tout dépassement supprime
+ assertEquals(Action.SUPPRIMER, eval(0, 64, 0, 11, 0, 0, false).action());
+ assertEquals(Action.RIEN, eval(0, 64, 0, 10, 0, 0, false).action());
+ }
+
+ @Test
+ void limiteurDAlertes() {
+ AntiCrashEntites.LimiteurAlertes l = new AntiCrashEntites.LimiteurAlertes(5, 10_000);
+ for (int i = 0; i < 5; i++) assertTrue(l.autoriser(1000));
+ assertFalse(l.autoriser(1000));
+ assertFalse(l.autoriser(9000));
+ assertEquals(2, l.masqueesDepuis());
+ assertEquals(0, l.masqueesDepuis());
+ assertTrue(l.autoriser(11_000)); // nouvelle fenêtre
+ }
+
+ // --- Empilement de minecarts (précision de Théo, 16/10) ----------------------------------------------------
+
+ /** Poussées vanilla (AbstractMinecart.push, cas non motorisé) dans une pile de n minecarts alignés sur l'axe X. */
+ private static double[] tickPile(double[] v, double plafond) {
+ int n = v.length;
+ for (int a = 0; a < n; a++) {
+ for (int b = 0; b < n; b++) {
+ if (a == b) continue;
+ double d0 = (b > a ? 1 : -1) * 0.05; // direction normalisée × 0,1 × 0,5 (écart ≥ 1)
+ double moy = (v[a] + v[b]) / 2.0;
+ v[a] = v[a] * 0.2 + (moy - d0);
+ v[b] = v[b] * 0.2 + (moy + d0);
+ if (plafond > 0) {
+ double[] pa = AntiCrashEntites.plafonner(v[a], 0, 0, plafond);
+ if (pa != null) v[a] = pa[0];
+ double[] pb = AntiCrashEntites.plafonner(v[b], 0, 0, plafond);
+ if (pb != null) v[b] = pb[0];
+ }
+ }
+ }
+ return v;
+ }
+
+ @Test
+ void laPileDeMinecartsDivergeSansParadeEtResteBorneeAvec() {
+ double[] libre = new double[10];
+ libre[0] = 0.1;
+ double max = 0;
+ for (int t = 0; t < 40; t++) {
+ tickPile(libre, 0);
+ for (double x : libre) max = Math.max(max, Math.abs(x));
+ }
+ assertTrue(max > 1e6 || !Double.isFinite(max), "croissance attendue, max=" + max);
+
+ double[] borne = new double[10];
+ borne[0] = 0.1;
+ for (int t = 0; t < 40; t++) tickPile(borne, r.vitesseMaxMinecart);
+ for (double x : borne) assertTrue(Math.abs(x) <= r.vitesseMaxMinecart + 1e-9);
+ }
+
+ @Test
+ void plafondMinecartEtPlafondProjectile() {
+ // Minecart à 50 b/t : ramené à 3 (plafond propre), un bateau au même 50 b/t passe (plafond 100).
+ Decision m = AntiCrashEntites.evaluer(r, b, 0, 64, 0, 50, 0, 0, false, r.vitesseMaxMinecart);
+ assertEquals(Action.PLAFONNER, m.action());
+ assertEquals(3.0, m.vx(), 1e-9);
+ assertEquals(Action.RIEN, eval(0, 64, 0, 50, 0, 0, false).action());
+ // Minecart à pleine vitesse vanilla (2,0 au plus après moveAlongTrack) : rien.
+ assertEquals(Action.RIEN, AntiCrashEntites.evaluer(r, b, 0, 64, 0, 2.0, 0, 0, false, r.vitesseMaxMinecart).action());
+ // Minecart avec un joueur à 1e9 : arrêté, jamais supprimé.
+ assertEquals(Action.ARRETER, AntiCrashEntites.evaluer(r, b, 0, 64, 0, 1e9, 0, 0, true, r.vitesseMaxMinecart).action());
+ // Œuf lancé depuis un minecart : vitesse propre 1,5 + héritée ; au-delà de 100 ramené à 100, au-delà de 1 000 supprimé.
+ assertEquals(Action.PLAFONNER, eval(0, 65, 0, 1.5 + 400, 0, 0, false).action());
+ assertEquals(Action.SUPPRIMER, eval(0, 65, 0, 1.5 + 2.1e9, 0, 0, false).action());
+ // Le plafond propre ne peut pas dépasser vitesseMax.
+ r.vitesseMaxMinecart = 500;
+ assertEquals(100.0, AntiCrashEntites.evaluer(r, b, 0, 64, 0, 300, 0, 0, false, r.vitesseMaxMinecart).vx(), 1e-9);
+ }
+
+ @Test
+ void plafonnerVecteurEtEmpilement() {
+ assertEquals(null, AntiCrashEntites.plafonner(1, 1, 1, 3));
+ double[] p = AntiCrashEntites.plafonner(0, 30, 40, 5);
+ assertEquals(3.0, p[1], 1e-9);
+ assertEquals(4.0, p[2], 1e-9);
+ assertEquals(0.0, AntiCrashEntites.plafonner(Double.NaN, 0, 0, 3)[0], 0);
+ assertEquals(0.0, AntiCrashEntites.plafonner(1e200, 1e200, 0, 3)[0], 0);
+ assertFalse(AntiCrashEntites.empilementExcessif(4, r));
+ assertTrue(AntiCrashEntites.empilementExcessif(5, r));
+ assertTrue(AntiCrashEntites.empilementExcessif(15, r));
+ r.empilementMax = 0; // désactivé
+ assertFalse(AntiCrashEntites.empilementExcessif(15, r));
+ r.empilementMax = 4;
+ r.actif = false;
+ assertFalse(AntiCrashEntites.empilementExcessif(15, r));
+ }
+}
diff --git a/src/test/java/com/gastinelgarde/core/Garde1015Test.java b/src/test/java/com/gastinelgarde/core/Garde1015Test.java
new file mode 100644
index 0000000..8c65523
--- /dev/null
+++ b/src/test/java/com/gastinelgarde/core/Garde1015Test.java
@@ -0,0 +1,263 @@
+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.assertTrue;
+
+import java.util.List;
+import java.util.UUID;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/** 15/10/2026 : classes de contraption, portée / hitbox, contrôles 6 à 8 en observation seulement. */
+class Garde1015Test {
+
+ private GardeConfig cfg;
+ private Moteur moteur;
+ private final UUID joueur = UUID.randomUUID();
+
+ @BeforeEach
+ void init() {
+ cfg = new GardeConfig();
+ moteur = new Moteur(cfg);
+ }
+
+ // --- Contraptions (chaînes de classes relevées par javap dans les jars du serveur) ----------------------
+
+ private static final List DEFAUT = DetectionContraption.motifs(DetectionContraption.MOTIFS_DEFAUT);
+ private static final String ABSTRAITE = "com.simibubi.create.content.contraptions.AbstractContraptionEntity";
+
+ @Test
+ void contraptionsCreateEtAeronauticsReconnues() {
+ assertTrue(DetectionContraption.correspond(List.of(
+ "dev.eriksonn.aeronautics.content.blocks.propeller.bearing.contraption.PropellerBearingContraptionEntity",
+ "com.simibubi.create.content.contraptions.ControlledContraptionEntity", ABSTRAITE), DEFAUT));
+ assertTrue(DetectionContraption.correspond(List.of(
+ "dev.ryanhcode.offroad.content.entities.BoreheadContraptionEntity",
+ "com.simibubi.create.content.contraptions.ControlledContraptionEntity", ABSTRAITE), DEFAUT));
+ // Les trains : hors du paquet « contraptions », manqués par l'ancien réglage par préfixe.
+ assertTrue(DetectionContraption.correspond(List.of(
+ "com.simibubi.create.content.trains.entity.CarriageContraptionEntity",
+ "com.simibubi.create.content.contraptions.OrientedContraptionEntity", ABSTRAITE), DEFAUT));
+ assertTrue(DetectionContraption.correspond(List.of(
+ "com.simibubi.create.content.contraptions.gantry.GantryContraptionEntity", ABSTRAITE), DEFAUT));
+ }
+
+ @Test
+ void entitesImmobilesNonReconnues() {
+ assertFalse(DetectionContraption.correspond(List.of("com.simibubi.create.content.contraptions.glue.SuperGlueEntity"), DEFAUT));
+ assertFalse(DetectionContraption.correspond(List.of("com.simibubi.create.content.contraptions.actors.seat.SeatEntity"), DEFAUT));
+ assertFalse(DetectionContraption.correspond(List.of("dev.eriksonn.aeronautics.content.blocks.hot_air.gust.GustEntity"), DEFAUT));
+ assertFalse(DetectionContraption.correspond(List.of("dev.simulated_team.simulated.content.entities.honey_glue.HoneyGlueEntity"), DEFAUT));
+ assertFalse(DetectionContraption.correspond(List.of("net.minecraft.world.entity.animal.Pig"), DEFAUT));
+ }
+
+ @Test
+ void ancienReglageParPaquetToujoursCompris() {
+ List ancien = DetectionContraption.motifs("com.simibubi.create.content.contraptions, dev.ryanhcode, x.y.*");
+ assertTrue(DetectionContraption.correspond(List.of("com.simibubi.create.content.contraptions.glue.SuperGlueEntity"), ancien));
+ assertTrue(DetectionContraption.correspond(List.of("dev.ryanhcode.offroad.content.entities.BoreheadContraptionEntity"), ancien));
+ assertTrue(DetectionContraption.correspond(List.of("x.y.Truc"), ancien));
+ assertFalse(DetectionContraption.correspond(List.of("x.yz.Truc"), ancien));
+ // Pas de fausse correspondance sur un paquet voisin
+ assertFalse(DetectionContraption.correspond(List.of("dev.ryanhcodeX.Truc"), ancien));
+ // Un nom de classe exact couvre ses classes internes, pas un nom plus long
+ assertTrue(DetectionContraption.correspond(List.of(ABSTRAITE + "$Interne"), DEFAUT));
+ assertFalse(DetectionContraption.correspond(List.of(ABSTRAITE + "Bis"), DEFAUT));
+ assertTrue(DetectionContraption.motifs(" , ").isEmpty());
+ }
+
+ @Test
+ void graceApresContraption() {
+ assertFalse(DetectionContraption.dansLaGrace(100, Integer.MIN_VALUE, 40));
+ assertTrue(DetectionContraption.dansLaGrace(100, 60, 40));
+ assertFalse(DetectionContraption.dansLaGrace(101, 60, 40));
+ assertFalse(DetectionContraption.dansLaGrace(10, 60, 40)); // compteur de ticks revenu en arrière
+ }
+
+ // --- Géométrie portée / hitbox -----------------------------------------------------------------------
+
+ /** Boîte de joueur (0,6 × 1,8) centrée en (x, 0, z). */
+ private static double[] joueurEn(double x, double z) {
+ return new double[] {x - 0.3, 0, z - 0.3, x + 0.3, 1.8, z + 0.3};
+ }
+
+ private static double distance(double[] b) {
+ return PorteeHitbox.distanceOeilBoite(0, 1.62, 0, b[0], b[1], b[2], b[3], b[4], b[5]);
+ }
+
+ private static double manque(double lx, double ly, double lz, double longueur, double[] b) {
+ return PorteeHitbox.manqueRegard(0, 1.62, 0, lx, ly, lz, longueur, b[0], b[1], b[2], b[3], b[4], b[5]);
+ }
+
+ @Test
+ void distanceAuPointLePlusProche() {
+ assertEquals(3.2, distance(joueurEn(3.5, 0)), 1e-9);
+ assertEquals(0.0, distance(new double[] {-1, 0, -1, 1, 2, 1}), 1e-9); // œil dedans
+ assertEquals(Math.sqrt(2) * 2.7, distance(joueurEn(3, 3)), 1e-9);
+ }
+
+ @Test
+ void manqueDuRegard() {
+ double[] b = joueurEn(2.3, 0); // boîte x 2,0 à 2,6
+ assertEquals(0.0, manque(1, 0, 0, 4, b), 1e-9); // regard droit dessus
+ assertEquals(0.0, manque(1, -0.1, 0.05, 4, b), 1e-9); // un peu de biais, touche encore
+ // Regard le long de z : il faut gonfler la boîte de 2,0 en x pour toucher.
+ assertEquals(2.0, manque(0, 0, 1, 4, b), 1e-6);
+ // Regard droit dessus mais trop court : il manque 0,5 bloc au bout.
+ assertEquals(0.5, manque(1, 0, 0, 1.5, b), 1e-6);
+ // Regard à l'opposé : il faut gonfler jusqu'à englober l'œil (2,0).
+ assertEquals(2.0, manque(-1, 0, 0, 4, b), 1e-6);
+ // Très loin et à l'opposé : plafonné.
+ assertEquals(PorteeHitbox.MANQUE_MAX, manque(-1, 0, 0, 4, joueurEn(20.3, 0)), 1e-9);
+ // Regard nul : rien à mesurer
+ assertEquals(0.0, manque(0, 0, 0, 4, b), 1e-9);
+ }
+
+ @Test
+ void hitboxGonfleeDeTroisDixiemes() {
+ // Cible à 2,5 blocs, regard qui passe 0,3 bloc à côté de la boîte (cas d'un cheat hitbox +0,3) :
+ // le rayon le long de x à z = 0,6 manque une boîte z -0,3..0,3 de 0,3.
+ double[] b = joueurEn(2.8, 0);
+ double m = PorteeHitbox.manqueRegard(0, 1.62, 0.6, 1, 0, 0, 4, b[0], b[1], b[2], b[3], b[4], b[5]);
+ assertEquals(0.3, m, 1e-6);
+ }
+
+ @Test
+ void tolerancesEtPoints() {
+ assertEquals(0.0, PorteeHitbox.toleranceLatence(0, cfg), 1e-9);
+ assertEquals(0.84, PorteeHitbox.toleranceLatence(0.28, cfg), 1e-9); // sprint × 3 ticks
+ assertEquals(1.0, PorteeHitbox.toleranceLatence(5, cfg), 1e-9); // plafond
+ assertEquals(3.3, PorteeHitbox.seuilPortee(3.0, 0, cfg, 1.0), 1e-9);
+ assertEquals(0.0, PorteeHitbox.pointsPortee(3.3, 3.3), 1e-9);
+ assertEquals(2.0, PorteeHitbox.pointsPortee(3.8, 3.3), 1e-9);
+ assertEquals(4.0, PorteeHitbox.pointsPortee(9, 3.3), 1e-9);
+ assertEquals(0.0, PorteeHitbox.pointsPortee(Double.NaN, 3.3), 1e-9);
+ assertEquals(0.0, PorteeHitbox.pointsHitbox(0.25, 0.25), 1e-9);
+ assertEquals(2.0, PorteeHitbox.pointsHitbox(0.55, 0.25), 1e-9);
+ assertEquals(3.0, PorteeHitbox.pointsHitbox(4, 0.25), 1e-9);
+ }
+
+ // --- Moteur : portée / hitbox ------------------------------------------------------------------------
+
+ @Test
+ void coupHonneteSansVerdict() {
+ assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 2.9, 0.0, 3.0, 0.0).isEmpty());
+ assertTrue(moteur.porteeHitbox(joueur, 50, EtatJoueur.normal(), 3.25, 0.2, 3.0, 0.0).isEmpty());
+ }
+
+ @Test
+ void porteeEtHitboxEnObservation() {
+ List v = moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.7, 0.6, 3.0, 0.0);
+ assertEquals(2, v.size());
+ assertEquals(Controle.PORTEE, v.get(0).controle());
+ assertEquals(Controle.HITBOX, v.get(1).controle());
+ for (Verdict x : v) assertEquals(Mode.OBSERVE, x.mode());
+ }
+
+ @Test
+ void cibleRapideToleree() {
+ // Cible qui sprinte (0,28 bloc/tick) : 0,84 bloc de plus sur les deux seuils.
+ assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.9, 0.9, 3.0, 0.28).isEmpty());
+ }
+
+ @Test
+ void exemptionsEtLag() {
+ assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().creatif(true).build(), 4.9, 2, 5.0, 0).isEmpty());
+ assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().pocheContraption(true).build(), 3.9, 2, 3.0, 0).isEmpty());
+ assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().enVehicule(true).build(), 3.9, 2, 3.0, 0).isEmpty());
+ // Serveur à 15 TPS : marges × 1,5 → portée 3,45, hitbox 0,375
+ EtatJoueur lag = EtatJoueur.builder().tps(15).build();
+ assertTrue(moteur.porteeHitbox(joueur, 0, lag, 3.4, 0.35, 3.0, 0).isEmpty());
+ }
+
+ @Test
+ void porteeEtHitboxCoupables() {
+ cfg.mode(Controle.PORTEE, Mode.OFF);
+ cfg.mode(Controle.HITBOX, Mode.OFF);
+ assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.9, 2, 3.0, 0).isEmpty());
+ cfg.mode(Controle.HITBOX, Mode.ENFORCE); // OBSERVE par défaut, ENFORCE possible
+ assertEquals(Mode.ENFORCE, cfg.mode(Controle.HITBOX));
+ List v = moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.9, 2, 3.0, 0);
+ assertEquals(1, v.size());
+ assertEquals(Controle.HITBOX, v.get(0).controle());
+ }
+
+ // --- Modes : OBSERVE par défaut partout, ENFORCE possible partout (correction du 16/10) -------------
+
+ @Test
+ void enforcePossiblePourTousLesControles() {
+ for (Controle c : Controle.values()) {
+ assertEquals(Mode.OBSERVE, cfg.mode(c), c.id());
+ cfg.mode(c, Mode.ENFORCE);
+ assertEquals(Mode.ENFORCE, cfg.mode(c), c.id());
+ cfg.mode(c, Mode.OFF);
+ assertEquals(Mode.OFF, cfg.mode(c), c.id());
+ }
+ for (Controle c : new Controle[] {Controle.NO_FALL, Controle.VITESSE, Controle.VOL,
+ Controle.PORTEE, Controle.HITBOX}) {
+ assertTrue(c.observeParDefaut(), c.id());
+ }
+ assertFalse(Controle.CADENCE.observeParDefaut());
+ }
+
+ @Test
+ void noFallEnforceCorrigeLeDrapeauAuSol() {
+ cfg.mode(Controle.NO_FALL, Mode.ENFORCE);
+ assertFalse(moteur.auSolPourDegatsDeChute(EtatJoueur.normal(), true, false));
+ assertTrue(moteur.auSolPourDegatsDeChute(EtatJoueur.normal(), true, true));
+ }
+
+ private static EtatMouvement mvt(double dxz, double dy, boolean solClient, boolean solServeur) {
+ return new EtatMouvement(dxz, dy, 1, solClient, solServeur, false, false, false, 0, 0, false, false);
+ }
+
+ /**
+ * Triche continue 30 s. En OBSERVE (défaut) : des verdicts, un VL qui dépasse l'expulsion, jamais plus qu'une
+ * alerte. En ENFORCE : la sanction devient applicable (comportement de d0c001d).
+ */
+ private void triche(Controle attendu, EtatMouvement m, Mode mode) {
+ if (mode == Mode.ENFORCE) cfg.mode(attendu, Mode.ENFORCE);
+ boolean vu = false;
+ double vlMax = 0;
+ Sanction max = Sanction.AUCUNE;
+ for (int i = 0; i < 600; i++) {
+ for (Verdict v : moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), m)) {
+ if (v.controle() != attendu) continue;
+ assertEquals(mode, v.mode());
+ vu = true;
+ vlMax = Math.max(vlMax, v.vl());
+ if (v.applicable().ordinal() > max.ordinal()) max = v.applicable();
+ }
+ }
+ assertTrue(vu, attendu.id());
+ assertTrue(vlMax >= cfg.seuilExpulsion, attendu.id() + " vl=" + vlMax);
+ if (mode == Mode.OBSERVE) assertTrue(max.ordinal() <= Sanction.ALERTE.ordinal(), attendu.id() + " " + max);
+ else assertTrue(max.ordinal() > Sanction.ALERTE.ordinal(), attendu.id() + " " + max);
+ }
+
+ @Test
+ void noFallJournaliseSansSanctionParDefaut() {
+ triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.OBSERVE);
+ assertTrue(moteur.auSolPourDegatsDeChute(EtatJoueur.normal(), true, false)); // drapeau client gardé
+ }
+
+ @Test
+ void vitesseJournaliseeSansSanctionParDefaut() {
+ triche(Controle.VITESSE, mvt(1.5, 0, true, true), Mode.OBSERVE);
+ }
+
+ @Test
+ void volJournaliseSansSanctionParDefaut() {
+ triche(Controle.VOL, mvt(0, 0.0, false, false), Mode.OBSERVE);
+ }
+
+ @Test
+ void noFallVitesseVolSanctionnesEnEnforce() {
+ triche(Controle.VITESSE, mvt(1.5, 0, true, true), Mode.ENFORCE);
+ init();
+ triche(Controle.VOL, mvt(0, 0.0, false, false), Mode.ENFORCE);
+ init();
+ triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.ENFORCE);
+ }
+}
diff --git a/src/test/java/com/gastinelgarde/core/Garde1016Test.java b/src/test/java/com/gastinelgarde/core/Garde1016Test.java
new file mode 100644
index 0000000..91fd5af
--- /dev/null
+++ b/src/test/java/com/gastinelgarde/core/Garde1016Test.java
@@ -0,0 +1,257 @@
+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 java.util.List;
+import java.util.UUID;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * 16/10/2026 : riptide (délégué par GastinelClaims 1.1.7) avec ENFORCE rétabli, et faux positifs prévisibles de
+ * portée / hitbox (ping, rotation en retard d'un tick, élytres, riptide, téléportation, recul, cible rapide).
+ */
+class Garde1016Test {
+
+ private GardeConfig cfg;
+ private Moteur moteur;
+ private final UUID joueur = UUID.randomUUID();
+
+ @BeforeEach
+ void init() {
+ cfg = new GardeConfig();
+ moteur = new Moteur(cfg);
+ }
+
+ // --- Riptide ------------------------------------------------------------------------------------------
+
+ @Test
+ void riptideReleveLeSeuilVanillaPendantLaVrilleEtDeuxSecondesApres() {
+ RiptideSuivi r = new RiptideSuivi();
+ assertEquals(100f, r.seuil(100f, 0, false), 0f); // jamais de vrille : vanilla
+ r.observer(10, true);
+ assertEquals(RiptideTolerance.SEUIL_RIPTIDE, r.seuil(100f, 10, true), 0f);
+ assertEquals(RiptideTolerance.SEUIL_RIPTIDE, r.seuil(100f, 10 + RiptideTolerance.GRACE_TICKS, false), 0f);
+ assertEquals(100f, r.seuil(100f, 11 + RiptideTolerance.GRACE_TICKS, false), 0f);
+ // Seuil élytres (300) relevé aussi pendant la vrille.
+ assertEquals(RiptideTolerance.SEUIL_RIPTIDE, r.seuil(300f, 10, true), 0f);
+ }
+
+ @Test
+ void riptideEnchaineSousLaPluieSansRetourEnArriere() {
+ // Enchaînement de 5 riptides (relâchement toutes les 15 ticks) : le seuil reste relevé sans interruption.
+ RiptideSuivi r = new RiptideSuivi();
+ for (int t = 0; t < 75; t++) {
+ if (t % 15 == 0) assertTrue(r.relache(t, true, 12, true, true));
+ r.observer(t, t % 15 < 8);
+ assertEquals(RiptideTolerance.SEUIL_RIPTIDE, r.seuil(100f, t, t % 15 < 8), 0f, "tick " + t);
+ }
+ }
+
+ @Test
+ void tenirOuChargerTropPeuLeTridentNeReleveRien() {
+ RiptideSuivi r = new RiptideSuivi();
+ assertFalse(r.relache(0, false, 30, true, true)); // pas Impulsion
+ assertFalse(r.relache(0, true, RiptideSuivi.CHARGE_MIN_TICKS - 1, true, true)); // charge trop courte
+ assertFalse(r.relache(0, true, 30, false, false)); // sec, sous un toit
+ assertEquals(100f, r.seuil(100f, 1, false), 0f);
+ }
+
+ @Test
+ void riptideExempteLeMouvementMemeEnEnforce() {
+ for (Controle c : Controle.values()) cfg.mode(c, Mode.ENFORCE);
+ EtatJoueur vrille = EtatJoueur.builder().riptide(true).build();
+ EtatMouvement saut = new EtatMouvement(60, 8, 1, false, false, false, false, false, 0, 0, false, false);
+ for (int i = 0; i < 200; i++) {
+ assertTrue(moteur.mouvement(joueur, i * 50L, vrille, saut).isEmpty());
+ }
+ // Atterrissage en vrille : le drapeau « au sol » du client est gardé (pas de dégâts de chute ajoutés).
+ assertTrue(moteur.auSolPourDegatsDeChute(vrille, true, false));
+ // Sans riptide, en ENFORCE, ce même mouvement est sanctionné.
+ Sanction max = Sanction.AUCUNE;
+ for (int i = 0; i < 200; i++) {
+ for (Verdict v : moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), saut)) {
+ if (v.applicable().ordinal() > max.ordinal()) max = v.applicable();
+ }
+ }
+ assertTrue(max.ordinal() >= Sanction.SETBACK.ordinal(), max.toString());
+ }
+
+ // --- Portée / hitbox : géométrie de test ----------------------------------------------------------------
+
+ /** Cible de 0,6 × 1,8 à 3 blocs devant l'œil (axe +z). */
+ private static final double[] BOITE = {0.0, 0.0, 3.0, 0.6, 1.8, 3.6};
+ private static final double[] OEIL = {0.3, 1.62, 0.0};
+ private static final double[] VERS_CIBLE = {0, 0, 1};
+ private static final double[] A_COTE = {1, 0, 0.2};
+
+ private static boolean contient(List v, Controle c) {
+ return v.stream().anyMatch(x -> x.controle() == c);
+ }
+
+ @Test
+ void regardEnRetardDUnTickPasDeFauxPositif() {
+ // Au coup, le serveur a encore le regard du tick précédent (à côté) ; le paquet suivant vise la cible.
+ assertTrue(moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0).isEmpty());
+ assertTrue(moteur.regardPorteeHitbox(joueur, 1000, OEIL, VERS_CIBLE).isEmpty());
+ }
+
+ @Test
+ void regardAcoteAuCoupEtApresEstSignale() {
+ moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
+ assertTrue(contient(moteur.regardPorteeHitbox(joueur, 1050, OEIL, A_COTE), Controle.HITBOX));
+ }
+
+ @Test
+ void paquetTropTardifNeBlanchitPasLeCoup() {
+ moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
+ // Plus de 2 ticks sans paquet : le regard n'avait pas changé, la mesure du coup reste.
+ assertTrue(contient(moteur.regardPorteeHitbox(joueur, 1000 + 50 * 3, OEIL, VERS_CIBLE), Controle.HITBOX));
+ }
+
+ @Test
+ void coupSuivantTermineLeCoupEnAttente() {
+ moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
+ List v = moteur.coupPorteeHitbox(joueur, 1500, EtatJoueur.normal(), OEIL, VERS_CIBLE, BOITE, 3.0, 0);
+ assertTrue(contient(v, Controle.HITBOX));
+ assertTrue(moteur.regardPorteeHitbox(joueur, 1500, OEIL, VERS_CIBLE).isEmpty());
+ }
+
+ @Test
+ void oeilEnRetardSprintPotionGlacePasDeFauxPositif() {
+ // Au coup, l'œil connu du serveur est 0,8 bloc en arrière (sprint-saut sous Vitesse II, glace) :
+ // 3,8 blocs. Le paquet suivant le place à 3,0.
+ double[] oeilAncien = {0.3, 1.62, -0.8};
+ moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), oeilAncien, VERS_CIBLE, BOITE, 3.0, 0);
+ assertTrue(moteur.regardPorteeHitbox(joueur, 1000, OEIL, VERS_CIBLE).isEmpty());
+ // Un vrai coup à 3,8 blocs, sans rapprochement ensuite, reste signalé.
+ moteur.coupPorteeHitbox(joueur, 2000, EtatJoueur.normal(), oeilAncien, VERS_CIBLE, BOITE, 3.0, 0);
+ assertTrue(contient(moteur.regardPorteeHitbox(joueur, 2000, oeilAncien, VERS_CIBLE), Controle.PORTEE));
+ }
+
+ @Test
+ void pingEleveElargitLaToleranceMaisPlafonnee() {
+ assertEquals(0.3, PorteeHitbox.toleranceLatence(0.1, 0, cfg), 1e-9);
+ assertEquals(0.8, PorteeHitbox.toleranceLatence(0.1, 250, cfg), 1e-9);
+ assertEquals(0.9, PorteeHitbox.toleranceLatence(0.1, 5000, cfg), 1e-9); // ping falsifié : borné à 300 ms
+ assertEquals(1.0, PorteeHitbox.toleranceLatence(0.5, 5000, cfg), 1e-9); // plafond total
+ // Cible qui recule à 0,1 bloc/tick, coup à 3,9 : signalé à 0 ms de ping, pas à 250 ms.
+ assertTrue(contient(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().pingMs(0).build(),
+ 3.9, 0, 3.0, 0.1), Controle.PORTEE));
+ assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().pingMs(250).build(),
+ 3.9, 0, 3.0, 0.1).isEmpty());
+ }
+
+ @Test
+ void situationsNonMesurees() {
+ for (Controle c : Controle.values()) cfg.mode(c, Mode.ENFORCE);
+ EtatJoueur[] etats = {
+ EtatJoueur.builder().riptide(true).build(), // trident : coup au contact de la vrille
+ EtatJoueur.builder().elytres(true).build(),
+ EtatJoueur.builder().ticksDepuisTeleport(5).build(), // /tpa, réapparition, dimension, connexion
+ EtatJoueur.builder().ticksDepuisRecul(3).build(), // knockback
+ };
+ for (EtatJoueur e : etats) {
+ assertTrue(moteur.porteeHitbox(joueur, 0, e, 3.95, 3.0, 3.0, 0).isEmpty(), e.toString());
+ moteur.coupPorteeHitbox(joueur, 0, e, OEIL, A_COTE, BOITE, 3.0, 0);
+ assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, A_COTE).isEmpty(), e.toString());
+ }
+ // Cible très rapide (élytres, cible repoussée, cible téléportée) : non mesurée.
+ assertEquals("cible-rapide", PorteeHitbox.raisonNonMesure(EtatJoueur.normal(), 1.6, cfg));
+ assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.95, 3.0, 3.0, 1.6).isEmpty());
+ assertNull(PorteeHitbox.raisonNonMesure(EtatJoueur.normal(), 0.3, cfg));
+ // Après la grâce : de nouveau mesuré.
+ assertFalse(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().ticksDepuisTeleport(200).build(),
+ 3.95, 3.0, 3.0, 0).isEmpty());
+ }
+
+ @Test
+ void contraptionOuVehiculeDeLAttaquantExempte() {
+ moteur.coupPorteeHitbox(joueur, 0, EtatJoueur.builder().pocheContraption(true).build(), OEIL, A_COTE, BOITE, 3.0, 0);
+ assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, A_COTE).isEmpty());
+ }
+
+ @Test
+ void observeParDefautJamaisDeBlocage() {
+ for (int i = 0; i < 40; i++) {
+ moteur.coupPorteeHitbox(joueur, i * 100L, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
+ for (Verdict v : moteur.regardPorteeHitbox(joueur, i * 100L, OEIL, A_COTE)) {
+ assertEquals(Mode.OBSERVE, v.mode());
+ assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal());
+ }
+ }
+ assertFalse(moteur.coupsBloques(joueur, 4000));
+ }
+
+ @Test
+ void enforceBloqueLesCoupsApresSanction() {
+ cfg.mode(Controle.HITBOX, Mode.ENFORCE);
+ long t = 0;
+ while (!moteur.coupsBloques(joueur, t) && t < 10_000) {
+ moteur.coupPorteeHitbox(joueur, t, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
+ moteur.regardPorteeHitbox(joueur, t, OEIL, A_COTE);
+ t += 100;
+ }
+ assertTrue(moteur.coupsBloques(joueur, t), "jamais bloqué");
+ assertFalse(moteur.coupsBloques(joueur, t + Moteur.DUREE_BLOCAGE_COUPS_MS + 100));
+ }
+
+ // --- Angle killaura différé (16/10, suite) -----------------------------------------------------------------
+
+ private static final double[] DERRIERE = {0, 0, -1};
+
+ @Test
+ void angleKillauraRegardEnRetardPasDeFauxPositif() {
+ cfg.mode(Controle.KILLAURA_ANGLE, Mode.ENFORCE);
+ // Rotation de 180° pendant le tick : le serveur voit encore l'ancien regard au coup.
+ assertTrue(moteur.coupDiffere(joueur, 1000, EtatJoueur.normal(), OEIL, DERRIERE, BOITE, 3.0, 0, true, true).isEmpty());
+ assertTrue(moteur.regardPorteeHitbox(joueur, 1000, OEIL, VERS_CIBLE).isEmpty());
+ assertFalse(moteur.coupsBloques(joueur, 1100));
+ }
+
+ @Test
+ void angleKillauraDerriereSignaleEtBloqueEnEnforce() {
+ cfg.mode(Controle.KILLAURA_ANGLE, Mode.ENFORCE);
+ long t = 0;
+ boolean vu = false;
+ while (!moteur.coupsBloques(joueur, t) && t < 10_000) {
+ moteur.coupDiffere(joueur, t, EtatJoueur.normal(), OEIL, DERRIERE, BOITE, 3.0, 0, false, true);
+ for (Verdict v : moteur.regardPorteeHitbox(joueur, t, OEIL, DERRIERE)) {
+ vu |= v.controle() == Controle.KILLAURA_ANGLE;
+ assertFalse(v.controle() == Controle.HITBOX || v.controle() == Controle.PORTEE); // cible sur contraption
+ }
+ t += 100;
+ }
+ assertTrue(vu);
+ assertTrue(moteur.coupsBloques(joueur, t));
+ }
+
+ @Test
+ void angleKillauraPasCompteDeuxFois() {
+ // attaque() reçoit -1 (angle différé) : seul le chemin différé compte l'angle.
+ assertTrue(moteur.attaque(joueur, 0, EtatJoueur.normal(), -1, 1, true).isEmpty());
+ moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), OEIL, DERRIERE, BOITE, 3.0, 0, false, true);
+ long n = moteur.regardPorteeHitbox(joueur, 0, OEIL, DERRIERE).stream()
+ .filter(v -> v.controle() == Controle.KILLAURA_ANGLE).count();
+ assertEquals(1, n);
+ }
+
+ @Test
+ void angleKillauraCoupeOuExempte() {
+ cfg.mode(Controle.KILLAURA_ANGLE, Mode.OFF);
+ moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), OEIL, DERRIERE, BOITE, 3.0, 0, false, true);
+ assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, DERRIERE).isEmpty());
+ cfg.mode(Controle.KILLAURA_ANGLE, Mode.OBSERVE);
+ moteur.coupDiffere(joueur, 0, EtatJoueur.builder().enVehicule(true).build(), OEIL, DERRIERE, BOITE, 3.0, 0, false, true);
+ assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, DERRIERE).isEmpty());
+ }
+
+ @Test
+ void angleKillauraPasMesureEnVrilleRiptide() {
+ moteur.coupDiffere(joueur, 0, EtatJoueur.builder().riptide(true).build(), OEIL, DERRIERE, BOITE, 3.0, 0, true, true);
+ assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, DERRIERE).isEmpty());
+ }
+}