package com.gastinelgarde; import com.gastinelgarde.core.Controle; import com.gastinelgarde.core.DetectionContraption; import com.gastinelgarde.core.EtatJoueur; import com.gastinelgarde.core.EtatMouvement; import com.gastinelgarde.core.EtatVehicule; import com.gastinelgarde.core.GardeConfig; import com.gastinelgarde.core.GraceRecul; import com.gastinelgarde.core.GraceTeleport; import com.gastinelgarde.core.HistoriqueBoites; import com.gastinelgarde.core.PorteeHitbox; import com.gastinelgarde.core.Mode; import com.gastinelgarde.core.Moteur; import com.gastinelgarde.core.RiptideSuivi; import com.gastinelgarde.core.Sanction; import com.gastinelgarde.core.Suivi; import com.gastinelgarde.core.TraceFichier; import com.gastinelgarde.core.TraceLigne; import com.gastinelgarde.core.Verdict; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.StandardOpenOption; import java.time.Instant; import java.util.HashMap; import java.util.HashSet; import java.util.List; 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; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.UseAnim; import net.minecraft.world.item.Items; import net.minecraft.world.item.ItemStack; import net.minecraft.world.item.enchantment.EnchantmentHelper; import net.neoforged.fml.loading.FMLPaths; /** * État d'exécution du mod (une seule instance par serveur) et pont entre Minecraft et le moteur pur. * Toute la logique de décision est dans {@code com.gastinelgarde.core} ; ici on ne fait que lire l'état du * serveur, appeler le moteur et appliquer le résultat. */ public final class Garde { /** Marques propres à un joueur, côté adaptateur (ticks du serveur). */ private static final class Marques { int teleportTick = Integer.MIN_VALUE; int reculTick = Integer.MIN_VALUE; int dernierVerdictTick = Integer.MIN_VALUE; int dernierTraceTick = Integer.MIN_VALUE; final RiptideSuivi riptide = new RiptideSuivi(); final GraceTeleport graceTeleport = new GraceTeleport(); final GraceRecul graceRecul = new GraceRecul(); long exemptJusquaMs = 0; double dernierX, dernierY, dernierZ; boolean aDernierePosition; // Mouvement (phase 2) int mouvementTick = Integer.MIN_VALUE; double mouvementX, mouvementY, mouvementZ; // Véhicule piloté (F20) int vehiculeId = -1; 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; // 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; // #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux) double[] oeilDernier; double[] oeilAvant; } /** #92 : historique des boîtes d'une entité suivie (joueurs, et entités frappées récemment). */ private static final class Suivie { final Entity entite; final HistoriqueBoites historique = new HistoriqueBoites(); net.minecraft.world.level.Level niveau; int jusquaTick; Suivie(Entity e) { this.entite = e; this.niveau = e.level(); } } /** Entités dont on garde les boîtes, par identifiant (unique sur le serveur). */ private static final Map SUIVIES = new HashMap<>(); /** Une entité non joueur frappée est suivie pendant 10 s après le dernier coup. */ private static final int SUIVI_ENTITE_TICKS = 200; /** Garde-fou mémoire : au plus ce nombre d'entités non joueur suivies. */ private static final int SUIVIES_MAX = 256; private static final GardeConfig CONFIG = new GardeConfig(); private static final Moteur MOTEUR = new Moteur(CONFIG); private static final Map MARQUES = new HashMap<>(); private static final Set ALERTES_COUPEES = new HashSet<>(); private static TraceFichier traces; private static Path journal; private static boolean tracesEnCours; private static int gelTick = Integer.MIN_VALUE; private static double tpsEstime = 20.0; private Garde() { } public static GardeConfig config() { return CONFIG; } public static Moteur moteur() { return MOTEUR; } // --- Cycle de vie --- public static void surConfigChargee() { GastinelGarde.LOGGER.info("[GastinelGarde] Configuration appliquée."); } public static synchronized void demarrer() { GardeSpec.appliquer(CONFIG); Path jeu = FMLPaths.GAMEDIR.get(); journal = jeu.resolve("logs").resolve("gastinelgarde.log"); try { Files.createDirectories(journal.getParent()); traces = new TraceFichier(jeu.resolve("gastinelgarde-traces"), GardeSpec.tracesJours(), GardeSpec.tracesTailleOctets()); tracesEnCours = GardeSpec.tracesActives(); } catch (IOException e) { GastinelGarde.LOGGER.error("[GastinelGarde] Impossible d'ouvrir le dossier de traces", e); traces = null; tracesEnCours = false; } } public static synchronized void arreter() { if (traces != null) { try { traces.close(); } catch (IOException ignored) { // fermeture du serveur : rien à faire de plus } traces = null; } MARQUES.clear(); SUIVIES.clear(); } public static synchronized void flushTraces() { if (traces == null) return; try { traces.flush(); } catch (IOException e) { GastinelGarde.LOGGER.warn("[GastinelGarde] flush des traces : {}", e.toString()); } } public static boolean tracesEnCours() { return tracesEnCours && traces != null; } public static void definirTraces(boolean actif) { tracesEnCours = actif && traces != null; } public static void joueurParti(UUID id) { MOTEUR.retirer(id); MARQUES.remove(id); ALERTES_COUPEES.remove(id); } // --- Faits collectés --- /** Connexion, changement de dimension, réapparition : toujours une grâce. */ public static void noterTeleport(ServerPlayer p) { if (!surThreadServeur(p)) return; Marques m = marques(p.getUUID()); m.teleportTick = p.server.getTickCount(); m.mouvementTick = Integer.MIN_VALUE; m.vehiculeId = -1; m.oeilAvant = null; m.oeilDernier = null; } /** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */ public static void annoncerTeleport(ServerPlayer p, GraceTeleport.Origine origine) { if (!surThreadServeur(p)) return; marques(p.getUUID()).graceTeleport.annoncer(origine); } /** * Tout teleport() du joueur (mixin) : la grâce ne s'ouvre que pour une origine externe (F05). Le mouvement * suivant n'est jamais comparé à la position d'avant la téléportation. */ public static void teleportVanilla(ServerPlayer p) { if (!surThreadServeur(p)) return; Marques m = marques(p.getUUID()); if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount(); m.mouvementTick = Integer.MIN_VALUE; m.vehiculeId = -1; m.oeilAvant = null; m.oeilDernier = null; } // --- Historique des cibles (#92, contrôle coups-hors-boite) --- /** * Début de tick (après les paquets reçus entre deux ticks, avant l'envoi des positions aux clients) : boîte de * chaque joueur et de chaque entité frappée récemment. C'est ce que les clients vont recevoir pendant ce tick. * Coût : quelques joueurs et quelques mobs, 6 doubles chacun. */ public static void enregistrerHistoriques(MinecraftServer server) { if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) { if (!SUIVIES.isEmpty()) SUIVIES.clear(); return; } int tick = server.getTickCount(); for (ServerPlayer p : server.getPlayerList().getPlayers()) { Suivie s = SUIVIES.get(p.getId()); if (s == null || s.entite != p) { s = new Suivie(p); // connexion, ou réapparition (nouvel objet joueur, même identifiant) SUIVIES.put(p.getId(), s); } s.jusquaTick = tick + SUIVI_ENTITE_TICKS; } java.util.Iterator> it = SUIVIES.entrySet().iterator(); while (it.hasNext()) { Suivie s = it.next().getValue(); Entity e = s.entite; if (e.isRemoved() || tick > s.jusquaTick) { it.remove(); continue; } if (e.level() != s.niveau) { // changement de dimension : les anciennes boîtes ne veulent plus rien dire s.historique.vider(); s.niveau = e.level(); } net.minecraft.world.phys.AABB b = boiteVisee(e); s.historique.ajouter(tick, b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ); } } /** Boîte que le client vise (vanilla : boîte gonflée du rayon de visée de l'entité, 0 pour presque toutes). */ static net.minecraft.world.phys.AABB boiteVisee(Entity e) { float r = e.getPickRadius(); return r > 0 ? e.getBoundingBox().inflate(r) : e.getBoundingBox(); } /** * Boîtes de la cible sur la fenêtre où l'attaquant a pu la voir (selon son ping), ou null si l'historique ne * couvre pas toute la fenêtre (entité jamais frappée jusque-là, connexion récente) : on ne mesure pas. * Une entité non joueur frappée commence ici à être suivie. */ public static double[][] boitesVues(Entity cible, ServerPlayer attaquant, int tick) { if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return null; Suivie s = SUIVIES.get(cible.getId()); if (s == null || s.entite != cible) { if (!(cible instanceof Player) && SUIVIES.size() < SUIVIES_MAX) { s = new Suivie(cible); s.jusquaTick = tick + SUIVI_ENTITE_TICKS; SUIVIES.put(cible.getId(), s); } return null; } if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS; if (s.niveau != cible.level()) return null; int fenetre = PorteeHitbox.ticksFenetre(attaquant.connection.latency(), CONFIG); return s.historique.depuis(tick - fenetre); } /** Œil de l'attaquant au paquet de mouvement d'avant le dernier (null si inconnu). */ public static double[] oeilAvant(ServerPlayer p) { Marques m = MARQUES.get(p.getUUID()); return m == null ? null : m.oeilAvant; } /** * La cible est-elle sur ou près d'une contraption Create / d'un vaisseau Sable ? Sa position affichée chez les * autres clients peut alors suivre la contraption autrement que ses positions serveur : on ne mesure pas. */ public static boolean cibleProcheContraption(Entity cible, int tick) { if (cible instanceof ServerPlayer j) return pocheContraptionEnCache(j, marques(j.getUUID()), tick); if (SableAcces.surSousNiveau(cible)) return true; int dist = GardeSpec.distanceContraption(); if (dist <= 0) return false; return !cible.level().getEntities(cible, cible.getBoundingBox().inflate(dist), Garde::estContraption).isEmpty(); } /** Recul réel (F06). Auto-infligé (charge de vent à ses pieds) : grâce limitée, voir GraceRecul. */ public static void noterRecul(ServerPlayer p, boolean autoInflige) { if (!surThreadServeur(p)) return; Marques m = marques(p.getUUID()); int tick = p.server.getTickCount(); if (m.graceRecul.recul(tick, autoInflige)) m.reculTick = tick; } public static void noterTickServeur(MinecraftServer server, long dureeNs) { double ms = dureeNs / 1_000_000.0; if (ms > 250.0) gelTick = server.getTickCount(); double moyenne = server.getAverageTickTimeNanos() / 1_000_000.0; tpsEstime = moyenne <= 50.0 ? 20.0 : 1000.0 / moyenne; } public static void exempter(UUID id, long dureeMs) { marques(id).exemptJusquaMs = System.currentTimeMillis() + dureeMs; } public static boolean estExempteManuellement(UUID id) { Marques m = MARQUES.get(id); return m != null && m.exemptJusquaMs > System.currentTimeMillis(); } public static boolean alertesActivesPour(UUID id) { return !ALERTES_COUPEES.contains(id); } public static void definirAlertes(UUID id, boolean actif) { if (actif) ALERTES_COUPEES.remove(id); else ALERTES_COUPEES.add(id); } /** L'état du mod n'est pas thread-safe : seul le thread du serveur y touche (F01). */ static boolean surThreadServeur(ServerPlayer p) { return p.server == null || p.server.isSameThread(); } private static Marques marques(UUID id) { return MARQUES.computeIfAbsent(id, k -> new Marques()); } // --- État d'un joueur pour le moteur --- public static EtatJoueur etat(ServerPlayer p, boolean chercherContraption) { int tick = p.server.getTickCount(); Marques m = marques(p.getUUID()); // F04 : tenir un trident Impulsion n'exempte plus ; seulement la vrille ou un relâchement valide, et 2 s après. m.riptide.observer(tick, p.isAutoSpinAttack()); boolean riptideRecent = m.riptide.actif(tick); boolean mange = false; if (p.isUsingItem()) { UseAnim anim = p.getUseItem().getUseAnimation(); mange = anim == UseAnim.EAT || anim == UseAnim.DRINK; } return EtatJoueur.builder() .creatif(p.isCreative()) .spectateur(p.isSpectator()) .peutVoler(p.getAbilities().mayfly) .riptide(riptideRecent) .elytres(p.isFallFlying()) .levitation(p.hasEffect(MobEffects.LEVITATION)) .chuteLente(p.hasEffect(MobEffects.SLOW_FALLING)) .enVehicule(p.isPassenger()) .pocheContraption(chercherContraption && pocheContraptionEnCache(p, m, tick)) .utiliseObjet(mange) .ticksDepuisTeleport(depuis(tick, m.teleportTick)) .ticksDepuisRecul(depuis(tick, m.reculTick)) .ticksDepuisGel(depuis(tick, gelTick)) .tps(tpsEstime) .pingMs(p.connection.latency()) .build(); } private static int depuis(int tick, int marque) { if (marque == Integer.MIN_VALUE) return EtatJoueur.JAMAIS; return Math.max(0, tick - marque); } private static boolean tridentImpulsion(ItemStack stack, ServerPlayer joueur) { return stack.is(Items.TRIDENT) && EnchantmentHelper.getTridentSpinAttackStrength(stack, joueur) > 0.0F; } /** Un objet vient d'être relâché (événement Stop) : un trident Impulsion chargé ouvre la tolérance riptide. */ public static void noterRelache(ServerPlayer p, ItemStack stack, int ticksRestants) { if (!surThreadServeur(p) || !tridentImpulsion(stack, p)) return; int charge = stack.getUseDuration(p) - ticksRestants; boolean ouvert = marques(p.getUUID()).riptide.relache(p.server.getTickCount(), true, charge, p.isInWaterOrRain(), pluieProche(p)); if (ouvert) { GastinelGarde.LOGGER.debug("[GastinelGarde] riptide : relâchement de {} (charge {} ticks)", p.getGameProfile().getName(), charge); } } /** * Critère de pluie relâché par rapport à isInWaterOrRain (le client peut voir la pluie quand le serveur ne la * voit pas : niveau de pluie qui monte, feuillage) : temps pluvieux (drapeau ou niveau), biome pluvieux et ciel * visible aux pieds ou à la tête, comme vanilla. Seul le contrôle de la carte des hauteurs MOTION_BLOCKING est * omis. Un toit (même d'un bloc) ou un temps sec : non. */ private static boolean pluieProche(ServerPlayer p) { net.minecraft.world.level.Level l = p.level(); if (!l.getLevelData().isRaining() && l.getRainLevel(1.0F) <= 0.0F) return false; BlockPos pieds = p.blockPosition(); BlockPos tete = BlockPos.containing(p.getX(), p.getBoundingBox().maxY, p.getZ()); for (BlockPos pos : new BlockPos[] {pieds, tete}) { if (l.canSeeSky(pos) && l.getBiome(pos).value().getPrecipitationAt(pos) == net.minecraft.world.level.biome.Biome.Precipitation.RAIN) return true; } return false; } /** Seuil vanilla « moved too quickly » (appelé par RiptideMoveMixin) : relevé seulement pendant un riptide réel. */ public static float seuilMouvementVanilla(ServerPlayer p, float seuil) { RiptideSuivi r = marques(p.getUUID()).riptide; int tick = p.server.getTickCount(); r.observer(tick, p.isAutoSpinAttack()); float resultat = r.seuil(seuil, tick, p.isAutoSpinAttack()); if (resultat != seuil) { GastinelGarde.LOGGER.debug("[GastinelGarde] riptide : seuil relevé pour {} (vrille={}, depuis={} ticks)", p.getGameProfile().getName(), p.isAutoSpinAttack(), r.ticksDepuis(tick)); } return resultat; } /** Vrille en cours ou dans les 2 s (appelé par RiptideMoveMixin pour le contrôle anti-vol vanilla). */ public static boolean riptideRecent(ServerPlayer p) { RiptideSuivi r = marques(p.getUUID()).riptide; int tick = p.server.getTickCount(); r.observer(tick, p.isAutoSpinAttack()); return r.actif(tick); } /** Ticks pendant lesquels un joueur reste exempté après avoir quitté une contraption ou un vaisseau Sable. */ private static final int GRACE_CONTRAPTION_TICKS = 40; /** La détection est refaite au plus toutes les 10 ticks par joueur ; grâce de 2 s après la dernière détection. */ private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) { if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) { m.contraptionProche = pocheContraption(p); m.contraptionTick = tick; if (m.contraptionProche) m.contraptionVuTick = tick; } return m.contraptionProche || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS); } /** * Le joueur est-il sur ou près d'une contraption ? Deux sources : *
    *
  • Create (et les contraptions d'Aeronautics / Offroad, qui en héritent) : entités proches dont une classe de * la chaîne correspond au réglage prefixesContraption ;
  • *
  • Aeronautics 1.3.2 : les vaisseaux ne sont PAS des entités, ce sont des « sous-niveaux » de Sable 2.0.6. * On demande à Sable (par réflexion, sans dépendance de compilation) si le joueur est suivi par un * sous-niveau, ou s'il est dans un véhicule posé sur un sous-niveau.
  • *
*/ private static boolean pocheContraption(Player p) { if (SableAcces.surSousNiveau(p)) return true; int dist = GardeSpec.distanceContraption(); if (dist <= 0) return false; return !p.level().getEntities(p, p.getBoundingBox().inflate(dist), Garde::estContraption).isEmpty(); } /** L'entité est-elle une contraption (classe ou classe parente dans le réglage) ? */ public static boolean estContraption(Entity e) { List motifs = DetectionContraption.motifs(GardeSpec.prefixesContraption()); if (motifs.isEmpty()) return false; List chaine = new java.util.ArrayList<>(6); for (Class c = e.getClass(); c != null && c != Entity.class && c != Object.class; c = c.getSuperclass()) { chaine.add(c.getName()); } return DetectionContraption.correspond(chaine, motifs); } // --- Réaction aux verdicts --- /** * Journalise, prévient les ops et renvoie la pire sanction applicable. Ne modifie pas le joueur : l'appelant * décide de l'action (annuler le coup, retour arrière, expulsion). */ 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) { 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); } private static void alerterOps(ServerPlayer cible, Verdict v) { Component msg = Component.literal(String.format("[Garde] %s : %s VL=%.1f (%s, %s)", cible.getGameProfile().getName(), v.controle().id(), v.vl(), v.mode(), v.applicable())) .withStyle(ChatFormatting.GOLD); for (ServerPlayer op : cible.server.getPlayerList().getPlayers()) { if (op.hasPermissions(2) && alertesActivesPour(op.getUUID())) op.sendSystemMessage(msg); } } /** Ligne dans logs/gastinelgarde.log et le journal du serveur (anti-crash, 16/10). */ public static void journaliser(String ligne) { ecrireJournal(ligne); } private static synchronized void ecrireJournal(String ligne) { GastinelGarde.LOGGER.warn("[GastinelGarde] {}", ligne); if (journal == null) return; try { Files.writeString(journal, Instant.now() + " " + ligne + System.lineSeparator(), StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.APPEND); } catch (IOException e) { GastinelGarde.LOGGER.warn("[GastinelGarde] journal : {}", e.toString()); } } // --- Traces --- public static synchronized void tracer(TraceLigne l) { if (!tracesEnCours()) return; try { traces.ecrire(System.currentTimeMillis(), l.json()); } catch (IOException e) { GastinelGarde.LOGGER.warn("[GastinelGarde] trace : {}", e.toString()); tracesEnCours = false; } } // --- Paquet de mouvement (appelé par le mixin) --- /** 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; 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); } /** 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 int tick = p.server.getTickCount(); Marques m = marques(p.getUUID()); boolean solServeur = auSolServeur(p, m); // Phase 2 : no-fall (divergence), vitesse horizontale, vol. boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID()); EtatMouvement em = null; EtatJoueur etatMouvement = null; if ((controler || tracesEnCours()) && m.mouvementTick != Integer.MIN_VALUE) { double dx = p.getX() - m.mouvementX; double dz = p.getZ() - m.mouvementZ; 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, m, tick), frictionAnormale(p), facteurVitesse(p), facteurFurtif(p)); etatMouvement = etat(p, true); } 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); } // F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup. if (!estExempteManuellement(p.getUUID())) { List v = MOTEUR.regard(p.getUUID(), tick * 50L, () -> etat(p, true), p.getYRot(), p.getXRot()); traiter(p, v); // le coup a déjà eu lieu : journal et VL seulement // Portée / hitbox : mesure du dernier coup refaite avec l'œil et le regard de ce paquet (core.CoupDiffere). net.minecraft.world.phys.Vec3 oeil = p.getEyePosition(); net.minecraft.world.phys.Vec3 regard = p.getLookAngle(); List vh = MOTEUR.regardPorteeHitbox(p.getUUID(), tick * 50L, new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z}); Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques) if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh); // #92 : œil des deux derniers paquets, pour le prochain coup. m.oeilAvant = m.oeilDernier; m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z}; } m.mouvementTick = tick; m.mouvementX = p.getX(); m.mouvementY = p.getY(); m.mouvementZ = p.getZ(); // 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())) { MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(), p.level().dimension().location().toString()); } // 15/10 : une ligne par paquet (avant : une par tick, et le paquet suivant du même tick était compté dans la // ligne suivante, deux déplacements pour un tick au rejeu). Deux lignes au même tick : 1 tick chacune (Rejeu). if (tracesEnCours()) { m.dernierTraceTick = tick; double vx = m.aDernierePosition ? p.getX() - m.dernierX : 0; double vy = m.aDernierePosition ? p.getY() - m.dernierY : 0; double vz = m.aDernierePosition ? p.getZ() - m.dernierZ : 0; m.dernierX = p.getX(); m.dernierY = p.getY(); m.dernierZ = p.getZ(); m.aDernierePosition = true; EtatJoueur etatTrace = etatMouvement != null ? etatMouvement : etat(p, true); tracer(new TraceLigne(tick, p.getGameProfile().getName(), "move", p.getX(), p.getY(), p.getZ(), vx, vy, vz, p.onGround(), solServeur, TraceLigne.masqueMouvement(etatTrace, em, CONFIG), -1, Double.NaN, TraceLigne.messageFacteurs(em))); } } // --- Paquet de mouvement de véhicule (F20, appelé par le mixin à la fin de handleMoveVehicle) --- /** * Fin du traitement d'un paquet de véhicule. Vanilla n'applique le paquet que si le joueur pilote son * véhicule racine ; sinon (ou au changement de véhicule) on repart de zéro. Un paquet refusé (« moved too * quickly », « moved wrongly ») ne passe pas ici : la position de référence reste la dernière acceptée. */ public static void apresVehicule(ServerPlayer p) { if (!surThreadServeur(p)) return; Marques m = marques(p.getUUID()); Entity v = p.getRootVehicle(); if (v == p || v.getControllingPassenger() != p) { m.vehiculeId = -1; return; } int tick = p.server.getTickCount(); if (v.getId() != m.vehiculeId) { // Pas de position de référence pour ce véhicule : rien à mesurer sur ce paquet. Le temps en l'air et le // solde ne repartent de zéro qu'après 2 s sans véhicule (revue de sécurité de F20 : descendre puis // remonter en l'air ne doit pas remettre le compteur de vol à zéro). if (m.vehiculeTick == Integer.MIN_VALUE || tick - m.vehiculeTick > 40) MOTEUR.nouveauVehicule(p.getUUID()); else MOTEUR.changementVehicule(p.getUUID()); m.vehiculeId = v.getId(); } else { boolean controler = vehiculeControle(p); if (controler || tracesEnCours()) { double dx = v.getX() - m.vehiculeX; double dz = v.getZ() - m.vehiculeZ; EtatVehicule ev = etatVehicule(v, Math.sqrt(dx * dx + dz * dz), v.getY() - m.vehiculeY, tick - m.vehiculeTick); EtatJoueur etat = etat(p, true); if (controler) { List verdicts = MOTEUR.vehicule(p.getUUID(), tick * 50L, etat, ev); // Position de retour : seulement après un paquet de véhicule sans verdict (sinon apresMouvement). if (verdicts.isEmpty() && m.dernierVerdictTick != tick) memoriserPositionJoueur(p); Sanction s = traiter(p, verdicts); if (s.ordinal() >= Sanction.SETBACK.ordinal()) { p.stopRiding(); // le retour arrière ramène le joueur, pas le véhicule appliquerSanctionMouvement(p, s, verdicts); } } if (tracesEnCours()) { int f = TraceLigne.masque(etat); if (ev.milieuSpecial()) f |= TraceLigne.F_MILIEU; if (ev.frictionAnormale()) f |= TraceLigne.F_FRICTION; tracer(new TraceLigne(tick, p.getGameProfile().getName(), "veh", v.getX(), v.getY(), v.getZ(), dx, ev.dy(), dz, v.onGround(), ev.auSolServeur(), f, -1, Double.NaN, ev.type() + " " + v.getType().builtInRegistryHolder().key().location())); } } } m.vehiculeTick = tick; m.vehiculeX = v.getX(); m.vehiculeY = v.getY(); m.vehiculeZ = v.getZ(); } /** * Le véhicule du joueur est-il contrôlé (F20) ? Il le pilote, un contrôle de véhicule est actif, pas d'exemption * manuelle, et ce n'est pas un véhicule de mod inconnu. Sinon, la position de retour suit le joueur comme avant. */ private static boolean vehiculeControle(ServerPlayer p) { Entity v = p.getRootVehicle(); if (v == p || v.getControllingPassenger() != p) return false; if (!(v instanceof net.minecraft.world.entity.vehicle.Boat) && !(v instanceof net.minecraft.world.entity.LivingEntity)) return false; return (CONFIG.mode(Controle.VEHICULE_VITESSE) != Mode.OFF || CONFIG.mode(Controle.VEHICULE_VOL) != Mode.OFF) && !estExempteManuellement(p.getUUID()); } private static void memoriserPositionJoueur(ServerPlayer p) { MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(), p.level().dimension().location().toString()); } private static EtatVehicule etatVehicule(Entity v, double dxz, double dy, int ticks) { EtatVehicule.Type type; double attribut = 0; if (v instanceof net.minecraft.world.entity.vehicle.Boat) { type = EtatVehicule.Type.BATEAU; // bateaux, bateaux à coffre, radeaux } else if (v instanceof net.minecraft.world.entity.LivingEntity l) { type = EtatVehicule.Type.MONTURE; attribut = l.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.MOVEMENT_SPEED); } else { type = EtatVehicule.Type.AUTRE; } net.minecraft.world.level.Level l = v.level(); BlockPos pos = v.blockPosition(); boolean auSol = !l.noCollision(v, v.getBoundingBox().move(0.0, -0.05, 0.0)); boolean milieu = v.isInWater() || v.isInLava() || !l.getFluidState(pos.below()).isEmpty() || l.getBlockState(pos).is(Blocks.BUBBLE_COLUMN) || l.getBlockState(pos.below()).is(Blocks.BUBBLE_COLUMN) || l.getBlockState(pos).is(Blocks.COBWEB); if (v instanceof net.minecraft.world.entity.LivingEntity le) { milieu |= le.onClimbable() || le.hasEffect(MobEffects.LEVITATION) || le.hasEffect(MobEffects.SLOW_FALLING); } BlockState sous = l.getBlockState(v.getBlockPosBelowThatAffectsMyMovement()); boolean friction = sous.getBlock().getFriction() > 0.6F || sous.getBlock().getSpeedFactor() > 1.0F; return new EtatVehicule(type, dxz, dy, ticks, auSol, milieu, friction, attribut, v.isNoGravity()); } /** * 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 (!surThreadServeur(p)) return auSolClient; 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, marques(p.getUUID()))); } 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). * * 15/10/2026 (faux no-fall de totoche10 à y = 114,0 et 110,5) : vanilla résout la collision verticale AVANT le * déplacement horizontal du même tick. Un joueur qui atterrit au bord d'un bloc puis glisse au-delà dans le même * tick est « au sol » pour le client, sans bloc sous sa position finale. On regarde donc aussi sous le trajet * horizontal du paquet (tranche des pieds seulement, voir NoFall.trancheBalayee). */ private static boolean auSolServeur(ServerPlayer p, Marques m) { net.minecraft.world.phys.AABB b = p.getBoundingBox(); if (!p.level().noCollision(p, b.move(0.0, -0.05, 0.0))) return true; if (m == null || m.mouvementTick == Integer.MIN_VALUE) return false; double dx = p.getX() - m.mouvementX; double dz = p.getZ() - m.mouvementZ; if (dx * dx + dz * dz > com.gastinelgarde.core.NoFall.BALAYAGE_MAX * com.gastinelgarde.core.NoFall.BALAYAGE_MAX || (dx == 0 && dz == 0)) return false; double[] t = com.gastinelgarde.core.NoFall.trancheBalayee(b.minX, b.minY, b.minZ, b.maxX, b.maxZ, dx, dz); return !p.level().noCollision(p, new net.minecraft.world.phys.AABB(t[0], t[1], t[2], t[3], t[4], t[5])); } /** Attribut de vitesse / sa base, hors bonus de course (Vitesse, Lenteur, Agilité des âmes, mods). NaN si inconnu. */ private static double facteurVitesse(ServerPlayer p) { net.minecraft.world.entity.ai.attributes.AttributeInstance a = p.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.MOVEMENT_SPEED); if (a == null || a.getBaseValue() <= 0) return Double.NaN; double v = a.getValue() / a.getBaseValue(); if (a.hasModifier(net.minecraft.resources.ResourceLocation.withDefaultNamespace("sprinting"))) v /= 1.3; return v; } /** Vitesse accroupi / 0,3 (Furtivité rapide). NaN si inconnu. */ private static double facteurFurtif(ServerPlayer p) { net.minecraft.world.entity.ai.attributes.AttributeInstance a = p.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.SNEAKING_SPEED); return a == null ? Double.NaN : a.getValue() / 0.3; } 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, baie sucrée, miel, colonne à bulles, slime, lit, tapis * roulant et courant d'air Create : la vitesse et le vol vanilla ne s'appliquent pas. * * 15/10/2026 (vol en ENFORCE) : toile, baies, neige poudreuse, miel et colonne à bulles sont cherchés dans toute la * boîte du joueur (+0,1 bloc de côté : glissade le long d'un bloc de miel), plus seulement au niveau des pieds : * une toile à hauteur de tête freine la chute pendant plus de 10 ticks. */ private static boolean milieuSpecial(ServerPlayer p, Marques m, int tick) { if (p.isInWater() || p.isInLava() || p.onClimbable() || p.isSwimming() || p.getAbilities().flying) return true; if (p.isInPowderSnow || p.wasInPowderSnow) return true; net.minecraft.world.level.Level l = p.level(); BlockPos pos = p.blockPosition(); BlockState pied = l.getBlockState(pos); BlockState sous = l.getBlockState(pos.below()); if (sous.is(Blocks.SLIME_BLOCK) || sous.is(BlockTags.BEDS)) return true; net.minecraft.world.phys.AABB b = p.getBoundingBox().inflate(0.1, 0.0, 0.1); for (BlockPos q : BlockPos.betweenClosed(net.minecraft.util.Mth.floor(b.minX), net.minecraft.util.Mth.floor(b.minY), net.minecraft.util.Mth.floor(b.minZ), net.minecraft.util.Mth.floor(b.maxX), net.minecraft.util.Mth.floor(b.maxY), net.minecraft.util.Mth.floor(b.maxZ))) { BlockState s = l.getBlockState(q); if (s.is(Blocks.COBWEB) || s.is(Blocks.SWEET_BERRY_BUSH) || s.is(Blocks.POWDER_SNOW) || s.is(Blocks.HONEY_BLOCK) || s.is(Blocks.BUBBLE_COLUMN)) return true; } Set tapis = GardeSpec.blocsEntrainement(); if (!tapis.isEmpty() && (tapis.contains(idBloc(pied)) || tapis.contains(idBloc(sous)) || tapis.contains(idBloc(l.getBlockState(p.getBlockPosBelowThatAffectsMyMovement()))))) return true; return courantAirEnCache(p, m, tick); } private static String idBloc(BlockState s) { return net.minecraft.core.registries.BuiltInRegistries.BLOCK.getKey(s.getBlock()).toString(); } /** Grâce après avoir quitté un courant d'air (élan, retard d'état) : comme les contraptions. */ private static final int GRACE_COURANT_TICKS = 40; /** 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); } /** * Un ventilateur Create (réglage blocsCourantAir) dans l'un des 6 axes partant des pieds ou de la tête, à au plus * distanceCourantAirBlocs, sans bloc plein entre les deux. Le courant d'air de Create pousse le joueur côté client * seulement (AirCurrent remet même à zéro le compteur anti-vol vanilla) : sans ça, un ascenseur à ventilateur * serait pris pour du vol (contrôle en ENFORCE depuis le 15/10). */ private static boolean courantAir(ServerPlayer p) { int dist = GardeSpec.distanceCourantAir(); Set ventilateurs = GardeSpec.blocsCourantAir(); if (dist <= 0 || ventilateurs.isEmpty()) return false; net.minecraft.world.level.Level l = p.level(); BlockPos pieds = p.blockPosition(); BlockPos tete = BlockPos.containing(p.getX(), p.getEyeY(), p.getZ()); for (net.minecraft.core.Direction d : net.minecraft.core.Direction.values()) { // vers le bas depuis les pieds, vers le haut depuis la tête, à l'horizontale depuis les deux BlockPos[] departs = d == net.minecraft.core.Direction.DOWN ? new BlockPos[] {pieds} : d == net.minecraft.core.Direction.UP ? new BlockPos[] {tete} : new BlockPos[] {pieds, tete}; for (BlockPos depart : departs) { BlockPos.MutableBlockPos q = depart.mutable(); for (int i = 1; i <= dist; i++) { q.move(d); if (!l.hasChunkAt(q)) break; BlockState s = l.getBlockState(q); if (s.isAir()) continue; if (ventilateurs.contains(idBloc(s))) return true; if (s.isCollisionShapeFullBlock(l, q)) break; // le courant ne traverse pas un bloc plein } } } return false; } /** 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) { // 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 + ")"); } } } }