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