GastinelGarde : anti-crash entites (exploit minecart), contraptions, portee/hitbox, phase 2
- Anti-crash : plafond de vitesse projectiles/vehicules, suppression hors bordure, anti-empilement des minecarts (exploit Minecart Velocity du 16/10). - Detection des contraptions Create/Aeronautics et des vaisseaux Sable. - Controles portee et hitbox, angle killaura differe, no-fall/vitesse/vol. - ENFORCE disponible pour tous les controles, OBSERVE par defaut. - Config proposee, 180 tests. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
d0c001d1e2
révision
b5e53a4d85
24 fichiers modifiés
+2076
-23
Aucun fichier ne correspond à votre recherche
@@ -4,3 +4,6 @@ build-out/
|
||||
run/
|
||||
*.jar
|
||||
!gradle/wrapper/gradle-wrapper.jar
|
||||
|
||||
# sauvegardes avant modification
|
||||
*.avant-*
|
||||
+103
-1
@@ -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`.
|
||||
|
||||
@@ -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
|
||||
@@ -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 :
|
||||
* <ul>
|
||||
* <li>Create (et les contraptions d'Aeronautics / Offroad, qui en héritent) : entités proches dont une classe de
|
||||
* la chaîne correspond au réglage prefixesContraption ;</li>
|
||||
* <li>Aeronautics 1.3.2 : les vaisseaux ne sont PAS des entités, ce sont des « sous-niveaux » de Sable 2.0.6.
|
||||
* On demande à Sable (par réflexion, sans dépendance de compilation) si le joueur est suivi par un
|
||||
* sous-niveau, ou s'il est dans un véhicule posé sur un sous-niveau.</li>
|
||||
* </ul>
|
||||
*/
|
||||
private static boolean pocheContraption(Player p) {
|
||||
if (SableAcces.surSousNiveau(p)) return true;
|
||||
int dist = GardeSpec.distanceContraption();
|
||||
if (dist <= 0) return false;
|
||||
String[] prefixes = GardeSpec.prefixesContraption().split(",");
|
||||
List<Entity> 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<String> motifs = DetectionContraption.motifs(GardeSpec.prefixesContraption());
|
||||
if (motifs.isEmpty()) return false;
|
||||
List<String> chaine = new java.util.ArrayList<>(6);
|
||||
for (Class<?> c = e.getClass(); c != null && c != Entity.class && c != Object.class; c = c.getSuperclass()) {
|
||||
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<Verdict> v = MOTEUR.regard(p.getUUID(), tick * 50L, () -> etat(p, true), p.getYRot(), p.getXRot());
|
||||
traiter(p, v); // le coup a déjà eu lieu : journal et VL seulement
|
||||
// Portée / hitbox : mesure du dernier coup refaite avec l'œil et le regard de ce paquet (core.CoupDiffere).
|
||||
net.minecraft.world.phys.Vec3 oeil = p.getEyePosition();
|
||||
net.minecraft.world.phys.Vec3 regard = p.getLookAngle();
|
||||
List<Verdict> vh = MOTEUR.regardPorteeHitbox(p.getUUID(), tick * 50L,
|
||||
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z});
|
||||
Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques)
|
||||
if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh);
|
||||
}
|
||||
m.mouvementTick = tick;
|
||||
m.mouvementX = p.getX();
|
||||
|
||||
@@ -0,0 +1,215 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import com.gastinelgarde.core.AntiCrashEntites;
|
||||
import com.gastinelgarde.core.AntiCrashEntites.Action;
|
||||
import com.gastinelgarde.core.AntiCrashEntites.Bordure;
|
||||
import com.gastinelgarde.core.AntiCrashEntites.Decision;
|
||||
import net.minecraft.ChatFormatting;
|
||||
import net.minecraft.core.registries.BuiltInRegistries;
|
||||
import net.minecraft.network.chat.Component;
|
||||
import net.minecraft.server.MinecraftServer;
|
||||
import net.minecraft.server.level.ServerLevel;
|
||||
import net.minecraft.server.level.ServerPlayer;
|
||||
import net.minecraft.world.entity.Entity;
|
||||
import net.minecraft.world.entity.TraceableEntity;
|
||||
import net.minecraft.world.entity.player.Player;
|
||||
import net.minecraft.world.entity.vehicle.AbstractMinecart;
|
||||
import net.minecraft.world.level.border.WorldBorder;
|
||||
import net.minecraft.world.phys.Vec3;
|
||||
import net.neoforged.bus.api.EventPriority;
|
||||
import net.neoforged.bus.api.SubscribeEvent;
|
||||
import net.neoforged.neoforge.event.entity.EntityJoinLevelEvent;
|
||||
import net.neoforged.neoforge.event.tick.EntityTickEvent;
|
||||
|
||||
/**
|
||||
* Anti-crash des entités non joueurs (incident du 16/10/2026, voir {@link AntiCrashEntites}). Toujours actif
|
||||
* (désactivable dans la config, section antiCrash), indépendant des modes OBSERVE / ENFORCE des contrôles de triche.
|
||||
*
|
||||
* Vérifié à l'arrivée de l'entité dans le monde (lancer, /summon, chargement d'un chunk) et au début de chacun de
|
||||
* ses ticks (avant que son tick ne trace son rayon ou ne la déplace). Les joueurs ne sont jamais concernés
|
||||
* (riptide, élytres) ; leurs véhicules et projectiles le sont.
|
||||
*/
|
||||
public final class GardeAntiCrash {
|
||||
|
||||
private static final AntiCrashEntites.LimiteurAlertes LIMITEUR = new AntiCrashEntites.LimiteurAlertes(5, 10_000);
|
||||
|
||||
private GardeAntiCrash() { }
|
||||
|
||||
@SubscribeEvent(priority = EventPriority.HIGHEST)
|
||||
public static void onArrivee(EntityJoinLevelEvent event) {
|
||||
if (!(event.getLevel() instanceof ServerLevel)) return;
|
||||
if (verifier(event.getEntity(), "arrivee")) event.setCanceled(true);
|
||||
}
|
||||
|
||||
@SubscribeEvent(priority = EventPriority.HIGHEST)
|
||||
public static void onTick(EntityTickEvent.Pre event) {
|
||||
Entity e = event.getEntity();
|
||||
if (e.level().isClientSide()) return;
|
||||
if (verifier(e, "tick")) event.setCanceled(true);
|
||||
}
|
||||
|
||||
/** @return vrai si l'entité a été supprimée (l'événement doit être annulé). */
|
||||
static boolean verifier(Entity e, String moment) {
|
||||
if (e == null || e instanceof Player || e.isRemoved()) return false;
|
||||
AntiCrashEntites.Reglages r = GardeSpec.antiCrash();
|
||||
if (!r.actif) return false;
|
||||
|
||||
Vec3 v = e.getDeltaMovement();
|
||||
WorldBorder wb = e.level().getWorldBorder();
|
||||
Bordure b = new Bordure(wb.getMinX(), wb.getMinZ(), wb.getMaxX(), wb.getMaxZ());
|
||||
|
||||
// Chemin rapide (chaque entité, chaque tick) : rien d'anormal sans protection à calculer.
|
||||
// Minecarts : plafond propre, bien plus bas (exploit d'empilement, 16/10).
|
||||
double plafond = e instanceof AbstractMinecart ? r.vitesseMaxMinecart : r.vitesseMax;
|
||||
if (e instanceof AbstractMinecart cart && "tick".equals(moment) && empilementTraite(cart, r)) return true;
|
||||
Decision d = AntiCrashEntites.evaluer(r, b, e.getX(), e.getY(), e.getZ(), v.x, v.y, v.z, false, plafond);
|
||||
if (d.action() == Action.RIEN) return false;
|
||||
if (d.action() == Action.SUPPRIMER && estProtegee(e)) {
|
||||
d = AntiCrashEntites.evaluer(r, b, e.getX(), e.getY(), e.getZ(), v.x, v.y, v.z, true, plafond);
|
||||
}
|
||||
|
||||
// Entité protégée déjà immobile hors limites : rien à refaire, pas de journal à chaque tick.
|
||||
if (d.action() == Action.ARRETER && v.equals(Vec3.ZERO)) return false;
|
||||
|
||||
switch (d.action()) {
|
||||
case PLAFONNER -> e.setDeltaMovement(d.vx(), d.vy(), d.vz());
|
||||
case ARRETER -> e.setDeltaMovement(Vec3.ZERO);
|
||||
case SUPPRIMER -> {
|
||||
// Les passagers (non joueurs) partent avec le véhicule ; un joueur passager est seulement descendu.
|
||||
e.ejectPassengers();
|
||||
e.discard();
|
||||
}
|
||||
default -> { }
|
||||
}
|
||||
// Une entité qui ré-accélère d'elle-même (boule de feu) serait plafonnée à chaque tick : 1 ligne / 5 s.
|
||||
if (d.action() != Action.PLAFONNER || plafonnementASignaler(e.getUUID())) signaler(e, d, moment, v);
|
||||
return d.action() == Action.SUPPRIMER;
|
||||
}
|
||||
|
||||
// --- Empilement de minecarts (« Minecart Velocity Exploit », précision de Théo du 16/10) ---------------------
|
||||
// 6 à 15 minecarts superposés se poussent mutuellement à chaque tick (AbstractMinecart.push(Entity) : chacun
|
||||
// reçoit la moyenne des deux vitesses + 0,05, une fois par voisin) : la vitesse croît exponentiellement.
|
||||
// moveAlongTrack la ramène à 2,0 au tick suivant, mais les poussées ont lieu APRÈS : entre deux ticks la
|
||||
// vitesse est énorme, et un œuf lancé par le joueur assis en hérite (Projectile.shootFromRotation →
|
||||
// ServerPlayer.getKnownMovement → vitesse du minecart).
|
||||
|
||||
/** Nombre de minecarts dont la boîte chevauche celle de ce minecart (lui compris). */
|
||||
public static int minecartsEmpiles(AbstractMinecart cart) {
|
||||
return cart.level().getEntitiesOfClass(AbstractMinecart.class, cart.getBoundingBox()).size();
|
||||
}
|
||||
|
||||
/** Appelé par MinecartPushMixin avant chaque poussée minecart-minecart : vrai = poussée coupée. */
|
||||
public static boolean couperPoussee(AbstractMinecart cart, Entity autre) {
|
||||
AntiCrashEntites.Reglages r = GardeSpec.antiCrash();
|
||||
if (!r.actif || !(autre instanceof AbstractMinecart) || cart.level().isClientSide()) return false;
|
||||
return AntiCrashEntites.empilementExcessif(minecartsEmpiles(cart), r);
|
||||
}
|
||||
|
||||
/** Appelé par MinecartPushMixin après chaque poussée : les deux minecarts restent sous leur plafond. */
|
||||
public static void apresPoussee(AbstractMinecart cart, Entity autre) {
|
||||
AntiCrashEntites.Reglages r = GardeSpec.antiCrash();
|
||||
if (!r.actif || cart.level().isClientSide()) return;
|
||||
plafonnerMinecart(cart, r);
|
||||
if (autre instanceof AbstractMinecart m) plafonnerMinecart(m, r);
|
||||
}
|
||||
|
||||
private static void plafonnerMinecart(AbstractMinecart m, AntiCrashEntites.Reglages r) {
|
||||
Vec3 v = m.getDeltaMovement();
|
||||
double[] n = AntiCrashEntites.plafonner(v.x, v.y, v.z, r.vitesseMaxMinecart);
|
||||
if (n == null) return;
|
||||
m.setDeltaMovement(n[0], n[1], n[2]);
|
||||
// Une poussée vanilla ne dépasse guère 2,5 : au-delà de 2 × le plafond, c'est l'exploit, on le journalise.
|
||||
double vitesse = v.length();
|
||||
if (!(vitesse <= r.vitesseMaxMinecart * 2) && plafonnementASignaler(m.getUUID())) {
|
||||
signaler(m, new Decision(Action.PLAFONNER, AntiCrashEntites.Motif.VITESSE_EXCESSIVE, n[0], n[1], n[2],
|
||||
vitesse), "poussee", v);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Toutes les 10 ticks : au-delà de empilementMax minecarts superposés, ce minecart (s'il ne porte personne et
|
||||
* n'est pas une contraption) est cassé et lâche son objet (et son contenu, pour un minecart à coffre).
|
||||
* @return vrai s'il a été cassé
|
||||
*/
|
||||
private static boolean empilementTraite(AbstractMinecart cart, AntiCrashEntites.Reglages r) {
|
||||
if ((cart.tickCount + cart.getId()) % 10 != 0 || r.empilementMax <= 0) return false;
|
||||
int n = minecartsEmpiles(cart);
|
||||
if (!AntiCrashEntites.empilementExcessif(n, r)) return false;
|
||||
if (cart.isVehicle() || Garde.estContraption(cart) || SableAcces.surSousNiveau(cart)) return false;
|
||||
Vec3 v = cart.getDeltaMovement();
|
||||
cart.destroy(cart.getPickResult().getItem());
|
||||
String type = BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()).toString();
|
||||
String ligne = String.format(java.util.Locale.ROOT,
|
||||
"anti-crash EMPILEMENT %s cassé (%d minecarts superposés > %d), dim=%s pos=(%.1f, %.1f, %.1f) vitesse=%.4g b/t",
|
||||
type, n, r.empilementMax, cart.level().dimension().location(), cart.getX(), cart.getY(), cart.getZ(),
|
||||
v.length());
|
||||
Garde.journaliser(ligne);
|
||||
alerterOps(cart.level().getServer(), String.format(java.util.Locale.ROOT,
|
||||
"[Garde] Anti-crash : empilement de %d minecarts à %.0f %.0f %.0f, un minecart cassé", n,
|
||||
cart.getX(), cart.getY(), cart.getZ()));
|
||||
return true;
|
||||
}
|
||||
|
||||
private static void alerterOps(MinecraftServer server, String texte) {
|
||||
if (server == null || !GardeSpec.antiCrashAlertesOps()) return;
|
||||
if (!LIMITEUR.autoriser(System.currentTimeMillis())) return;
|
||||
int masquees = LIMITEUR.masqueesDepuis();
|
||||
Component msg = Component.literal(texte + (masquees > 0 ? " (+" + masquees + " masqués, voir gastinelgarde.log)" : ""))
|
||||
.withStyle(ChatFormatting.RED);
|
||||
for (ServerPlayer op : server.getPlayerList().getPlayers()) {
|
||||
if (op.hasPermissions(2) && Garde.alertesActivesPour(op.getUUID())) op.sendSystemMessage(msg);
|
||||
}
|
||||
}
|
||||
|
||||
private static final java.util.Map<java.util.UUID, Long> DERNIER_PLAFOND = new java.util.HashMap<>();
|
||||
|
||||
private static boolean plafonnementASignaler(java.util.UUID id) {
|
||||
long t = System.currentTimeMillis();
|
||||
if (DERNIER_PLAFOND.size() > 1000) DERNIER_PLAFOND.values().removeIf(x -> t - x > 5000);
|
||||
Long avant = DERNIER_PLAFOND.get(id);
|
||||
if (avant != null && t - avant < 5000) return false;
|
||||
DERNIER_PLAFOND.put(id, t);
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Contraption Create, entité portée par un vaisseau Sable, ou véhicule qui porte un joueur. */
|
||||
private static boolean estProtegee(Entity e) {
|
||||
if (Garde.estContraption(e) || SableAcces.surSousNiveau(e)) return true;
|
||||
for (Entity p : e.getIndirectPassengers()) {
|
||||
if (p instanceof Player) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private static void signaler(Entity e, Decision d, String moment, Vec3 avant) {
|
||||
String proprio = "inconnu";
|
||||
Entity owner = e instanceof TraceableEntity t ? t.getOwner() : null;
|
||||
if (owner == null) owner = e.getControllingPassenger();
|
||||
if (owner == null && e.getVehicle() != null) owner = e.getVehicle().getControllingPassenger();
|
||||
if (owner instanceof ServerPlayer sp) proprio = sp.getGameProfile().getName();
|
||||
else if (owner != null) proprio = BuiltInRegistries.ENTITY_TYPE.getKey(owner.getType()).toString();
|
||||
|
||||
String type = BuiltInRegistries.ENTITY_TYPE.getKey(e.getType()).toString();
|
||||
String ligne = String.format(java.util.Locale.ROOT,
|
||||
"anti-crash %s %s (%s) : %s, proprietaire=%s, dim=%s pos=(%.1f, %.1f, %.1f) vitesse=%.4g b/t (%.4g, %.4g, %.4g)%s",
|
||||
d.action(), type, moment, d.motif(), proprio, e.level().dimension().location(),
|
||||
e.getX(), e.getY(), e.getZ(), d.vitesse(), avant.x, avant.y, avant.z,
|
||||
d.action() == Action.PLAFONNER ? String.format(java.util.Locale.ROOT, " -> %.1f b/t",
|
||||
Math.sqrt(d.vx() * d.vx() + d.vy() * d.vy() + d.vz() * d.vz())) : "");
|
||||
Garde.journaliser(ligne);
|
||||
|
||||
MinecraftServer server = e.level().getServer();
|
||||
if (server == null || !GardeSpec.antiCrashAlertesOps()) return;
|
||||
if (!LIMITEUR.autoriser(System.currentTimeMillis())) return;
|
||||
int masquees = LIMITEUR.masqueesDepuis();
|
||||
Component msg = Component.literal(String.format(java.util.Locale.ROOT,
|
||||
"[Garde] Anti-crash : %s %s (%s) par %s à %.0f %.0f %.0f, %.3g b/t%s",
|
||||
d.action() == Action.SUPPRIMER ? "supprimé" : d.action() == Action.ARRETER ? "arrêté" : "ralenti",
|
||||
type, d.motif(), proprio, e.getX(), e.getY(), e.getZ(), d.vitesse(),
|
||||
masquees > 0 ? " (+" + masquees + " masqués, voir gastinelgarde.log)" : ""))
|
||||
.withStyle(ChatFormatting.RED);
|
||||
for (ServerPlayer op : server.getPlayerList().getPlayers()) {
|
||||
if (op.hasPermissions(2) && Garde.alertesActivesPour(op.getUUID())) op.sendSystemMessage(msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<Verdict> verdicts = Garde.moteur().attaque(p.getUUID(), tick * 50L, etat, excedent, cible.getId(), visible);
|
||||
List<Verdict> verdicts = new ArrayList<>(
|
||||
Garde.moteur().attaque(p.getUUID(), tick * 50L, etat, -1, cible.getId(), visible)); // angle : différé
|
||||
|
||||
// Portée et hitbox (test de Rednixxu, 14/10). Cible sur une contraption ou un vaisseau Sable : ses
|
||||
// coordonnées et sa boîte ne sont pas fiables pour cette géométrie, on ne mesure pas.
|
||||
// 16/10 : cible assise sur une contraption (siège Create) ; mesure terminée au paquet de mouvement suivant
|
||||
// (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere).
|
||||
// L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
|
||||
Entity racine = cible.getRootVehicle();
|
||||
boolean mesurerPH = !Garde.estContraption(cible) && !SableAcces.surSousNiveau(cible)
|
||||
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
|
||||
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
|
||||
+ Math.pow(cible.getZ() - cible.zo, 2));
|
||||
verdicts.addAll(Garde.moteur().coupDiffere(p.getUUID(), tick * 50L, etat,
|
||||
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z},
|
||||
new double[] {bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ}, p.entityInteractionRange(),
|
||||
vitesseCible, mesurerPH, true));
|
||||
|
||||
if (Garde.tracesEnCours()) {
|
||||
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);
|
||||
|
||||
@@ -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<String> 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();
|
||||
}
|
||||
|
||||
@@ -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).");
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,183 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* Protection anti-crash des entités non joueurs (incident du 16/10/2026, « Minecart Velocity Exploit »).
|
||||
*
|
||||
* Un œuf lancé à ~7e53 blocs/tick : à son tick, {@code ProjectileUtil.getHitResultOnMoveVector} trace un rayon
|
||||
* (BlockGetter.clip) le long de toute sa vitesse ; chaque {@code getBlockState} charge ou GÉNÈRE le chunk traversé.
|
||||
* Les coordonnées, bornées à ±2^31, tombent sur des chunks (~134 217 720) où la génération déborde
|
||||
* (Aquifer : ArrayIndexOutOfBoundsException) : « Exception generating new chunk », serveur planté ou figé.
|
||||
*
|
||||
* Parade, avant que l'entité ne bouge (arrivée dans le monde et début de chaque tick) :
|
||||
* <ul>
|
||||
* <li>position non finie, ou hors bordure + marge (ou hors des limites absolues du jeu) : suppression ;</li>
|
||||
* <li>vitesse non finie : suppression ;</li>
|
||||
* <li>vitesse au-delà de {@code vitesseMax × facteurSuppression} : suppression ;</li>
|
||||
* <li>vitesse au-delà de {@code vitesseMax} : ramenée à {@code vitesseMax} (même direction) ;</li>
|
||||
* <li>position après ce tick (position + vitesse) hors bordure + marge : suppression.</li>
|
||||
* </ul>
|
||||
* Une entité « protégée » (contraption Create, entité portée par un vaisseau Sable, véhicule qui porte un joueur)
|
||||
* n'est jamais supprimée : sa vitesse est mise à zéro à la place (ARRETER).
|
||||
*
|
||||
* Logique pure, sans Minecraft.
|
||||
*/
|
||||
public final class AntiCrashEntites {
|
||||
|
||||
/** Limite horizontale absolue de Minecraft (Level.MAX_LEVEL_SIZE). */
|
||||
public static final double LIMITE_HORIZONTALE = 30_000_000.0;
|
||||
/** Limite verticale absolue des positions acceptées par Minecraft (Level.isInSpawnableBounds : ±20 000 000). */
|
||||
public static final double LIMITE_VERTICALE = 20_000_000.0;
|
||||
|
||||
public enum Action { RIEN, PLAFONNER, ARRETER, SUPPRIMER }
|
||||
|
||||
public enum Motif { AUCUN, POSITION_NON_FINIE, VITESSE_NON_FINIE, HORS_BORDURE, VITESSE_EXTREME, VITESSE_EXCESSIVE, TRAJECTOIRE_HORS_BORDURE }
|
||||
|
||||
/** Réglages (recopiés du fichier de configuration). */
|
||||
public static final class Reglages {
|
||||
public boolean actif = true;
|
||||
/** Vitesse maximale d'une entité non joueur (blocs/tick). */
|
||||
public double vitesseMax = 100.0;
|
||||
/** Au-delà de vitesseMax × ce facteur, l'entité est supprimée au lieu d'être ralentie. */
|
||||
public double facteurSuppression = 10.0;
|
||||
/** Marge (blocs) tolérée au-delà de la bordure du monde. */
|
||||
public double margeBordure = 64.0;
|
||||
/**
|
||||
* Vitesse maximale d'un minecart (blocs/tick). Vanilla 1.21.1 : déplacement sur rail borné à 0,4 (NeoForge
|
||||
* jusqu'à 1,2), vitesse ramenée à 2,0 au plus par moveAlongTrack, 0,4 hors rail (comeOffTrack).
|
||||
*/
|
||||
public double vitesseMaxMinecart = 3.0;
|
||||
/** Minecarts au plus qui se chevauchent ; au-delà, la poussée mutuelle est coupée et les excédentaires cassés. */
|
||||
public int empilementMax = 4;
|
||||
}
|
||||
|
||||
/** Bordure du monde (rectangle horizontal). */
|
||||
public record Bordure(double minX, double minZ, double maxX, double maxZ) {
|
||||
public static final Bordure VANILLA = new Bordure(-29_999_984, -29_999_984, 29_999_984, 29_999_984);
|
||||
}
|
||||
|
||||
/** Décision : action, motif, et la nouvelle vitesse si PLAFONNER / ARRETER. */
|
||||
public record Decision(Action action, Motif motif, double vx, double vy, double vz, double vitesse) {
|
||||
static final Decision RIEN = new Decision(Action.RIEN, Motif.AUCUN, 0, 0, 0, 0);
|
||||
}
|
||||
|
||||
private AntiCrashEntites() { }
|
||||
|
||||
/**
|
||||
* @param protege contraption, entité sur un vaisseau Sable, véhicule portant un joueur : jamais supprimée
|
||||
*/
|
||||
public static Decision evaluer(Reglages r, Bordure b, double x, double y, double z,
|
||||
double vx, double vy, double vz, boolean protege) {
|
||||
return evaluer(r, b, x, y, z, vx, vy, vz, protege, r == null ? 0 : r.vitesseMax);
|
||||
}
|
||||
|
||||
/**
|
||||
* Comme {@link #evaluer(Reglages, Bordure, double, double, double, double, double, double, boolean)} avec un
|
||||
* plafond propre (minecarts : {@code vitesseMaxMinecart}). Le seuil de suppression reste
|
||||
* {@code vitesseMax × facteurSuppression}.
|
||||
*/
|
||||
public static Decision evaluer(Reglages r, Bordure b, double x, double y, double z,
|
||||
double vx, double vy, double vz, boolean protege, double plafond) {
|
||||
if (r == null || !r.actif) return Decision.RIEN;
|
||||
|
||||
if (!Double.isFinite(x) || !Double.isFinite(y) || !Double.isFinite(z)) {
|
||||
return grave(Motif.POSITION_NON_FINIE, protege, Double.NaN);
|
||||
}
|
||||
boolean vitesseFinie = Double.isFinite(vx) && Double.isFinite(vy) && Double.isFinite(vz);
|
||||
double v = vitesseFinie ? Math.sqrt(vx * vx + vy * vy + vz * vz) : Double.NaN;
|
||||
if (vitesseFinie && Double.isInfinite(v)) vitesseFinie = false; // composantes finies mais carré infini
|
||||
if (!vitesseFinie) return grave(Motif.VITESSE_NON_FINIE, protege, v);
|
||||
|
||||
if (!dansLimites(b, r.margeBordure, x, y, z)) {
|
||||
// Une entité protégée hors limites est seulement arrêtée (elle ne génère plus rien en bougeant).
|
||||
return grave(Motif.HORS_BORDURE, protege, v);
|
||||
}
|
||||
|
||||
if (v > Math.max(r.vitesseMax, 0.0) * Math.max(r.facteurSuppression, 1.0)) {
|
||||
return grave(Motif.VITESSE_EXTREME, protege, v);
|
||||
}
|
||||
double max = Math.max(Math.min(plafond, r.vitesseMax), 0.0);
|
||||
|
||||
double nx = vx, ny = vy, nz = vz;
|
||||
Action action = Action.RIEN;
|
||||
Motif motif = Motif.AUCUN;
|
||||
if (v > max) {
|
||||
double k = v > 0 ? max / v : 0;
|
||||
nx = vx * k;
|
||||
ny = vy * k;
|
||||
nz = vz * k;
|
||||
action = Action.PLAFONNER;
|
||||
motif = Motif.VITESSE_EXCESSIVE;
|
||||
}
|
||||
// Le rayon de ce tick va de la position à position + vitesse : il ne doit pas sortir de la bordure + marge.
|
||||
if (!dansLimites(b, r.margeBordure, x + nx, y + ny, z + nz)) {
|
||||
return grave(Motif.TRAJECTOIRE_HORS_BORDURE, protege, v);
|
||||
}
|
||||
return action == Action.RIEN ? Decision.RIEN : new Decision(action, motif, nx, ny, nz, v);
|
||||
}
|
||||
|
||||
private static Decision grave(Motif m, boolean protege, double v) {
|
||||
return new Decision(protege ? Action.ARRETER : Action.SUPPRIMER, m, 0, 0, 0, v);
|
||||
}
|
||||
|
||||
/**
|
||||
* Vecteur ramené à la norme {@code max} (même direction) ; NaN / infini → zéro. Renvoie null si rien à changer.
|
||||
*/
|
||||
public static double[] plafonner(double vx, double vy, double vz, double max) {
|
||||
if (!Double.isFinite(vx) || !Double.isFinite(vy) || !Double.isFinite(vz)) return new double[] {0, 0, 0};
|
||||
double v = Math.sqrt(vx * vx + vy * vy + vz * vz);
|
||||
if (!Double.isFinite(v)) return new double[] {0, 0, 0};
|
||||
if (v <= max) return null;
|
||||
double k = max / v;
|
||||
return new double[] {vx * k, vy * k, vz * k};
|
||||
}
|
||||
|
||||
/** Empilement : y a-t-il trop de minecarts qui se chevauchent (lui compris) ? */
|
||||
public static boolean empilementExcessif(int minecartsQuiSeChevauchent, Reglages r) {
|
||||
return r != null && r.actif && r.empilementMax > 0 && minecartsQuiSeChevauchent > r.empilementMax;
|
||||
}
|
||||
|
||||
/** Position dans la bordure + marge, et dans les limites absolues du jeu. */
|
||||
public static boolean dansLimites(Bordure b, double marge, double x, double y, double z) {
|
||||
if (Math.abs(x) > LIMITE_HORIZONTALE || Math.abs(z) > LIMITE_HORIZONTALE || Math.abs(y) > LIMITE_VERTICALE) {
|
||||
return false;
|
||||
}
|
||||
if (b == null) return true;
|
||||
double m = Math.max(marge, 0.0);
|
||||
return x >= b.minX() - m && x <= b.maxX() + m && z >= b.minZ() - m && z <= b.maxZ() + m;
|
||||
}
|
||||
|
||||
/** Limiteur des messages aux ops : au plus {@code max} par fenêtre de {@code fenetreMs} (le journal garde tout). */
|
||||
public static final class LimiteurAlertes {
|
||||
private final int max;
|
||||
private final long fenetreMs;
|
||||
private long debut = Long.MIN_VALUE;
|
||||
private int compte;
|
||||
private int masquees;
|
||||
|
||||
public LimiteurAlertes(int max, long fenetreMs) {
|
||||
this.max = max;
|
||||
this.fenetreMs = fenetreMs;
|
||||
}
|
||||
|
||||
/** Vrai si le message peut partir ; sinon il est compté comme masqué. */
|
||||
public synchronized boolean autoriser(long maintenantMs) {
|
||||
if (debut == Long.MIN_VALUE || maintenantMs - debut >= fenetreMs) {
|
||||
debut = maintenantMs;
|
||||
compte = 0;
|
||||
}
|
||||
if (compte < max) {
|
||||
compte++;
|
||||
return true;
|
||||
}
|
||||
masquees++;
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Nombre de messages masqués depuis le dernier appel (remis à zéro). */
|
||||
public synchronized int masqueesDepuis() {
|
||||
int m = masquees;
|
||||
masquees = 0;
|
||||
return m;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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()) {
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Reconnaît une entité de contraption à partir de la chaîne de ses classes (la sienne, puis ses parents).
|
||||
*
|
||||
* Un motif est soit un nom de classe exact (« com.simibubi.create.content.contraptions.AbstractContraptionEntity »),
|
||||
* qui couvre aussi toutes ses sous-classes puisque toute la chaîne est examinée, soit un paquet (dernier segment en
|
||||
* minuscule, ou motif terminé par « . » ou « * ») : ancienne forme du réglage, gardée pour les fichiers existants.
|
||||
*
|
||||
* Noms relevés le 15/10/2026 dans les jars du serveur (identiques au bit près à ceux de dist_mods) :
|
||||
* voir README, section « Contraptions ».
|
||||
*/
|
||||
public final class DetectionContraption {
|
||||
|
||||
/** Valeur par défaut du réglage prefixesContraption (noms exacts, voir README). */
|
||||
public static final String MOTIFS_DEFAUT =
|
||||
"com.simibubi.create.content.contraptions.AbstractContraptionEntity";
|
||||
|
||||
private DetectionContraption() { }
|
||||
|
||||
public static List<String> motifs(String reglage) {
|
||||
List<String> l = new ArrayList<>();
|
||||
if (reglage == null) return l;
|
||||
for (String m : reglage.split(",")) {
|
||||
String t = m.trim();
|
||||
if (!t.isEmpty()) l.add(t);
|
||||
}
|
||||
return l;
|
||||
}
|
||||
|
||||
/** Un nom de la chaîne de classes correspond-il à un motif ? */
|
||||
public static boolean correspond(Iterable<String> chaineClasses, List<String> motifs) {
|
||||
for (String nom : chaineClasses) {
|
||||
for (String m : motifs) {
|
||||
if (m.endsWith("*")) {
|
||||
if (nom.startsWith(m.substring(0, m.length() - 1))) return true;
|
||||
} else if (estPaquet(m)) {
|
||||
if (nom.startsWith(m.endsWith(".") ? m : m + ".")) return true;
|
||||
} else if (nom.equals(m) || nom.startsWith(m + "$")) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Paquet si le dernier segment commence par une minuscule (convention Java : classes en majuscule). */
|
||||
static boolean estPaquet(String m) {
|
||||
String t = m.endsWith(".") ? m.substring(0, m.length() - 1) : m;
|
||||
if (m.endsWith(".")) return true;
|
||||
int i = t.lastIndexOf('.');
|
||||
String dernier = i < 0 ? t : t.substring(i + 1);
|
||||
return !dernier.isEmpty() && Character.isLowerCase(dernier.charAt(0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Grâce après avoir quitté une contraption ou un vaisseau Sable : le joueur garde l'élan du vaisseau quelques
|
||||
* ticks. Vrai si la contraption a été vue il y a au plus {@code graceTicks} ticks.
|
||||
*/
|
||||
public static boolean dansLaGrace(int tick, int dernierVuTick, int graceTicks) {
|
||||
if (dernierVuTick == Integer.MIN_VALUE || tick < dernierVuTick) return false;
|
||||
return tick - dernierVuTick <= graceTicks;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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<Verdict> porteeHitbox(UUID joueur, long nowMs, EtatJoueur etat, double distance, double manque,
|
||||
double porteeJoueur, double vitesseCible) {
|
||||
boolean portee = cfg.mode(Controle.PORTEE) != Mode.OFF;
|
||||
boolean hitbox = cfg.mode(Controle.HITBOX) != Mode.OFF;
|
||||
if (!portee && !hitbox) return List.of();
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
|
||||
if (ex.exempt()) return List.of();
|
||||
if (PorteeHitbox.raisonNonMesure(etat, vitesseCible, cfg) != null) return List.of();
|
||||
|
||||
Suivi s = suivi(joueur);
|
||||
List<Verdict> verdicts = new ArrayList<>(2);
|
||||
double lat = PorteeHitbox.toleranceLatence(vitesseCible, etat.pingMs(), cfg);
|
||||
if (portee && distance >= 0) {
|
||||
double seuil = PorteeHitbox.seuilPortee(porteeJoueur, lat, cfg, ex.facteur());
|
||||
ajouter(verdicts, s, Controle.PORTEE, PorteeHitbox.pointsPortee(distance, seuil), nowMs, ex,
|
||||
String.format(Locale.ROOT, "distance=%.2f (seuil %.2f, portee %.1f)", distance, seuil, porteeJoueur));
|
||||
}
|
||||
if (hitbox && manque >= 0) {
|
||||
double seuil = PorteeHitbox.seuilHitbox(lat, cfg, ex.facteur());
|
||||
ajouter(verdicts, s, Controle.HITBOX, PorteeHitbox.pointsHitbox(manque, seuil), nowMs, ex,
|
||||
String.format(Locale.ROOT, "regard hors boite de %.2f (seuil %.2f)", manque, seuil));
|
||||
}
|
||||
for (Verdict v : verdicts) {
|
||||
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
|
||||
s.coupsBloquesJusqua = nowMs + DUREE_BLOCAGE_COUPS_MS;
|
||||
}
|
||||
}
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
/** Après une sanction portée / hitbox (ENFORCE), les coups sont annulés pendant cette durée. */
|
||||
public static final long DUREE_BLOCAGE_COUPS_MS = 2000;
|
||||
|
||||
/**
|
||||
* Mesure différée d'un coup (voir {@link CoupDiffere}) : la mesure est mise de côté et terminée au paquet de
|
||||
* mouvement suivant ({@link #regardPorteeHitbox}). Un coup encore en attente est terminé ici.
|
||||
*
|
||||
* @param oeil position de l'œil vue par le serveur (x, y, z)
|
||||
* @param regard direction du regard vue par le serveur
|
||||
* @param boite boîte réelle de la cible (minX, minY, minZ, maxX, maxY, maxZ)
|
||||
* @return les verdicts du coup précédent s'il était encore en attente
|
||||
*/
|
||||
public List<Verdict> coupPorteeHitbox(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
|
||||
double[] boite, double porteeJoueur, double vitesseCible) {
|
||||
return coupDiffere(joueur, nowMs, etat, oeil, regard, boite, porteeJoueur, vitesseCible, true, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Mesure différée générale (16/10/2026) : portée / hitbox si {@code porteeHitbox}, angle killaura si
|
||||
* {@code angle} (dans ce cas, {@link #attaque} doit recevoir -1 comme excédent pour ne pas le compter deux fois).
|
||||
*/
|
||||
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
|
||||
double[] boite, double porteeJoueur, double vitesseCible,
|
||||
boolean porteeHitbox, boolean angle) {
|
||||
List<Verdict> verdicts = terminerCoup(joueur);
|
||||
boolean ph = porteeHitbox
|
||||
&& (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
|
||||
boolean an = angle && cfg.mode(Controle.KILLAURA_ANGLE) != Mode.OFF;
|
||||
if (!ph && !an) return verdicts;
|
||||
double ex = an ? KillauraAngle.excedentDegres(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
||||
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]) : -1;
|
||||
if (an && ex < 0) ex = -1;
|
||||
double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2],
|
||||
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
|
||||
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
||||
porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
|
||||
suivi(joueur).coupDiffere = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
/** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */
|
||||
public List<Verdict> regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) {
|
||||
Suivi s = suivis.get(joueur);
|
||||
if (s == null || s.coupDiffere == null) return List.of();
|
||||
if (s.coupDiffere.encoreValable(nowMs)) s.coupDiffere.affiner(oeil, regard);
|
||||
return terminerCoup(joueur);
|
||||
}
|
||||
|
||||
/** Termine le coup en attente (paquet suivant, coup suivant). */
|
||||
public List<Verdict> terminerCoup(UUID joueur) {
|
||||
Suivi s = suivis.get(joueur);
|
||||
if (s == null || s.coupDiffere == null) return new ArrayList<>(0);
|
||||
CoupDiffere c = s.coupDiffere;
|
||||
s.coupDiffere = null;
|
||||
List<Verdict> verdicts = new ArrayList<>(3);
|
||||
// Vrille riptide : le coup part au contact (Player.doAutoAttackOnTouch), sans viser.
|
||||
if (c.excedent >= 0 && !c.etat.riptide() && cfg.mode(Controle.KILLAURA_ANGLE) != Mode.OFF) {
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(c.etat, cfg, Exemptions.Famille.COMBAT);
|
||||
if (!ex.exempt()) {
|
||||
double seuil = cfg.angleMaxDegres * ex.facteur();
|
||||
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, KillauraAngle.points(c.excedent, seuil), c.nowMs, ex,
|
||||
String.format(Locale.ROOT, "excedent=%.1f deg (seuil %.0f, mesure differee)", c.excedent, seuil));
|
||||
}
|
||||
}
|
||||
if (c.porteeHitbox) {
|
||||
verdicts.addAll(porteeHitbox(joueur, c.nowMs, c.etat, c.distance, c.manque, c.porteeJoueur, c.vitesseCible));
|
||||
}
|
||||
for (Verdict v : verdicts) { // le coup est déjà passé : en ENFORCE, on annule les suivants
|
||||
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
|
||||
s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS);
|
||||
}
|
||||
}
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
/** Les coups de ce joueur sont-ils annulés (sanction portée / hitbox récente en ENFORCE) ? */
|
||||
public boolean coupsBloques(UUID joueur, long nowMs) {
|
||||
Suivi s = suivis.get(joueur);
|
||||
return s != null && nowMs < s.coupsBloquesJusqua;
|
||||
}
|
||||
|
||||
/**
|
||||
* Un regard accepté (paquet de mouvement) : termine éventuellement un aller-retour de rotation autour d'un
|
||||
* 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);
|
||||
|
||||
@@ -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 {
|
||||
|
||||
|
||||
@@ -0,0 +1,129 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* Contrôles portée et hitbox (géométrie pure), ajoutés après le test de Rednixxu (14/10/2026) : un cheat « hitbox »
|
||||
* grossit côté client la boîte des cibles, ce qui permet de toucher sans viser la vraie boîte, et souvent de plus loin.
|
||||
*
|
||||
* Ce que vanilla fait déjà (1.21.1, ServerGamePacketListenerImpl.handleInteract) : un coup est refusé si la boîte
|
||||
* de la cible est à plus de « portée d'interaction + 1,0 » de l'œil (3,0 + 1,0 = 4,0 blocs en survie). Le serveur
|
||||
* laisse donc passer toute la bande 3,0 à 4,0 blocs, et ne regarde jamais si le regard touche la boîte.
|
||||
*
|
||||
* Ici, deux mesures sur les positions vues par le serveur :
|
||||
* <ul>
|
||||
* <li>portée : distance de l'œil au point le plus proche de la boîte réelle de la cible ;</li>
|
||||
* <li>hitbox : de combien il faudrait gonfler la boîte réelle pour que le rayon du regard la touche.</li>
|
||||
* </ul>
|
||||
* La cible affichée chez le client a quelques ticks de retard : sa vitesse par tick, multipliée par ce retard,
|
||||
* s'ajoute aux deux tolérances.
|
||||
*/
|
||||
public final class PorteeHitbox {
|
||||
|
||||
/** Gonflement maximal recherché (blocs) : au-delà, le manque est plafonné à cette valeur. */
|
||||
public static final double MANQUE_MAX = 4.0;
|
||||
|
||||
private PorteeHitbox() { }
|
||||
|
||||
/** Distance de l'œil au point le plus proche de la boîte (0 si l'œil est dedans). */
|
||||
public static double distanceOeilBoite(double ex, double ey, double ez,
|
||||
double minX, double minY, double minZ,
|
||||
double maxX, double maxY, double maxZ) {
|
||||
double dx = ex < minX ? minX - ex : (ex > maxX ? ex - maxX : 0);
|
||||
double dy = ey < minY ? minY - ey : (ey > maxY ? ey - maxY : 0);
|
||||
double dz = ez < minZ ? minZ - ez : (ez > maxZ ? ez - maxZ : 0);
|
||||
return Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gonflement minimal (blocs) de la boîte pour que le segment [œil, œil + regard × longueur] la touche.
|
||||
* 0 si le regard touche déjà la boîte ; {@link #MANQUE_MAX} au plus.
|
||||
*/
|
||||
public static double manqueRegard(double ex, double ey, double ez,
|
||||
double lx, double ly, double lz, double longueur,
|
||||
double minX, double minY, double minZ,
|
||||
double maxX, double maxY, double maxZ) {
|
||||
double n = Math.sqrt(lx * lx + ly * ly + lz * lz);
|
||||
if (n < 1e-9) return 0;
|
||||
double dx = lx / n * longueur, dy = ly / n * longueur, dz = lz / n * longueur;
|
||||
if (touche(ex, ey, ez, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, 0)) return 0;
|
||||
if (!touche(ex, ey, ez, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, MANQUE_MAX)) return MANQUE_MAX;
|
||||
double bas = 0, haut = MANQUE_MAX;
|
||||
for (int i = 0; i < 30; i++) { // précision ~4e-9 bloc
|
||||
double mil = (bas + haut) / 2;
|
||||
if (touche(ex, ey, ez, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, mil)) haut = mil;
|
||||
else bas = mil;
|
||||
}
|
||||
return haut;
|
||||
}
|
||||
|
||||
/** Test des plans (slabs) : le segment origine + t·d, t dans [0, 1], coupe-t-il la boîte gonflée de g ? */
|
||||
static boolean touche(double ox, double oy, double oz, double dx, double dy, double dz,
|
||||
double minX, double minY, double minZ, double maxX, double maxY, double maxZ, double g) {
|
||||
double[] t = {0.0, 1.0};
|
||||
return plan(ox, dx, minX - g, maxX + g, t) && plan(oy, dy, minY - g, maxY + g, t)
|
||||
&& plan(oz, dz, minZ - g, maxZ + g, t);
|
||||
}
|
||||
|
||||
private static boolean plan(double o, double d, double min, double max, double[] t) {
|
||||
if (Math.abs(d) < 1e-12) return o >= min && o <= max;
|
||||
double t1 = (min - o) / d, t2 = (max - o) / d;
|
||||
if (t1 > t2) { double x = t1; t1 = t2; t2 = x; }
|
||||
t[0] = Math.max(t[0], t1);
|
||||
t[1] = Math.min(t[1], t2);
|
||||
return t[0] <= t[1];
|
||||
}
|
||||
|
||||
/** Tolérance due au retard d'affichage de la cible : vitesse (blocs/tick) × ticks, plafonnée. */
|
||||
public static double toleranceLatence(double vitesseCibleParTick, GardeConfig cfg) {
|
||||
return toleranceLatence(vitesseCibleParTick, 0, cfg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Idem avec le ping de l'attaquant : la cible qu'il voit a ping / 50 ticks de retard de plus (16/10/2026, ping
|
||||
* élevé). Ping borné par {@link GardeConfig#pingLatenceMaxMs}, total plafonné : falsifier son ping ne donne
|
||||
* jamais plus de {@link GardeConfig#latenceCibleMaxBlocs}, et vanilla refuse de toute façon au-delà de portée + 1.
|
||||
*/
|
||||
public static double toleranceLatence(double vitesseCibleParTick, int pingMs, GardeConfig cfg) {
|
||||
double ticks = Math.max(0, cfg.ticksLatenceCible)
|
||||
+ Math.min(Math.max(0, pingMs), Math.max(0, cfg.pingLatenceMaxMs)) / 50.0;
|
||||
double v = Math.max(0, vitesseCibleParTick) * ticks;
|
||||
return Math.min(v, cfg.latenceCibleMaxBlocs);
|
||||
}
|
||||
|
||||
/**
|
||||
* Situations où la géométrie du coup n'est pas fiable (16/10/2026) : vrille riptide (le coup part au contact,
|
||||
* sans viser), élytres, téléportation récente (/tpa, réapparition, dimension, connexion), recul récent, cible
|
||||
* trop rapide (le client l'affiche ailleurs). On ne mesure pas : ni point, ni sanction.
|
||||
*
|
||||
* @return la raison, ou null si la mesure est fiable
|
||||
*/
|
||||
public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) {
|
||||
if (e.riptide()) return "riptide";
|
||||
if (e.elytres()) return "elytres";
|
||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) return "teleportation";
|
||||
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul";
|
||||
if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide";
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Seuil de portée (blocs) : portée d'interaction du joueur + marge + latence, le tout × facteur de lag. */
|
||||
public static double seuilPortee(double porteeJoueur, double latence, GardeConfig cfg, double facteur) {
|
||||
return porteeJoueur + (cfg.porteeToleranceBlocs + latence) * facteur;
|
||||
}
|
||||
|
||||
/** Seuil de hitbox (blocs). */
|
||||
public static double seuilHitbox(double latence, GardeConfig cfg, double facteur) {
|
||||
return (cfg.hitboxMargeBlocs + latence) * facteur;
|
||||
}
|
||||
|
||||
/** Points de portée : 0 sous le seuil, puis 1 + 1 par demi-bloc d'excès, au plus 4. */
|
||||
public static double pointsPortee(double distance, double seuil) {
|
||||
if (!(distance > seuil)) return 0;
|
||||
return 1.0 + Math.min(3.0, (distance - seuil) / 0.5);
|
||||
}
|
||||
|
||||
/** Points de hitbox : 0 sous le seuil, puis 1 + 1 par 0,3 bloc d'excès, au plus 3. */
|
||||
public static double pointsHitbox(double manque, double seuil) {
|
||||
if (!(manque > seuil)) return 0;
|
||||
return 1.0 + Math.min(2.0, (manque - seuil) / 0.3);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,6 @@
|
||||
"minVersion": "0.8",
|
||||
"package": "com.gastinelgarde.mixin",
|
||||
"compatibilityLevel": "JAVA_21",
|
||||
"mixins": ["MovePacketMixin", "RiptideMoveMixin"],
|
||||
"mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin"],
|
||||
"injectors": {"defaultRequire": 1}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,263 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 15/10/2026 : classes de contraption, portée / hitbox, contrôles 6 à 8 en observation seulement. */
|
||||
class Garde1015Test {
|
||||
|
||||
private GardeConfig cfg;
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
moteur = new Moteur(cfg);
|
||||
}
|
||||
|
||||
// --- Contraptions (chaînes de classes relevées par javap dans les jars du serveur) ----------------------
|
||||
|
||||
private static final List<String> DEFAUT = DetectionContraption.motifs(DetectionContraption.MOTIFS_DEFAUT);
|
||||
private static final String ABSTRAITE = "com.simibubi.create.content.contraptions.AbstractContraptionEntity";
|
||||
|
||||
@Test
|
||||
void contraptionsCreateEtAeronauticsReconnues() {
|
||||
assertTrue(DetectionContraption.correspond(List.of(
|
||||
"dev.eriksonn.aeronautics.content.blocks.propeller.bearing.contraption.PropellerBearingContraptionEntity",
|
||||
"com.simibubi.create.content.contraptions.ControlledContraptionEntity", ABSTRAITE), DEFAUT));
|
||||
assertTrue(DetectionContraption.correspond(List.of(
|
||||
"dev.ryanhcode.offroad.content.entities.BoreheadContraptionEntity",
|
||||
"com.simibubi.create.content.contraptions.ControlledContraptionEntity", ABSTRAITE), DEFAUT));
|
||||
// Les trains : hors du paquet « contraptions », manqués par l'ancien réglage par préfixe.
|
||||
assertTrue(DetectionContraption.correspond(List.of(
|
||||
"com.simibubi.create.content.trains.entity.CarriageContraptionEntity",
|
||||
"com.simibubi.create.content.contraptions.OrientedContraptionEntity", ABSTRAITE), DEFAUT));
|
||||
assertTrue(DetectionContraption.correspond(List.of(
|
||||
"com.simibubi.create.content.contraptions.gantry.GantryContraptionEntity", ABSTRAITE), DEFAUT));
|
||||
}
|
||||
|
||||
@Test
|
||||
void entitesImmobilesNonReconnues() {
|
||||
assertFalse(DetectionContraption.correspond(List.of("com.simibubi.create.content.contraptions.glue.SuperGlueEntity"), DEFAUT));
|
||||
assertFalse(DetectionContraption.correspond(List.of("com.simibubi.create.content.contraptions.actors.seat.SeatEntity"), DEFAUT));
|
||||
assertFalse(DetectionContraption.correspond(List.of("dev.eriksonn.aeronautics.content.blocks.hot_air.gust.GustEntity"), DEFAUT));
|
||||
assertFalse(DetectionContraption.correspond(List.of("dev.simulated_team.simulated.content.entities.honey_glue.HoneyGlueEntity"), DEFAUT));
|
||||
assertFalse(DetectionContraption.correspond(List.of("net.minecraft.world.entity.animal.Pig"), DEFAUT));
|
||||
}
|
||||
|
||||
@Test
|
||||
void ancienReglageParPaquetToujoursCompris() {
|
||||
List<String> ancien = DetectionContraption.motifs("com.simibubi.create.content.contraptions, dev.ryanhcode, x.y.*");
|
||||
assertTrue(DetectionContraption.correspond(List.of("com.simibubi.create.content.contraptions.glue.SuperGlueEntity"), ancien));
|
||||
assertTrue(DetectionContraption.correspond(List.of("dev.ryanhcode.offroad.content.entities.BoreheadContraptionEntity"), ancien));
|
||||
assertTrue(DetectionContraption.correspond(List.of("x.y.Truc"), ancien));
|
||||
assertFalse(DetectionContraption.correspond(List.of("x.yz.Truc"), ancien));
|
||||
// Pas de fausse correspondance sur un paquet voisin
|
||||
assertFalse(DetectionContraption.correspond(List.of("dev.ryanhcodeX.Truc"), ancien));
|
||||
// Un nom de classe exact couvre ses classes internes, pas un nom plus long
|
||||
assertTrue(DetectionContraption.correspond(List.of(ABSTRAITE + "$Interne"), DEFAUT));
|
||||
assertFalse(DetectionContraption.correspond(List.of(ABSTRAITE + "Bis"), DEFAUT));
|
||||
assertTrue(DetectionContraption.motifs(" , ").isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void graceApresContraption() {
|
||||
assertFalse(DetectionContraption.dansLaGrace(100, Integer.MIN_VALUE, 40));
|
||||
assertTrue(DetectionContraption.dansLaGrace(100, 60, 40));
|
||||
assertFalse(DetectionContraption.dansLaGrace(101, 60, 40));
|
||||
assertFalse(DetectionContraption.dansLaGrace(10, 60, 40)); // compteur de ticks revenu en arrière
|
||||
}
|
||||
|
||||
// --- Géométrie portée / hitbox -----------------------------------------------------------------------
|
||||
|
||||
/** Boîte de joueur (0,6 × 1,8) centrée en (x, 0, z). */
|
||||
private static double[] joueurEn(double x, double z) {
|
||||
return new double[] {x - 0.3, 0, z - 0.3, x + 0.3, 1.8, z + 0.3};
|
||||
}
|
||||
|
||||
private static double distance(double[] b) {
|
||||
return PorteeHitbox.distanceOeilBoite(0, 1.62, 0, b[0], b[1], b[2], b[3], b[4], b[5]);
|
||||
}
|
||||
|
||||
private static double manque(double lx, double ly, double lz, double longueur, double[] b) {
|
||||
return PorteeHitbox.manqueRegard(0, 1.62, 0, lx, ly, lz, longueur, b[0], b[1], b[2], b[3], b[4], b[5]);
|
||||
}
|
||||
|
||||
@Test
|
||||
void distanceAuPointLePlusProche() {
|
||||
assertEquals(3.2, distance(joueurEn(3.5, 0)), 1e-9);
|
||||
assertEquals(0.0, distance(new double[] {-1, 0, -1, 1, 2, 1}), 1e-9); // œil dedans
|
||||
assertEquals(Math.sqrt(2) * 2.7, distance(joueurEn(3, 3)), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void manqueDuRegard() {
|
||||
double[] b = joueurEn(2.3, 0); // boîte x 2,0 à 2,6
|
||||
assertEquals(0.0, manque(1, 0, 0, 4, b), 1e-9); // regard droit dessus
|
||||
assertEquals(0.0, manque(1, -0.1, 0.05, 4, b), 1e-9); // un peu de biais, touche encore
|
||||
// Regard le long de z : il faut gonfler la boîte de 2,0 en x pour toucher.
|
||||
assertEquals(2.0, manque(0, 0, 1, 4, b), 1e-6);
|
||||
// Regard droit dessus mais trop court : il manque 0,5 bloc au bout.
|
||||
assertEquals(0.5, manque(1, 0, 0, 1.5, b), 1e-6);
|
||||
// Regard à l'opposé : il faut gonfler jusqu'à englober l'œil (2,0).
|
||||
assertEquals(2.0, manque(-1, 0, 0, 4, b), 1e-6);
|
||||
// Très loin et à l'opposé : plafonné.
|
||||
assertEquals(PorteeHitbox.MANQUE_MAX, manque(-1, 0, 0, 4, joueurEn(20.3, 0)), 1e-9);
|
||||
// Regard nul : rien à mesurer
|
||||
assertEquals(0.0, manque(0, 0, 0, 4, b), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void hitboxGonfleeDeTroisDixiemes() {
|
||||
// Cible à 2,5 blocs, regard qui passe 0,3 bloc à côté de la boîte (cas d'un cheat hitbox +0,3) :
|
||||
// le rayon le long de x à z = 0,6 manque une boîte z -0,3..0,3 de 0,3.
|
||||
double[] b = joueurEn(2.8, 0);
|
||||
double m = PorteeHitbox.manqueRegard(0, 1.62, 0.6, 1, 0, 0, 4, b[0], b[1], b[2], b[3], b[4], b[5]);
|
||||
assertEquals(0.3, m, 1e-6);
|
||||
}
|
||||
|
||||
@Test
|
||||
void tolerancesEtPoints() {
|
||||
assertEquals(0.0, PorteeHitbox.toleranceLatence(0, cfg), 1e-9);
|
||||
assertEquals(0.84, PorteeHitbox.toleranceLatence(0.28, cfg), 1e-9); // sprint × 3 ticks
|
||||
assertEquals(1.0, PorteeHitbox.toleranceLatence(5, cfg), 1e-9); // plafond
|
||||
assertEquals(3.3, PorteeHitbox.seuilPortee(3.0, 0, cfg, 1.0), 1e-9);
|
||||
assertEquals(0.0, PorteeHitbox.pointsPortee(3.3, 3.3), 1e-9);
|
||||
assertEquals(2.0, PorteeHitbox.pointsPortee(3.8, 3.3), 1e-9);
|
||||
assertEquals(4.0, PorteeHitbox.pointsPortee(9, 3.3), 1e-9);
|
||||
assertEquals(0.0, PorteeHitbox.pointsPortee(Double.NaN, 3.3), 1e-9);
|
||||
assertEquals(0.0, PorteeHitbox.pointsHitbox(0.25, 0.25), 1e-9);
|
||||
assertEquals(2.0, PorteeHitbox.pointsHitbox(0.55, 0.25), 1e-9);
|
||||
assertEquals(3.0, PorteeHitbox.pointsHitbox(4, 0.25), 1e-9);
|
||||
}
|
||||
|
||||
// --- Moteur : portée / hitbox ------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void coupHonneteSansVerdict() {
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 2.9, 0.0, 3.0, 0.0).isEmpty());
|
||||
assertTrue(moteur.porteeHitbox(joueur, 50, EtatJoueur.normal(), 3.25, 0.2, 3.0, 0.0).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void porteeEtHitboxEnObservation() {
|
||||
List<Verdict> v = moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.7, 0.6, 3.0, 0.0);
|
||||
assertEquals(2, v.size());
|
||||
assertEquals(Controle.PORTEE, v.get(0).controle());
|
||||
assertEquals(Controle.HITBOX, v.get(1).controle());
|
||||
for (Verdict x : v) assertEquals(Mode.OBSERVE, x.mode());
|
||||
}
|
||||
|
||||
@Test
|
||||
void cibleRapideToleree() {
|
||||
// Cible qui sprinte (0,28 bloc/tick) : 0,84 bloc de plus sur les deux seuils.
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.9, 0.9, 3.0, 0.28).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptionsEtLag() {
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().creatif(true).build(), 4.9, 2, 5.0, 0).isEmpty());
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().pocheContraption(true).build(), 3.9, 2, 3.0, 0).isEmpty());
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().enVehicule(true).build(), 3.9, 2, 3.0, 0).isEmpty());
|
||||
// Serveur à 15 TPS : marges × 1,5 → portée 3,45, hitbox 0,375
|
||||
EtatJoueur lag = EtatJoueur.builder().tps(15).build();
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, lag, 3.4, 0.35, 3.0, 0).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void porteeEtHitboxCoupables() {
|
||||
cfg.mode(Controle.PORTEE, Mode.OFF);
|
||||
cfg.mode(Controle.HITBOX, Mode.OFF);
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.9, 2, 3.0, 0).isEmpty());
|
||||
cfg.mode(Controle.HITBOX, Mode.ENFORCE); // OBSERVE par défaut, ENFORCE possible
|
||||
assertEquals(Mode.ENFORCE, cfg.mode(Controle.HITBOX));
|
||||
List<Verdict> v = moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.9, 2, 3.0, 0);
|
||||
assertEquals(1, v.size());
|
||||
assertEquals(Controle.HITBOX, v.get(0).controle());
|
||||
}
|
||||
|
||||
// --- Modes : OBSERVE par défaut partout, ENFORCE possible partout (correction du 16/10) -------------
|
||||
|
||||
@Test
|
||||
void enforcePossiblePourTousLesControles() {
|
||||
for (Controle c : Controle.values()) {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(c), c.id());
|
||||
cfg.mode(c, Mode.ENFORCE);
|
||||
assertEquals(Mode.ENFORCE, cfg.mode(c), c.id());
|
||||
cfg.mode(c, Mode.OFF);
|
||||
assertEquals(Mode.OFF, cfg.mode(c), c.id());
|
||||
}
|
||||
for (Controle c : new Controle[] {Controle.NO_FALL, Controle.VITESSE, Controle.VOL,
|
||||
Controle.PORTEE, Controle.HITBOX}) {
|
||||
assertTrue(c.observeParDefaut(), c.id());
|
||||
}
|
||||
assertFalse(Controle.CADENCE.observeParDefaut());
|
||||
}
|
||||
|
||||
@Test
|
||||
void noFallEnforceCorrigeLeDrapeauAuSol() {
|
||||
cfg.mode(Controle.NO_FALL, Mode.ENFORCE);
|
||||
assertFalse(moteur.auSolPourDegatsDeChute(EtatJoueur.normal(), true, false));
|
||||
assertTrue(moteur.auSolPourDegatsDeChute(EtatJoueur.normal(), true, true));
|
||||
}
|
||||
|
||||
private static EtatMouvement mvt(double dxz, double dy, boolean solClient, boolean solServeur) {
|
||||
return new EtatMouvement(dxz, dy, 1, solClient, solServeur, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Triche continue 30 s. En OBSERVE (défaut) : des verdicts, un VL qui dépasse l'expulsion, jamais plus qu'une
|
||||
* alerte. En ENFORCE : la sanction devient applicable (comportement de d0c001d).
|
||||
*/
|
||||
private void triche(Controle attendu, EtatMouvement m, Mode mode) {
|
||||
if (mode == Mode.ENFORCE) cfg.mode(attendu, Mode.ENFORCE);
|
||||
boolean vu = false;
|
||||
double vlMax = 0;
|
||||
Sanction max = Sanction.AUCUNE;
|
||||
for (int i = 0; i < 600; i++) {
|
||||
for (Verdict v : moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), m)) {
|
||||
if (v.controle() != attendu) continue;
|
||||
assertEquals(mode, v.mode());
|
||||
vu = true;
|
||||
vlMax = Math.max(vlMax, v.vl());
|
||||
if (v.applicable().ordinal() > max.ordinal()) max = v.applicable();
|
||||
}
|
||||
}
|
||||
assertTrue(vu, attendu.id());
|
||||
assertTrue(vlMax >= cfg.seuilExpulsion, attendu.id() + " vl=" + vlMax);
|
||||
if (mode == Mode.OBSERVE) assertTrue(max.ordinal() <= Sanction.ALERTE.ordinal(), attendu.id() + " " + max);
|
||||
else assertTrue(max.ordinal() > Sanction.ALERTE.ordinal(), attendu.id() + " " + max);
|
||||
}
|
||||
|
||||
@Test
|
||||
void noFallJournaliseSansSanctionParDefaut() {
|
||||
triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.OBSERVE);
|
||||
assertTrue(moteur.auSolPourDegatsDeChute(EtatJoueur.normal(), true, false)); // drapeau client gardé
|
||||
}
|
||||
|
||||
@Test
|
||||
void vitesseJournaliseeSansSanctionParDefaut() {
|
||||
triche(Controle.VITESSE, mvt(1.5, 0, true, true), Mode.OBSERVE);
|
||||
}
|
||||
|
||||
@Test
|
||||
void volJournaliseSansSanctionParDefaut() {
|
||||
triche(Controle.VOL, mvt(0, 0.0, false, false), Mode.OBSERVE);
|
||||
}
|
||||
|
||||
@Test
|
||||
void noFallVitesseVolSanctionnesEnEnforce() {
|
||||
triche(Controle.VITESSE, mvt(1.5, 0, true, true), Mode.ENFORCE);
|
||||
init();
|
||||
triche(Controle.VOL, mvt(0, 0.0, false, false), Mode.ENFORCE);
|
||||
init();
|
||||
triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.ENFORCE);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,257 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* 16/10/2026 : riptide (délégué par GastinelClaims 1.1.7) avec ENFORCE rétabli, et faux positifs prévisibles de
|
||||
* portée / hitbox (ping, rotation en retard d'un tick, élytres, riptide, téléportation, recul, cible rapide).
|
||||
*/
|
||||
class Garde1016Test {
|
||||
|
||||
private GardeConfig cfg;
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
moteur = new Moteur(cfg);
|
||||
}
|
||||
|
||||
// --- Riptide ------------------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void riptideReleveLeSeuilVanillaPendantLaVrilleEtDeuxSecondesApres() {
|
||||
RiptideSuivi r = new RiptideSuivi();
|
||||
assertEquals(100f, r.seuil(100f, 0, false), 0f); // jamais de vrille : vanilla
|
||||
r.observer(10, true);
|
||||
assertEquals(RiptideTolerance.SEUIL_RIPTIDE, r.seuil(100f, 10, true), 0f);
|
||||
assertEquals(RiptideTolerance.SEUIL_RIPTIDE, r.seuil(100f, 10 + RiptideTolerance.GRACE_TICKS, false), 0f);
|
||||
assertEquals(100f, r.seuil(100f, 11 + RiptideTolerance.GRACE_TICKS, false), 0f);
|
||||
// Seuil élytres (300) relevé aussi pendant la vrille.
|
||||
assertEquals(RiptideTolerance.SEUIL_RIPTIDE, r.seuil(300f, 10, true), 0f);
|
||||
}
|
||||
|
||||
@Test
|
||||
void riptideEnchaineSousLaPluieSansRetourEnArriere() {
|
||||
// Enchaînement de 5 riptides (relâchement toutes les 15 ticks) : le seuil reste relevé sans interruption.
|
||||
RiptideSuivi r = new RiptideSuivi();
|
||||
for (int t = 0; t < 75; t++) {
|
||||
if (t % 15 == 0) assertTrue(r.relache(t, true, 12, true, true));
|
||||
r.observer(t, t % 15 < 8);
|
||||
assertEquals(RiptideTolerance.SEUIL_RIPTIDE, r.seuil(100f, t, t % 15 < 8), 0f, "tick " + t);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void tenirOuChargerTropPeuLeTridentNeReleveRien() {
|
||||
RiptideSuivi r = new RiptideSuivi();
|
||||
assertFalse(r.relache(0, false, 30, true, true)); // pas Impulsion
|
||||
assertFalse(r.relache(0, true, RiptideSuivi.CHARGE_MIN_TICKS - 1, true, true)); // charge trop courte
|
||||
assertFalse(r.relache(0, true, 30, false, false)); // sec, sous un toit
|
||||
assertEquals(100f, r.seuil(100f, 1, false), 0f);
|
||||
}
|
||||
|
||||
@Test
|
||||
void riptideExempteLeMouvementMemeEnEnforce() {
|
||||
for (Controle c : Controle.values()) cfg.mode(c, Mode.ENFORCE);
|
||||
EtatJoueur vrille = EtatJoueur.builder().riptide(true).build();
|
||||
EtatMouvement saut = new EtatMouvement(60, 8, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
for (int i = 0; i < 200; i++) {
|
||||
assertTrue(moteur.mouvement(joueur, i * 50L, vrille, saut).isEmpty());
|
||||
}
|
||||
// Atterrissage en vrille : le drapeau « au sol » du client est gardé (pas de dégâts de chute ajoutés).
|
||||
assertTrue(moteur.auSolPourDegatsDeChute(vrille, true, false));
|
||||
// Sans riptide, en ENFORCE, ce même mouvement est sanctionné.
|
||||
Sanction max = Sanction.AUCUNE;
|
||||
for (int i = 0; i < 200; i++) {
|
||||
for (Verdict v : moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), saut)) {
|
||||
if (v.applicable().ordinal() > max.ordinal()) max = v.applicable();
|
||||
}
|
||||
}
|
||||
assertTrue(max.ordinal() >= Sanction.SETBACK.ordinal(), max.toString());
|
||||
}
|
||||
|
||||
// --- Portée / hitbox : géométrie de test ----------------------------------------------------------------
|
||||
|
||||
/** Cible de 0,6 × 1,8 à 3 blocs devant l'œil (axe +z). */
|
||||
private static final double[] BOITE = {0.0, 0.0, 3.0, 0.6, 1.8, 3.6};
|
||||
private static final double[] OEIL = {0.3, 1.62, 0.0};
|
||||
private static final double[] VERS_CIBLE = {0, 0, 1};
|
||||
private static final double[] A_COTE = {1, 0, 0.2};
|
||||
|
||||
private static boolean contient(List<Verdict> v, Controle c) {
|
||||
return v.stream().anyMatch(x -> x.controle() == c);
|
||||
}
|
||||
|
||||
@Test
|
||||
void regardEnRetardDUnTickPasDeFauxPositif() {
|
||||
// Au coup, le serveur a encore le regard du tick précédent (à côté) ; le paquet suivant vise la cible.
|
||||
assertTrue(moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0).isEmpty());
|
||||
assertTrue(moteur.regardPorteeHitbox(joueur, 1000, OEIL, VERS_CIBLE).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void regardAcoteAuCoupEtApresEstSignale() {
|
||||
moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
|
||||
assertTrue(contient(moteur.regardPorteeHitbox(joueur, 1050, OEIL, A_COTE), Controle.HITBOX));
|
||||
}
|
||||
|
||||
@Test
|
||||
void paquetTropTardifNeBlanchitPasLeCoup() {
|
||||
moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
|
||||
// Plus de 2 ticks sans paquet : le regard n'avait pas changé, la mesure du coup reste.
|
||||
assertTrue(contient(moteur.regardPorteeHitbox(joueur, 1000 + 50 * 3, OEIL, VERS_CIBLE), Controle.HITBOX));
|
||||
}
|
||||
|
||||
@Test
|
||||
void coupSuivantTermineLeCoupEnAttente() {
|
||||
moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
|
||||
List<Verdict> v = moteur.coupPorteeHitbox(joueur, 1500, EtatJoueur.normal(), OEIL, VERS_CIBLE, BOITE, 3.0, 0);
|
||||
assertTrue(contient(v, Controle.HITBOX));
|
||||
assertTrue(moteur.regardPorteeHitbox(joueur, 1500, OEIL, VERS_CIBLE).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void oeilEnRetardSprintPotionGlacePasDeFauxPositif() {
|
||||
// Au coup, l'œil connu du serveur est 0,8 bloc en arrière (sprint-saut sous Vitesse II, glace) :
|
||||
// 3,8 blocs. Le paquet suivant le place à 3,0.
|
||||
double[] oeilAncien = {0.3, 1.62, -0.8};
|
||||
moteur.coupPorteeHitbox(joueur, 1000, EtatJoueur.normal(), oeilAncien, VERS_CIBLE, BOITE, 3.0, 0);
|
||||
assertTrue(moteur.regardPorteeHitbox(joueur, 1000, OEIL, VERS_CIBLE).isEmpty());
|
||||
// Un vrai coup à 3,8 blocs, sans rapprochement ensuite, reste signalé.
|
||||
moteur.coupPorteeHitbox(joueur, 2000, EtatJoueur.normal(), oeilAncien, VERS_CIBLE, BOITE, 3.0, 0);
|
||||
assertTrue(contient(moteur.regardPorteeHitbox(joueur, 2000, oeilAncien, VERS_CIBLE), Controle.PORTEE));
|
||||
}
|
||||
|
||||
@Test
|
||||
void pingEleveElargitLaToleranceMaisPlafonnee() {
|
||||
assertEquals(0.3, PorteeHitbox.toleranceLatence(0.1, 0, cfg), 1e-9);
|
||||
assertEquals(0.8, PorteeHitbox.toleranceLatence(0.1, 250, cfg), 1e-9);
|
||||
assertEquals(0.9, PorteeHitbox.toleranceLatence(0.1, 5000, cfg), 1e-9); // ping falsifié : borné à 300 ms
|
||||
assertEquals(1.0, PorteeHitbox.toleranceLatence(0.5, 5000, cfg), 1e-9); // plafond total
|
||||
// Cible qui recule à 0,1 bloc/tick, coup à 3,9 : signalé à 0 ms de ping, pas à 250 ms.
|
||||
assertTrue(contient(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().pingMs(0).build(),
|
||||
3.9, 0, 3.0, 0.1), Controle.PORTEE));
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().pingMs(250).build(),
|
||||
3.9, 0, 3.0, 0.1).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void situationsNonMesurees() {
|
||||
for (Controle c : Controle.values()) cfg.mode(c, Mode.ENFORCE);
|
||||
EtatJoueur[] etats = {
|
||||
EtatJoueur.builder().riptide(true).build(), // trident : coup au contact de la vrille
|
||||
EtatJoueur.builder().elytres(true).build(),
|
||||
EtatJoueur.builder().ticksDepuisTeleport(5).build(), // /tpa, réapparition, dimension, connexion
|
||||
EtatJoueur.builder().ticksDepuisRecul(3).build(), // knockback
|
||||
};
|
||||
for (EtatJoueur e : etats) {
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, e, 3.95, 3.0, 3.0, 0).isEmpty(), e.toString());
|
||||
moteur.coupPorteeHitbox(joueur, 0, e, OEIL, A_COTE, BOITE, 3.0, 0);
|
||||
assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, A_COTE).isEmpty(), e.toString());
|
||||
}
|
||||
// Cible très rapide (élytres, cible repoussée, cible téléportée) : non mesurée.
|
||||
assertEquals("cible-rapide", PorteeHitbox.raisonNonMesure(EtatJoueur.normal(), 1.6, cfg));
|
||||
assertTrue(moteur.porteeHitbox(joueur, 0, EtatJoueur.normal(), 3.95, 3.0, 3.0, 1.6).isEmpty());
|
||||
assertNull(PorteeHitbox.raisonNonMesure(EtatJoueur.normal(), 0.3, cfg));
|
||||
// Après la grâce : de nouveau mesuré.
|
||||
assertFalse(moteur.porteeHitbox(joueur, 0, EtatJoueur.builder().ticksDepuisTeleport(200).build(),
|
||||
3.95, 3.0, 3.0, 0).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void contraptionOuVehiculeDeLAttaquantExempte() {
|
||||
moteur.coupPorteeHitbox(joueur, 0, EtatJoueur.builder().pocheContraption(true).build(), OEIL, A_COTE, BOITE, 3.0, 0);
|
||||
assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, A_COTE).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefautJamaisDeBlocage() {
|
||||
for (int i = 0; i < 40; i++) {
|
||||
moteur.coupPorteeHitbox(joueur, i * 100L, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
|
||||
for (Verdict v : moteur.regardPorteeHitbox(joueur, i * 100L, OEIL, A_COTE)) {
|
||||
assertEquals(Mode.OBSERVE, v.mode());
|
||||
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal());
|
||||
}
|
||||
}
|
||||
assertFalse(moteur.coupsBloques(joueur, 4000));
|
||||
}
|
||||
|
||||
@Test
|
||||
void enforceBloqueLesCoupsApresSanction() {
|
||||
cfg.mode(Controle.HITBOX, Mode.ENFORCE);
|
||||
long t = 0;
|
||||
while (!moteur.coupsBloques(joueur, t) && t < 10_000) {
|
||||
moteur.coupPorteeHitbox(joueur, t, EtatJoueur.normal(), OEIL, A_COTE, BOITE, 3.0, 0);
|
||||
moteur.regardPorteeHitbox(joueur, t, OEIL, A_COTE);
|
||||
t += 100;
|
||||
}
|
||||
assertTrue(moteur.coupsBloques(joueur, t), "jamais bloqué");
|
||||
assertFalse(moteur.coupsBloques(joueur, t + Moteur.DUREE_BLOCAGE_COUPS_MS + 100));
|
||||
}
|
||||
|
||||
// --- Angle killaura différé (16/10, suite) -----------------------------------------------------------------
|
||||
|
||||
private static final double[] DERRIERE = {0, 0, -1};
|
||||
|
||||
@Test
|
||||
void angleKillauraRegardEnRetardPasDeFauxPositif() {
|
||||
cfg.mode(Controle.KILLAURA_ANGLE, Mode.ENFORCE);
|
||||
// Rotation de 180° pendant le tick : le serveur voit encore l'ancien regard au coup.
|
||||
assertTrue(moteur.coupDiffere(joueur, 1000, EtatJoueur.normal(), OEIL, DERRIERE, BOITE, 3.0, 0, true, true).isEmpty());
|
||||
assertTrue(moteur.regardPorteeHitbox(joueur, 1000, OEIL, VERS_CIBLE).isEmpty());
|
||||
assertFalse(moteur.coupsBloques(joueur, 1100));
|
||||
}
|
||||
|
||||
@Test
|
||||
void angleKillauraDerriereSignaleEtBloqueEnEnforce() {
|
||||
cfg.mode(Controle.KILLAURA_ANGLE, Mode.ENFORCE);
|
||||
long t = 0;
|
||||
boolean vu = false;
|
||||
while (!moteur.coupsBloques(joueur, t) && t < 10_000) {
|
||||
moteur.coupDiffere(joueur, t, EtatJoueur.normal(), OEIL, DERRIERE, BOITE, 3.0, 0, false, true);
|
||||
for (Verdict v : moteur.regardPorteeHitbox(joueur, t, OEIL, DERRIERE)) {
|
||||
vu |= v.controle() == Controle.KILLAURA_ANGLE;
|
||||
assertFalse(v.controle() == Controle.HITBOX || v.controle() == Controle.PORTEE); // cible sur contraption
|
||||
}
|
||||
t += 100;
|
||||
}
|
||||
assertTrue(vu);
|
||||
assertTrue(moteur.coupsBloques(joueur, t));
|
||||
}
|
||||
|
||||
@Test
|
||||
void angleKillauraPasCompteDeuxFois() {
|
||||
// attaque() reçoit -1 (angle différé) : seul le chemin différé compte l'angle.
|
||||
assertTrue(moteur.attaque(joueur, 0, EtatJoueur.normal(), -1, 1, true).isEmpty());
|
||||
moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), OEIL, DERRIERE, BOITE, 3.0, 0, false, true);
|
||||
long n = moteur.regardPorteeHitbox(joueur, 0, OEIL, DERRIERE).stream()
|
||||
.filter(v -> v.controle() == Controle.KILLAURA_ANGLE).count();
|
||||
assertEquals(1, n);
|
||||
}
|
||||
|
||||
@Test
|
||||
void angleKillauraCoupeOuExempte() {
|
||||
cfg.mode(Controle.KILLAURA_ANGLE, Mode.OFF);
|
||||
moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), OEIL, DERRIERE, BOITE, 3.0, 0, false, true);
|
||||
assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, DERRIERE).isEmpty());
|
||||
cfg.mode(Controle.KILLAURA_ANGLE, Mode.OBSERVE);
|
||||
moteur.coupDiffere(joueur, 0, EtatJoueur.builder().enVehicule(true).build(), OEIL, DERRIERE, BOITE, 3.0, 0, false, true);
|
||||
assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, DERRIERE).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void angleKillauraPasMesureEnVrilleRiptide() {
|
||||
moteur.coupDiffere(joueur, 0, EtatJoueur.builder().riptide(true).build(), OEIL, DERRIERE, BOITE, 3.0, 0, true, true);
|
||||
assertTrue(moteur.regardPorteeHitbox(joueur, 0, OEIL, DERRIERE).isEmpty());
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur