From a70809df6c2257ddf3b65b0e302849ccbc94d656 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Wed, 14 Oct 2026 00:14:03 +0200 Subject: [PATCH] GastinelGarde 0.2.0 : phase 2 (no-fall corrige en enforce, vitesse horizontale, vol vertical), 90 tests Co-Authored-By: Claude Sonnet 5.5 --- README.md | 123 +++++++++ gradle.properties | 2 +- src/main/java/com/gastinelgarde/Garde.java | 101 ++++++- .../java/com/gastinelgarde/GardeSpec.java | 9 + .../java/com/gastinelgarde/core/Controle.java | 7 +- .../com/gastinelgarde/core/EtatMouvement.java | 24 ++ .../com/gastinelgarde/core/GardeConfig.java | 4 + .../java/com/gastinelgarde/core/Moteur.java | 43 +++ .../java/com/gastinelgarde/core/NoFall.java | 35 +++ .../java/com/gastinelgarde/core/Suivi.java | 12 + .../core/VitesseHorizontale.java | 62 +++++ .../com/gastinelgarde/core/VolVertical.java | 61 ++++ .../gastinelgarde/mixin/MovePacketMixin.java | 13 + .../resources/META-INF/neoforge.mods.toml | 4 +- .../com/gastinelgarde/core/MouvementTest.java | 261 ++++++++++++++++++ 15 files changed, 750 insertions(+), 11 deletions(-) create mode 100644 README.md create mode 100644 src/main/java/com/gastinelgarde/core/EtatMouvement.java create mode 100644 src/main/java/com/gastinelgarde/core/NoFall.java create mode 100644 src/main/java/com/gastinelgarde/core/VitesseHorizontale.java create mode 100644 src/main/java/com/gastinelgarde/core/VolVertical.java create mode 100644 src/test/java/com/gastinelgarde/core/MouvementTest.java diff --git a/README.md b/README.md new file mode 100644 index 0000000..72f6968 --- /dev/null +++ b/README.md @@ -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 off|observe|enforce (écrit dans la configuration) +/garde exempter +/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. diff --git a/gradle.properties b/gradle.properties index 36f5839..59d3a1e 100644 --- a/gradle.properties +++ b/gradle.properties @@ -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 diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 6f37525..5a667ee 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -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 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 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 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 verdicts) { String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id(); if (s == Sanction.EXPULSION) { diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index eb34ed2..1ada378 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -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(); diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index 1d0728c..c2cf0c5 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -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; diff --git a/src/main/java/com/gastinelgarde/core/EtatMouvement.java b/src/main/java/com/gastinelgarde/core/EtatMouvement.java new file mode 100644 index 0000000..b7e3eaa --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/EtatMouvement.java @@ -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) { +} diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index d73cbf8..65fcfa0 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -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; diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index af4d0d8..211d145 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -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 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 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 sortie, Suivi s, Controle c, double points, long nowMs, diff --git a/src/main/java/com/gastinelgarde/core/NoFall.java b/src/main/java/com/gastinelgarde/core/NoFall.java new file mode 100644 index 0000000..63f67e3 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/NoFall.java @@ -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; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index c28e358..643c162 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -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 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; + } } diff --git a/src/main/java/com/gastinelgarde/core/VitesseHorizontale.java b/src/main/java/com/gastinelgarde/core/VitesseHorizontale.java new file mode 100644 index 0000000..31dcb82 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/VitesseHorizontale.java @@ -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; + } +} diff --git a/src/main/java/com/gastinelgarde/core/VolVertical.java b/src/main/java/com/gastinelgarde/core/VolVertical.java new file mode 100644 index 0000000..67e81ce --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/VolVertical.java @@ -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; + } +} diff --git a/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java b/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java index 8b19742..47bbf6b 100644 --- a/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java +++ b/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java @@ -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, diff --git a/src/main/resources/META-INF/neoforge.mods.toml b/src/main/resources/META-INF/neoforge.mods.toml index c04e0e1..a750b6e 100644 --- a/src/main/resources/META-INF/neoforge.mods.toml +++ b/src/main/resources/META-INF/neoforge.mods.toml @@ -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" diff --git a/src/test/java/com/gastinelgarde/core/MouvementTest.java b/src/test/java/com/gastinelgarde/core/MouvementTest.java new file mode 100644 index 0000000..4b20eef --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/MouvementTest.java @@ -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 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)); + } +}