259 lignes
13 KiB
Java
259 lignes
13 KiB
Java
package com.gastinelgarde;
|
|
|
|
import com.gastinelgarde.core.DetectionContraption;
|
|
import com.gastinelgarde.core.GraceTeleport;
|
|
import com.gastinelgarde.core.Moteur;
|
|
import com.gastinelgarde.core.Sanction;
|
|
import com.gastinelgarde.core.Suivi;
|
|
import com.gastinelgarde.core.Verdict;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
import java.util.function.BooleanSupplier;
|
|
|
|
/**
|
|
* Décisions du câblage Minecraft (Garde, GardeEvents) sorties sans changement de comportement (16/10, constat C4 ⚠️),
|
|
* pour être testées sans serveur. Aucun type Minecraft ici : Garde et GardeEvents lisent le serveur, appellent ces
|
|
* méthodes et appliquent le résultat.
|
|
*/
|
|
final class Cablage {
|
|
|
|
private Cablage() { }
|
|
|
|
// --- Entrées des événements ---
|
|
|
|
/** Ce que fait onAttaque avant toute mesure. */
|
|
enum EntreeAttaque {
|
|
/** C4 : expulsion en cours, le coup est annulé et rien n'est évalué. */
|
|
ANNULER,
|
|
/** Exemption manuelle (/garde exempter) : le coup passe sans mesure. */
|
|
IGNORER,
|
|
EVALUER
|
|
}
|
|
|
|
static EntreeAttaque entreeAttaque(boolean expulse, boolean exempteManuellement) {
|
|
if (expulse) return EntreeAttaque.ANNULER;
|
|
if (exempteManuellement) return EntreeAttaque.IGNORER;
|
|
return EntreeAttaque.EVALUER;
|
|
}
|
|
|
|
/** Fin de onAttaque : le coup est-il annulé ? (portée / hitbox ENFORCE, ou sanction ≥ SETBACK). */
|
|
static boolean annulerCoup(boolean coupsBloques, Sanction s) {
|
|
return coupsBloques || s.ordinal() >= Sanction.SETBACK.ordinal();
|
|
}
|
|
|
|
/** Fin de onAttaque : seule une EXPULSION est appliquée au joueur (un SETBACK de combat annule seulement le coup). */
|
|
static boolean appliquerApresCoup(Sanction s) {
|
|
return s == Sanction.EXPULSION;
|
|
}
|
|
|
|
/** avantMouvement : évaluer ce paquet ? (F01 thread serveur, C4 expulsion, exemption manuelle). */
|
|
static boolean evaluerAvantMouvement(boolean surThreadServeur, BooleanSupplier expulse,
|
|
BooleanSupplier exempteManuellement) {
|
|
// Paresseux : hors du thread serveur, l'état du mod n'est pas lu du tout (F01).
|
|
return surThreadServeur && !expulse.getAsBoolean() && !exempteManuellement.getAsBoolean();
|
|
}
|
|
|
|
/** apresMouvement : traiter ce paquet (état, position, traces) ? L'exemption manuelle est vue plus loin. */
|
|
static boolean traiterApresMouvement(boolean surThreadServeur, BooleanSupplier expulse) {
|
|
return surThreadServeur && !expulse.getAsBoolean();
|
|
}
|
|
|
|
/** Sanction de mouvement à appliquer (≥ SETBACK). */
|
|
static boolean sanctionDeMouvement(Sanction s) {
|
|
return s.ordinal() >= Sanction.SETBACK.ordinal();
|
|
}
|
|
|
|
// --- Exemptions contraption de la cible (portée / hitbox) ---
|
|
|
|
/**
|
|
* Portée et hitbox mesurées ? Non si la cible, ou son véhicule racine, est une contraption ou sur un vaisseau
|
|
* Sable. Évaluation paresseuse dans le même ordre que l'ancien code.
|
|
*/
|
|
static boolean mesurerPorteeHitbox(BooleanSupplier cibleContraption, BooleanSupplier cibleSable,
|
|
boolean racineEstCible, BooleanSupplier racineContraption,
|
|
BooleanSupplier racineSable) {
|
|
return !cibleContraption.getAsBoolean() && !cibleSable.getAsBoolean()
|
|
&& (racineEstCible || (!racineContraption.getAsBoolean() && !racineSable.getAsBoolean()));
|
|
}
|
|
|
|
// --- C7 : déploiement des élytres ---
|
|
|
|
/** Suivi du plané en cours : est-il commencé moins de elytresAirMinTicks après le dernier sol serveur ? */
|
|
static final class Elytres {
|
|
boolean vues;
|
|
boolean suspectes;
|
|
|
|
/** À chaque construction de l'état : transition isFallFlying. */
|
|
void observer(boolean plane, int solServeurTick, int tick, int airMinTicks) {
|
|
if (plane) {
|
|
if (!vues) {
|
|
vues = true;
|
|
suspectes = solServeurTick != Integer.MIN_VALUE && tick - solServeurTick < airMinTicks;
|
|
}
|
|
} else {
|
|
vues = false;
|
|
suspectes = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Détection en cache (contraption, courant d'air) ---
|
|
|
|
/** Détection refaite au plus toutes les 10 ticks, puis grâce après la dernière détection positive. */
|
|
static final class CacheDetection {
|
|
int tick = Integer.MIN_VALUE;
|
|
int vuTick = Integer.MIN_VALUE;
|
|
boolean proche;
|
|
|
|
boolean lire(int maintenant, BooleanSupplier detecter, int graceTicks) {
|
|
if (tick == Integer.MIN_VALUE || maintenant - tick >= 10 || maintenant < tick) {
|
|
proche = detecter.getAsBoolean();
|
|
tick = maintenant;
|
|
if (proche) vuTick = maintenant;
|
|
}
|
|
return proche || DetectionContraption.dansLaGrace(maintenant, vuTick, graceTicks);
|
|
}
|
|
}
|
|
|
|
// --- 0.4.0 : grace de propulsion d'une fusee (plane en elytres) ---
|
|
|
|
/** Ticks de marge après la fin de vie de la fusée (dernier tick de poussée, retard d'état). */
|
|
static final int MARGE_FUSEE_TICKS = 20;
|
|
/** 0.4.1 : duree de vie vanilla d'une fusee : 10 x (1 + duree de vol) + 0..11, soit 20 a 51 ticks pour les durees 1 a 3. */
|
|
static final int VIE_FUSEE_MAX = 60;
|
|
|
|
/**
|
|
* Grâce de propulsion accordée à l'apparition d'une fusée : seulement si elle est réellement attachée au joueur
|
|
* (propulsion en plané, pas une fusée d'arbalète ou posée au sol), si le joueur plane à cet instant, et si elle
|
|
* ne vient pas d'être rechargée depuis le disque. Durée : vie restante réelle de la fusée + marge, au lieu de 6 s
|
|
* fixes (un tricheur qui tire une fusée toutes les quelques secondes n'obtient jamais plus que la vie de la fusée).
|
|
*
|
|
* @return nombre de ticks de grâce (0 = aucune)
|
|
*/
|
|
static int graceFusee(boolean attacheeAuJoueur, boolean joueurPlane, boolean rechargeeDuDisque, int vie, int dureeDeVie) {
|
|
if (!attacheeAuJoueur || !joueurPlane || rechargeeDuDisque) return 0;
|
|
int restant = Math.max(0, dureeDeVie - Math.max(0, vie));
|
|
return Math.min(restant, VIE_FUSEE_MAX) + MARGE_FUSEE_TICKS;
|
|
}
|
|
|
|
// --- Position de retour (C3) ---
|
|
|
|
/** apresMouvement : la position de ce paquet devient-elle la position de retour ? */
|
|
static boolean memoriserRetour(Moteur moteur, int dernierVerdictTick, int tick, BooleanSupplier vehiculeControle,
|
|
boolean solServeur, boolean milieuSpecial) {
|
|
return dernierVerdictTick != tick && !vehiculeControle.getAsBoolean()
|
|
&& moteur.positionDeRetourAdmise(solServeur, milieuSpecial);
|
|
}
|
|
|
|
// --- 0.5 (P1.1) : journal des verdicts ---
|
|
|
|
/**
|
|
* Ligne de journal pour ce verdict ? Le journal est limité (une ligne par seconde et par contrôle, voir
|
|
* Suivi.autoriserJournal) pour ne pas écrire une ligne par tick pendant une chute ; mais le verdict qui déclenche
|
|
* un SETBACK ou une EXPULSION est toujours écrit si {@code toujoursSanctions} (diagnostic 0.4.0 : l'expulsion
|
|
* arrivait sans la ligne du verdict qui l'avait causée). Paresseux : la limite n'est pas consommée pour un
|
|
* verdict de sanction écrit d'office.
|
|
*/
|
|
static boolean ecrireVerdict(Verdict v, boolean toujoursSanctions, BooleanSupplier limiteAutorise) {
|
|
if (toujoursSanctions && v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) return true;
|
|
return limiteAutorise.getAsBoolean();
|
|
}
|
|
|
|
/** Délai (ms) entre deux lignes d'un même contrôle pour {@code lignesParSeconde} lignes par seconde (au moins 1). */
|
|
static long delaiJournalMs(int lignesParSeconde) {
|
|
return 1000L / Math.max(1, lignesParSeconde);
|
|
}
|
|
|
|
// --- Sanctions (C2, C4) ---
|
|
|
|
/** Ce que la sanction fait au joueur réel (adaptateur ServerPlayer dans Garde, doublure dans les tests). */
|
|
interface Joueur {
|
|
UUID id();
|
|
String nom();
|
|
String dimension();
|
|
int tick();
|
|
void annoncerTeleport(GraceTeleport.Origine origine);
|
|
void teleporter(double x, double y, double z, float yaw, float pitch);
|
|
void deconnecter(String message);
|
|
void journal(String ligne);
|
|
|
|
/**
|
|
* 0.5 (P1.2) : position au sol juste SOUS le joueur (même x, z ; y du premier bloc solide en dessous, au plus
|
|
* 64 blocs), {x, y, z, yaw, pitch}, ou null si rien trouvé ou place insuffisante. Jamais de déplacement
|
|
* horizontal : le setback de secours ne peut pas servir à se téléporter.
|
|
*/
|
|
default double[] solSous() { return null; }
|
|
}
|
|
|
|
/**
|
|
* Motif écrit pour une sanction : le contrôle du verdict qui l'a déclenchée (applicable == sanction). Avant 0.4.0
|
|
* c'était le premier de la liste, donc un contrôle en OBSERVE (vitesse) pouvait être accusé à la place du vol.
|
|
* À défaut, le verdict le plus sévère, puis « anti-triche ».
|
|
*/
|
|
static String raison(List<Verdict> verdicts, Sanction s) {
|
|
Verdict retenu = null;
|
|
Verdict auPalier = null;
|
|
for (Verdict v : verdicts) {
|
|
// 0.5 (P1.3) : plusieurs verdicts au même palier : celui de plus fort VL (avant : le premier, ordre de l'enum).
|
|
if (v.applicable() == s && (auPalier == null || v.vl() > auPalier.vl())) auPalier = v;
|
|
if (retenu == null || v.applicable().ordinal() > retenu.applicable().ordinal()) retenu = v;
|
|
}
|
|
if (auPalier != null) return auPalier.controle().id();
|
|
return retenu == null ? "anti-triche" : retenu.controle().id();
|
|
}
|
|
|
|
/**
|
|
* 0.5 (P1.3) : motif complet pour le journal : le contrôle retenu, puis les autres contrôles au même palier
|
|
* (« vol ; aussi : vitesse »). Le message d'expulsion au joueur garde le seul motif retenu.
|
|
*/
|
|
static String motifJournal(List<Verdict> verdicts, Sanction s) {
|
|
String r = raison(verdicts, s);
|
|
java.util.LinkedHashSet<String> autres = new java.util.LinkedHashSet<>();
|
|
for (Verdict v : verdicts) {
|
|
if (v.applicable() == s && !v.controle().id().equals(r)) autres.add(v.controle().id());
|
|
}
|
|
return autres.isEmpty() ? r : r + " ; aussi : " + String.join(", ", autres);
|
|
}
|
|
|
|
/** Expulsion à usage unique (C4) ; setback vers la position de retour de la même dimension, puis remise à zéro (C2). */
|
|
static void appliquerSanction(Moteur moteur, Joueur p, Sanction s, List<Verdict> verdicts) {
|
|
String raison = raison(verdicts, s);
|
|
String motif = motifJournal(verdicts, s); // P1.3 : journal avec les autres contrôles du palier
|
|
if (s == Sanction.EXPULSION) {
|
|
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
|
|
if (!moteur.expulser(p.id(), p.tick() * 50L)) return;
|
|
p.journal(p.nom() + " EXPULSE (" + motif + ")");
|
|
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
|
|
} else if (s == Sanction.SETBACK) {
|
|
if (moteur.setbackDejaApplique(p.id(), p.tick() * 50L)) {
|
|
// 0.6.1 (revue M1) : même paquet, second contrôle : pas de second retour ni de second compte.
|
|
moteur.apresSetbackDuMemeTick(p.id(), verdicts);
|
|
p.journal(p.nom() + " SETBACK deja applique ce tick (" + motif + ") : ni second retour ni second compte");
|
|
return;
|
|
}
|
|
Suivi sv = moteur.suivi(p.id());
|
|
double[] sol;
|
|
if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) {
|
|
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
|
|
p.teleporter(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
|
|
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
|
|
moteur.apresSetback(p.id(), p.tick() * 50L, verdicts);
|
|
p.journal(p.nom() + " SETBACK (" + motif + ")");
|
|
} else if (!sv.aPositionValide() && moteur.config().setbackSolSiPasDePosition && (sol = p.solSous()) != null) {
|
|
// 0.5 (P1.2) : reconnexion en l'air (aucune position au sol connue) : retour au sol sous le joueur.
|
|
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
|
|
p.teleporter(sol[0], sol[1], sol[2], (float) sol[3], (float) sol[4]);
|
|
moteur.apresSetback(p.id(), p.tick() * 50L, verdicts);
|
|
p.journal(String.format(java.util.Locale.ROOT, "%s SETBACK au sol (%s) : pas de position de retour, y=%.2f",
|
|
p.nom(), motif, sol[1]));
|
|
} else {
|
|
// 0.5 (P1.1) : avant, rien n'était fait ni écrit (reconnexion en l'air) et le VL montait jusqu'à
|
|
// l'expulsion sans trace du setback raté.
|
|
String pourquoi = !sv.aPositionValide() ? "pas de position de retour valide"
|
|
: "position de retour dans une autre dimension (" + sv.dimension() + ")";
|
|
p.journal(p.nom() + " SETBACK impossible (" + motif + ") : " + pourquoi);
|
|
}
|
|
}
|
|
}
|
|
}
|