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); } } // --- 0.4.0 : grace de propulsion d'une fusee (plane en elytres) --- /** Ticks de marge après la fin de vie de la fusée (dernier tick de poussée, retard d'état). */ static final int MARGE_FUSEE_TICKS = 5; /** * Grâce de propulsion accordée à l'apparition d'une fusée : seulement si elle est réellement attachée au joueur * (propulsion en plané, pas une fusée d'arbalète ou posée au sol), si le joueur plane à cet instant, et si elle * ne vient pas d'être rechargée depuis le disque. Durée : vie restante réelle de la fusée + marge, au lieu de 6 s * fixes (un tricheur qui tire une fusée toutes les quelques secondes n'obtient jamais plus que la vie de la fusée). * * @return nombre de ticks de grâce (0 = aucune) */ static int graceFusee(boolean attacheeAuJoueur, boolean joueurPlane, boolean rechargeeDuDisque, int vie, int dureeDeVie) { if (!attacheeAuJoueur || !joueurPlane || rechargeeDuDisque) return 0; int restant = Math.max(0, dureeDeVie - Math.max(0, vie)); return Math.min(restant, 200) + MARGE_FUSEE_TICKS; } // --- 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); } /** * Motif écrit pour une sanction : le contrôle du verdict qui l'a déclenchée (applicable == sanction). Avant 0.4.0 * c'était le premier de la liste, donc un contrôle en OBSERVE (vitesse) pouvait être accusé à la place du vol. * À défaut, le verdict le plus sévère, puis « anti-triche ». */ static String raison(List verdicts, Sanction s) { Verdict retenu = null; for (Verdict v : verdicts) { if (v.applicable() == s) return v.controle().id(); if (retenu == null || v.applicable().ordinal() > retenu.applicable().ordinal()) retenu = v; } return retenu == null ? "anti-triche" : retenu.controle().id(); } /** 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 = raison(verdicts, s); 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 + ")"); } } } }