diff --git a/src/main/java/com/gastinelgarde/Cablage.java b/src/main/java/com/gastinelgarde/Cablage.java new file mode 100644 index 0000000..e5f6035 --- /dev/null +++ b/src/main/java/com/gastinelgarde/Cablage.java @@ -0,0 +1,160 @@ +package com.gastinelgarde; + +import com.gastinelgarde.core.DetectionContraption; +import com.gastinelgarde.core.GraceTeleport; +import com.gastinelgarde.core.Moteur; +import com.gastinelgarde.core.Sanction; +import com.gastinelgarde.core.Suivi; +import com.gastinelgarde.core.Verdict; +import java.util.List; +import java.util.UUID; +import java.util.function.BooleanSupplier; + +/** + * Décisions du câblage Minecraft (Garde, GardeEvents) sorties sans changement de comportement (16/10, constat C4 ⚠️), + * pour être testées sans serveur. Aucun type Minecraft ici : Garde et GardeEvents lisent le serveur, appellent ces + * méthodes et appliquent le résultat. + */ +final class Cablage { + + private Cablage() { } + + // --- Entrées des événements --- + + /** Ce que fait onAttaque avant toute mesure. */ + enum EntreeAttaque { + /** C4 : expulsion en cours, le coup est annulé et rien n'est évalué. */ + ANNULER, + /** Exemption manuelle (/garde exempter) : le coup passe sans mesure. */ + IGNORER, + EVALUER + } + + static EntreeAttaque entreeAttaque(boolean expulse, boolean exempteManuellement) { + if (expulse) return EntreeAttaque.ANNULER; + if (exempteManuellement) return EntreeAttaque.IGNORER; + return EntreeAttaque.EVALUER; + } + + /** Fin de onAttaque : le coup est-il annulé ? (portée / hitbox ENFORCE, ou sanction ≥ SETBACK). */ + static boolean annulerCoup(boolean coupsBloques, Sanction s) { + return coupsBloques || s.ordinal() >= Sanction.SETBACK.ordinal(); + } + + /** Fin de onAttaque : seule une EXPULSION est appliquée au joueur (un SETBACK de combat annule seulement le coup). */ + static boolean appliquerApresCoup(Sanction s) { + return s == Sanction.EXPULSION; + } + + /** avantMouvement : évaluer ce paquet ? (F01 thread serveur, C4 expulsion, exemption manuelle). */ + static boolean evaluerAvantMouvement(boolean surThreadServeur, BooleanSupplier expulse, + BooleanSupplier exempteManuellement) { + // Paresseux : hors du thread serveur, l'état du mod n'est pas lu du tout (F01). + return surThreadServeur && !expulse.getAsBoolean() && !exempteManuellement.getAsBoolean(); + } + + /** apresMouvement : traiter ce paquet (état, position, traces) ? L'exemption manuelle est vue plus loin. */ + static boolean traiterApresMouvement(boolean surThreadServeur, BooleanSupplier expulse) { + return surThreadServeur && !expulse.getAsBoolean(); + } + + /** Sanction de mouvement à appliquer (≥ SETBACK). */ + static boolean sanctionDeMouvement(Sanction s) { + return s.ordinal() >= Sanction.SETBACK.ordinal(); + } + + // --- Exemptions contraption de la cible (portée / hitbox) --- + + /** + * Portée et hitbox mesurées ? Non si la cible, ou son véhicule racine, est une contraption ou sur un vaisseau + * Sable. Évaluation paresseuse dans le même ordre que l'ancien code. + */ + static boolean mesurerPorteeHitbox(BooleanSupplier cibleContraption, BooleanSupplier cibleSable, + boolean racineEstCible, BooleanSupplier racineContraption, + BooleanSupplier racineSable) { + return !cibleContraption.getAsBoolean() && !cibleSable.getAsBoolean() + && (racineEstCible || (!racineContraption.getAsBoolean() && !racineSable.getAsBoolean())); + } + + // --- C7 : déploiement des élytres --- + + /** Suivi du plané en cours : est-il commencé moins de elytresAirMinTicks après le dernier sol serveur ? */ + static final class Elytres { + boolean vues; + boolean suspectes; + + /** À chaque construction de l'état : transition isFallFlying. */ + void observer(boolean plane, int solServeurTick, int tick, int airMinTicks) { + if (plane) { + if (!vues) { + vues = true; + suspectes = solServeurTick != Integer.MIN_VALUE && tick - solServeurTick < airMinTicks; + } + } else { + vues = false; + suspectes = false; + } + } + } + + // --- Détection en cache (contraption, courant d'air) --- + + /** Détection refaite au plus toutes les 10 ticks, puis grâce après la dernière détection positive. */ + static final class CacheDetection { + int tick = Integer.MIN_VALUE; + int vuTick = Integer.MIN_VALUE; + boolean proche; + + boolean lire(int maintenant, BooleanSupplier detecter, int graceTicks) { + if (tick == Integer.MIN_VALUE || maintenant - tick >= 10 || maintenant < tick) { + proche = detecter.getAsBoolean(); + tick = maintenant; + if (proche) vuTick = maintenant; + } + return proche || DetectionContraption.dansLaGrace(maintenant, vuTick, graceTicks); + } + } + + // --- Position de retour (C3) --- + + /** apresMouvement : la position de ce paquet devient-elle la position de retour ? */ + static boolean memoriserRetour(Moteur moteur, int dernierVerdictTick, int tick, BooleanSupplier vehiculeControle, + boolean solServeur, boolean milieuSpecial) { + return dernierVerdictTick != tick && !vehiculeControle.getAsBoolean() + && moteur.positionDeRetourAdmise(solServeur, milieuSpecial); + } + + // --- Sanctions (C2, C4) --- + + /** Ce que la sanction fait au joueur réel (adaptateur ServerPlayer dans Garde, doublure dans les tests). */ + interface Joueur { + UUID id(); + String nom(); + String dimension(); + int tick(); + void annoncerTeleport(GraceTeleport.Origine origine); + void teleporter(double x, double y, double z, float yaw, float pitch); + void deconnecter(String message); + void journal(String ligne); + } + + /** Expulsion à usage unique (C4) ; setback vers la position de retour de la même dimension, puis remise à zéro (C2). */ + static void appliquerSanction(Moteur moteur, Joueur p, Sanction s, List verdicts) { + String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id(); + if (s == Sanction.EXPULSION) { + // C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement. + if (!moteur.expulser(p.id(), p.tick() * 50L)) return; + p.journal(p.nom() + " EXPULSE (" + raison + ")"); + p.deconnecter("Expulsé par l'anti-triche (" + raison + ")."); + } else if (s == Sanction.SETBACK) { + Suivi sv = moteur.suivi(p.id()); + if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) { + p.annoncerTeleport(GraceTeleport.Origine.SETBACK); + p.teleporter(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch()); + // C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol. + moteur.apresSetback(p.id(), p.tick() * 50L); + p.journal(p.nom() + " SETBACK (" + raison + ")"); + } + } + } +} diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 4abb5e7..5ec89e1 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -77,17 +77,12 @@ public final class Garde { int vehiculeTick = Integer.MIN_VALUE; 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; + final Cablage.CacheDetection contraption = new Cablage.CacheDetection(); // C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours int solServeurTick = Integer.MIN_VALUE; - boolean elytresVues; - boolean elytresSuspectes; + final Cablage.Elytres elytres = new Cablage.Elytres(); // Cache de la détection d'un courant d'air (ventilateur Create), même principe - int courantTick = Integer.MIN_VALUE; - int courantVuTick = Integer.MIN_VALUE; - boolean courantProche; + final Cablage.CacheDetection courant = new Cablage.CacheDetection(); // #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux) double[] oeilDernier; double[] oeilAvant; @@ -391,16 +386,7 @@ public final class Garde { } // C7 : au début du plané, combien de ticks en l'air (sol serveur) ? Moins que elytresAirMinTicks : suspect. - if (p.isFallFlying()) { - if (!m.elytresVues) { - m.elytresVues = true; - m.elytresSuspectes = m.solServeurTick != Integer.MIN_VALUE - && tick - m.solServeurTick < config().elytresAirMinTicks; - } - } else { - m.elytresVues = false; - m.elytresSuspectes = false; - } + m.elytres.observer(p.isFallFlying(), m.solServeurTick, tick, config().elytresAirMinTicks); return EtatJoueur.builder() .creatif(p.isCreative()) @@ -408,7 +394,7 @@ public final class Garde { .peutVoler(p.getAbilities().mayfly) .riptide(riptideRecent) .elytres(p.isFallFlying()) - .elytresDeploiementSuspect(m.elytresSuspectes) + .elytresDeploiementSuspect(m.elytres.suspectes) .levitation(p.hasEffect(MobEffects.LEVITATION)) .chuteLente(p.hasEffect(MobEffects.SLOW_FALLING)) .enVehicule(p.isPassenger()) @@ -487,12 +473,7 @@ public final class Garde { /** 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 || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS); + return m.contraption.lire(tick, () -> pocheContraption(p), GRACE_CONTRAPTION_TICKS); } /** @@ -587,19 +568,19 @@ public final class Garde { /** Début du traitement d'un paquet de mouvement : contrôle du débit. */ public static void avantMouvement(ServerPlayer p) { - if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà) - if (MOTEUR.estExpulse(p.getUUID())) return; // C4 : expulsion en cours, plus rien à évaluer - if (estExempteManuellement(p.getUUID())) return; + // F01 : jamais depuis le thread réseau (le mixin l'évite déjà) ; C4 : expulsion en cours, plus rien à évaluer + if (!Cablage.evaluerAvantMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()), + () -> estExempteManuellement(p.getUUID()))) return; EtatJoueur etat = etat(p, false); List v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat); Sanction s = traiter(p, v); - if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v); + if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v); } /** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */ public static void apresMouvement(ServerPlayer p) { - if (!surThreadServeur(p)) return; - if (MOTEUR.estExpulse(p.getUUID())) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion + // C4 / C6 : ni évaluation ni état recréé après l'expulsion + if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return; int tick = p.server.getTickCount(); Marques m = marques(p.getUUID()); boolean solServeur = auSolServeur(p, m); @@ -621,7 +602,7 @@ public final class Garde { if (controler && em != null) { List v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em); Sanction s = traiter(p, v); - if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v); + if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v); } // F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup. if (!estExempteManuellement(p.getUUID())) { @@ -646,8 +627,8 @@ public final class Garde { // En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée // qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait. // C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air. - if (m.dernierVerdictTick != tick && !vehiculeControle(p) - && MOTEUR.positionDeRetourAdmise(solServeur, em != null && em.milieuSpecial())) { + if (Cablage.memoriserRetour(MOTEUR, m.dernierVerdictTick, tick, () -> vehiculeControle(p), solServeur, + em != null && em.milieuSpecial())) { MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(), p.level().dimension().location().toString()); } @@ -867,12 +848,7 @@ public final class Garde { /** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */ private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) { - if (m.courantTick == Integer.MIN_VALUE || tick - m.courantTick >= 10 || tick < m.courantTick) { - m.courantProche = courantAir(p); - m.courantTick = tick; - if (m.courantProche) m.courantVuTick = tick; - } - return m.courantProche || DetectionContraption.dansLaGrace(tick, m.courantVuTick, GRACE_COURANT_TICKS); + return m.courant.lire(tick, () -> courantAir(p), GRACE_COURANT_TICKS); } /** @@ -914,22 +890,22 @@ public final class Garde { } 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) { - // C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement. - if (!MOTEUR.expulser(p.getUUID(), p.server.getTickCount() * 50L)) return; - ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")"); - p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ").")); - } else if (s == Sanction.SETBACK) { - Suivi sv = MOTEUR.suivi(p.getUUID()); - String dim = p.level().dimension().location().toString(); - if (sv.aPositionValide() && sv.dimension().equals(dim)) { - annoncerTeleport(p, GraceTeleport.Origine.SETBACK); - p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch()); - // C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol. - MOTEUR.apresSetback(p.getUUID(), p.server.getTickCount() * 50L); - ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")"); + Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts); + } + + /** Adaptateur ServerPlayer de Cablage.appliquerSanction. */ + private static Cablage.Joueur joueur(ServerPlayer p) { + return new Cablage.Joueur() { + @Override public UUID id() { return p.getUUID(); } + @Override public String nom() { return p.getGameProfile().getName(); } + @Override public String dimension() { return p.level().dimension().location().toString(); } + @Override public int tick() { return p.server.getTickCount(); } + @Override public void annoncerTeleport(GraceTeleport.Origine origine) { Garde.annoncerTeleport(p, origine); } + @Override public void teleporter(double x, double y, double z, float yaw, float pitch) { + p.connection.teleport(x, y, z, yaw, pitch); } - } + @Override public void deconnecter(String message) { p.connection.disconnect(Component.literal(message)); } + @Override public void journal(String ligne) { ecrireJournal(ligne); } + }; } } diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index d91dd7f..ebbb0ac 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -57,11 +57,16 @@ public final class GardeEvents { @SubscribeEvent public static void onAttaque(AttackEntityEvent event) { if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; - if (Garde.moteur().estExpulse(p.getUUID())) { // C4 : expulsion en cours - event.setCanceled(true); - return; + switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) { + case ANNULER -> { // C4 : expulsion en cours + event.setCanceled(true); + return; + } + case IGNORER -> { + return; + } + case EVALUER -> { } } - if (Garde.estExempteManuellement(p.getUUID())) return; Entity cible = event.getTarget(); int tick = p.server.getTickCount(); @@ -83,8 +88,9 @@ public final class GardeEvents { // (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))); + boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> 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)); // #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge @@ -103,11 +109,9 @@ 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); - } + // portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé + if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true); + if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts); } /** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */ diff --git a/src/test/java/com/gastinelgarde/CablageTest.java b/src/test/java/com/gastinelgarde/CablageTest.java new file mode 100644 index 0000000..e9b9800 --- /dev/null +++ b/src/test/java/com/gastinelgarde/CablageTest.java @@ -0,0 +1,300 @@ +package com.gastinelgarde; + +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.Controle; +import com.gastinelgarde.core.EtatJoueur; +import com.gastinelgarde.core.Exemptions; +import com.gastinelgarde.core.GardeConfig; +import com.gastinelgarde.core.GraceTeleport; +import com.gastinelgarde.core.Mode; +import com.gastinelgarde.core.Moteur; +import com.gastinelgarde.core.Sanction; +import com.gastinelgarde.core.Verdict; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.BooleanSupplier; +import org.junit.jupiter.api.Test; + +/** + * Câblage Minecraft (constat C4 ⚠️) : décisions de Garde / GardeEvents sorties dans {@link Cablage}, testées sans + * serveur avec une doublure du joueur et un vrai {@link Moteur}. + */ +class CablageTest { + + private static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042"); + private static final String MONDE = "minecraft:overworld"; + + /** Doublure de ServerPlayer : enregistre ce que la sanction lui fait, dans l'ordre. */ + static final class FauxJoueur implements Cablage.Joueur { + final List actions = new ArrayList<>(); + String dimension = MONDE; + int tick = 1000; + + @Override public UUID id() { return ID; } + @Override public String nom() { return "Tricheur"; } + @Override public String dimension() { return dimension; } + @Override public int tick() { return tick; } + @Override public void annoncerTeleport(GraceTeleport.Origine o) { actions.add("annonce " + o); } + @Override public void teleporter(double x, double y, double z, float yaw, float pitch) { + actions.add(String.format(java.util.Locale.ROOT, "teleport %.1f %.1f %.1f %.0f %.0f", x, y, z, yaw, pitch)); + } + @Override public void deconnecter(String message) { actions.add("deconnexion " + message); } + @Override public void journal(String ligne) { actions.add("journal " + ligne); } + + long compte(String prefixe) { + return actions.stream().filter(a -> a.startsWith(prefixe)).count(); + } + } + + private static Verdict verdict(Controle c, Sanction s) { + return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of()); + } + + private static BooleanSupplier compteur(AtomicInteger n, boolean valeur) { + return () -> { + n.incrementAndGet(); + return valeur; + }; + } + + // --- Expulsion unique (C4) --- + + @Test + void C4_expulsionUneSeuleFoisPuisDeNouveauApresReconnexion() { + Moteur moteur = new Moteur(new GardeConfig()); + FauxJoueur p = new FauxJoueur(); + List v = List.of(verdict(Controle.VOL, Sanction.EXPULSION)); + for (int i = 0; i < 344; i++) { // incident du 15/10 : 344 disconnect en 18 s + p.tick++; + Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v); + } + assertEquals(1, p.compte("deconnexion"), p.actions.toString()); + assertEquals(1, p.compte("journal")); + assertEquals("journal Tricheur EXPULSE (vol)", p.actions.get(0)); // journal avant la déconnexion + assertEquals("deconnexion Expulsé par l'anti-triche (vol).", p.actions.get(1)); + assertTrue(moteur.estExpulse(ID)); + + // GardeEvents.onConnexion : oublierExpulsion, la prochaine expulsion est de nouveau possible. + moteur.oublierExpulsion(ID); + assertFalse(moteur.estExpulse(ID)); + Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v); + assertEquals(2, p.compte("deconnexion")); + } + + @Test + void C4_apresLExpulsionPlusAucuneEvaluationNiCoup() { + assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, false)); + assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, true)); // l'expulsion passe avant + assertEquals(Cablage.EntreeAttaque.IGNORER, Cablage.entreeAttaque(false, true)); + assertEquals(Cablage.EntreeAttaque.EVALUER, Cablage.entreeAttaque(false, false)); + + AtomicInteger lus = new AtomicInteger(); + assertFalse(Cablage.evaluerAvantMouvement(true, () -> true, compteur(lus, false))); + assertEquals(0, lus.get(), "expulsé : l'exemption n'est même pas lue"); + assertFalse(Cablage.evaluerAvantMouvement(true, () -> false, () -> true)); // exemption manuelle + assertTrue(Cablage.evaluerAvantMouvement(true, () -> false, () -> false)); + assertFalse(Cablage.traiterApresMouvement(true, () -> true)); + assertTrue(Cablage.traiterApresMouvement(true, () -> false)); + } + + @Test + void F01_horsDuThreadServeurLEtatDuModNEstPasLu() { + AtomicInteger lus = new AtomicInteger(); + assertFalse(Cablage.evaluerAvantMouvement(false, compteur(lus, false), compteur(lus, false))); + assertFalse(Cablage.traiterApresMouvement(false, compteur(lus, false))); + assertEquals(0, lus.get()); + } + + @Test + void expulsionSansVerdictRaisonParDefaut() { + Moteur moteur = new Moteur(new GardeConfig()); + FauxJoueur p = new FauxJoueur(); + Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, List.of()); + assertEquals("journal Tricheur EXPULSE (anti-triche)", p.actions.get(0)); + } + + // --- Setback (C2, C3) --- + + @Test + void C2_setbackVersLaPositionAuSolPuisRemiseAZeroDuVol() { + Moteur moteur = new Moteur(new GardeConfig()); + FauxJoueur p = new FauxJoueur(); + long ms = p.tick * 50L; + moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE); + moteur.suivi(ID).vl.ajouter(Controle.VOL, 30, ms); + moteur.suivi(ID).vl.ajouter(Controle.VITESSE, 20, ms); + moteur.suivi(ID).vl.ajouter(Controle.KILLAURA_CIBLES, 7, ms); + + Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK))); + + assertEquals(List.of("annonce SETBACK", "teleport 10.5 64.0 -3.5 90 10", "journal Tricheur SETBACK (vol)"), + p.actions, "la grâce est annoncée avant le teleport (F05)"); + assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VOL, ms), 1e-9); + assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VITESSE, ms), 1e-9); + assertTrue(moteur.suivi(ID).vl.valeur(Controle.KILLAURA_CIBLES, ms) > 6.9, "les autres VL ne sont pas touchées"); + assertFalse(moteur.estExpulse(ID)); + } + + @Test + void setbackSansPositionOuAutreDimensionNeFaitRien() { + Moteur moteur = new Moteur(new GardeConfig()); + FauxJoueur p = new FauxJoueur(); + List v = List.of(verdict(Controle.VOL, Sanction.SETBACK)); + Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v); + assertTrue(p.actions.isEmpty(), "aucune position de retour : rien"); + + moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether"); + Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v); + assertTrue(p.actions.isEmpty(), "position dans une autre dimension : jamais de teleport inter-dimension"); + } + + @Test + void sanctionsInferieuresAuSetbackNeTouchentPasLeJoueur() { + Moteur moteur = new Moteur(new GardeConfig()); + moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, MONDE); + FauxJoueur p = new FauxJoueur(); + for (Sanction s : new Sanction[] {Sanction.AUCUNE, Sanction.JOURNAL, Sanction.ALERTE}) { + Cablage.appliquerSanction(moteur, p, s, List.of(verdict(Controle.VOL, s))); + assertFalse(Cablage.sanctionDeMouvement(s), s.name()); + } + assertTrue(p.actions.isEmpty()); + assertTrue(Cablage.sanctionDeMouvement(Sanction.SETBACK)); + assertTrue(Cablage.sanctionDeMouvement(Sanction.EXPULSION)); + } + + @Test + void C3_positionDeRetourSeulementAuSolEtSansVerdictNiVehicule() { + Moteur moteur = new Moteur(new GardeConfig()); + int tick = 500; + assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, true, false)); + assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, true), "eau, échelle…"); + assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, false), "en l'air"); + assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> true, true, false), "véhicule contrôlé"); + AtomicInteger lus = new AtomicInteger(); + assertFalse(Cablage.memoriserRetour(moteur, tick, tick, compteur(lus, false), true, false), "verdict ce tick"); + assertEquals(0, lus.get(), "le véhicule n'est pas lu si un verdict est tombé à ce tick"); + } + + // --- Coups (GardeEvents.onAttaque) --- + + @Test + void coupAnnuleEnEnforceOuSurSanctionEtExpulsionSeuleAppliquee() { + for (Sanction s : Sanction.values()) { + boolean grave = s.ordinal() >= Sanction.SETBACK.ordinal(); + assertEquals(grave, Cablage.annulerCoup(false, s), s.name()); + assertTrue(Cablage.annulerCoup(true, s), "portée / hitbox ENFORCE : " + s); + assertEquals(s == Sanction.EXPULSION, Cablage.appliquerApresCoup(s), "pas de setback sur un coup : " + s); + } + } + + @Test + void cibleSurContraptionOuVaisseauPasDeMesurePorteeHitbox() { + BooleanSupplier oui = () -> true; + BooleanSupplier non = () -> false; + assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, non, non)); + assertFalse(Cablage.mesurerPorteeHitbox(oui, non, true, non, non), "cible contraption"); + assertFalse(Cablage.mesurerPorteeHitbox(non, oui, true, non, non), "cible sur vaisseau Sable"); + assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, oui, non), "assise sur un siège Create"); + assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, non, oui), "véhicule sur un vaisseau"); + assertTrue(Cablage.mesurerPorteeHitbox(non, non, false, non, non), "cheval, bateau : mesuré"); + AtomicInteger lus = new AtomicInteger(); + assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, compteur(lus, true), compteur(lus, true))); + assertEquals(0, lus.get(), "sans véhicule, la racine n'est pas interrogée"); + } + + // --- C7 : élytres --- + + @Test + void C7_deploiementTropTotApresLeSolEstSuspectPourTouteLaDureeDuPlane() { + Cablage.Elytres e = new Cablage.Elytres(); + int sol = 100; + e.observer(false, sol, 100, 2); + e.observer(true, sol, 101, 2); // 1 tick après le sol (onGround falsifié) + assertTrue(e.suspectes); + for (int t = 102; t < 300; t++) e.observer(true, sol, t, 2); + assertTrue(e.suspectes, "reste suspect jusqu'à la fin du plané"); + e.observer(false, sol, 300, 2); + assertFalse(e.suspectes); + assertFalse(e.vues); + + Cablage.Elytres h = new Cablage.Elytres(); + h.observer(true, sol, 102, 2); // 2 ticks en l'air : honnête + assertFalse(h.suspectes); + Cablage.Elytres jamais = new Cablage.Elytres(); + jamais.observer(true, Integer.MIN_VALUE, 5, 2); // jamais vu au sol (connexion en plein vol) + assertFalse(jamais.suspectes); + } + + @Test + void C7_unSolServeurVuPendantLePlaneNeRendPasSuspectApresCoup() { + Cablage.Elytres e = new Cablage.Elytres(); + e.observer(true, 100, 120, 2); + assertFalse(e.suspectes); + e.observer(true, 125, 125, 2); // frôle un bloc en plané + assertFalse(e.suspectes, "seul le début du plané compte"); + } + + @Test + void C7_cableJusquAuxExemptions_avecEtSansOption() { + Cablage.Elytres e = new Cablage.Elytres(); + e.observer(true, 100, 101, 2); + EtatJoueur etat = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(e.suspectes).build(); + GardeConfig defaut = new GardeConfig(); + assertFalse(defaut.elytresExemptionStricte, "option désactivée par défaut"); + assertTrue(Exemptions.evaluer(etat, defaut, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres")); + GardeConfig stricte = new GardeConfig(); + stricte.elytresExemptionStricte = true; + assertFalse(Exemptions.evaluer(etat, stricte, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres")); + } + + // --- C8 : combat en véhicule --- + + @Test + void C8_passagerMesureSeulementAvecLOptionEtContraptionToujoursExemptee() { + EtatJoueur cheval = EtatJoueur.builder().enVehicule(true).build(); + EtatJoueur siege = EtatJoueur.builder().enVehicule(true).pocheContraption(true).build(); + GardeConfig defaut = new GardeConfig(); + assertFalse(defaut.combatMesureEnVehicule); + assertTrue(Exemptions.evaluer(cheval, defaut, Exemptions.Famille.COMBAT).exempt()); + GardeConfig option = new GardeConfig(); + option.combatMesureEnVehicule = true; + assertFalse(Exemptions.evaluer(cheval, option, Exemptions.Famille.COMBAT).exempt()); + assertTrue(Exemptions.evaluer(siege, option, Exemptions.Famille.COMBAT).raisons().contains("contraption")); + assertTrue(Exemptions.evaluer(cheval, option, Exemptions.Famille.MOUVEMENT).raisons().contains("vehicule"), + "l'option ne touche que le combat"); + } + + // --- Cache des détections (contraption, courant d'air) --- + + @Test + void cacheDeDetectionToutesLesDixTicksPuisGrace() { + Cablage.CacheDetection c = new Cablage.CacheDetection(); + AtomicInteger appels = new AtomicInteger(); + boolean[] present = {true}; + BooleanSupplier detecter = () -> { + appels.incrementAndGet(); + return present[0]; + }; + assertTrue(c.lire(100, detecter, 40)); + assertEquals(1, appels.get()); + present[0] = false; // la contraption s'éloigne + assertTrue(c.lire(109, detecter, 40), "valeur en cache"); + assertEquals(1, appels.get()); + assertTrue(c.lire(110, detecter, 40), "redétecté (absent) mais dans la grâce"); + assertEquals(2, appels.get()); + assertTrue(c.lire(140, detecter, 40)); + assertFalse(c.lire(150, detecter, 40), "grâce terminée"); + assertTrue(c.lire(5, () -> true, 40), "tick qui recule (redémarrage) : redétecté"); + } + + @Test + void cacheJamaisVuPasDeGrace() { + Cablage.CacheDetection c = new Cablage.CacheDetection(); + assertFalse(c.lire(100, () -> false, 40)); + } +}