Comparer les révisions
4
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
288087080f | |||
|
|
9b5273f830 | |||
|
|
d90e40c8b9 | |||
|
|
6e208dccd2 | |||
Aucun fichier ne correspond à votre recherche
@@ -7,3 +7,4 @@ run/
|
||||
|
||||
# sauvegardes avant modification
|
||||
*.avant-*
|
||||
livrable/
|
||||
@@ -0,0 +1,42 @@
|
||||
# Journal des versions
|
||||
|
||||
## 0.3.1 (16/10/2026)
|
||||
|
||||
Version de correctifs. Les modes OBSERVE / ENFORCE de chaque contrôle sont inchangés (aucun défaut de mode modifié).
|
||||
Toutes les options nouvelles sont désactivées par défaut : sans changement de config, seuls les correctifs « actifs
|
||||
sans option » ci-dessous changent le comportement. Tout est testé hors jeu seulement ; rien n'a été essayé en jeu.
|
||||
|
||||
### Vol et élytres (incident VOL du 15/10, branche fix/vol-elytres)
|
||||
- C1 : grâce de fin de plané en élytres bornée (`graceFinElytresTicks` = 50 ticks, finit à l'atterrissage).
|
||||
- C2 : après un setback, vol, vitesse et points VOL / VITESSE remis à zéro.
|
||||
- C3 : position de retour du setback = dernière position au sol (ou milieu spécial : eau, échelle).
|
||||
- C4 : expulsion à usage unique (une ligne EXPULSE), contrôles de nouveau actifs après reconnexion. Jamais de bannissement.
|
||||
- C5 : escalade : expulsion seulement après 4 setbacks en 60 s.
|
||||
|
||||
### Coups-hors-boite, portée, C10, C13, C15 (branche fix/hitbox-c10-c13-c15)
|
||||
- Le ping élevé (> 500 ms) n'exempte plus le coup ; fenêtre bornée à `seriePingMaxMs`.
|
||||
- Œil / regard suivants bornés (un tick, 90°) ; éviction de la cible non joueur la plus ancienne quand la table est pleine.
|
||||
- Fenêtre de ping fondée sur le plancher des 2 dernières minutes (`PingPlancher`, `seriePingMargeMs` = 50 ms).
|
||||
- Options (désactivées par défaut) : `volFenetreGlissante` (C10, sauts en l'air espacés), `vitesseMoyenne` (C15, bhop / sol),
|
||||
`timerSoldeMax` (C15, timer ; 0 = désactivé, essai conseillé 20).
|
||||
- Seuils de `portee` / `hitbox` non resserrés.
|
||||
|
||||
### Rafales réseau (branche fix/rafales-reseau)
|
||||
- Faux positif VOL sur chute reçue en rafales (3, 0, 0) corrigé : ticks dus bornés (`AVANCE_MAX` = 4). Actif sans option ;
|
||||
la chute ralentie par triche reste détectée.
|
||||
|
||||
### Constats hauts (branche fix/constats-hauts)
|
||||
- Options (désactivées par défaut) : `elytresExemptionStricte` (C7), `combatMesureEnVehicule` (C8),
|
||||
`empilementSeulementEnMouvement` (C18, minecarts à contenu immobiles non cassés).
|
||||
- C27 (modes vol / portée / hitbox en production) : décision de config, non traitée par le code.
|
||||
|
||||
### Tests du câblage Minecraft (branche test/cablage-minecraft)
|
||||
- Refactoring sans changement de comportement : classe `Cablage` (entrées d'événements, sanctions, C7).
|
||||
- `CablageTest` et `CablageMinecraftTest` ajoutés.
|
||||
- Défaut connu non corrigé : `Garde.apresVehicule` ne consulte pas la marque d'expulsion (test `FAILLE_C4_...`).
|
||||
|
||||
### Version
|
||||
- `gradle.properties` et `neoforge.mods.toml` en 0.3.1 ; jar `gastinelgarde-neoforge-1.21.1-0.3.1.jar`.
|
||||
|
||||
## 0.3.0
|
||||
Corrections de l'audit du 14/10/2026 (voir `audit/CORRECTIONS.md`).
|
||||
+2
-2
@@ -1,7 +1,7 @@
|
||||
# GastinelGarde
|
||||
|
||||
Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur uniquement). Plan et décisions :
|
||||
`../PLAN-GASTINELGARDE.md`. Version **0.3.0** : phases 0, 1 et 2 du plan, plus les corrections de l'audit du
|
||||
`../PLAN-GASTINELGARDE.md`. Version **0.3.1** (voir `CHANGELOG.md`) : phases 0, 1 et 2 du plan, plus les corrections de l'audit du
|
||||
2026-10-14 (`audit/`).
|
||||
|
||||
**État** : compilé, 180 tests JUnit verts (au 16/10) (cœur pur, commandes, configuration, application réelle des mixins,
|
||||
@@ -251,7 +251,7 @@ journaliser et alerter (le coup a déjà eu lieu quand l'aller-retour est vu).
|
||||
Les traces JSONL se rejouent dans le moteur, sans serveur :
|
||||
|
||||
```
|
||||
java -cp build/libs/gastinelgarde-neoforge-1.21.1-0.3.0.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl
|
||||
java -cp build/libs/gastinelgarde-neoforge-1.21.1-0.3.1.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl
|
||||
```
|
||||
|
||||
Sortie : nombre de mouvements et d'attaques, infractions et points maximaux par contrôle, vingt exemples. Méthode :
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
org.gradle.jvmargs=-Xmx2G
|
||||
org.gradle.parallel=true
|
||||
|
||||
mod_version=0.3.0
|
||||
mod_version=0.3.1
|
||||
mod_group_id=com.gastinelgarde
|
||||
mod_id=gastinelgarde
|
||||
|
||||
|
||||
@@ -0,0 +1,160 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
// --- Position de retour (C3) ---
|
||||
|
||||
/** apresMouvement : la position de ce paquet devient-elle la position de retour ? */
|
||||
static boolean memoriserRetour(Moteur moteur, int dernierVerdictTick, int tick, BooleanSupplier vehiculeControle,
|
||||
boolean solServeur, boolean milieuSpecial) {
|
||||
return dernierVerdictTick != tick && !vehiculeControle.getAsBoolean()
|
||||
&& moteur.positionDeRetourAdmise(solServeur, milieuSpecial);
|
||||
}
|
||||
|
||||
// --- Sanctions (C2, C4) ---
|
||||
|
||||
/** Ce que la sanction fait au joueur réel (adaptateur ServerPlayer dans Garde, doublure dans les tests). */
|
||||
interface Joueur {
|
||||
UUID id();
|
||||
String nom();
|
||||
String dimension();
|
||||
int tick();
|
||||
void annoncerTeleport(GraceTeleport.Origine origine);
|
||||
void teleporter(double x, double y, double z, float yaw, float pitch);
|
||||
void deconnecter(String message);
|
||||
void journal(String ligne);
|
||||
}
|
||||
|
||||
/** 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 = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
|
||||
if (s == Sanction.EXPULSION) {
|
||||
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
|
||||
if (!moteur.expulser(p.id(), p.tick() * 50L)) return;
|
||||
p.journal(p.nom() + " EXPULSE (" + raison + ")");
|
||||
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
|
||||
} else if (s == Sanction.SETBACK) {
|
||||
Suivi sv = moteur.suivi(p.id());
|
||||
if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) {
|
||||
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
|
||||
p.teleporter(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
|
||||
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
|
||||
moteur.apresSetback(p.id(), p.tick() * 50L);
|
||||
p.journal(p.nom() + " SETBACK (" + raison + ")");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -77,17 +77,12 @@ public final class Garde {
|
||||
int vehiculeTick = Integer.MIN_VALUE;
|
||||
double vehiculeX, vehiculeY, vehiculeZ;
|
||||
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
|
||||
int contraptionTick = Integer.MIN_VALUE;
|
||||
int contraptionVuTick = Integer.MIN_VALUE;
|
||||
boolean contraptionProche;
|
||||
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;
|
||||
boolean elytresVues;
|
||||
boolean elytresSuspectes;
|
||||
final Cablage.Elytres elytres = new Cablage.Elytres();
|
||||
// Cache de la détection d'un courant d'air (ventilateur Create), même principe
|
||||
int courantTick = Integer.MIN_VALUE;
|
||||
int courantVuTick = Integer.MIN_VALUE;
|
||||
boolean courantProche;
|
||||
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;
|
||||
@@ -391,16 +386,7 @@ public final class Garde {
|
||||
}
|
||||
|
||||
// C7 : au début du plané, combien de ticks en l'air (sol serveur) ? Moins que elytresAirMinTicks : suspect.
|
||||
if (p.isFallFlying()) {
|
||||
if (!m.elytresVues) {
|
||||
m.elytresVues = true;
|
||||
m.elytresSuspectes = m.solServeurTick != Integer.MIN_VALUE
|
||||
&& tick - m.solServeurTick < config().elytresAirMinTicks;
|
||||
}
|
||||
} else {
|
||||
m.elytresVues = false;
|
||||
m.elytresSuspectes = false;
|
||||
}
|
||||
m.elytres.observer(p.isFallFlying(), m.solServeurTick, tick, config().elytresAirMinTicks);
|
||||
|
||||
return EtatJoueur.builder()
|
||||
.creatif(p.isCreative())
|
||||
@@ -408,7 +394,7 @@ public final class Garde {
|
||||
.peutVoler(p.getAbilities().mayfly)
|
||||
.riptide(riptideRecent)
|
||||
.elytres(p.isFallFlying())
|
||||
.elytresDeploiementSuspect(m.elytresSuspectes)
|
||||
.elytresDeploiementSuspect(m.elytres.suspectes)
|
||||
.levitation(p.hasEffect(MobEffects.LEVITATION))
|
||||
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
|
||||
.enVehicule(p.isPassenger())
|
||||
@@ -487,12 +473,7 @@ public final class Garde {
|
||||
|
||||
/** La détection est refaite au plus toutes les 10 ticks par joueur ; grâce de 2 s après la dernière détection. */
|
||||
private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) {
|
||||
if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) {
|
||||
m.contraptionProche = pocheContraption(p);
|
||||
m.contraptionTick = tick;
|
||||
if (m.contraptionProche) m.contraptionVuTick = tick;
|
||||
}
|
||||
return m.contraptionProche || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS);
|
||||
return m.contraption.lire(tick, () -> pocheContraption(p), GRACE_CONTRAPTION_TICKS);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -587,19 +568,19 @@ public final class Garde {
|
||||
|
||||
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */
|
||||
public static void avantMouvement(ServerPlayer p) {
|
||||
if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà)
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 : expulsion en cours, plus rien à évaluer
|
||||
if (estExempteManuellement(p.getUUID())) return;
|
||||
// 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 (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, 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) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion
|
||||
// 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);
|
||||
@@ -621,7 +602,7 @@ public final class Garde {
|
||||
if (controler && em != null) {
|
||||
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
|
||||
Sanction s = traiter(p, v);
|
||||
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, 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())) {
|
||||
@@ -646,8 +627,8 @@ public final class Garde {
|
||||
// En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée
|
||||
// qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait.
|
||||
// C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air.
|
||||
if (m.dernierVerdictTick != tick && !vehiculeControle(p)
|
||||
&& MOTEUR.positionDeRetourAdmise(solServeur, em != null && em.milieuSpecial())) {
|
||||
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());
|
||||
}
|
||||
@@ -867,12 +848,7 @@ public final class Garde {
|
||||
|
||||
/** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */
|
||||
private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) {
|
||||
if (m.courantTick == Integer.MIN_VALUE || tick - m.courantTick >= 10 || tick < m.courantTick) {
|
||||
m.courantProche = courantAir(p);
|
||||
m.courantTick = tick;
|
||||
if (m.courantProche) m.courantVuTick = tick;
|
||||
}
|
||||
return m.courantProche || DetectionContraption.dansLaGrace(tick, m.courantVuTick, GRACE_COURANT_TICKS);
|
||||
return m.courant.lire(tick, () -> courantAir(p), GRACE_COURANT_TICKS);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -914,22 +890,22 @@ public final class Garde {
|
||||
}
|
||||
|
||||
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
|
||||
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
|
||||
if (s == Sanction.EXPULSION) {
|
||||
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
|
||||
if (!MOTEUR.expulser(p.getUUID(), p.server.getTickCount() * 50L)) return;
|
||||
ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")");
|
||||
p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ")."));
|
||||
} else if (s == Sanction.SETBACK) {
|
||||
Suivi sv = MOTEUR.suivi(p.getUUID());
|
||||
String dim = p.level().dimension().location().toString();
|
||||
if (sv.aPositionValide() && sv.dimension().equals(dim)) {
|
||||
annoncerTeleport(p, GraceTeleport.Origine.SETBACK);
|
||||
p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
|
||||
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
|
||||
MOTEUR.apresSetback(p.getUUID(), p.server.getTickCount() * 50L);
|
||||
ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")");
|
||||
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); }
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -57,11 +57,16 @@ public final class GardeEvents {
|
||||
@SubscribeEvent
|
||||
public static void onAttaque(AttackEntityEvent event) {
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.moteur().estExpulse(p.getUUID())) { // C4 : expulsion en cours
|
||||
event.setCanceled(true);
|
||||
return;
|
||||
switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) {
|
||||
case ANNULER -> { // C4 : expulsion en cours
|
||||
event.setCanceled(true);
|
||||
return;
|
||||
}
|
||||
case IGNORER -> {
|
||||
return;
|
||||
}
|
||||
case EVALUER -> { }
|
||||
}
|
||||
if (Garde.estExempteManuellement(p.getUUID())) return;
|
||||
|
||||
Entity cible = event.getTarget();
|
||||
int tick = p.server.getTickCount();
|
||||
@@ -83,8 +88,9 @@ public final class GardeEvents {
|
||||
// (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere).
|
||||
// L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
|
||||
Entity racine = cible.getRootVehicle();
|
||||
boolean mesurerPH = !Garde.estContraption(cible) && !SableAcces.surSousNiveau(cible)
|
||||
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
|
||||
boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> Garde.estContraption(cible),
|
||||
() -> SableAcces.surSousNiveau(cible), racine == cible, () -> Garde.estContraption(racine),
|
||||
() -> SableAcces.surSousNiveau(racine));
|
||||
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
|
||||
+ Math.pow(cible.getZ() - cible.zo, 2));
|
||||
// #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge
|
||||
@@ -103,11 +109,9 @@ public final class GardeEvents {
|
||||
}
|
||||
|
||||
Sanction s = Garde.traiter(p, verdicts);
|
||||
if (Garde.moteur().coupsBloques(p.getUUID(), tick * 50L)) event.setCanceled(true); // portée / hitbox ENFORCE
|
||||
if (s.ordinal() >= Sanction.SETBACK.ordinal()) {
|
||||
event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé
|
||||
if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts);
|
||||
}
|
||||
// portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé
|
||||
if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true);
|
||||
if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
|
||||
}
|
||||
|
||||
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
|
||||
|
||||
@@ -4,7 +4,7 @@ license="MIT"
|
||||
|
||||
[[mods]]
|
||||
modId="gastinelgarde"
|
||||
version="0.3.0"
|
||||
version="0.3.1"
|
||||
displayName="GastinelGarde"
|
||||
authors="Théo Gastinel"
|
||||
description='''Anti-triche maison : combat, cadence, rotation, timer (phase 1), no-fall, vitesse, vol et véhicules (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
|
||||
|
||||
@@ -0,0 +1,336 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import com.gastinelgarde.core.GardeConfig;
|
||||
import java.io.InputStream;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Proxy;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import net.neoforged.neoforge.common.ModConfigSpec;
|
||||
import org.junit.jupiter.api.Assumptions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.objectweb.asm.ClassReader;
|
||||
import org.objectweb.asm.tree.AbstractInsnNode;
|
||||
import org.objectweb.asm.tree.ClassNode;
|
||||
import org.objectweb.asm.tree.InvokeDynamicInsnNode;
|
||||
import org.objectweb.asm.tree.MethodInsnNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
|
||||
/**
|
||||
* Câblage Minecraft (constat C4 ⚠️), partie qui demande les classes du jeu mais pas de serveur : événements
|
||||
* NeoForge abonnés, gardes d'expulsion lues dans le bytecode, types d'entités (C18, F20), options (C7, C8, C10, C15,
|
||||
* C18) du fichier toml jusqu'à la configuration du moteur.
|
||||
*/
|
||||
class CablageMinecraftTest {
|
||||
|
||||
// --- Bytecode ---
|
||||
|
||||
private static ClassNode lire(Class<?> c) throws Exception {
|
||||
try (InputStream in = c.getResourceAsStream("/" + c.getName().replace('.', '/') + ".class")) {
|
||||
assertNotNull(in, c.getName());
|
||||
ClassNode n = new ClassNode();
|
||||
new ClassReader(in).accept(n, 0);
|
||||
return n;
|
||||
}
|
||||
}
|
||||
|
||||
/** Méthodes appelées par une méthode et par ses lambdas (récursivement, dans la même classe). */
|
||||
private static Set<String> appels(ClassNode classe, String methode) {
|
||||
Set<String> sortie = new HashSet<>();
|
||||
Set<String> vues = new HashSet<>();
|
||||
parcourir(classe, methode, sortie, vues);
|
||||
return sortie;
|
||||
}
|
||||
|
||||
private static void parcourir(ClassNode classe, String methode, Set<String> sortie, Set<String> vues) {
|
||||
if (!vues.add(methode)) return;
|
||||
boolean trouvee = false;
|
||||
for (MethodNode m : classe.methods) {
|
||||
if (!m.name.equals(methode)) continue;
|
||||
trouvee = true;
|
||||
for (AbstractInsnNode i : m.instructions) {
|
||||
if (i instanceof MethodInsnNode mi) {
|
||||
sortie.add(mi.owner.substring(mi.owner.lastIndexOf('/') + 1) + "." + mi.name);
|
||||
} else if (i instanceof InvokeDynamicInsnNode d) {
|
||||
for (Object a : d.bsmArgs) {
|
||||
if (a instanceof org.objectweb.asm.Handle h && h.getOwner().equals(classe.name)) {
|
||||
parcourir(classe, h.getName(), sortie, vues);
|
||||
} else if (a instanceof org.objectweb.asm.Handle h) {
|
||||
sortie.add(h.getOwner().substring(h.getOwner().lastIndexOf('/') + 1) + "." + h.getName());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
assertTrue(trouvee, methode);
|
||||
}
|
||||
|
||||
@Test
|
||||
void C4_lesPointsDEntreeConsultentLaMarqueDExpulsion() throws Exception {
|
||||
ClassNode garde = lire(Garde.class);
|
||||
ClassNode events = lire(GardeEvents.class);
|
||||
assertTrue(appels(garde, "avantMouvement").contains("Moteur.estExpulse"));
|
||||
assertTrue(appels(garde, "avantMouvement").contains("Cablage.evaluerAvantMouvement"));
|
||||
assertTrue(appels(garde, "apresMouvement").contains("Moteur.estExpulse"));
|
||||
assertTrue(appels(garde, "apresMouvement").contains("Cablage.traiterApresMouvement"));
|
||||
assertTrue(appels(events, "onAttaque").contains("Moteur.estExpulse"));
|
||||
assertTrue(appels(events, "onAttaque").contains("Cablage.entreeAttaque"));
|
||||
assertTrue(appels(events, "onConnexion").contains("Moteur.oublierExpulsion"), "reconnexion : marque effacée");
|
||||
assertFalse(appels(events, "onDeconnexion").contains("Moteur.oublierExpulsion"),
|
||||
"la marque survit à la déconnexion (C6)");
|
||||
assertTrue(appels(garde, "appliquerSanctionMouvement").contains("Cablage.appliquerSanction"));
|
||||
Set<String> sanction = appels(lire(Cablage.class), "appliquerSanction");
|
||||
assertTrue(sanction.contains("Moteur.expulser"));
|
||||
assertTrue(sanction.contains("Moteur.apresSetback"));
|
||||
assertFalse(appels(garde, "appliquerSanctionMouvement").stream().anyMatch(a -> a.toLowerCase().contains("ban")),
|
||||
"jamais de bannissement");
|
||||
}
|
||||
|
||||
/**
|
||||
* FAILLE (16/10, trouvée en écrivant ces tests) : apresVehicule ne regarde pas la marque d'expulsion, à la
|
||||
* différence de avantMouvement / apresMouvement / onAttaque. Un paquet de véhicule traité après l'expulsion
|
||||
* (même lot de paquets, avant la fermeture de la connexion) est encore évalué : journal, alerte aux ops,
|
||||
* stopRiding + setback, et l'état du moteur (Suivi) est recréé. L'expulsion elle-même reste unique
|
||||
* (Moteur.expulser). Ce test est vert tant que le défaut existe. Proposition : en tête d'apresVehicule,
|
||||
* {@code if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;}
|
||||
* (même garde, et idem pour auSolPourChute, qui peut encore appeler le moteur). Non corrigé : décision de Théo.
|
||||
*/
|
||||
@Test
|
||||
void FAILLE_C4_apresVehiculeNeConsultePasLaMarqueDExpulsion() throws Exception {
|
||||
ClassNode garde = lire(Garde.class);
|
||||
Set<String> a = appels(garde, "apresVehicule");
|
||||
assertTrue(a.contains("Moteur.vehicule"), "le paquet de véhicule est bien évalué par le moteur");
|
||||
assertFalse(a.contains("Moteur.estExpulse"), "défaut corrigé : inverser en CORRIGE_");
|
||||
assertFalse(appels(garde, "auSolPourChute").contains("Moteur.estExpulse"));
|
||||
}
|
||||
|
||||
// --- Événements NeoForge abonnés ---
|
||||
|
||||
@Test
|
||||
void evenementsAbonnes() {
|
||||
Set<Class<?>> ev = new HashSet<>();
|
||||
for (Method m : GardeEvents.class.getDeclaredMethods()) {
|
||||
if (m.isAnnotationPresent(net.neoforged.bus.api.SubscribeEvent.class)) {
|
||||
assertEquals(1, m.getParameterCount(), m.getName());
|
||||
assertTrue(java.lang.reflect.Modifier.isStatic(m.getModifiers()), m.getName());
|
||||
ev.add(m.getParameterTypes()[0]);
|
||||
}
|
||||
}
|
||||
for (Class<?> c : new Class<?>[] {
|
||||
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class,
|
||||
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent.class,
|
||||
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedOutEvent.class,
|
||||
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerChangedDimensionEvent.class,
|
||||
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerRespawnEvent.class,
|
||||
net.neoforged.neoforge.event.tick.ServerTickEvent.Pre.class,
|
||||
net.neoforged.neoforge.event.tick.ServerTickEvent.Post.class,
|
||||
net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent.Stop.class,
|
||||
net.neoforged.neoforge.event.server.ServerStartingEvent.class,
|
||||
net.neoforged.neoforge.event.server.ServerStoppedEvent.class}) {
|
||||
assertTrue(ev.contains(c), c.getName());
|
||||
}
|
||||
assertTrue(net.neoforged.bus.api.ICancellableEvent.class.isAssignableFrom(
|
||||
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class), "un coup peut être annulé");
|
||||
}
|
||||
|
||||
@Test
|
||||
void lesFauxJoueursNeSontJamaisControles() {
|
||||
// GardeEvents filtre « p instanceof FakePlayer » : un FakePlayer est un ServerPlayer.
|
||||
assertTrue(net.minecraft.server.level.ServerPlayer.class.isAssignableFrom(
|
||||
net.neoforged.neoforge.common.util.FakePlayer.class));
|
||||
}
|
||||
|
||||
// --- Types d'entités (C18 GardeAntiCrash, F20 vehiculeControle / etatVehicule) ---
|
||||
|
||||
@Test
|
||||
void C18_seulsLesMinecartsContenantsSontGardesImmobiles() {
|
||||
Class<?> container = net.minecraft.world.Container.class;
|
||||
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartChest.class));
|
||||
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartHopper.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.Minecart.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartTNT.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartFurnace.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartSpawner.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartCommandBlock.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
void F20_vehiculesControles() {
|
||||
Class<?> bateau = net.minecraft.world.entity.vehicle.Boat.class;
|
||||
Class<?> monture = net.minecraft.world.entity.LivingEntity.class;
|
||||
assertTrue(bateau.isAssignableFrom(net.minecraft.world.entity.vehicle.ChestBoat.class), "bateau à coffre, radeau");
|
||||
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.horse.Horse.class));
|
||||
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.Pig.class));
|
||||
Class<?> minecart = net.minecraft.world.entity.vehicle.AbstractMinecart.class;
|
||||
assertFalse(bateau.isAssignableFrom(minecart) || monture.isAssignableFrom(minecart),
|
||||
"minecart : non contrôlé (type AUTRE), la position de retour suit le joueur");
|
||||
}
|
||||
|
||||
// --- Options : du fichier toml au moteur ---
|
||||
|
||||
private static Object valeur(String champ) throws Exception {
|
||||
Field f = GardeSpec.class.getDeclaredField(champ);
|
||||
f.setAccessible(true);
|
||||
return f.get(null);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static <T> T defaut(String champ) throws Exception {
|
||||
return ((ModConfigSpec.ConfigValue<T>) valeur(champ)).getDefault();
|
||||
}
|
||||
|
||||
@Test
|
||||
void optionsDesactiveesParDefautDansLeFichierEtLeMoteur() throws Exception {
|
||||
GardeConfig c = new GardeConfig();
|
||||
assertEquals(false, defaut("ELYTRES_STRICTE"));
|
||||
assertEquals(c.elytresExemptionStricte, defaut("ELYTRES_STRICTE"));
|
||||
assertEquals(2, (int) defaut("ELYTRES_AIR_MIN"));
|
||||
assertEquals(c.elytresAirMinTicks, (int) defaut("ELYTRES_AIR_MIN"));
|
||||
assertEquals(false, defaut("COMBAT_VEHICULE"));
|
||||
assertEquals(c.combatMesureEnVehicule, defaut("COMBAT_VEHICULE"));
|
||||
assertEquals(false, defaut("VOL_FENETRE_GLISSANTE"));
|
||||
assertEquals(c.volFenetreGlissante, defaut("VOL_FENETRE_GLISSANTE"));
|
||||
assertEquals(false, defaut("VITESSE_MOYENNE"));
|
||||
assertEquals(c.vitesseMoyenne, defaut("VITESSE_MOYENNE"));
|
||||
assertEquals(0, (int) defaut("TIMER_SOLDE_MAX"));
|
||||
assertEquals(c.timerSoldeMax, (int) defaut("TIMER_SOLDE_MAX"));
|
||||
assertEquals(c.seriePingMargeMs, (int) defaut("SERIE_PING_MARGE"));
|
||||
assertEquals(false, defaut("AC_EMPILEMENT_MOUVEMENT"));
|
||||
assertFalse(new com.gastinelgarde.core.AntiCrashEntites.Reglages().empilementSeulementEnMouvement);
|
||||
assertFalse(GardeSpec.antiCrash().empilementSeulementEnMouvement, "fichier non chargé : défaut");
|
||||
}
|
||||
|
||||
@Test
|
||||
void laConfigProposeeNActivePasLesNouvellesOptions() throws Exception {
|
||||
// Les tests tournent dans build/minecraft-junit : on remonte jusqu'à la racine du projet.
|
||||
Path toml = null;
|
||||
for (Path d = Path.of("").toAbsolutePath(); d != null && toml == null; d = d.getParent()) {
|
||||
Path f = d.resolve("config-proposee").resolve("gastinelgarde-server.toml");
|
||||
if (Files.exists(f)) toml = f;
|
||||
}
|
||||
Assumptions.assumeTrue(toml != null, "config-proposee introuvable depuis " + Path.of("").toAbsolutePath());
|
||||
String t = Files.readString(toml, StandardCharsets.UTF_8);
|
||||
for (String cle : new String[] {"elytresExemptionStricte", "combatMesureEnVehicule", "volFenetreGlissante",
|
||||
"vitesseMoyenne", "empilementSeulementEnMouvement"}) {
|
||||
assertFalse(t.matches("(?s).*\\b" + cle + "\\s*=\\s*true.*"), cle);
|
||||
}
|
||||
assertFalse(t.matches("(?s).*\\btimerSoldeMax\\s*=\\s*[1-9].*"), "timerSoldeMax");
|
||||
}
|
||||
|
||||
/**
|
||||
* GardeSpec.appliquer recopie bien chaque option dans GardeConfig. On charge le fichier en mémoire
|
||||
* (ModConfigSpec.acceptConfig, par réflexion : signature propre à NeoForge 21.1), puis on le décharge.
|
||||
*/
|
||||
@Test
|
||||
void appliquerRecopieLesOptionsDuFichier() throws Exception {
|
||||
Object charge = chargerEnMemoire();
|
||||
Assumptions.assumeTrue(charge != null, "[À VÉRIFIER] chargement en mémoire du ModConfigSpec impossible ici");
|
||||
try {
|
||||
assertTrue(GardeSpec.SPEC.isLoaded());
|
||||
GardeConfig vide = new GardeConfig();
|
||||
GardeSpec.appliquer(vide);
|
||||
assertFalse(vide.elytresExemptionStricte);
|
||||
assertFalse(vide.combatMesureEnVehicule);
|
||||
assertFalse(vide.volFenetreGlissante);
|
||||
assertFalse(vide.vitesseMoyenne);
|
||||
assertEquals(0, vide.timerSoldeMax);
|
||||
for (com.gastinelgarde.core.Controle k : com.gastinelgarde.core.Controle.values()) {
|
||||
assertEquals(new GardeConfig().mode(k), vide.mode(k), "mode par défaut inchangé : " + k);
|
||||
}
|
||||
|
||||
((ModConfigSpec.BooleanValue) valeur("ELYTRES_STRICTE")).set(true);
|
||||
((ModConfigSpec.IntValue) valeur("ELYTRES_AIR_MIN")).set(5);
|
||||
((ModConfigSpec.BooleanValue) valeur("COMBAT_VEHICULE")).set(true);
|
||||
((ModConfigSpec.BooleanValue) valeur("VOL_FENETRE_GLISSANTE")).set(true);
|
||||
((ModConfigSpec.BooleanValue) valeur("VITESSE_MOYENNE")).set(true);
|
||||
((ModConfigSpec.IntValue) valeur("TIMER_SOLDE_MAX")).set(20);
|
||||
GardeConfig c = new GardeConfig();
|
||||
GardeSpec.appliquer(c);
|
||||
assertTrue(c.elytresExemptionStricte, "C7");
|
||||
assertEquals(5, c.elytresAirMinTicks, "C7");
|
||||
assertTrue(c.combatMesureEnVehicule, "C8");
|
||||
assertTrue(c.volFenetreGlissante, "C10");
|
||||
assertTrue(c.vitesseMoyenne, "C15");
|
||||
assertEquals(20, c.timerSoldeMax, "C15");
|
||||
} finally {
|
||||
dechargerEnMemoire();
|
||||
}
|
||||
assertFalse(GardeSpec.SPEC.isLoaded(), "les autres tests attendent un fichier non chargé");
|
||||
}
|
||||
|
||||
/** null si l'API n'est pas celle attendue (le test est alors ignoré, pas faux). */
|
||||
private static Object chargerEnMemoire() {
|
||||
try {
|
||||
Method accept = null;
|
||||
for (Method m : ModConfigSpec.class.getMethods()) {
|
||||
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) accept = m;
|
||||
}
|
||||
if (accept == null) return null;
|
||||
Class<?> type = accept.getParameterTypes()[0];
|
||||
com.electronwill.nightconfig.core.CommentedConfig cc =
|
||||
com.electronwill.nightconfig.core.CommentedConfig.inMemory();
|
||||
// Fichier déjà corrigé (valeurs par défaut) : acceptConfig n'a rien à sauvegarder.
|
||||
for (Method m : ModConfigSpec.class.getMethods()) {
|
||||
if (m.getName().equals("correct") && m.getParameterCount() == 1
|
||||
&& m.getParameterTypes()[0].isInstance(cc)) {
|
||||
m.invoke(GardeSpec.SPEC, cc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
Object config = null;
|
||||
if (type.isInstance(cc)) {
|
||||
config = cc;
|
||||
} else if (type.isSealed()) {
|
||||
// NeoForge 21.1 : IConfigSpec.ILoadedConfig est scellée, seule implémentation LoadedConfig.
|
||||
for (Class<?> impl : type.getPermittedSubclasses()) {
|
||||
for (java.lang.reflect.Constructor<?> k : impl.getDeclaredConstructors()) {
|
||||
Class<?>[] p = k.getParameterTypes();
|
||||
if (p.length == 0 || !p[0].isInstance(cc)) continue;
|
||||
Object[] args = new Object[p.length];
|
||||
args[0] = cc;
|
||||
k.setAccessible(true);
|
||||
config = k.newInstance(args);
|
||||
break;
|
||||
}
|
||||
if (config != null) break;
|
||||
}
|
||||
} else if (type.isInterface()) {
|
||||
config = Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[] {type}, (o, m, a) -> switch (m.getName()) {
|
||||
case "config" -> cc;
|
||||
case "hashCode" -> System.identityHashCode(o);
|
||||
case "equals" -> o == a[0];
|
||||
case "toString" -> "config-en-memoire";
|
||||
default -> null;
|
||||
});
|
||||
}
|
||||
if (config == null) return null;
|
||||
accept.invoke(GardeSpec.SPEC, config);
|
||||
return GardeSpec.SPEC.isLoaded() ? config : null;
|
||||
} catch (ReflectiveOperationException | RuntimeException | LinkageError e) {
|
||||
System.out.println("[CablageMinecraftTest] chargement en mémoire impossible : " + e);
|
||||
dechargerEnMemoire();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static void dechargerEnMemoire() {
|
||||
try {
|
||||
for (Method m : ModConfigSpec.class.getMethods()) {
|
||||
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) {
|
||||
m.invoke(GardeSpec.SPEC, new Object[] {null});
|
||||
}
|
||||
}
|
||||
} catch (ReflectiveOperationException | RuntimeException e) {
|
||||
System.out.println("[CablageMinecraftTest] déchargement : " + e);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,300 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import com.gastinelgarde.core.Controle;
|
||||
import com.gastinelgarde.core.EtatJoueur;
|
||||
import com.gastinelgarde.core.Exemptions;
|
||||
import com.gastinelgarde.core.GardeConfig;
|
||||
import com.gastinelgarde.core.GraceTeleport;
|
||||
import com.gastinelgarde.core.Mode;
|
||||
import com.gastinelgarde.core.Moteur;
|
||||
import com.gastinelgarde.core.Sanction;
|
||||
import com.gastinelgarde.core.Verdict;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import java.util.function.BooleanSupplier;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* Câblage Minecraft (constat C4 ⚠️) : décisions de Garde / GardeEvents sorties dans {@link Cablage}, testées sans
|
||||
* serveur avec une doublure du joueur et un vrai {@link Moteur}.
|
||||
*/
|
||||
class CablageTest {
|
||||
|
||||
private static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
|
||||
private static final String MONDE = "minecraft:overworld";
|
||||
|
||||
/** Doublure de ServerPlayer : enregistre ce que la sanction lui fait, dans l'ordre. */
|
||||
static final class FauxJoueur implements Cablage.Joueur {
|
||||
final List<String> actions = new ArrayList<>();
|
||||
String dimension = MONDE;
|
||||
int tick = 1000;
|
||||
|
||||
@Override public UUID id() { return ID; }
|
||||
@Override public String nom() { return "Tricheur"; }
|
||||
@Override public String dimension() { return dimension; }
|
||||
@Override public int tick() { return tick; }
|
||||
@Override public void annoncerTeleport(GraceTeleport.Origine o) { actions.add("annonce " + o); }
|
||||
@Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
|
||||
actions.add(String.format(java.util.Locale.ROOT, "teleport %.1f %.1f %.1f %.0f %.0f", x, y, z, yaw, pitch));
|
||||
}
|
||||
@Override public void deconnecter(String message) { actions.add("deconnexion " + message); }
|
||||
@Override public void journal(String ligne) { actions.add("journal " + ligne); }
|
||||
|
||||
long compte(String prefixe) {
|
||||
return actions.stream().filter(a -> a.startsWith(prefixe)).count();
|
||||
}
|
||||
}
|
||||
|
||||
private static Verdict verdict(Controle c, Sanction s) {
|
||||
return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of());
|
||||
}
|
||||
|
||||
private static BooleanSupplier compteur(AtomicInteger n, boolean valeur) {
|
||||
return () -> {
|
||||
n.incrementAndGet();
|
||||
return valeur;
|
||||
};
|
||||
}
|
||||
|
||||
// --- Expulsion unique (C4) ---
|
||||
|
||||
@Test
|
||||
void C4_expulsionUneSeuleFoisPuisDeNouveauApresReconnexion() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
FauxJoueur p = new FauxJoueur();
|
||||
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.EXPULSION));
|
||||
for (int i = 0; i < 344; i++) { // incident du 15/10 : 344 disconnect en 18 s
|
||||
p.tick++;
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
|
||||
}
|
||||
assertEquals(1, p.compte("deconnexion"), p.actions.toString());
|
||||
assertEquals(1, p.compte("journal"));
|
||||
assertEquals("journal Tricheur EXPULSE (vol)", p.actions.get(0)); // journal avant la déconnexion
|
||||
assertEquals("deconnexion Expulsé par l'anti-triche (vol).", p.actions.get(1));
|
||||
assertTrue(moteur.estExpulse(ID));
|
||||
|
||||
// GardeEvents.onConnexion : oublierExpulsion, la prochaine expulsion est de nouveau possible.
|
||||
moteur.oublierExpulsion(ID);
|
||||
assertFalse(moteur.estExpulse(ID));
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
|
||||
assertEquals(2, p.compte("deconnexion"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void C4_apresLExpulsionPlusAucuneEvaluationNiCoup() {
|
||||
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, false));
|
||||
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, true)); // l'expulsion passe avant
|
||||
assertEquals(Cablage.EntreeAttaque.IGNORER, Cablage.entreeAttaque(false, true));
|
||||
assertEquals(Cablage.EntreeAttaque.EVALUER, Cablage.entreeAttaque(false, false));
|
||||
|
||||
AtomicInteger lus = new AtomicInteger();
|
||||
assertFalse(Cablage.evaluerAvantMouvement(true, () -> true, compteur(lus, false)));
|
||||
assertEquals(0, lus.get(), "expulsé : l'exemption n'est même pas lue");
|
||||
assertFalse(Cablage.evaluerAvantMouvement(true, () -> false, () -> true)); // exemption manuelle
|
||||
assertTrue(Cablage.evaluerAvantMouvement(true, () -> false, () -> false));
|
||||
assertFalse(Cablage.traiterApresMouvement(true, () -> true));
|
||||
assertTrue(Cablage.traiterApresMouvement(true, () -> false));
|
||||
}
|
||||
|
||||
@Test
|
||||
void F01_horsDuThreadServeurLEtatDuModNEstPasLu() {
|
||||
AtomicInteger lus = new AtomicInteger();
|
||||
assertFalse(Cablage.evaluerAvantMouvement(false, compteur(lus, false), compteur(lus, false)));
|
||||
assertFalse(Cablage.traiterApresMouvement(false, compteur(lus, false)));
|
||||
assertEquals(0, lus.get());
|
||||
}
|
||||
|
||||
@Test
|
||||
void expulsionSansVerdictRaisonParDefaut() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
FauxJoueur p = new FauxJoueur();
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, List.of());
|
||||
assertEquals("journal Tricheur EXPULSE (anti-triche)", p.actions.get(0));
|
||||
}
|
||||
|
||||
// --- Setback (C2, C3) ---
|
||||
|
||||
@Test
|
||||
void C2_setbackVersLaPositionAuSolPuisRemiseAZeroDuVol() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
FauxJoueur p = new FauxJoueur();
|
||||
long ms = p.tick * 50L;
|
||||
moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE);
|
||||
moteur.suivi(ID).vl.ajouter(Controle.VOL, 30, ms);
|
||||
moteur.suivi(ID).vl.ajouter(Controle.VITESSE, 20, ms);
|
||||
moteur.suivi(ID).vl.ajouter(Controle.KILLAURA_CIBLES, 7, ms);
|
||||
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
|
||||
assertEquals(List.of("annonce SETBACK", "teleport 10.5 64.0 -3.5 90 10", "journal Tricheur SETBACK (vol)"),
|
||||
p.actions, "la grâce est annoncée avant le teleport (F05)");
|
||||
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VOL, ms), 1e-9);
|
||||
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VITESSE, ms), 1e-9);
|
||||
assertTrue(moteur.suivi(ID).vl.valeur(Controle.KILLAURA_CIBLES, ms) > 6.9, "les autres VL ne sont pas touchées");
|
||||
assertFalse(moteur.estExpulse(ID));
|
||||
}
|
||||
|
||||
@Test
|
||||
void setbackSansPositionOuAutreDimensionNeFaitRien() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
FauxJoueur p = new FauxJoueur();
|
||||
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.SETBACK));
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
|
||||
assertTrue(p.actions.isEmpty(), "aucune position de retour : rien");
|
||||
|
||||
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
|
||||
assertTrue(p.actions.isEmpty(), "position dans une autre dimension : jamais de teleport inter-dimension");
|
||||
}
|
||||
|
||||
@Test
|
||||
void sanctionsInferieuresAuSetbackNeTouchentPasLeJoueur() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, MONDE);
|
||||
FauxJoueur p = new FauxJoueur();
|
||||
for (Sanction s : new Sanction[] {Sanction.AUCUNE, Sanction.JOURNAL, Sanction.ALERTE}) {
|
||||
Cablage.appliquerSanction(moteur, p, s, List.of(verdict(Controle.VOL, s)));
|
||||
assertFalse(Cablage.sanctionDeMouvement(s), s.name());
|
||||
}
|
||||
assertTrue(p.actions.isEmpty());
|
||||
assertTrue(Cablage.sanctionDeMouvement(Sanction.SETBACK));
|
||||
assertTrue(Cablage.sanctionDeMouvement(Sanction.EXPULSION));
|
||||
}
|
||||
|
||||
@Test
|
||||
void C3_positionDeRetourSeulementAuSolEtSansVerdictNiVehicule() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
int tick = 500;
|
||||
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, true, false));
|
||||
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, true), "eau, échelle…");
|
||||
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, false), "en l'air");
|
||||
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> true, true, false), "véhicule contrôlé");
|
||||
AtomicInteger lus = new AtomicInteger();
|
||||
assertFalse(Cablage.memoriserRetour(moteur, tick, tick, compteur(lus, false), true, false), "verdict ce tick");
|
||||
assertEquals(0, lus.get(), "le véhicule n'est pas lu si un verdict est tombé à ce tick");
|
||||
}
|
||||
|
||||
// --- Coups (GardeEvents.onAttaque) ---
|
||||
|
||||
@Test
|
||||
void coupAnnuleEnEnforceOuSurSanctionEtExpulsionSeuleAppliquee() {
|
||||
for (Sanction s : Sanction.values()) {
|
||||
boolean grave = s.ordinal() >= Sanction.SETBACK.ordinal();
|
||||
assertEquals(grave, Cablage.annulerCoup(false, s), s.name());
|
||||
assertTrue(Cablage.annulerCoup(true, s), "portée / hitbox ENFORCE : " + s);
|
||||
assertEquals(s == Sanction.EXPULSION, Cablage.appliquerApresCoup(s), "pas de setback sur un coup : " + s);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void cibleSurContraptionOuVaisseauPasDeMesurePorteeHitbox() {
|
||||
BooleanSupplier oui = () -> true;
|
||||
BooleanSupplier non = () -> false;
|
||||
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, non, non));
|
||||
assertFalse(Cablage.mesurerPorteeHitbox(oui, non, true, non, non), "cible contraption");
|
||||
assertFalse(Cablage.mesurerPorteeHitbox(non, oui, true, non, non), "cible sur vaisseau Sable");
|
||||
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, oui, non), "assise sur un siège Create");
|
||||
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, non, oui), "véhicule sur un vaisseau");
|
||||
assertTrue(Cablage.mesurerPorteeHitbox(non, non, false, non, non), "cheval, bateau : mesuré");
|
||||
AtomicInteger lus = new AtomicInteger();
|
||||
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, compteur(lus, true), compteur(lus, true)));
|
||||
assertEquals(0, lus.get(), "sans véhicule, la racine n'est pas interrogée");
|
||||
}
|
||||
|
||||
// --- C7 : élytres ---
|
||||
|
||||
@Test
|
||||
void C7_deploiementTropTotApresLeSolEstSuspectPourTouteLaDureeDuPlane() {
|
||||
Cablage.Elytres e = new Cablage.Elytres();
|
||||
int sol = 100;
|
||||
e.observer(false, sol, 100, 2);
|
||||
e.observer(true, sol, 101, 2); // 1 tick après le sol (onGround falsifié)
|
||||
assertTrue(e.suspectes);
|
||||
for (int t = 102; t < 300; t++) e.observer(true, sol, t, 2);
|
||||
assertTrue(e.suspectes, "reste suspect jusqu'à la fin du plané");
|
||||
e.observer(false, sol, 300, 2);
|
||||
assertFalse(e.suspectes);
|
||||
assertFalse(e.vues);
|
||||
|
||||
Cablage.Elytres h = new Cablage.Elytres();
|
||||
h.observer(true, sol, 102, 2); // 2 ticks en l'air : honnête
|
||||
assertFalse(h.suspectes);
|
||||
Cablage.Elytres jamais = new Cablage.Elytres();
|
||||
jamais.observer(true, Integer.MIN_VALUE, 5, 2); // jamais vu au sol (connexion en plein vol)
|
||||
assertFalse(jamais.suspectes);
|
||||
}
|
||||
|
||||
@Test
|
||||
void C7_unSolServeurVuPendantLePlaneNeRendPasSuspectApresCoup() {
|
||||
Cablage.Elytres e = new Cablage.Elytres();
|
||||
e.observer(true, 100, 120, 2);
|
||||
assertFalse(e.suspectes);
|
||||
e.observer(true, 125, 125, 2); // frôle un bloc en plané
|
||||
assertFalse(e.suspectes, "seul le début du plané compte");
|
||||
}
|
||||
|
||||
@Test
|
||||
void C7_cableJusquAuxExemptions_avecEtSansOption() {
|
||||
Cablage.Elytres e = new Cablage.Elytres();
|
||||
e.observer(true, 100, 101, 2);
|
||||
EtatJoueur etat = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(e.suspectes).build();
|
||||
GardeConfig defaut = new GardeConfig();
|
||||
assertFalse(defaut.elytresExemptionStricte, "option désactivée par défaut");
|
||||
assertTrue(Exemptions.evaluer(etat, defaut, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
|
||||
GardeConfig stricte = new GardeConfig();
|
||||
stricte.elytresExemptionStricte = true;
|
||||
assertFalse(Exemptions.evaluer(etat, stricte, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
|
||||
}
|
||||
|
||||
// --- C8 : combat en véhicule ---
|
||||
|
||||
@Test
|
||||
void C8_passagerMesureSeulementAvecLOptionEtContraptionToujoursExemptee() {
|
||||
EtatJoueur cheval = EtatJoueur.builder().enVehicule(true).build();
|
||||
EtatJoueur siege = EtatJoueur.builder().enVehicule(true).pocheContraption(true).build();
|
||||
GardeConfig defaut = new GardeConfig();
|
||||
assertFalse(defaut.combatMesureEnVehicule);
|
||||
assertTrue(Exemptions.evaluer(cheval, defaut, Exemptions.Famille.COMBAT).exempt());
|
||||
GardeConfig option = new GardeConfig();
|
||||
option.combatMesureEnVehicule = true;
|
||||
assertFalse(Exemptions.evaluer(cheval, option, Exemptions.Famille.COMBAT).exempt());
|
||||
assertTrue(Exemptions.evaluer(siege, option, Exemptions.Famille.COMBAT).raisons().contains("contraption"));
|
||||
assertTrue(Exemptions.evaluer(cheval, option, Exemptions.Famille.MOUVEMENT).raisons().contains("vehicule"),
|
||||
"l'option ne touche que le combat");
|
||||
}
|
||||
|
||||
// --- Cache des détections (contraption, courant d'air) ---
|
||||
|
||||
@Test
|
||||
void cacheDeDetectionToutesLesDixTicksPuisGrace() {
|
||||
Cablage.CacheDetection c = new Cablage.CacheDetection();
|
||||
AtomicInteger appels = new AtomicInteger();
|
||||
boolean[] present = {true};
|
||||
BooleanSupplier detecter = () -> {
|
||||
appels.incrementAndGet();
|
||||
return present[0];
|
||||
};
|
||||
assertTrue(c.lire(100, detecter, 40));
|
||||
assertEquals(1, appels.get());
|
||||
present[0] = false; // la contraption s'éloigne
|
||||
assertTrue(c.lire(109, detecter, 40), "valeur en cache");
|
||||
assertEquals(1, appels.get());
|
||||
assertTrue(c.lire(110, detecter, 40), "redétecté (absent) mais dans la grâce");
|
||||
assertEquals(2, appels.get());
|
||||
assertTrue(c.lire(140, detecter, 40));
|
||||
assertFalse(c.lire(150, detecter, 40), "grâce terminée");
|
||||
assertTrue(c.lire(5, () -> true, 40), "tick qui recule (redémarrage) : redétecté");
|
||||
}
|
||||
|
||||
@Test
|
||||
void cacheJamaisVuPasDeGrace() {
|
||||
Cablage.CacheDetection c = new Cablage.CacheDetection();
|
||||
assertFalse(c.lire(100, () -> false, 40));
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur