GastinelGarde : anti-crash entites (exploit minecart), contraptions, portee/hitbox, phase 2

- Anti-crash : plafond de vitesse projectiles/vehicules, suppression hors bordure,
  anti-empilement des minecarts (exploit Minecart Velocity du 16/10).
- Detection des contraptions Create/Aeronautics et des vaisseaux Sable.
- Controles portee et hitbox, angle killaura differe, no-fall/vitesse/vol.
- ENFORCE disponible pour tous les controles, OBSERVE par defaut.
- Config proposee, 180 tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Theo GastineletClaude Opus 5.5 a révisé 2026-10-15 14:26:09 +02:00
1 Parent d0c001d1e2
révision b5e53a4d85
24 fichiers modifiés
+2076 -23

Aucun fichier ne correspond à votre recherche

+3
Voir le fichier
@@ -4,3 +4,6 @@ build-out/
run/ run/
*.jar *.jar
!gradle/wrapper/gradle-wrapper.jar !gradle/wrapper/gradle-wrapper.jar
# sauvegardes avant modification
*.avant-*
+103 -1
Voir le fichier
@@ -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 `../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/`). 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 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. 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) ## 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`. Détail faille par faille : `audit/CORRECTIONS.md`. Essais en jeu à faire : `audit/ESSAIS-EN-JEU.md`.
+173
Voir le fichier
@@ -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
+43 -13
Voir le fichier
@@ -1,6 +1,7 @@
package com.gastinelgarde; package com.gastinelgarde;
import com.gastinelgarde.core.Controle; import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.DetectionContraption;
import com.gastinelgarde.core.EtatJoueur; import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.EtatMouvement; import com.gastinelgarde.core.EtatMouvement;
import com.gastinelgarde.core.EtatVehicule; import com.gastinelgarde.core.EtatVehicule;
@@ -75,6 +76,7 @@ public final class Garde {
double vehiculeX, vehiculeY, vehiculeZ; double vehiculeX, vehiculeY, vehiculeZ;
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste) // Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
int contraptionTick = Integer.MIN_VALUE; int contraptionTick = Integer.MIN_VALUE;
int contraptionVuTick = Integer.MIN_VALUE;
boolean contraptionProche; boolean contraptionProche;
} }
@@ -321,29 +323,45 @@ public final class Garde {
return r.actif(tick); 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) { private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) {
if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) { if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) {
m.contraptionProche = pocheContraption(p); m.contraptionProche = pocheContraption(p);
m.contraptionTick = tick; 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 :
* <ul>
* <li>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 ;</li>
* <li>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.</li>
* </ul>
*/
private static boolean pocheContraption(Player p) { private static boolean pocheContraption(Player p) {
if (SableAcces.surSousNiveau(p)) return true;
int dist = GardeSpec.distanceContraption(); int dist = GardeSpec.distanceContraption();
if (dist <= 0) return false; if (dist <= 0) return false;
String[] prefixes = GardeSpec.prefixesContraption().split(","); return !p.level().getEntities(p, p.getBoundingBox().inflate(dist), Garde::estContraption).isEmpty();
List<Entity> proches = p.level().getEntities(p, p.getBoundingBox().inflate(dist), e -> { }
String nom = e.getClass().getName();
for (String pre : prefixes) { /** L'entité est-elle une contraption (classe ou classe parente dans le réglage) ? */
String t = pre.trim(); public static boolean estContraption(Entity e) {
if (!t.isEmpty() && nom.startsWith(t)) return true; List<String> motifs = DetectionContraption.motifs(GardeSpec.prefixesContraption());
} if (motifs.isEmpty()) return false;
return false; List<String> chaine = new java.util.ArrayList<>(6);
}); for (Class<?> c = e.getClass(); c != null && c != Entity.class && c != Object.class; c = c.getSuperclass()) {
return !proches.isEmpty(); chaine.add(c.getName());
}
return DetectionContraption.correspond(chaine, motifs);
} }
// --- Réaction aux verdicts --- // --- 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) { private static synchronized void ecrireJournal(String ligne) {
GastinelGarde.LOGGER.warn("[GastinelGarde] {}", ligne); GastinelGarde.LOGGER.warn("[GastinelGarde] {}", ligne);
if (journal == null) return; if (journal == null) return;
@@ -442,6 +465,13 @@ public final class Garde {
if (!estExempteManuellement(p.getUUID())) { if (!estExempteManuellement(p.getUUID())) {
List<Verdict> v = MOTEUR.regard(p.getUUID(), tick * 50L, () -> etat(p, true), p.getYRot(), p.getXRot()); List<Verdict> 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 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<Verdict> 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.mouvementTick = tick;
m.mouvementX = p.getX(); m.mouvementX = p.getX();
+215
Voir le fichier
@@ -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<java.util.UUID, Long> 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);
}
}
}
+20 -1
Voir le fichier
@@ -2,9 +2,11 @@ package com.gastinelgarde;
import com.gastinelgarde.core.EtatJoueur; import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.KillauraAngle; import com.gastinelgarde.core.KillauraAngle;
import com.gastinelgarde.core.PorteeHitbox;
import com.gastinelgarde.core.Sanction; import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.TraceLigne; import com.gastinelgarde.core.TraceLigne;
import com.gastinelgarde.core.Verdict; import com.gastinelgarde.core.Verdict;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import net.minecraft.server.level.ServerPlayer; import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.entity.Entity; 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); bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ);
boolean visible = p.hasLineOfSight(cible); boolean visible = p.hasLineOfSight(cible);
List<Verdict> verdicts = Garde.moteur().attaque(p.getUUID(), tick * 50L, etat, excedent, cible.getId(), visible); List<Verdict> 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()) { if (Garde.tracesEnCours()) {
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(), 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); 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()) { if (s.ordinal() >= Sanction.SETBACK.ordinal()) {
event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé
if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts); if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts);
+94 -4
Voir le fichier
@@ -40,9 +40,24 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue PING_LAG; private static final ModConfigSpec.IntValue PING_LAG;
private static final ModConfigSpec.DoubleValue FACTEUR_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<String> PREFIXES_CONTRAPTION; private static final ModConfigSpec.ConfigValue<String> PREFIXES_CONTRAPTION;
private static final ModConfigSpec.IntValue DISTANCE_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.BooleanValue TRACES_ACTIVES;
private static final ModConfigSpec.IntValue TRACES_JOURS; private static final ModConfigSpec.IntValue TRACES_JOURS;
private static final ModConfigSpec.IntValue TRACES_TAILLE_MO; 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),", 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", "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()) { for (Controle c : Controle.values()) {
MODES.put(c, b.defineEnum(c.id(), Mode.OBSERVE)); MODES.put(c, b.defineEnum(c.id(), Mode.OBSERVE));
} }
@@ -77,6 +93,18 @@ public final class GardeSpec {
.defineInRange("cpsMax", 20, 5, 100); .defineInRange("cpsMax", 20, 5, 100);
ECART_TYPE_MIN = b.defineInRange("ecartTypeMinMs", 12.0, 0.0, 100.0); ECART_TYPE_MIN = b.defineInRange("ecartTypeMinMs", 12.0, 0.0, 100.0);
INTERVALLE_MOYEN_MAX = b.defineInRange("intervalleMoyenMaxMs", 150.0, 20.0, 1000.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.pop();
b.push("timer"); b.push("timer");
@@ -99,12 +127,40 @@ public final class GardeSpec {
.defineInRange("pingLagMs", 250, 50, 5000); .defineInRange("pingLagMs", 250, 50, 5000);
FACTEUR_LAG = b.comment("Multiplicateur des seuils quand le serveur tire (TPS sous tpsLag, mesuré par le serveur).") 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); .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.", PREFIXES_CONTRAPTION = b.comment("Classes (séparées par des virgules) des entités de contraption ; les sous-classes sont couvertes.",
"Un joueur près d'une telle entité est exempté. À valider sur le serveur réel (voir README).") "Un nom finissant par une minuscule, « . » ou « * » est un préfixe de paquet. Un joueur près d'une telle entité est exempté.",
.define("prefixesContraption", "com.simibubi.create.content.contraptions,dev.simulated_team,dev.ryanhcode"); "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); DISTANCE_CONTRAPTION = b.defineInRange("distanceContraptionBlocs", 3, 0, 16);
b.pop(); 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.") b.comment("Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.")
.push("traces"); .push("traces");
TRACES_ACTIVES = b.comment("Enregistrement continu pour tous les joueurs (décision T7 de Théo, 13/10/2026).") 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) { public static void onConfig(ModConfigEvent event) {
if (event.getConfig().getSpec() == SPEC) { if (event.getConfig().getSpec() == SPEC) {
acCache = null;
appliquer(Garde.config()); appliquer(Garde.config());
Garde.surConfigChargee(); Garde.surConfigChargee();
} }
@@ -145,6 +202,12 @@ public final class GardeSpec {
c.paquetsParSecondeMax = PAQUETS_PAR_SECONDE.get(); c.paquetsParSecondeMax = PAQUETS_PAR_SECONDE.get();
c.timerSecondesSoutenues = TIMER_SECONDES.get(); c.timerSecondesSoutenues = TIMER_SECONDES.get();
c.excesVitesseBlocs = EXCES_VITESSE.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.graceTeleportTicks = GRACE_TELEPORT.get();
c.graceReculTicks = GRACE_RECUL.get(); c.graceReculTicks = GRACE_RECUL.get();
c.graceGelTicks = GRACE_GEL.get(); c.graceGelTicks = GRACE_GEL.get();
@@ -163,6 +226,33 @@ public final class GardeSpec {
return SPEC.isLoaded() ? DISTANCE_CONTRAPTION.get() : DISTANCE_CONTRAPTION.getDefault(); 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() { public static boolean tracesActives() {
return SPEC.isLoaded() ? TRACES_ACTIVES.get() : TRACES_ACTIVES.getDefault(); return SPEC.isLoaded() ? TRACES_ACTIVES.get() : TRACES_ACTIVES.getDefault();
} }
+1
Voir le fichier
@@ -23,6 +23,7 @@ public class GastinelGarde {
NeoForge.EVENT_BUS.register(GardeEvents.class); NeoForge.EVENT_BUS.register(GardeEvents.class);
NeoForge.EVENT_BUS.register(GardeCommands.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)."); LOGGER.info("[GastinelGarde] Anti-triche chargé (tous les contrôles démarrent en observe).");
} }
+51
Voir le fichier
@@ -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;
}
}
}
+183
Voir le fichier
@@ -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) :
* <ul>
* <li>position non finie, ou hors bordure + marge (ou hors des limites absolues du jeu) : suppression ;</li>
* <li>vitesse non finie : suppression ;</li>
* <li>vitesse au-delà de {@code vitesseMax × facteurSuppression} : suppression ;</li>
* <li>vitesse au-delà de {@code vitesseMax} : ramenée à {@code vitesseMax} (même direction) ;</li>
* <li>position après ce tick (position + vitesse) hors bordure + marge : suppression.</li>
* </ul>
* 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;
}
}
}
+11
Voir le fichier
@@ -8,6 +8,8 @@ public enum Controle {
REGULARITE("regularite"), REGULARITE("regularite"),
ATTAQUE_IMPOSSIBLE("attaque-impossible"), ATTAQUE_IMPOSSIBLE("attaque-impossible"),
ROTATION("rotation"), ROTATION("rotation"),
PORTEE("portee"),
HITBOX("hitbox"),
TIMER("timer"), TIMER("timer"),
NO_FALL("no-fall"), NO_FALL("no-fall"),
VITESSE("vitesse"), VITESSE("vitesse"),
@@ -25,6 +27,15 @@ public enum Controle {
return id; 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) { public static Controle parse(String texte) {
if (texte == null) return null; if (texte == null) return null;
for (Controle c : values()) { for (Controle c : values()) {
+62
Voir le fichier
@@ -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);
}
}
}
+67
Voir le fichier
@@ -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<String> motifs(String reglage) {
List<String> 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<String> chaineClasses, List<String> 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;
}
}
+17
Voir le fichier
@@ -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. */ /** Total d'excès de vitesse horizontale (blocs) sur 20 ticks au-delà duquel on lève une infraction. */
public double excesVitesseBlocs = 1.5; 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 --- // --- Exemptions ---
public int graceTeleportTicks = 40; public int graceTeleportTicks = 40;
public int graceReculTicks = 20; public int graceReculTicks = 20;
+122 -2
Voir le fichier
@@ -86,6 +86,126 @@ public final class Moteur {
return verdicts; 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<Verdict> 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<Verdict> 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<Verdict> 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<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
double[] boite, double porteeJoueur, double vitesseCible,
boolean porteeHitbox, boolean angle) {
List<Verdict> 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<Verdict> 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<Verdict> 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<Verdict> 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 * 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. * 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 * Drapeau « au sol » à donner aux dégâts de chute. Celui du serveur en ENFORCE (sauf exemption), celui du
* client sinon. * client sinon (OBSERVE, le défaut).
*/ */
public boolean auSolPourDegatsDeChute(EtatJoueur etat, boolean auSolClient, boolean auSolServeur) { public boolean auSolPourDegatsDeChute(EtatJoueur etat, boolean auSolClient, boolean auSolServeur) {
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT); Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
+2 -1
Voir le fichier
@@ -5,7 +5,8 @@ package com.gastinelgarde.core;
* calcule lui-même s'il y a un bloc sous le joueur. * 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 * 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 { public final class NoFall {
+129
Voir le fichier
@@ -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 :
* <ul>
* <li>portée : distance de l'œil au point le plus proche de la boîte réelle de la cible ;</li>
* <li>hitbox : de combien il faudrait gonfler la boîte réelle pour que le rayon du regard la touche.</li>
* </ul>
* 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);
}
}
+5
Voir le fichier
@@ -15,6 +15,11 @@ public final class Suivi {
public final VolVertical vol = new VolVertical(); public final VolVertical vol = new VolVertical();
public final VehiculeMouvement vehicule = new VehiculeMouvement(); 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). // Dernière position jugée valide (retour en arrière).
private boolean positionValide; private boolean positionValide;
private double x, y, z; private double x, y, z;
+29
Voir le fichier
@@ -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);
}
}
+1 -1
Voir le fichier
@@ -3,6 +3,6 @@
"minVersion": "0.8", "minVersion": "0.8",
"package": "com.gastinelgarde.mixin", "package": "com.gastinelgarde.mixin",
"compatibilityLevel": "JAVA_21", "compatibilityLevel": "JAVA_21",
"mixins": ["MovePacketMixin", "RiptideMoveMixin"], "mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin"],
"injectors": {"defaultRequire": 1} "injectors": {"defaultRequire": 1}
} }
+8
Voir le fichier
@@ -19,4 +19,12 @@ class MixinsAppliquesTest {
// Force le chargement complet (liaison) de la classe transformée. // Force le chargement complet (liaison) de la classe transformée.
c.getDeclaredMethods(); 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();
}
} }
+217
Voir le fichier
@@ -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));
}
}
+263
Voir le fichier
@@ -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<String> 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<String> 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<Verdict> 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<Verdict> 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);
}
}
+257
Voir le fichier
@@ -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<Verdict> 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<Verdict> 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());
}
}