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; /** 0.4.0 : jusqu'à ce tick, une fusée a propulsé le joueur (plané non contrôlé). */ int propulsionJusquaTick = 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) 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; final Cablage.Elytres elytres = new Cablage.Elytres(); // Cache de la détection d'un courant d'air (ventilateur Create), même principe 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; } /** #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(); // Historique de suspicion : même dossier de jeu que les traces et les journaux (voir HistoriqueSuspicion). try { MOTEUR.historique().ouvrir(jeu.resolve("gastinelgarde-suspicion").resolve("incidents.csv"), System.currentTimeMillis(), CONFIG.suspicionHistoriqueJours); } catch (IOException | RuntimeException e) { GastinelGarde.LOGGER.warn("[GastinelGarde] historique de suspicion illisible, repart à vide : {}", e.toString()); } } 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; // Revue 4 (16/10) : ping noté chaque seconde, hors combat aussi, pour le plancher de ping. if (tick % 20 == 0) MOTEUR.pingFenetre(p.getUUID(), tick * 50L, p.connection.latency()); } 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)) { // Revue 3 (16/10) : table pleine, on évince la cible non joueur frappée il y a le plus longtemps // (avant : la nouvelle cible n'était jamais suivie, faire frapper beaucoup d'entités aveuglait le // contrôle). La cible qu'on frappe sans arrêt est la plus récente : jamais évincée. if (s == null && SUIVIES.size() >= SUIVIES_MAX) evincerPlusAncienne(); 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; // Revue 4 (16/10) : ping plancher des 2 dernières minutes + marge, pas le ping déclaré du moment. int fenetre = PorteeHitbox.ticksFenetre( MOTEUR.pingFenetre(attaquant.getUUID(), tick * 50L, attaquant.connection.latency()), CONFIG); return s.historique.depuis(tick - fenetre); } /** Revue 3 : retire de la table l'entrée non joueur dont le dernier coup est le plus ancien. */ private static void evincerPlusAncienne() { Integer cle = null; int plusTot = Integer.MAX_VALUE; for (Map.Entry e : SUIVIES.entrySet()) { Suivie v = e.getValue(); if (v != null && v.entite instanceof Player) continue; int t = v == null ? Integer.MIN_VALUE : v.jusquaTick; if (cle == null || t < plusTot) { cle = e.getKey(); plusTot = t; } } if (cle != null) SUIVIES.remove(cle); } /** Œ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; } /** Fusée de feu d'artifice tirée par ce joueur (propulsion en plané) : le plané n'est pas contrôlé pendant 6 s. */ public static void noterFusee(ServerPlayer p, int ticks) { if (!surThreadServeur(p)) return; Marques m = marques(p.getUUID()); m.propulsionJusquaTick = Math.max(m.propulsionJusquaTick, p.server.getTickCount() + ticks); MOTEUR.nouvelleFusee(p.getUUID()); } /** 0.4.0 : recul appliqué par le serveur (direction du déplacement attendu, force avant résistance). */ public static void noterVelocite(ServerPlayer p, double dirX, double dirZ, double force) { if (!surThreadServeur(p)) return; double resistance = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.KNOCKBACK_RESISTANCE); // Le joueur est-il libre de reculer ? Boîte déplacée de 0,6 puis 1,2 bloc dans le sens du recul : un mur, un trou // d'un bloc ou un plafond bas (coup d'un tiers qui coince le joueur) annulent la mesure. double norme = Math.hypot(dirX, dirZ); boolean libre = norme > 1e-6; if (libre) { net.minecraft.world.phys.AABB b = p.getBoundingBox(); double ux = dirX / norme, uz = dirZ / norme; libre = p.level().noCollision(p, b.move(ux * 0.6, 0, uz * 0.6)) && p.level().noCollision(p, b.move(ux * 1.2, 0, uz * 1.2)); } MOTEUR.reculApplique(p.getUUID(), p.server.getTickCount() * 50L, dirX, dirZ, force * Math.max(0.0, 1.0 - resistance), libre); } /** 0.4.0 : un totem d'immortalité vient d'éclater (hand = main qui le tenait). */ public static void noterTotem(ServerPlayer p, net.minecraft.world.InteractionHand hand) { if (!surThreadServeur(p)) return; net.minecraft.world.InteractionHand autre = hand == net.minecraft.world.InteractionHand.MAIN_HAND ? net.minecraft.world.InteractionHand.OFF_HAND : net.minecraft.world.InteractionHand.MAIN_HAND; boolean reserve = p.getItemInHand(autre).is(Items.TOTEM_OF_UNDYING); MOTEUR.totemEclate(p.getUUID(), p.server.getTickCount() * 50L, reserve); // 0.4.1 : trace de diagnostic (rare : un totem qui eclate) ; explique l'absence de ligne auto-totem ensuite. ecrireJournal(String.format("%s auto-totem eclatement main=%s reserve=%s mode=%s expulse=%s exempte=%s", p.getGameProfile().getName(), hand, reserve, CONFIG.mode(Controle.AUTO_TOTEM), MOTEUR.estExpulse(p.getUUID()), estExempteManuellement(p.getUUID()))); } 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; } // C7 : au début du plané, combien de ticks en l'air (sol serveur) ? Moins que elytresAirMinTicks : suspect. m.elytres.observer(p.isFallFlying(), m.solServeurTick, tick, config().elytresAirMinTicks); return EtatJoueur.builder() .creatif(p.isCreative()) .spectateur(p.isSpectator()) .peutVoler(p.getAbilities().mayfly) .riptide(riptideRecent) .elytres(p.isFallFlying()) .elytresDeploiementSuspect(m.elytres.suspectes) .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()) .propulsionRecente(tick <= m.propulsionJusquaTick) .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) { return m.contraption.lire(tick, () -> pocheContraption(p), 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()); long delai = Cablage.delaiJournalMs(CONFIG.journalLignesParSeconde); for (Verdict v : verdicts) { // Au plus journalLignesParSeconde lignes par seconde et par contrôle ; 0.5 (P1.1) : sauf le verdict qui // déclenche un SETBACK ou une EXPULSION, toujours écrit (journalToujoursSanctions). if (Cablage.ecrireVerdict(v, CONFIG.journalToujoursSanctions, () -> suivi.autoriserJournal(v.controle(), maintenant, delai))) { 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); } reagirSuspicion(p); return Verdict.pire(verdicts); } /** * Score de suspicion (0.4.0) : journal dès « à surveiller », message aux ops dès « suspect ». À « suspect fort », * seulement une proposition de sanction à valider dans le Portail : le mod ne sanctionne jamais à partir du score. */ private static void reagirSuspicion(ServerPlayer p) { Moteur.AlerteSuspicion a = MOTEUR.alerteSuspicion(p.getUUID(), System.currentTimeMillis()); if (a == null) return; String nom = p.getGameProfile().getName(); ecrireJournal(String.format("SUSPICION %s (%s) score=%d niveau=%s incidents7j=%d contributions=[%s]", nom, p.getUUID(), a.score(), a.niveau(), a.incidents(), a.controles())); if (a.niveau().ordinal() < com.gastinelgarde.core.Suspicion.Niveau.SUSPECT.ordinal()) return; String texte = a.niveau() == com.gastinelgarde.core.Suspicion.Niveau.SUSPECT_FORT ? String.format("[Garde] %s : suspect fort (score %d). Proposition de sanction suspect_2, à valider dans le Portail.", nom, a.score()) : String.format("[Garde] %s : suspect (score %d, %d incident(s) sur 7 jours).", nom, a.score(), a.incidents()); Component msg = Component.literal(texte).withStyle(ChatFormatting.RED); for (ServerPlayer op : p.server.getPlayerList().getPlayers()) { if (op.hasPermissions(2) && alertesActivesPour(op.getUUID())) op.sendSystemMessage(msg); } } 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) { // 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 (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) { // 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); if (solServeur) m.solServeurTick = tick; // C7 // 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 (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())) { 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}; } // 0.4.0 : recul mesuré (anti-recul) et totem remis en main (auto-totem), sur les mêmes paquets. if (!estExempteManuellement(p.getUUID()) && (CONFIG.mode(Controle.VELOCITE) != Mode.OFF || CONFIG.mode(Controle.AUTO_TOTEM) != Mode.OFF)) { EtatJoueur etatSup = etat(p, true); long maintenant = tick * 50L; if (m.mouvementTick != Integer.MIN_VALUE) { // milieuSpecial toujours calculé ici, indépendamment de em (nul quand vol/vitesse/no-fall sont coupés). List v = MOTEUR.mesureRecul(p.getUUID(), maintenant, etatSup, p.getX() - m.mouvementX, p.getZ() - m.mouvementZ, milieuSpecial(p, m, tick), (ux, uz) -> !p.level().noCollision(p, p.getBoundingBox().move(ux * 0.3, 0, uz * 0.3))); Sanction sv = traiter(p, v); // 0.4.2 : setback (retour en arrière) ou expulsion en ENFORCE if (Cablage.sanctionDeMouvement(sv)) appliquerSanctionMouvement(p, sv, v); } boolean totem = p.getMainHandItem().is(Items.TOTEM_OF_UNDYING) || p.getOffhandItem().is(Items.TOTEM_OF_UNDYING); List vt = MOTEUR.totemEnMain(p.getUUID(), maintenant, etatSup, totem); Sanction st = traiter(p, vt); // 0.4.2 : expulsion en ENFORCE (le palier SETBACK reste une alerte) if (st == Sanction.EXPULSION) appliquerSanctionMouvement(p, st, vt); } 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 (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()); } // 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) { return m.courant.lire(tick, () -> courantAir(p), 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) { 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); } }; } }