- Nouveau controle inventaire (mixin ContainerClickMixin apres ensureRunningOnSameThread, PlayerContainerEvent.Open/Close) : vol-de-coffre (reaction apres ouverture ping retire plafonne, prises d'objets differents a <= 1,5 tick en moyenne, double-clic shift exclu), regard-conteneur (rotation avec conteneur ouvert apres grace + ping : contre le stealer "silencieux" et l'InventoryMove), clic-en-rotation (InvCleaner / AutoArmor), clics sur conteneur ferme (journal seulement). - Seuils de VL propres par controle (Paliers), sections de configuration [inventaire], [scaffold], [blink], [phase]. - Ce commit contient deja le cablage (Garde, Moteur, mixins) des trois autres controles 0.6 (fichiers partages) ; leurs tests suivent dans les commits suivants. - Tests : InventaireP06Test (18), MixinsThreadTest etendu. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1413 lignes
77 KiB
Java
1413 lignes
77 KiB
Java
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.5 (P1.2) : jusqu'à ce tick, grâce de connexion. */
|
|
int connexionJusquaTick = 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;
|
|
/** 0.5 (P1.6) : en plané au paquet de mouvement précédent. */
|
|
boolean planeAvant;
|
|
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;
|
|
// 0.6 (scaffold) : rotation des deux derniers paquets de mouvement acceptés
|
|
float yawDernier = Float.NaN, pitchDernier, yawAvant = Float.NaN, pitchAvant;
|
|
}
|
|
|
|
/** #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<Integer, Suivie> 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<UUID, Marques> MARQUES = new HashMap<>();
|
|
private static final Set<UUID> 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());
|
|
ecrireJournal("demarrage GastinelGarde " + GastinelGarde.version()); // 0.5 (P1.4) : version au journal
|
|
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;
|
|
}
|
|
|
|
/** 0.5 (P1.2) : connexion : grâce de connexion (plus longue après une expulsion récente), en plus de la téléportation. */
|
|
public static void noterConnexion(ServerPlayer p) {
|
|
if (!surThreadServeur(p)) return;
|
|
noterTeleport(p);
|
|
int tick = p.server.getTickCount();
|
|
int grace = MOTEUR.graceConnexionTicks(p.getUUID(), tick * 50L);
|
|
marques(p.getUUID()).connexionJusquaTick = tick + grace;
|
|
if (grace > CONFIG.graceConnexionTicks) {
|
|
ecrireJournal(p.getGameProfile().getName() + " reconnexion apres expulsion recente : grace de " + grace + " ticks");
|
|
}
|
|
}
|
|
|
|
/** 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<Map.Entry<Integer, Suivie>> 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<Integer, Suivie> 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())));
|
|
}
|
|
|
|
/**
|
|
* 0.5 (P1.10) : coup critique vanilla accordé à ce joueur. Renvoie vrai si le critique doit être annulé (contrôle
|
|
* criticals en ENFORCE, palier SETBACK ou plus) ; une EXPULSION est appliquée ici.
|
|
*/
|
|
public static boolean noterCritique(ServerPlayer p) {
|
|
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID()) || estExempteManuellement(p.getUUID())) return false;
|
|
List<Verdict> v = MOTEUR.critique(p.getUUID(), p.server.getTickCount() * 50L, etat(p, true));
|
|
Sanction s = traiter(p, v);
|
|
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
|
return Cablage.sanctionDeMouvement(s);
|
|
}
|
|
/**
|
|
* 0.5 (P1.13) : action de casse de bloc reçue (événement LeftClickBlock, vu même annulé). Diagnostic seulement :
|
|
* ligne de journal pour un ABORT sans START correspondant (message vanilla « Mismatch in destroy block pos »).
|
|
*/
|
|
public static void noterActionBloc(ServerPlayer p, boolean start, boolean abort, BlockPos pos, boolean annule) {
|
|
if (!CONFIG.diagnosticActionsBloc || !surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
|
|
com.gastinelgarde.core.ActionsBloc a = MOTEUR.suivi(p.getUUID()).actionsBloc;
|
|
if (start) {
|
|
a.start(pos.getX(), pos.getY(), pos.getZ(), annule);
|
|
} else if (abort) {
|
|
String ligne = a.abort(pos.getX(), pos.getY(), pos.getZ(), System.currentTimeMillis());
|
|
if (ligne != null) ecrireJournal("DIAGNOSTIC " + p.getGameProfile().getName() + " casse de bloc : " + ligne);
|
|
}
|
|
}
|
|
/** 0.5 (P2.3) : START de casse accepté : début de la mesure fast-break. */
|
|
public static void noterDebutCasse(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face) {
|
|
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
|
|
MOTEUR.debutCasse(p.getUUID(), p.server.getTickCount(), pos.getX(), pos.getY(), pos.getZ());
|
|
// 0.5 (P2.5) : début de casse sans impact : face et portée seulement (journal, expulsion en ENFORCE).
|
|
List<Verdict> v = verdictsInteraction(p, pos, face, null, -1);
|
|
Sanction s = traiter(p, v);
|
|
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
|
}
|
|
|
|
/**
|
|
* 0.5 (P2.5) : clic droit sur un bloc (main principale). Vrai si l'interaction doit être annulée (interaction-bloc
|
|
* en ENFORCE, palier SETBACK ou plus) ; une EXPULSION est appliquée ici. Câblage non testé en jeu.
|
|
*/
|
|
public static boolean noterInteractionBloc(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
|
|
net.minecraft.world.phys.Vec3 impact, boolean mainPrincipale) {
|
|
if (!surThreadServeur(p)) return false;
|
|
// 0.5 (P3, revue) : joueur en cours d'expulsion : interaction annulée (comme les coups, C4). Avant, le doublon
|
|
// main secondaire d'un clic qui venait d'expulser se lisait « autorisé ».
|
|
if (MOTEUR.estExpulse(p.getUUID())) return true;
|
|
autrePaquet(p); // 0.6 (blink)
|
|
List<Verdict> v = verdictsInteraction(p, pos, face, impact, mainPrincipale ? 0 : 1);
|
|
Sanction s = traiter(p, v);
|
|
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
|
boolean annulerScaffold = poseScaffold(p, pos, face, impact, mainPrincipale);
|
|
return Cablage.sanctionDeMouvement(s) || annulerScaffold;
|
|
}
|
|
|
|
/**
|
|
* 0.6 (P3.2) : clic droit avec un bloc en main qui posera un bloc de pont sous les pieds. La pose est jugée au paquet
|
|
* de mouvement suivant ; vrai si elle doit être annulée (scaffold en ENFORCE, période suspecte). Non testé en jeu.
|
|
*/
|
|
private static boolean poseScaffold(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
|
|
net.minecraft.world.phys.Vec3 impact, boolean mainPrincipale) {
|
|
if (CONFIG.mode(Controle.SCAFFOLD) == Mode.OFF || impact == null || face == null
|
|
|| estExempteManuellement(p.getUUID())) return false;
|
|
net.minecraft.world.InteractionHand main = mainPrincipale ? net.minecraft.world.InteractionHand.MAIN_HAND
|
|
: net.minecraft.world.InteractionHand.OFF_HAND;
|
|
if (!(p.getItemInHand(main).getItem() instanceof net.minecraft.world.item.BlockItem)) return false;
|
|
if (!mainPrincipale && p.getMainHandItem().getItem() instanceof net.minecraft.world.item.BlockItem) return false;
|
|
BlockPos cible = p.level().getBlockState(pos).canBeReplaced() ? pos : pos.relative(face);
|
|
Marques m = marques(p.getUUID());
|
|
if (m.oeilDernier == null || m.oeilAvant == null || Float.isNaN(m.yawAvant)) return false;
|
|
double dx = m.oeilDernier[0] - m.oeilAvant[0], dz = m.oeilDernier[2] - m.oeilAvant[2];
|
|
double dy = m.oeilDernier[1] - m.oeilAvant[1];
|
|
if (!com.gastinelgarde.core.Scaffold.estPont(cible.getX(), cible.getY(), cible.getZ(), p.getX(), p.getY(), p.getZ(),
|
|
dy, Math.sqrt(dx * dx + dz * dz))) return false;
|
|
int tick = p.server.getTickCount();
|
|
boolean annuler = MOTEUR.scaffoldAnnuler(p.getUUID(), tick * 50L, tick);
|
|
net.minecraft.world.phys.Vec3 oeil = p.getEyePosition();
|
|
float[] dir = com.gastinelgarde.core.Scaffold.rotation(impact.x - oeil.x, impact.y - oeil.y, impact.z - oeil.z);
|
|
MOTEUR.poseScaffold(p.getUUID(), etat(p, true), dir[0], dir[1], m.yawAvant, m.pitchAvant, p.getYRot(), p.getXRot());
|
|
return annuler;
|
|
}
|
|
|
|
/** 0.6 (P3.4) : un paquet autre que de mouvement vient d'être traité sur le thread serveur (blink). */
|
|
public static void autrePaquet(ServerPlayer p) {
|
|
if (!surThreadServeur(p) || CONFIG.mode(Controle.BLINK) == Mode.OFF) return;
|
|
MOTEUR.autrePaquet(p.getUUID(), p.server.getTickCount());
|
|
}
|
|
|
|
/** 0.6 (P2.6) : le serveur ouvre (vrai) ou ferme un conteneur pour ce joueur (PlayerContainerEvent). */
|
|
public static void noterConteneur(ServerPlayer p, boolean ouvert) {
|
|
if (!surThreadServeur(p)) return;
|
|
if (ouvert) MOTEUR.ouvrirConteneur(p.getUUID(), p.server.getTickCount());
|
|
else MOTEUR.fermerConteneur(p.getUUID());
|
|
}
|
|
|
|
/**
|
|
* 0.6 (P2.6) : clic de conteneur (mixin, après ensureRunningOnSameThread). Vrai si le clic doit être ignoré
|
|
* (inventaire en ENFORCE au palier SETBACK, ou expulsion en cours) ; le menu est alors renvoyé au client.
|
|
*/
|
|
public static boolean noterClicConteneur(ServerPlayer p, int idConteneur, int numCase,
|
|
net.minecraft.world.inventory.ClickType type) {
|
|
if (!surThreadServeur(p)) return false;
|
|
if (MOTEUR.estExpulse(p.getUUID())) return true;
|
|
autrePaquet(p);
|
|
if (CONFIG.mode(Controle.INVENTAIRE) == Mode.OFF || estExempteManuellement(p.getUUID())) return false;
|
|
net.minecraft.world.inventory.AbstractContainerMenu menu = p.containerMenu;
|
|
boolean idValide = idConteneur == menu.containerId;
|
|
boolean menuConteneur = menu != p.inventoryMenu;
|
|
boolean caseConteneur = false;
|
|
int objet = 0;
|
|
if (idValide && numCase >= 0 && numCase < menu.slots.size()) {
|
|
net.minecraft.world.inventory.Slot c = menu.getSlot(numCase);
|
|
caseConteneur = !(c.container instanceof net.minecraft.world.entity.player.Inventory);
|
|
net.minecraft.world.item.ItemStack st = c.getItem();
|
|
if (!st.isEmpty()) objet = net.minecraft.core.registries.BuiltInRegistries.ITEM.getId(st.getItem()) + 1;
|
|
}
|
|
com.gastinelgarde.core.Inventaire.Clic clic = switch (type) {
|
|
case QUICK_MOVE, SWAP -> com.gastinelgarde.core.Inventaire.Clic.PRISE;
|
|
case THROW -> menuConteneur ? com.gastinelgarde.core.Inventaire.Clic.AUTRE : com.gastinelgarde.core.Inventaire.Clic.PRISE;
|
|
default -> com.gastinelgarde.core.Inventaire.Clic.AUTRE;
|
|
};
|
|
int tick = p.server.getTickCount();
|
|
List<Verdict> v = MOTEUR.clicConteneur(p.getUUID(), tick * 50L, tick, etat(p, false), idValide, menuConteneur,
|
|
clic, caseConteneur, objet);
|
|
Sanction s = traiter(p, v);
|
|
if (s == Sanction.EXPULSION) {
|
|
appliquerSanctionMouvement(p, s, v);
|
|
return true;
|
|
}
|
|
if (Cablage.sanctionDeMouvement(s)) {
|
|
menu.sendAllDataToRemote(); // le client a prédit le clic : on lui renvoie l'état réel
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 0.6 (P3.5) : paquet de mouvement refusé par vanilla (mixin, juste avant le teleport() de refus). La boîte déclarée
|
|
* chevauche-t-elle un bloc solide, alors que celle de la dernière position acceptée est libre ? Non testé en jeu.
|
|
*/
|
|
public static void refusMouvement(ServerPlayer p, double x, double y, double z) {
|
|
if (!surThreadServeur(p) || CONFIG.mode(Controle.PHASE) == Mode.OFF || MOTEUR.estExpulse(p.getUUID())
|
|
|| estExempteManuellement(p.getUUID()) || p.isSleeping() || p.isPassenger()) return;
|
|
Marques m = marques(p.getUUID());
|
|
if (m.mouvementTick == Integer.MIN_VALUE || !Double.isFinite(x + y + z)) return;
|
|
double dist = Math.sqrt(Math.pow(x - m.mouvementX, 2) + Math.pow(y - m.mouvementY, 2) + Math.pow(z - m.mouvementZ, 2));
|
|
if (dist > 16) return; // lecture de blocs bornée (chunks peut-être non chargés) ; vanilla refuse déjà ce saut
|
|
net.minecraft.world.entity.EntityDimensions d = p.getDimensions(p.getPose());
|
|
net.minecraft.world.phys.AABB avant = d.makeBoundingBox(m.mouvementX, m.mouvementY, m.mouvementZ).deflate(1.0E-3);
|
|
net.minecraft.world.phys.AABB declaree = d.makeBoundingBox(x, y, z).deflate(1.0E-3);
|
|
// Déjà coincé dans un bloc (sable tombé, piston) : pas une tentative de phase.
|
|
boolean dansBloc = p.level().noCollision(p, avant) && !p.level().noCollision(p, declaree);
|
|
int tick = p.server.getTickCount();
|
|
List<Verdict> v = MOTEUR.refusPhase(p.getUUID(), tick * 50L, etat(p, true), dansBloc, dist);
|
|
Sanction s = traiter(p, v); // vanilla a déjà refusé la position : journal, VL et expulsion seulement
|
|
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
|
}
|
|
|
|
private static List<Verdict> verdictsInteraction(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
|
|
net.minecraft.world.phys.Vec3 impact, int main) {
|
|
if (CONFIG.mode(Controle.INTERACTION_BLOC) == Mode.OFF || estExempteManuellement(p.getUUID())) return List.of();
|
|
net.minecraft.world.level.Level l = p.level();
|
|
BlockState st = l.getBlockState(pos);
|
|
net.minecraft.world.phys.shapes.VoxelShape forme = st.getShape(l, pos);
|
|
net.minecraft.world.phys.AABB b = forme.isEmpty() ? new net.minecraft.world.phys.AABB(pos) : forme.bounds().move(pos);
|
|
net.minecraft.world.phys.Vec3 oeil = p.getEyePosition();
|
|
Marques m = marques(p.getUUID());
|
|
double deplacement = 0;
|
|
if (m.oeilDernier != null && m.oeilAvant != null) {
|
|
deplacement = Math.sqrt(Math.pow(m.oeilDernier[0] - m.oeilAvant[0], 2) + Math.pow(m.oeilDernier[1] - m.oeilAvant[1], 2)
|
|
+ Math.pow(m.oeilDernier[2] - m.oeilAvant[2], 2));
|
|
}
|
|
return MOTEUR.interactionBloc(p.getUUID(), p.server.getTickCount() * 50L, pos.asLong(), main, etat(p, true),
|
|
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ},
|
|
face == null ? -1 : face.get3DDataValue(), impact == null ? null : new double[] {impact.x, impact.y, impact.z},
|
|
st.isAir(), st.isCollisionShapeFullBlock(l, pos), p.blockInteractionRange(), deplacement);
|
|
}
|
|
|
|
/**
|
|
* 0.5 (P2.3) : bloc cassé par ce joueur. Renvoie vrai si la casse doit être annulée (fast-break en ENFORCE, palier
|
|
* SETBACK ou plus) ; une EXPULSION est appliquée ici.
|
|
*/
|
|
public static boolean noterCasse(ServerPlayer p, BlockPos pos, BlockState state) {
|
|
if (!surThreadServeur(p)) return false;
|
|
if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, casse annulée (C4)
|
|
if (estExempteManuellement(p.getUUID())) return false;
|
|
int tick = p.server.getTickCount();
|
|
if (CONFIG.mode(Controle.XRAY) != Mode.OFF) { // 0.5 (P2.10) : alerte seulement
|
|
boolean rare = state.is(Blocks.DIAMOND_ORE) || state.is(Blocks.DEEPSLATE_DIAMOND_ORE) || state.is(Blocks.ANCIENT_DEBRIS);
|
|
traiter(p, MOTEUR.casseXray(p.getUUID(), tick * 50L, etat(p, false), pos.getY(), rare, rare && expose(p, pos)));
|
|
}
|
|
boolean annulerNuker = false;
|
|
if (CONFIG.mode(Controle.NUKER) != Mode.OFF) { // 0.5 (P3.3)
|
|
List<Verdict> vn = MOTEUR.casseNuker(p.getUUID(), tick * 50L, tick, etat(p, true));
|
|
Sanction sn = traiter(p, vn);
|
|
if (sn == Sanction.EXPULSION) {
|
|
appliquerSanctionMouvement(p, sn, vn);
|
|
return true;
|
|
}
|
|
annulerNuker = Cablage.sanctionDeMouvement(sn) || MOTEUR.nukerAnnulerCasse(p.getUUID(), tick * 50L, tick);
|
|
}
|
|
if (CONFIG.mode(Controle.FAST_BREAK) == Mode.OFF) return annulerNuker;
|
|
double progression = state.getDestroyProgress(p, p.level(), pos);
|
|
List<Verdict> v = MOTEUR.casseBloc(p.getUUID(), tick * 50L, tick, etat(p, true), pos.getX(), pos.getY(),
|
|
pos.getZ(), progression);
|
|
Sanction s = traiter(p, v);
|
|
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
|
return annulerNuker || Cablage.sanctionDeMouvement(s);
|
|
}
|
|
|
|
/**
|
|
* 0.5 (P3.7) : demande de complétion de commande (mixin, après ensureRunningOnSameThread). Vrai si le paquet doit
|
|
* être ignoré (completion en ENFORCE et débit dépassé, ou expulsion en cours).
|
|
*/
|
|
public static boolean noterCompletion(ServerPlayer p) {
|
|
if (!surThreadServeur(p)) return false;
|
|
autrePaquet(p); // 0.6 (blink)
|
|
if (CONFIG.mode(Controle.COMPLETION) == Mode.OFF) return false;
|
|
if (MOTEUR.estExpulse(p.getUUID())) return true;
|
|
List<Verdict> v = MOTEUR.completion(p.getUUID(), System.currentTimeMillis(), etat(p, false));
|
|
Sanction s = traiter(p, v);
|
|
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
|
return MOTEUR.completionAIgnorer(p.getUUID());
|
|
}
|
|
|
|
// 0.5 (P3.1) : tick d'apparition des cristaux de l'End récents (id d'entité -> tick serveur). Thread serveur seulement.
|
|
private static final java.util.Map<Integer, Integer> CRISTAUX = new java.util.HashMap<>();
|
|
|
|
/** 0.5 (P3.1) : un cristal de l'End vient d'apparaître (posé, pas rechargé). */
|
|
public static void noterCristal(net.minecraft.world.entity.Entity c, int tick) {
|
|
if (c.getServer() != null && !c.getServer().isSameThread()) return;
|
|
if (CONFIG.mode(Controle.AUTO_CRISTAL) == Mode.OFF) return;
|
|
if (CRISTAUX.size() > 256) {
|
|
CRISTAUX.values().removeIf(t -> tick - t > com.gastinelgarde.core.AutoCristal.AGE_MAX_MESURE);
|
|
}
|
|
CRISTAUX.put(c.getId(), tick);
|
|
}
|
|
|
|
/** 0.5 (P3.1) : âge (ticks) d'un cristal frappé, -1 si son apparition n'a pas été vue. */
|
|
public static int ageCristal(net.minecraft.world.entity.Entity c, int tick) {
|
|
Integer t = CRISTAUX.remove(c.getId());
|
|
if (t == null || tick < t) return -1;
|
|
return tick - t;
|
|
}
|
|
|
|
/** 0.5 (P2.4) : bloc posé par ce joueur. Vrai si la pose doit être annulée (ENFORCE, palier SETBACK ou plus). */
|
|
public static boolean noterPose(ServerPlayer p, BlockPos pos) {
|
|
if (!surThreadServeur(p)) return false;
|
|
if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, pose annulée (C4)
|
|
if (estExempteManuellement(p.getUUID())) return false;
|
|
int tick = p.server.getTickCount();
|
|
boolean annulerTower = false;
|
|
if (CONFIG.mode(Controle.TOWER) != Mode.OFF) { // 0.5 (P3.2)
|
|
Marques m = marques(p.getUUID());
|
|
double dy = m.oeilDernier != null && m.oeilAvant != null ? m.oeilDernier[1] - m.oeilAvant[1] : 0;
|
|
List<Verdict> vt = MOTEUR.poseTower(p.getUUID(), tick * 50L, tick, etat(p, true), pos.getX(), pos.getY(),
|
|
pos.getZ(), p.getX(), p.getY(), p.getZ(), dy);
|
|
Sanction st = traiter(p, vt);
|
|
if (st == Sanction.EXPULSION) {
|
|
appliquerSanctionMouvement(p, st, vt);
|
|
return true;
|
|
}
|
|
annulerTower = Cablage.sanctionDeMouvement(st);
|
|
}
|
|
if (CONFIG.mode(Controle.FAST_PLACE) == Mode.OFF) return annulerTower;
|
|
List<Verdict> v = MOTEUR.poseBloc(p.getUUID(), tick * 50L, tick, etat(p, true));
|
|
Sanction s = traiter(p, v);
|
|
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
|
return annulerTower || Cablage.sanctionDeMouvement(s);
|
|
}
|
|
|
|
/** 0.5 (P2.10) : une face du bloc touche l'air ou un fluide (minerai visible sans x-ray). */
|
|
private static boolean expose(ServerPlayer p, BlockPos pos) {
|
|
for (net.minecraft.core.Direction d : net.minecraft.core.Direction.values()) {
|
|
BlockPos q = pos.relative(d);
|
|
BlockState s = p.level().getBlockState(q);
|
|
if (s.isAir() || !p.level().getFluidState(q).isEmpty() || !s.isCollisionShapeFullBlock(p.level(), q)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
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)
|
|
.connexionRecente(tick <= m.connexionJusquaTick)
|
|
.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 :
|
|
* <ul>
|
|
* <li>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 ;</li>
|
|
* <li>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.</li>
|
|
* </ul>
|
|
*/
|
|
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<String> motifs = DetectionContraption.motifs(GardeSpec.prefixesContraption());
|
|
if (motifs.isEmpty()) return false;
|
|
List<String> 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<Verdict> 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<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
|
|
Sanction s = traiter(p, v);
|
|
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
|
|
if (CONFIG.mode(Controle.BLINK) != Mode.OFF) { // 0.6 (P3.4)
|
|
int tick = p.server.getTickCount();
|
|
List<Verdict> vb = MOTEUR.mouvementBlink(p.getUUID(), tick * 50L, tick, etat, p.isAlive());
|
|
Sanction sb = traiter(p, vb);
|
|
if (Cablage.sanctionDeMouvement(sb)) appliquerSanctionMouvement(p, sb, vb);
|
|
}
|
|
}
|
|
|
|
/** 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<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em, hauteurPermise(p));
|
|
Sanction s = traiter(p, v);
|
|
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
|
|
// 0.5 (P2) : no-slow… (OBSERVE par défaut). Câblage non testé en jeu.
|
|
List<Verdict> v2 = MOTEUR.mouvementP2(p.getUUID(), tick * 50L, etatMouvement, em, faitsMouvement(p));
|
|
Sanction s2 = traiter(p, v2);
|
|
if (Cablage.sanctionDeMouvement(s2)) appliquerSanctionMouvement(p, s2, v2);
|
|
}
|
|
// F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup.
|
|
if (!estExempteManuellement(p.getUUID())) {
|
|
List<Verdict> 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<Verdict> 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.6 : inventaire (rotation avec un conteneur ouvert) et scaffold (pose de pont jugée sur ce regard).
|
|
if (CONFIG.mode(Controle.INVENTAIRE) != Mode.OFF) {
|
|
if (p.containerMenu == p.inventoryMenu) MOTEUR.fermerConteneur(p.getUUID());
|
|
List<Verdict> vi = MOTEUR.regardInventaire(p.getUUID(), tick * 50L, tick, etat(p, false),
|
|
p.getYRot(), p.getXRot());
|
|
Sanction si = traiter(p, vi);
|
|
if (si == Sanction.EXPULSION) appliquerSanctionMouvement(p, si, vi);
|
|
}
|
|
if (CONFIG.mode(Controle.SCAFFOLD) != Mode.OFF) {
|
|
List<Verdict> vs = MOTEUR.regardScaffold(p.getUUID(), tick * 50L, tick, p.getYRot(), p.getXRot());
|
|
Sanction ss = traiter(p, vs); // pose déjà faite : les suivantes sont annulées (scaffoldAnnuler)
|
|
if (ss == Sanction.EXPULSION) appliquerSanctionMouvement(p, ss, vs);
|
|
}
|
|
m.yawAvant = m.yawDernier;
|
|
m.pitchAvant = m.pitchDernier;
|
|
m.yawDernier = p.getYRot();
|
|
m.pitchDernier = p.getXRot();
|
|
}
|
|
// 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 || CONFIG.mode(Controle.AUTO_TOTEM_REGULIER) != 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<Verdict> 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<Verdict> 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);
|
|
}
|
|
// 0.5 (P1.6) : passage en plané depuis le paquet précédent (ElytraFly « packet » : bascule permanente).
|
|
boolean plane = p.isFallFlying();
|
|
if (plane && !m.planeAvant && !estExempteManuellement(p.getUUID())) {
|
|
List<Verdict> vd = MOTEUR.deploiementElytres(p.getUUID(), tick * 50L, etat(p, false));
|
|
traiter(p, vd); // OBSERVE en production ; en ENFORCE, l'expulsion seulement
|
|
if (Verdict.pire(vd) == Sanction.EXPULSION) appliquerSanctionMouvement(p, Sanction.EXPULSION, vd);
|
|
}
|
|
m.planeAvant = plane;
|
|
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<Verdict> 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 || CONFIG.mode(Controle.STEP) != Mode.OFF
|
|
|| CONFIG.mode(Controle.ANTI_FAIM) != Mode.OFF || CONFIG.mode(Controle.NO_SLOW) != Mode.OFF
|
|
|| CONFIG.mode(Controle.JESUS) != Mode.OFF || CONFIG.mode(Controle.OMNISPRINT) != Mode.OFF
|
|
|| CONFIG.mode(Controle.CRITICALS) != Mode.OFF; // criticals : suit la hauteur à chaque mouvement
|
|
}
|
|
|
|
/** 0.5 (P2) : faits supplémentaires du paquet accepté pour {@link Moteur#mouvementP2}. */
|
|
private static com.gastinelgarde.core.FaitsMouvement faitsMouvement(ServerPlayer p) {
|
|
return new com.gastinelgarde.core.FaitsMouvement()
|
|
.ticksUsage(p.isUsingItem() ? p.getTicksUsingItem() : -1)
|
|
.fluide(CONFIG.mode(Controle.JESUS) != Mode.OFF && surFluide(p), CONFIG.mode(Controle.JESUS) != Mode.OFF && entiteSolideSous(p))
|
|
.direction(p.getX() - marques(p.getUUID()).mouvementX, p.getZ() - marques(p.getUUID()).mouvementZ, p.getYRot());
|
|
}
|
|
|
|
/** 0.5 (P2.11) : fluide au bloc des pieds ou juste dessous (pieds à moins d'un bloc au-dessus de sa surface). */
|
|
private static boolean surFluide(ServerPlayer p) {
|
|
net.minecraft.world.level.Level l = p.level();
|
|
BlockPos pieds = BlockPos.containing(p.getX(), p.getY() - 0.05, p.getZ());
|
|
return !l.getFluidState(pieds).isEmpty() || !l.getFluidState(pieds.below()).isEmpty() && p.getY() - pieds.getY() < 0.2;
|
|
}
|
|
|
|
/** 0.5 (P2.11) : bateau, shulker, minecart… (entité sur laquelle on peut se tenir) ou vaisseau Sable sous les pieds. */
|
|
private static boolean entiteSolideSous(ServerPlayer p) {
|
|
if (SableAcces.surSousNiveau(p)) return true;
|
|
net.minecraft.world.phys.AABB b = p.getBoundingBox();
|
|
net.minecraft.world.phys.AABB sous = new net.minecraft.world.phys.AABB(b.minX - 0.1, b.minY - 0.6, b.minZ - 0.1,
|
|
b.maxX + 0.1, b.minY + 0.1, b.maxZ + 0.1);
|
|
return !p.level().getEntities(p, sous, e -> e.canBeCollidedWith() || e instanceof net.minecraft.world.entity.vehicle.VehicleEntity).isEmpty();
|
|
}
|
|
|
|
/**
|
|
* 0.5 (P1.9) : hauteur de marche permise en un tick : max(attribut step_height, puissance de saut = jump_strength
|
|
* + Saut amélioré). NaN (pas de mesure step) si un piston en mouvement touche la boîte du joueur élargie d'un
|
|
* bloc : un piston peut soulever un joueur d'un bloc entre deux paquets [À VÉRIFIER en jeu].
|
|
*/
|
|
private static double hauteurPermise(ServerPlayer p) {
|
|
if (CONFIG.mode(Controle.STEP) == Mode.OFF) return Double.NaN;
|
|
net.minecraft.world.phys.AABB b = p.getBoundingBox().inflate(1.0);
|
|
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))) {
|
|
if (p.level().getBlockState(q).is(Blocks.MOVING_PISTON)) return Double.NaN;
|
|
}
|
|
double marche = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.STEP_HEIGHT);
|
|
double saut = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.JUMP_STRENGTH) + p.getJumpBoostPower();
|
|
return Math.max(marche, saut);
|
|
}
|
|
|
|
/**
|
|
* 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<MobEffect> 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<String> 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<String> 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;
|
|
}
|
|
|
|
/** Profondeur maximale (blocs) de la recherche du sol sous le joueur (setback de secours, P1.2). */
|
|
private static final int SOL_SOUS_MAX_BLOCS = 64;
|
|
|
|
/**
|
|
* 0.5 (P1.2) : sol juste sous le joueur, même x et z : premier bloc à forme de collision non vide (ou fluide) en
|
|
* descendant, au plus 64 blocs, avec la place pour la boîte du joueur. Null sinon (vide, hors du monde).
|
|
*/
|
|
static double[] solSous(ServerPlayer p) {
|
|
net.minecraft.world.level.Level l = p.level();
|
|
BlockPos.MutableBlockPos q = p.blockPosition().mutable();
|
|
for (int i = 0; i <= SOL_SOUS_MAX_BLOCS && q.getY() >= l.getMinBuildHeight(); i++, q.move(0, -1, 0)) {
|
|
if (!l.hasChunkAt(q)) return null;
|
|
BlockState s = l.getBlockState(q);
|
|
double y;
|
|
if (!l.getFluidState(q).isEmpty()) {
|
|
y = q.getY(); // eau / lave : dans le fluide, la chute s'arrête ou ralentit
|
|
} else {
|
|
net.minecraft.world.phys.shapes.VoxelShape forme = s.getCollisionShape(l, q);
|
|
if (forme.isEmpty()) continue;
|
|
y = q.getY() + forme.max(net.minecraft.core.Direction.Axis.Y);
|
|
}
|
|
if (y > p.getY() + 1e-6) return null; // jamais vers le haut
|
|
net.minecraft.world.phys.AABB b = p.getBoundingBox().move(0, y - p.getY(), 0);
|
|
if (!l.noCollision(p, b)) return null;
|
|
return new double[] {p.getX(), y, p.getZ(), p.getYRot(), p.getXRot()};
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> 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); }
|
|
@Override public double[] solSous() { return Garde.solSous(p); }
|
|
};
|
|
}
|
|
}
|