GastinelGarde 0.2.0 : phase 2 (no-fall corrige en enforce, vitesse horizontale, vol vertical), 90 tests

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Sonnet 5.5 a révisé 2026-10-14 00:14:03 +02:00
1 Parent b7e57250ff
révision a70809df6c
15 fichiers modifiés
+750 -11

Aucun fichier ne correspond à votre recherche

+123
Voir le fichier
@@ -0,0 +1,123 @@
# GastinelGarde
Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur uniquement). Plan et décisions :
`../PLAN-GASTINELGARDE.md`. Version **0.2.0** : phases 0, 1 et 2 du plan.
**État** : compilé, 90 tests JUnit verts (cœur pur, commandes, configuration, application réelle des mixins).
**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.
## Architecture
| Couche | Contenu |
|---|---|
| `core/` (Java pur, sans Minecraft, testé en JUnit) | `Moteur`, contrôles, points d'infraction (`VlCompteur`, décroissance), `Paliers`, `Exemptions`, `TraceLigne` / `TraceFichier` |
| `Garde`, `GardeEvents`, `GardeCommands`, `GardeSpec` | lecture de l'état du serveur, événements NeoForge, commandes, configuration |
| `mixin/` | `MovePacketMixin` (lecture seule : débit des paquets, position acceptée, marque de téléportation), `RiptideMoveMixin` (tolérance riptide, reprise de GastinelClaims) |
Les décisions de langage (Java, Rust seulement après benchmark) sont à la section 8 du plan.
L'interface du cœur ne contient aucun type Minecraft (tableaux, primitifs, enregistrements) pour pouvoir
porter un module plus tard.
## Contrôles (phase 1)
| Id | Idée | Seuils par défaut |
|---|---|---|
| `killaura-angle` | angle entre le regard et la silhouette de la cible | 60° d'excédent |
| `killaura-cibles` | entités différentes touchées | plus de 3 en 1 s |
| `cadence` | coups par seconde | plus de 20 sur 2 s consécutives |
| `regularite` | intervalles quasi identiques à cadence rapide | écart type < 12 ms et moyenne < 150 ms |
| `attaque-impossible` | coup en mangeant ou en buvant, ou cible non visible | sans seuil |
| `timer` | paquets de mouvement par seconde | plus de 22 sur 3 s consécutives |
### Contrôles de mouvement (phase 2, version 0.2.0)
| Id | Idée | Détail |
|---|---|---|
| `no-fall` | le client déclare « au sol » en pleine chute sans bloc dessous | **Corrige, ne punit pas** : en `ENFORCE`, le serveur remplace le drapeau transmis aux dégâts de chute (mixin `@ModifyArg` sur `doCheckFallDamage`). En `OBSERVE`, rien n'est modifié. Faible poids (0,5 point). |
| `vitesse` | déplacement horizontal supérieur au maximum attendu | Tampon d'excès sur 20 ticks (1,5 bloc par défaut). Bornes : marche 0,23, course 0,30, saut en courant 0,42 bloc par tick, modulées par Vitesse et Lenteur. **Valeurs de départ généreuses, à resserrer avec les traces.** |
| `vol` | en l'air, la vitesse verticale ne suit pas la gravité | Modèle `vy suivante = (vy − 0,08) × 0,98`, tolérance 0,05, plus de 10 ticks anormaux consécutifs. Détecte le flottement, la montée constante et le plané lent. |
Exemptions propres au mouvement : eau, lave, échelle, nage, vol créatif, toile, neige poudreuse, baie sucrée, slime,
lit (milieu spécial) ; glace, âmes, miel (friction ou facteur de vitesse différents) ; plus toutes les exemptions
communes ci-dessous. **Non gérés pour l'instant** (fausses alertes possibles en `OBSERVE`) : charge de vent
(Wind Charge), propulsion par des mods tiers, vitesses imposées par des blocs de commande.
Les temps de combat sont ceux du serveur (tick × 50 ms) : la régularité est donc mesurée au tick, ce qui rend
l'écart type de 12 ms équivalent à « exactement constant ». Une arme à cadence fixe lente n'est pas suspecte.
### Exemptions (une seule fonction : `core/Exemptions`)
Créatif, spectateur ; riptide (trident Impulsion en main et 2 s après) ; élytres ; lévitation, chute lente ;
véhicule ; contraption Create / Aeronautics à moins de 3 blocs (détection par préfixe de nom de classe, **à valider
sur le serveur réel**) ; 2 s après une téléportation, un recul ou un dégât ; gel du serveur (tick de plus de
250 ms, 5 s de grâce). Serveur sous 18 TPS ou ping de plus de 250 ms : seuils × 1,5.
## Sanctions
| Palier (points d'un contrôle) | OBSERVE | ENFORCE |
|---|---|---|
| au-dessus de 0 | journal | journal |
| 5 | alerte aux ops | alerte aux ops |
| 10 | alerte | coup annulé / retour à la dernière position valide |
| 20 | alerte | expulsion |
Plafond configurable (`sanctionMax`). Les points décroissent de 0,5 par seconde.
## Commandes (ops, niveau 2)
```
/garde état
/garde status [joueur] modes, ou points d'infraction d'un joueur
/garde alertes on|off messages de l'anti-triche pour toi
/garde mode <contrôle> off|observe|enforce (écrit dans la configuration)
/garde exempter <joueur> <minutes>
/garde traces on|off enregistreur (jusqu'au redémarrage)
/garde reload
```
## Fichiers
- Configuration : `config/gastinelgarde-server.toml` (rechargée à chaud, plus `/garde reload`).
- Journal : `logs/gastinelgarde.log` (une ligne par infraction : contrôle, points, exemptions actives).
- Traces : `gastinelgarde-traces/trace-AAAA-MM-JJ.jsonl`. **Enregistrement continu pour tous** (décision T7 de
Théo). Ce sont des positions de joueurs, donc des données personnelles : conservation 7 jours et 1 Go au
maximum par défaut (`[traces]` dans la configuration). Ordre de grandeur : 20 lignes par seconde et par
joueur, environ 150 octets par ligne, donc environ 10 Mo par heure et par joueur connecté.
## Construire et déployer
```
sh build-sur-cornafserver.sh # sur cornafserver, conteneur JDK 21 jetable
.\gradlew.bat build # ou sur le PC (JDK 21) : build/libs/gastinelgarde-neoforge-1.21.1-0.2.0.jar
bash ../deployer-garde-0-2-0.sh # sur cornafserver, par Théo (non lancé)
```
### À vérifier en jeu (jamais fait)
1. `/garde status` répond, tous les contrôles en OBSERVE.
2. Marcher, sprinter, nager, prendre une perle : aucune alerte.
3. Avec ton client de triche : killaura (`killaura-angle`, `killaura-cibles`, `cadence`), timer, speed (`vitesse`),
fly (`vol`) et no-fall lèvent des infractions dans `logs/gastinelgarde.log`.
Honnêtement, essayer aussi : sauts en courant, chute, glace, échelle, eau, slime, Wind Charge, élytres avec
fusée, riptide, perle. Chaque ligne du journal indique les exemptions actives.
4. Riptide : plus de retour en arrière (le mixin est repris de GastinelClaims 1.1.6).
5. Create Aeronautics : monter dans une contraption, se battre dessus. Aucune fausse alerte, sinon relever les
noms de classe des entités et compléter `prefixesContraption`.
6. Lancer une session honnête (marche, combat, riptide, élytres, bateau volant) pour amorcer le corpus de traces.
### Riptide : GastinelClaims 1.1.6 contient le même mixin
Décision T6 : le mixin riptide vit désormais dans GastinelGarde. Tant que les deux mods sont présents, le seuil est
relevé deux fois au même maximum (sans danger). À faire plus tard : une 1.1.7 de GastinelClaims sans
`RiptideMoveMixin` ni `RiptideTolerance` (non fait : le code de GastinelClaims 1.1.2 à 1.1.6 n'est pas commité).
## Limites connues
- Phase 3 non commencée : élytres, débogage d'AntiXray, heuristique de minage.
- Phase 2 jamais essayée sur de vrais mouvements : les bornes de vitesse et le modèle de vol viennent des
formules vanilla, pas de mesures. Les traces enregistrées permettront de les ajuster avant tout `ENFORCE`.
- La grâce « gel du serveur » se base sur la durée d'un tick (> 250 ms), pas sur le message vanilla « Can't keep up ».
- `online-mode=false` : un tricheur expulsé peut revenir sous un autre pseudo de la whitelist.
- Le contrôle `attaque-impossible` ne couvre que les cas à courte portée : vanilla refuse déjà les coups à plus de
3 blocs sans ligne de vue.
+1 -1
Voir le fichier
@@ -1,7 +1,7 @@
org.gradle.jvmargs=-Xmx2G
org.gradle.parallel=true
mod_version=0.1.0
mod_version=0.2.0
mod_group_id=com.gastinelgarde
mod_id=gastinelgarde
+95 -6
Voir le fichier
@@ -1,7 +1,10 @@
package com.gastinelgarde;
import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.EtatMouvement;
import com.gastinelgarde.core.GardeConfig;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Suivi;
@@ -21,7 +24,14 @@ import java.util.Map;
import java.util.Set;
import java.util.UUID;
import net.minecraft.ChatFormatting;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Holder;
import net.minecraft.network.chat.Component;
import net.minecraft.tags.BlockTags;
import net.minecraft.world.effect.MobEffect;
import net.minecraft.world.effect.MobEffectInstance;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.effect.MobEffects;
@@ -50,6 +60,12 @@ public final class Garde {
long exemptJusquaMs = 0;
double dernierX, dernierY, dernierZ;
boolean aDernierePosition;
// Mouvement (phase 2)
int mouvementTick = Integer.MIN_VALUE;
double mouvementX, mouvementY, mouvementZ;
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
int contraptionTick = Integer.MIN_VALUE;
boolean contraptionProche;
}
private static final GardeConfig CONFIG = new GardeConfig();
@@ -194,7 +210,7 @@ public final class Garde {
.levitation(p.hasEffect(MobEffects.LEVITATION))
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
.enVehicule(p.isPassenger())
.pocheContraption(chercherContraption && pocheContraption(p))
.pocheContraption(chercherContraption && pocheContraptionEnCache(p, m, tick))
.utiliseObjet(mange)
.ticksDepuisTeleport(depuis(tick, m.teleportTick))
.ticksDepuisRecul(depuis(tick, m.reculTick))
@@ -213,6 +229,15 @@ public final class Garde {
return stack.is(Items.TRIDENT) && EnchantmentHelper.getTridentSpinAttackStrength(stack, joueur) > 0.0F;
}
/** La détection est refaite au plus toutes les 10 ticks par joueur. */
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;
}
return m.contraptionProche;
}
/** Une entité de contraption (Create, Aeronautics…) est-elle toute proche ? Détection par nom de classe. */
private static boolean pocheContraption(Player p) {
int dist = GardeSpec.distanceContraption();
@@ -238,11 +263,15 @@ public final class Garde {
public static Sanction traiter(ServerPlayer p, List<Verdict> verdicts) {
if (verdicts.isEmpty()) return Sanction.AUCUNE;
marques(p.getUUID()).dernierVerdictTick = p.server.getTickCount();
long maintenant = System.currentTimeMillis();
Suivi suivi = MOTEUR.suivi(p.getUUID());
for (Verdict v : verdicts) {
String ligne = String.format("%s %s mode=%s vl=%.1f (+%.1f) palier=%s applique=%s %s exemptions=%s",
p.getGameProfile().getName(), v.controle().id(), v.mode(), v.vl(), v.points(),
v.palier(), v.applicable(), v.details(), v.exemptions());
ecrireJournal(ligne);
if (suivi.autoriserJournal(v.controle(), maintenant, 1000)) { // au plus une ligne par seconde et par contrôle
String ligne = String.format("%s %s mode=%s vl=%.1f (+%.1f) palier=%s applique=%s %s exemptions=%s",
p.getGameProfile().getName(), v.controle().id(), v.mode(), v.vl(), v.points(),
v.palier(), v.applicable(), v.details(), v.exemptions());
ecrireJournal(ligne);
}
if (v.notifier()) alerterOps(p, v);
}
return Verdict.pire(verdicts);
@@ -295,6 +324,25 @@ public final class Garde {
public static void apresMouvement(ServerPlayer p) {
int tick = p.server.getTickCount();
Marques m = marques(p.getUUID());
boolean solServeur = auSolServeur(p);
// Phase 2 : no-fall (divergence), vitesse horizontale, vol.
if (mouvementControlesActifs() && !estExempteManuellement(p.getUUID()) && m.mouvementTick != Integer.MIN_VALUE) {
double dx = p.getX() - m.mouvementX;
double dz = p.getZ() - m.mouvementZ;
EtatMouvement em = new EtatMouvement(Math.sqrt(dx * dx + dz * dz), p.getY() - m.mouvementY,
tick - m.mouvementTick, p.onGround(), solServeur, p.isSprinting(), p.isShiftKeyDown(),
p.isUsingItem(), niveau(p, MobEffects.MOVEMENT_SPEED), niveau(p, MobEffects.MOVEMENT_SLOWDOWN),
milieuSpecial(p), frictionAnormale(p));
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etat(p, true), em);
Sanction s = traiter(p, v);
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v);
}
m.mouvementTick = tick;
m.mouvementX = p.getX();
m.mouvementY = p.getY();
m.mouvementZ = p.getZ();
if (m.dernierVerdictTick != tick) {
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
p.level().dimension().location().toString());
@@ -308,12 +356,53 @@ public final class Garde {
m.dernierY = p.getY();
m.dernierZ = p.getZ();
m.aDernierePosition = true;
boolean solServeur = !p.level().noCollision(p, p.getBoundingBox().move(0.0, -0.05, 0.0));
tracer(new TraceLigne(tick, p.getGameProfile().getName(), "move", p.getX(), p.getY(), p.getZ(),
vx, vy, vz, p.onGround(), solServeur, TraceLigne.masque(etat(p, false)), -1, Double.NaN, null));
}
}
/**
* Drapeau « au sol » à donner aux dégâts de chute (appelé par le mixin). En OBSERVE ou hors exemption
* inapplicable, c'est celui du client : comportement vanilla.
*/
public static boolean auSolPourChute(ServerPlayer p, boolean auSolClient) {
if (!auSolClient) return false;
if (CONFIG.mode(Controle.NO_FALL) != Mode.ENFORCE) return auSolClient;
if (estExempteManuellement(p.getUUID())) return auSolClient;
return MOTEUR.auSolPourDegatsDeChute(etat(p, true), auSolClient, auSolServeur(p));
}
private static boolean mouvementControlesActifs() {
return CONFIG.mode(Controle.NO_FALL) != Mode.OFF || CONFIG.mode(Controle.VITESSE) != Mode.OFF
|| CONFIG.mode(Controle.VOL) != Mode.OFF;
}
/** Bloc solide sous la boîte du joueur, vu par le serveur (0,05 bloc de marge). */
private static boolean auSolServeur(ServerPlayer p) {
return !p.level().noCollision(p, p.getBoundingBox().move(0.0, -0.05, 0.0));
}
private static int niveau(ServerPlayer p, Holder<MobEffect> effet) {
MobEffectInstance e = p.getEffect(effet);
return e == null ? 0 : e.getAmplifier() + 1;
}
/** Eau, lave, échelle, vol créatif, toile, neige poudreuse, miel, slime, lit : la vitesse et le vol vanilla ne s'appliquent pas. */
private static boolean milieuSpecial(ServerPlayer p) {
if (p.isInWater() || p.isInLava() || p.onClimbable() || p.isSwimming() || p.getAbilities().flying) return true;
BlockPos pos = p.blockPosition();
BlockState pied = p.level().getBlockState(pos);
BlockState sous = p.level().getBlockState(pos.below());
return pied.is(Blocks.COBWEB) || pied.is(Blocks.POWDER_SNOW) || pied.is(Blocks.SWEET_BERRY_BUSH)
|| sous.is(Blocks.SLIME_BLOCK) || sous.is(BlockTags.BEDS);
}
/** Glace, slime, âmes, miel : friction ou facteur de vitesse du bloc différents de la normale. */
private static boolean frictionAnormale(ServerPlayer p) {
BlockState sous = p.level().getBlockState(p.getBlockPosBelowThatAffectsMyMovement());
return sous.getBlock().getFriction() != 0.6F || sous.getBlock().getSpeedFactor() != 1.0F;
}
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
if (s == Sanction.EXPULSION) {
+9
Voir le fichier
@@ -31,6 +31,8 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue PAQUETS_PAR_SECONDE;
private static final ModConfigSpec.IntValue TIMER_SECONDES;
private static final ModConfigSpec.DoubleValue EXCES_VITESSE;
private static final ModConfigSpec.IntValue GRACE_TELEPORT;
private static final ModConfigSpec.IntValue GRACE_RECUL;
private static final ModConfigSpec.IntValue GRACE_GEL;
@@ -82,6 +84,12 @@ public final class GardeSpec {
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
b.pop();
b.push("mouvement");
EXCES_VITESSE = b.comment("Total d'excès de vitesse horizontale (blocs) sur 20 ticks avant une infraction.",
"Valeurs de départ généreuses, à resserrer avec les traces réelles.")
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
b.pop();
b.push("exemptions");
GRACE_TELEPORT = b.defineInRange("graceTeleportTicks", 40, 0, 600);
GRACE_RECUL = b.defineInRange("graceReculTicks", 20, 0, 600);
@@ -135,6 +143,7 @@ public final class GardeSpec {
c.intervalleMoyenMaxMs = INTERVALLE_MOYEN_MAX.get();
c.paquetsParSecondeMax = PAQUETS_PAR_SECONDE.get();
c.timerSecondesSoutenues = TIMER_SECONDES.get();
c.excesVitesseBlocs = EXCES_VITESSE.get();
c.graceTeleportTicks = GRACE_TELEPORT.get();
c.graceReculTicks = GRACE_RECUL.get();
c.graceGelTicks = GRACE_GEL.get();
+5 -2
Voir le fichier
@@ -1,13 +1,16 @@
package com.gastinelgarde.core;
/** Les contrôles de la phase 1 (combat et cadence). Les phases 2 et 3 s'ajouteront ici. */
/** Les contrôles : phase 1 (combat, cadence, timer) et phase 2 (no-fall, vitesse, vol). La phase 3 s'ajoutera. */
public enum Controle {
KILLAURA_ANGLE("killaura-angle"),
KILLAURA_CIBLES("killaura-cibles"),
CADENCE("cadence"),
REGULARITE("regularite"),
ATTAQUE_IMPOSSIBLE("attaque-impossible"),
TIMER("timer");
TIMER("timer"),
NO_FALL("no-fall"),
VITESSE("vitesse"),
VOL("vol");
private final String id;
+24
Voir le fichier
@@ -0,0 +1,24 @@
package com.gastinelgarde.core;
/**
* Un tick de mouvement d'un joueur, tel que le serveur l'a accepté (phase 2). Tout vient du serveur.
*
* @param dxz déplacement horizontal depuis le paquet précédent accepté (blocs)
* @param dy déplacement vertical (blocs)
* @param ticks nombre de ticks serveur écoulés depuis le paquet précédent (au moins 1)
* @param auSolClient ce que le client déclare
* @param auSolServeur bloc solide sous la boîte du joueur, vu par le serveur
* @param sprint le joueur court
* @param furtif le joueur est accroupi
* @param ralentiParObjet utilise un objet (manger, bloquer, arc…) : ralenti
* @param amplificateurVitesse niveau de l'effet Vitesse (0 si aucun, 1 = niveau I)
* @param amplificateurLenteur niveau de l'effet Lenteur (0 si aucun)
* @param milieuSpecial eau, lave, échelle, liane, toile, miel, neige poudreuse, colonne à bulles : le calcul
* de vitesse ne s'applique pas
* @param frictionAnormale glace, glace compacte, glace bleue, slime, âmes… : le calcul ne s'applique pas
*/
public record EtatMouvement(double dxz, double dy, int ticks, boolean auSolClient, boolean auSolServeur,
boolean sprint, boolean furtif, boolean ralentiParObjet,
int amplificateurVitesse, int amplificateurLenteur,
boolean milieuSpecial, boolean frictionAnormale) {
}
+4
Voir le fichier
@@ -37,6 +37,10 @@ public final class GardeConfig {
public int paquetsParSecondeMax = 22;
public int timerSecondesSoutenues = 3;
// --- Mouvement (phase 2) ---
/** Total d'excès de vitesse horizontale (blocs) sur 20 ticks au-delà duquel on lève une infraction. */
public double excesVitesseBlocs = 1.5;
// --- Exemptions ---
public int graceTeleportTicks = 40;
public int graceReculTicks = 20;
+43
Voir le fichier
@@ -103,6 +103,49 @@ public final class Moteur {
return verdicts;
}
/**
* Un mouvement accepté par le serveur (phase 2) : no-fall (divergence), vitesse horizontale, vol.
* Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout.
*/
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m) {
boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF;
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
if (!noFall && !vitesse && !vol) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
if (ex.exempt()) {
s.vitesse.vider();
s.vol.vider();
return List.of();
}
List<Verdict> verdicts = new ArrayList<>(3);
if (noFall) {
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m), nowMs, ex,
"au sol declare sans bloc dessous pendant une chute");
}
if (vitesse) {
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
ajouter(verdicts, s, Controle.VITESSE, pts, nowMs, ex,
String.format(Locale.ROOT, "dxz=%.3f max=%.3f", m.dxz(), VitesseHorizontale.vitesseMax(m)));
}
if (vol) {
double pts = s.vol.enregistrer(m, false);
ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy()));
}
return verdicts;
}
/**
* Drapeau « au sol » à donner aux dégâts de chute : celui du serveur en ENFORCE (sauf exemption), celui du
* client sinon.
*/
public boolean auSolPourDegatsDeChute(EtatJoueur etat, boolean auSolClient, boolean auSolServeur) {
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
}
// --- Interne ----------------------------------------------------------------------------------------
private void ajouter(List<Verdict> sortie, Suivi s, Controle c, double points, long nowMs,
+35
Voir le fichier
@@ -0,0 +1,35 @@
package com.gastinelgarde.core;
/**
* Contrôle 6 : no-fall. Le client déclare « au sol » et vanilla le croit, donc plus de dégâts de chute. Le serveur
* 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.
*/
public final class NoFall {
/** Chute rapide minimale (blocs par tick, négatif) à partir de laquelle une divergence compte. */
public static final double DY_CHUTE = -0.3;
private NoFall() { }
/**
* Drapeau « au sol » à utiliser pour les dégâts de chute.
*
* @param exempt joueur exempté du mouvement (contraption, véhicule, riptide…) : on ne touche à rien
*/
public static boolean auSolEffectif(boolean auSolClient, boolean auSolServeur, boolean exempt, Mode mode) {
if (mode != Mode.ENFORCE || exempt) return auSolClient;
return auSolClient && auSolServeur;
}
/**
* Points d'infraction : le client déclare « au sol » pendant une chute rapide alors qu'aucun bloc n'est sous
* lui. Faible volontairement (0,5) : le plan veut corriger sans punir au début.
*/
public static double points(EtatMouvement e) {
if (e.auSolClient() && !e.auSolServeur() && e.dy() <= DY_CHUTE && !e.milieuSpecial()) return 0.5;
return 0;
}
}
+12
Voir le fichier
@@ -10,6 +10,8 @@ public final class Suivi {
public final CiblesMultiples cibles = new CiblesMultiples();
public final Cadence cadence = new Cadence();
public final TimerPaquets timer = new TimerPaquets();
public final VitesseHorizontale vitesse = new VitesseHorizontale();
public final VolVertical vol = new VolVertical();
// Dernière position jugée valide (retour en arrière).
private boolean positionValide;
@@ -41,6 +43,8 @@ public final class Suivi {
public float pitch() { return pitch; }
public String dimension() { return dimension; }
private final Map<Controle, Long> dernierJournal = new EnumMap<>(Controle.class);
/** Vrai si une alerte peut partir maintenant pour ce contrôle (au plus une toutes les {@code delaiMs}). */
boolean autoriserAlerte(Controle c, long nowMs, long delaiMs) {
Long derniere = derniereAlerte.get(c);
@@ -48,4 +52,12 @@ public final class Suivi {
derniereAlerte.put(c, nowMs);
return true;
}
/** Idem pour le journal : évite une ligne par tick pendant une chute ou une course. */
public boolean autoriserJournal(Controle c, long nowMs, long delaiMs) {
Long derniere = dernierJournal.get(c);
if (derniere != null && nowMs - derniere < delaiMs) return false;
dernierJournal.put(c, nowMs);
return true;
}
}
+62
Voir le fichier
@@ -0,0 +1,62 @@
package com.gastinelgarde.core;
/**
* Contrôle 7 : vitesse horizontale. Un tampon d'excès sur 20 ticks plutôt qu'un seuil à chaque paquet (plan),
* pour absorber les paquets groupés par le réseau.
*
* Les bornes sont volontairement généreuses (les valeurs vanilla courantes : marche 0,22 bloc par tick, course
* 0,28, saut en courant environ 0,36). Elles seront resserrées avec les traces réelles (enregistreur).
*/
public final class VitesseHorizontale {
public static final double MARCHE = 0.23;
public static final double COURSE = 0.30;
public static final double COURSE_SAUT = 0.42;
public static final double FURTIF = 0.07;
public static final double RALENTI_OBJET = 0.12;
/** Les ticks d'historique conservés pour le tampon d'excès. */
public static final int FENETRE_TICKS = 20;
private final double[] exces = new double[FENETRE_TICKS];
private int index;
/** Vitesse maximale attendue (blocs par tick) pour cet état, avant la tolérance du lag. */
public static double vitesseMax(EtatMouvement e) {
double v;
if (e.furtif()) v = FURTIF;
else if (e.ralentiParObjet()) v = RALENTI_OBJET;
else if (e.sprint()) v = e.auSolServeur() ? COURSE : COURSE_SAUT;
else v = e.auSolServeur() ? MARCHE : COURSE; // en l'air sans courir : l'élan d'un saut en marchant
v *= 1.0 + 0.2 * Math.max(0, e.amplificateurVitesse());
v *= Math.max(0.05, 1.0 - 0.15 * Math.max(0, e.amplificateurLenteur()));
return v;
}
/**
* @param facteur tolérance (lag)
* @param seuilBlocs total d'excès sur la fenêtre au-delà duquel on lève une infraction
* @return points d'infraction (0 si rien)
*/
public double enregistrer(EtatMouvement e, double facteur, double seuilBlocs) {
if (e.milieuSpecial() || e.frictionAnormale()) {
exces[index] = 0;
index = (index + 1) % FENETRE_TICKS;
return 0;
}
int ticks = Math.max(1, e.ticks());
double permis = vitesseMax(e) * facteur * ticks;
double depasse = Math.max(0, e.dxz() - permis);
exces[index] = depasse;
index = (index + 1) % FENETRE_TICKS;
double total = 0;
for (double v : exces) total += v;
if (total <= seuilBlocs) return 0;
return 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0);
}
public void vider() {
java.util.Arrays.fill(exces, 0);
index = 0;
}
}
+61
Voir le fichier
@@ -0,0 +1,61 @@
package com.gastinelgarde.core;
/**
* Contrôle 8 : vol hors élytres. En l'air, sans exemption, la vitesse verticale doit suivre la gravité :
* {@code vy suivante = (vy - 0,08) × 0,98}. Une montée ou un plané anormal pendant plus de 10 ticks est une
* infraction (le plan : des VL, puis un setback).
*/
public final class VolVertical {
public static final double GRAVITE = 0.08;
public static final double TRAINEE = 0.98;
/** Écart toléré entre la vitesse observée et la vitesse prédite (blocs par tick). */
public static final double TOLERANCE = 0.05;
/** Nombre de ticks anormaux consécutifs avant la première infraction. */
public static final int TICKS_ANORMAUX = 10;
private double derniereVitesse;
private boolean aVitesse;
private boolean etaitEnAir;
private int anormauxConsecutifs;
/**
* @param exempt joueur exempté du mouvement
* @return points d'infraction (0 si rien)
*/
public double enregistrer(EtatMouvement e, boolean exempt) {
// Paquets groupés ou manquants : la prédiction d'un tick ne vaut plus, on oublie la vitesse précédente.
if (e.ticks() != 1) {
aVitesse = false;
return 0;
}
boolean enAir = !e.auSolServeur();
double dy = e.dy();
double points = 0;
if (exempt || e.milieuSpecial() || !enAir) {
anormauxConsecutifs = 0;
} else if (etaitEnAir && aVitesse) {
double prevue = (derniereVitesse - GRAVITE) * TRAINEE;
boolean ecart = Math.abs(dy - prevue) > TOLERANCE;
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08.
if (ecart) anormauxConsecutifs++;
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
if (anormauxConsecutifs > TICKS_ANORMAUX) {
points = 1.0 + Math.min(3.0, (anormauxConsecutifs - TICKS_ANORMAUX) / 10.0);
}
}
derniereVitesse = dy;
aVitesse = true;
etaitEnAir = enAir;
return points;
}
public void vider() {
derniereVitesse = 0;
aVitesse = false;
etaitEnAir = false;
anormauxConsecutifs = 0;
}
}
+13
Voir le fichier
@@ -7,6 +7,7 @@ import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyArg;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
/**
@@ -30,6 +31,18 @@ public abstract class MovePacketMixin {
if (player != null) Garde.apresMouvement(player);
}
/**
* No-fall : le drapeau « au sol » transmis aux dégâts de chute. Inchangé (comportement vanilla) tant que le
* contrôle no-fall n'est pas en ENFORCE ; sinon le serveur exige un bloc sous le joueur.
*/
@ModifyArg(method = "handleMovePlayer",
at = @At(value = "INVOKE",
target = "Lnet/minecraft/server/level/ServerPlayer;doCheckFallDamage(DDDZ)V"),
index = 3)
private boolean gastinelgarde$auSolPourChute(boolean auSolClient) {
return player != null ? Garde.auSolPourChute(player, auSolClient) : auSolClient;
}
// Toute téléportation (commande, mod, perle, setback) passe par cette méthode : on marque le joueur.
@Inject(method = "teleport(DDDFFLjava/util/Set;)V", at = @At("HEAD"))
private void gastinelgarde$marqueTeleport(double x, double y, double z, float yaw, float pitch,
+2 -2
Voir le fichier
@@ -4,10 +4,10 @@ license="MIT"
[[mods]]
modId="gastinelgarde"
version="0.1.0"
version="0.2.0"
displayName="GastinelGarde"
authors="Théo Gastinel"
description='''Anti-triche maison : contrôles de combat et de cadence (phase 1), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
description='''Anti-triche maison : combat, cadence, timer (phase 1), no-fall, vitesse et vol (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
# Les clients n'ont pas besoin du mod : ne pas exiger sa présence côté client.
displayTest="IGNORE_ALL_VERSION"
+261
Voir le fichier
@@ -0,0 +1,261 @@
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.Test;
class MouvementTest {
private static EtatMouvement marche(double dxz, double dy, boolean solServeur) {
return new EtatMouvement(dxz, dy, 1, solServeur, solServeur, false, false, false, 0, 0, false, false);
}
private static EtatMouvement course(double dxz, double dy, boolean solServeur) {
return new EtatMouvement(dxz, dy, 1, solServeur, solServeur, true, false, false, 0, 0, false, false);
}
// --- Vitesse maximale ---
@Test
void vitessesDeReference() {
assertEquals(VitesseHorizontale.MARCHE, VitesseHorizontale.vitesseMax(marche(0, 0, true)), 1e-9);
assertEquals(VitesseHorizontale.COURSE, VitesseHorizontale.vitesseMax(course(0, 0, true)), 1e-9);
assertEquals(VitesseHorizontale.COURSE_SAUT, VitesseHorizontale.vitesseMax(course(0, 0, false)), 1e-9);
}
@Test
void effetVitesseEtLenteur() {
EtatMouvement v2 = new EtatMouvement(0, 0, 1, true, true, true, false, false, 2, 0, false, false);
assertEquals(VitesseHorizontale.COURSE * 1.4, VitesseHorizontale.vitesseMax(v2), 1e-9);
EtatMouvement l1 = new EtatMouvement(0, 0, 1, true, true, true, false, false, 0, 1, false, false);
assertEquals(VitesseHorizontale.COURSE * 0.85, VitesseHorizontale.vitesseMax(l1), 1e-9);
}
@Test
void accroupiEtRalentiParObjet() {
EtatMouvement f = new EtatMouvement(0, 0, 1, true, true, false, true, false, 0, 0, false, false);
assertEquals(VitesseHorizontale.FURTIF, VitesseHorizontale.vitesseMax(f), 1e-9);
EtatMouvement o = new EtatMouvement(0, 0, 1, true, true, false, false, true, 0, 0, false, false);
assertEquals(VitesseHorizontale.RALENTI_OBJET, VitesseHorizontale.vitesseMax(o), 1e-9);
}
// --- Vitesse horizontale (tampon d'excès) ---
@Test
void courseNormaleSansInfraction() {
VitesseHorizontale v = new VitesseHorizontale();
for (int i = 0; i < 100; i++) assertEquals(0, v.enregistrer(course(0.28, 0, true), 1.0, 1.5), 1e-9);
}
@Test
void sautEnCourantSansInfraction() {
VitesseHorizontale v = new VitesseHorizontale();
for (int i = 0; i < 100; i++) assertEquals(0, v.enregistrer(course(0.36, 0, false), 1.0, 1.5), 1e-9);
}
@Test
void speedHackDoubleLaVitesse() {
VitesseHorizontale v = new VitesseHorizontale();
double dernier = 0;
for (int i = 0; i < 20; i++) dernier = v.enregistrer(course(0.6, 0, true), 1.0, 1.5);
assertTrue(dernier > 0);
}
@Test
void unPicIsoleEstAbsorbe() {
VitesseHorizontale v = new VitesseHorizontale();
assertEquals(0, v.enregistrer(course(1.0, 0, true), 1.0, 1.5), 1e-9); // 0,7 d'excès < 1,5
}
@Test
void paquetsGroupesToleres() {
VitesseHorizontale v = new VitesseHorizontale();
// 5 ticks de déplacement d'un coup : 5 × 0,28 = 1,4 permis
EtatMouvement e = new EtatMouvement(1.4, 0, 5, true, true, true, false, false, 0, 0, false, false);
assertEquals(0, v.enregistrer(e, 1.0, 1.5), 1e-9);
}
@Test
void milieuSpecialEtFrictionIgnores() {
VitesseHorizontale v = new VitesseHorizontale();
EtatMouvement eau = new EtatMouvement(2.0, 0, 1, false, false, false, false, false, 0, 0, true, false);
EtatMouvement glace = new EtatMouvement(2.0, 0, 1, true, true, true, false, false, 0, 0, false, true);
for (int i = 0; i < 30; i++) {
assertEquals(0, v.enregistrer(eau, 1.0, 1.5), 1e-9);
assertEquals(0, v.enregistrer(glace, 1.0, 1.5), 1e-9);
}
}
@Test
void leLagRelevaLaTolerance() {
VitesseHorizontale v = new VitesseHorizontale();
double max = 0;
for (int i = 0; i < 40; i++) max = Math.max(max, v.enregistrer(course(0.40, 0, true), 1.5, 1.5)); // 0,40 < 0,45
assertEquals(0, max, 1e-9);
}
// --- No-fall ---
@Test
void noFallPointsSeulementEnChuteSansSol() {
assertEquals(0.5, NoFall.points(new EtatMouvement(0, -0.5, 1, true, false, false, false, false, 0, 0, false, false)), 1e-9);
assertEquals(0, NoFall.points(new EtatMouvement(0, -0.1, 1, true, false, false, false, false, 0, 0, false, false)), 1e-9);
assertEquals(0, NoFall.points(new EtatMouvement(0, -0.5, 1, true, true, false, false, false, 0, 0, false, false)), 1e-9);
assertEquals(0, NoFall.points(new EtatMouvement(0, -0.5, 1, false, false, false, false, false, 0, 0, false, false)), 1e-9);
assertEquals(0, NoFall.points(new EtatMouvement(0, -0.5, 1, true, false, false, false, false, 0, 0, true, false)), 1e-9);
}
@Test
void noFallNeCorrigeQuEnEnforce() {
assertTrue(NoFall.auSolEffectif(true, false, false, Mode.OBSERVE));
assertTrue(NoFall.auSolEffectif(true, false, false, Mode.OFF));
assertFalse(NoFall.auSolEffectif(true, false, false, Mode.ENFORCE));
assertTrue(NoFall.auSolEffectif(true, true, false, Mode.ENFORCE));
assertTrue(NoFall.auSolEffectif(true, false, true, Mode.ENFORCE)); // exempté : on ne touche à rien
assertFalse(NoFall.auSolEffectif(false, true, false, Mode.ENFORCE)); // jamais d'invention d'un « au sol »
}
// --- Vol vertical ---
/** Simule une chute vanilla depuis le tick de saut. */
private static double[] sauts(int n) {
double[] dy = new double[n];
double v = 0.42;
for (int i = 0; i < n; i++) {
dy[i] = v;
v = (v - 0.08) * 0.98;
}
return dy;
}
@Test
void sautVanillaSansInfraction() {
VolVertical vol = new VolVertical();
assertEquals(0, vol.enregistrer(marche(0, 0, true), false), 1e-9); // au sol
double max = 0;
for (double dy : sauts(40)) max = Math.max(max, vol.enregistrer(marche(0.2, dy, false), false));
assertEquals(0, max, 1e-9);
}
@Test
void chuteLibreSansInfraction() {
VolVertical vol = new VolVertical();
double v = 0;
double max = 0;
for (int i = 0; i < 60; i++) {
v = (v - 0.08) * 0.98;
max = Math.max(max, vol.enregistrer(marche(0, v, false), false));
}
assertEquals(0, max, 1e-9);
}
@Test
void flottementEnLAirEstUneInfraction() {
VolVertical vol = new VolVertical();
double max = 0;
for (int i = 0; i < 40; i++) max = Math.max(max, vol.enregistrer(marche(0.2, 0.0, false), false));
assertTrue(max > 0);
}
@Test
void monteeConstanteEstUneInfraction() {
VolVertical vol = new VolVertical();
double max = 0;
for (int i = 0; i < 40; i++) max = Math.max(max, vol.enregistrer(marche(0.2, 0.5, false), false));
assertTrue(max > 0);
}
@Test
void planeLentEstUneInfraction() {
VolVertical vol = new VolVertical();
double max = 0;
for (int i = 0; i < 40; i++) max = Math.max(max, vol.enregistrer(marche(0.2, -0.05, false), false));
assertTrue(max > 0);
}
@Test
void exemptionCoupeLeControle() {
VolVertical vol = new VolVertical();
double max = 0;
for (int i = 0; i < 40; i++) max = Math.max(max, vol.enregistrer(marche(0.2, 0.0, false), true));
assertEquals(0, max, 1e-9);
}
@Test
void paquetsManquantsNeFontPasDInfraction() {
VolVertical vol = new VolVertical();
double max = 0;
for (int i = 0; i < 40; i++) {
EtatMouvement e = new EtatMouvement(0.2, 0.0, 3, false, false, false, false, false, 0, 0, false, false);
max = Math.max(max, vol.enregistrer(e, false));
}
assertEquals(0, max, 1e-9);
}
// --- Moteur ---
private final GardeConfig cfg = new GardeConfig();
private final Moteur moteur = new Moteur(cfg);
private final UUID joueur = UUID.randomUUID();
@Test
void moteurRemonteLeVolEtAttendLeSeuil() {
boolean infraction = false;
for (int i = 0; i < 60; i++) {
List<Verdict> v = moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), marche(0.2, 0.0, false));
for (Verdict x : v) if (x.controle() == Controle.VOL) infraction = true;
}
assertTrue(infraction);
}
@Test
void moteurExempteApresRiptideEtTeleportation() {
EtatJoueur riptide = EtatJoueur.builder().riptide(true).build();
EtatJoueur tp = EtatJoueur.builder().ticksDepuisTeleport(3).build();
for (int i = 0; i < 60; i++) {
assertTrue(moteur.mouvement(joueur, i * 50L, riptide, marche(3.0, 0.5, false)).isEmpty());
assertTrue(moteur.mouvement(joueur, i * 50L, tp, marche(3.0, 0.5, false)).isEmpty());
}
}
@Test
void moteurLesModesOffCoupentTout() {
cfg.mode(Controle.NO_FALL, Mode.OFF);
cfg.mode(Controle.VITESSE, Mode.OFF);
cfg.mode(Controle.VOL, Mode.OFF);
for (int i = 0; i < 60; i++) {
assertTrue(moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), course(5.0, 1.0, false)).isEmpty());
}
}
@Test
void moteurVitesseEnObserveNeDepasseJamaisLAlerte() {
Sanction pire = Sanction.AUCUNE;
for (int i = 0; i < 200; i++) {
Sanction s = Verdict.pire(moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), course(1.0, 0, true)));
if (s.ordinal() > pire.ordinal()) pire = s;
}
assertEquals(Sanction.ALERTE, pire);
}
@Test
void chuteLenteDuJoueurEtatEstExempteDuVol() {
EtatJoueur chute = EtatJoueur.builder().chuteLente(true).build();
for (int i = 0; i < 60; i++) {
assertTrue(moteur.mouvement(joueur, i * 50L, chute, marche(0.0, -0.01, false)).isEmpty());
}
}
@Test
void auSolPourDegatsDeChuteSuitLeMode() {
EtatJoueur e = EtatJoueur.normal();
assertTrue(moteur.auSolPourDegatsDeChute(e, true, false)); // OBSERVE : vanilla
cfg.mode(Controle.NO_FALL, Mode.ENFORCE);
assertFalse(moteur.auSolPourDegatsDeChute(e, true, false));
assertTrue(moteur.auSolPourDegatsDeChute(EtatJoueur.builder().elytres(true).build(), true, false));
}
}