Comparer les révisions

...
Auteur SHA1 Message Date

2026-10-19

Theo GastineletClaude Opus 5.5 b2e5189d8a GastinelGarde 0.3.2 : version, CHANGELOG
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:56:31 +02:00
Theo GastineletClaude Opus 5.5 86d4d56a52 GastinelGarde 0.3.2 D3 : no-fall voit le paquet d'etat au sol
Un paquet sans deplacement (dy = 0) qui declare au sol sans bloc dessous est
juge avec la vitesse verticale du dernier paquet qui a bouge pendant la chute
(remise a zero au sol, en milieu special, en exemption et apres un setback).
Avant, NoFall.points exigeait dy <= -0,3 sur le paquet meme : aucune ligne
no-fall contre le NoFall par paquet d'etat (rapport test 19/10, T5).
Test : Garde1015Test.D3_noFallVoitLePaquetDEtatAuSolPendantUneChute

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:55:56 +02:00
Theo GastineletClaude Opus 5.5 2325250fd2 GastinelGarde 0.3.2 D2 : expulsion de combat apres 4 setbacks en 60 s
Un setback portee/hitbox (coups annules) remet le VL de ce controle a zero
et compte pour la regle C5, comme le vol (C2). Avant, le VL de combat
montait a 20 en ~5 s et l'expulsion arrivait sans la regle des 4 setbacks.
Test : Garde1015Test.D2_hitboxEnforceExpulseApresQuatreSetbacksPasAuBoutDe5s

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:55:51 +02:00
Theo GastineletClaude Opus 5.5 963e01fc87 GastinelGarde 0.3.2 D1 : setback vers le point d'arrivee d'une teleportation
Une teleportation externe (/tp, TPA, perle, mod), une reapparition, un
changement de dimension ou une connexion prennent le point d'arrivee comme
position de retour. Avant, un setback avant le premier contact au sol
ramenait a la position d'avant la teleportation (rapport test 19/10, T3).
Test : CablageTest.D1_setbackApresTpRameneAuPointDArriveePasAvantLaTeleportation

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:55:26 +02:00

2026-10-16

gastineltetClaude Sonnet 5.5 288087080f gitignore : livrable/
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 10:15:06 +02:00
gastineltetClaude Sonnet 5.5 9b5273f830 GastinelGarde 0.3.1 : version, CHANGELOG, README
Passe mod_version et neoforge.mods.toml en 0.3.1, ajoute CHANGELOG.md
(resume des correctifs, options nouvelles desactivees par defaut, modes inchanges).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 10:13:26 +02:00
gastineltetClaude Opus 5.5 d90e40c8b9 GastinelGarde tests : cablage NeoForge (evenements, bytecode, options, FAILLE_C4 vehicule)
CablageMinecraftTest (9 tests, sans serveur) : evenements abonnes, gardes
d'expulsion lues dans le bytecode, types d'entites C18/F20, options C7 C8
C10 C15 C18 desactivees par defaut et recopiees par GardeSpec.appliquer
(fichier charge en memoire). FAILLE_C4_apresVehicule... : vert tant que
apresVehicule ignore la marque d'expulsion (non corrige). 291 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
gastineltetClaude Opus 5.5 6e208dccd2 GastinelGarde : couche Cablage testable (Garde, GardeEvents) et ses tests
Decisions du cablage Minecraft sorties sans changement de comportement :
entrees des evenements (C4 expulsion, F01, exemption manuelle), annulation
du coup, exemption contraption de la cible, C7 transition elytres, cache des
detections, position de retour (C3), sanction setback/expulsion (C2, C4)
via une interface Joueur (doublure dans les tests). Evaluation paresseuse
conservee. CablageTest : 16 tests. 266 -> 282 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
15 fichiers modifiés avec 1046 ajouts et 77 suppressions

Aucun fichier ne correspond à votre recherche

+1
Voir le fichier
@@ -7,3 +7,4 @@ run/
# sauvegardes avant modification # sauvegardes avant modification
*.avant-* *.avant-*
livrable/
+56
Voir le fichier
@@ -0,0 +1,56 @@
# Journal des versions
## 0.3.2 (19/10/2026)
Correctifs des défauts D1 à D3 trouvés aux essais en jeu du 19/10 (rapport-garde-test-1019). Modes et options
inchangés. Testé hors jeu seulement (tests unitaires) ; rien n'a été rejoué en jeu.
- D1 : après une téléportation externe (/tp, TPA, perle, mod), une réapparition, un changement de dimension ou une
connexion, le point d'arrivée devient la position de retour. Avant, un setback avant le premier contact au sol
ramenait à la position d'avant la téléportation.
- D2 : un setback `portee` / `hitbox` (coups annulés) remet le VL de ce contrôle à zéro et compte pour C5 : l'expulsion
de combat vient après 4 setbacks en 60 s (avant : ~5 s, VL à 20 sans passer par C5). Les setbacks de combat et de
mouvement sont comptés ensemble pour C5.
- D3 : no-fall voit le NoFall « paquet d'état » : un paquet sans déplacement qui déclare « au sol » sans bloc dessous
est jugé avec la vitesse verticale du dernier paquet de la chute.
## 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
Voir le fichier
@@ -1,7 +1,7 @@
# GastinelGarde # GastinelGarde
Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur uniquement). Plan et décisions : 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/`). 2026-10-14 (`audit/`).
**État** : compilé, 180 tests JUnit verts (au 16/10) (cœur pur, commandes, configuration, application réelle des mixins, **É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 : 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 : Sortie : nombre de mouvements et d'attaques, infractions et points maximaux par contrôle, vingt exemples. Méthode :
+1 -1
Voir le fichier
@@ -1,7 +1,7 @@
org.gradle.jvmargs=-Xmx2G org.gradle.jvmargs=-Xmx2G
org.gradle.parallel=true org.gradle.parallel=true
mod_version=0.3.0 mod_version=0.3.2
mod_group_id=com.gastinelgarde mod_group_id=com.gastinelgarde
mod_id=gastinelgarde mod_id=gastinelgarde
+169
Voir le fichier
@@ -0,0 +1,169 @@
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);
}
/**
* D1 (0.3.2) : après une téléportation externe (/tp, TPA, perle, réapparition, dimension), le point d'arrivée
* devient la position de retour. Les autres (setback, refus vanilla) ne la changent pas.
*/
static void retourApresTeleport(Suivi sv, boolean externe, double x, double y, double z, float yaw, float pitch,
String dimension) {
if (externe) sv.memoriserPosition(x, y, z, yaw, pitch, dimension);
}
// --- 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 + ")");
}
}
}
}
+48 -58
Voir le fichier
@@ -77,17 +77,12 @@ public final class Garde {
int vehiculeTick = Integer.MIN_VALUE; int vehiculeTick = Integer.MIN_VALUE;
double vehiculeX, vehiculeY, vehiculeZ; double vehiculeX, vehiculeY, vehiculeZ;
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste) // Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
int contraptionTick = Integer.MIN_VALUE; final Cablage.CacheDetection contraption = new Cablage.CacheDetection();
int contraptionVuTick = Integer.MIN_VALUE;
boolean contraptionProche;
// C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours // C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
int solServeurTick = Integer.MIN_VALUE; int solServeurTick = Integer.MIN_VALUE;
boolean elytresVues; final Cablage.Elytres elytres = new Cablage.Elytres();
boolean elytresSuspectes;
// Cache de la détection d'un courant d'air (ventilateur Create), même principe // Cache de la détection d'un courant d'air (ventilateur Create), même principe
int courantTick = Integer.MIN_VALUE; final Cablage.CacheDetection courant = new Cablage.CacheDetection();
int courantVuTick = Integer.MIN_VALUE;
boolean courantProche;
// #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux) // #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux)
double[] oeilDernier; double[] oeilDernier;
double[] oeilAvant; double[] oeilAvant;
@@ -202,6 +197,9 @@ public final class Garde {
m.vehiculeId = -1; m.vehiculeId = -1;
m.oeilAvant = null; m.oeilAvant = null;
m.oeilDernier = null; m.oeilDernier = null;
// D1 (0.3.2) : réapparition, changement de dimension, connexion : la position actuelle devient le retour.
Cablage.retourApresTeleport(MOTEUR.suivi(p.getUUID()), true, p.getX(), p.getY(), p.getZ(), p.getYRot(),
p.getXRot(), p.level().dimension().location().toString());
} }
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */ /** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
@@ -214,10 +212,21 @@ public final class Garde {
* Tout teleport() du joueur (mixin) : la grâce ne s'ouvre que pour une origine externe (F05). Le mouvement * 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. * suivant n'est jamais comparé à la position d'avant la téléportation.
*/ */
public static void teleportVanilla(ServerPlayer p) { public static void teleportVanilla(ServerPlayer p, double x, double y, double z, float yaw, float pitch,
Set<?> relatifs) {
if (!surThreadServeur(p)) return; if (!surThreadServeur(p)) return;
Marques m = marques(p.getUUID()); Marques m = marques(p.getUUID());
if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount(); boolean externe = m.graceTeleport.teleport();
if (externe) m.teleportTick = p.server.getTickCount();
// D1 (0.3.2) : téléportation externe (/tp, TPA, perle, mod) : le point d'arrivée devient la position de
// retour (avant : un setback ramenait à la position d'avant la téléportation).
Cablage.retourApresTeleport(MOTEUR.suivi(p.getUUID()), externe,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.X) ? p.getX() + x : x,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Y) ? p.getY() + y : y,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Z) ? p.getZ() + z : z,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Y_ROT) ? p.getYRot() + yaw : yaw,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.X_ROT) ? p.getXRot() + pitch : pitch,
p.level().dimension().location().toString());
m.mouvementTick = Integer.MIN_VALUE; m.mouvementTick = Integer.MIN_VALUE;
m.vehiculeId = -1; m.vehiculeId = -1;
m.oeilAvant = null; m.oeilAvant = null;
@@ -391,16 +400,7 @@ public final class Garde {
} }
// C7 : au début du plané, combien de ticks en l'air (sol serveur) ? Moins que elytresAirMinTicks : suspect. // C7 : au début du plané, combien de ticks en l'air (sol serveur) ? Moins que elytresAirMinTicks : suspect.
if (p.isFallFlying()) { m.elytres.observer(p.isFallFlying(), m.solServeurTick, tick, config().elytresAirMinTicks);
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;
}
return EtatJoueur.builder() return EtatJoueur.builder()
.creatif(p.isCreative()) .creatif(p.isCreative())
@@ -408,7 +408,7 @@ public final class Garde {
.peutVoler(p.getAbilities().mayfly) .peutVoler(p.getAbilities().mayfly)
.riptide(riptideRecent) .riptide(riptideRecent)
.elytres(p.isFallFlying()) .elytres(p.isFallFlying())
.elytresDeploiementSuspect(m.elytresSuspectes) .elytresDeploiementSuspect(m.elytres.suspectes)
.levitation(p.hasEffect(MobEffects.LEVITATION)) .levitation(p.hasEffect(MobEffects.LEVITATION))
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING)) .chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
.enVehicule(p.isPassenger()) .enVehicule(p.isPassenger())
@@ -487,12 +487,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. */ /** 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) { private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) {
if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) { return m.contraption.lire(tick, () -> pocheContraption(p), GRACE_CONTRAPTION_TICKS);
m.contraptionProche = pocheContraption(p);
m.contraptionTick = tick;
if (m.contraptionProche) m.contraptionVuTick = tick;
}
return m.contraptionProche || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS);
} }
/** /**
@@ -587,19 +582,19 @@ public final class Garde {
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */ /** Début du traitement d'un paquet de mouvement : contrôle du débit. */
public static void avantMouvement(ServerPlayer p) { public static void avantMouvement(ServerPlayer p) {
if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà) // F01 : jamais depuis le thread réseau (le mixin l'évite déjà) ; C4 : expulsion en cours, plus rien à évaluer
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 : expulsion en cours, plus rien à évaluer if (!Cablage.evaluerAvantMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()),
if (estExempteManuellement(p.getUUID())) return; () -> estExempteManuellement(p.getUUID()))) return;
EtatJoueur etat = etat(p, false); EtatJoueur etat = etat(p, false);
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat); List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
Sanction s = traiter(p, v); 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. */ /** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */
public static void apresMouvement(ServerPlayer p) { public static void apresMouvement(ServerPlayer p) {
if (!surThreadServeur(p)) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion
if (MOTEUR.estExpulse(p.getUUID())) return; // 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(); int tick = p.server.getTickCount();
Marques m = marques(p.getUUID()); Marques m = marques(p.getUUID());
boolean solServeur = auSolServeur(p, m); boolean solServeur = auSolServeur(p, m);
@@ -621,7 +616,7 @@ public final class Garde {
if (controler && em != null) { if (controler && em != null) {
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em); List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
Sanction s = traiter(p, v); 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. // F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup.
if (!estExempteManuellement(p.getUUID())) { if (!estExempteManuellement(p.getUUID())) {
@@ -646,8 +641,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 // 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. // 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. // 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) if (Cablage.memoriserRetour(MOTEUR, m.dernierVerdictTick, tick, () -> vehiculeControle(p), solServeur,
&& MOTEUR.positionDeRetourAdmise(solServeur, em != null && em.milieuSpecial())) { em != null && em.milieuSpecial())) {
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(), MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
p.level().dimension().location().toString()); p.level().dimension().location().toString());
} }
@@ -867,12 +862,7 @@ public final class Garde {
/** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */ /** 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) { private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) {
if (m.courantTick == Integer.MIN_VALUE || tick - m.courantTick >= 10 || tick < m.courantTick) { return m.courant.lire(tick, () -> courantAir(p), GRACE_COURANT_TICKS);
m.courantProche = courantAir(p);
m.courantTick = tick;
if (m.courantProche) m.courantVuTick = tick;
}
return m.courantProche || DetectionContraption.dansLaGrace(tick, m.courantVuTick, GRACE_COURANT_TICKS);
} }
/** /**
@@ -914,22 +904,22 @@ public final class Garde {
} }
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) { public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id(); Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts);
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; /** Adaptateur ServerPlayer de Cablage.appliquerSanction. */
ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")"); private static Cablage.Joueur joueur(ServerPlayer p) {
p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ").")); return new Cablage.Joueur() {
} else if (s == Sanction.SETBACK) { @Override public UUID id() { return p.getUUID(); }
Suivi sv = MOTEUR.suivi(p.getUUID()); @Override public String nom() { return p.getGameProfile().getName(); }
String dim = p.level().dimension().location().toString(); @Override public String dimension() { return p.level().dimension().location().toString(); }
if (sv.aPositionValide() && sv.dimension().equals(dim)) { @Override public int tick() { return p.server.getTickCount(); }
annoncerTeleport(p, GraceTeleport.Origine.SETBACK); @Override public void annoncerTeleport(GraceTeleport.Origine origine) { Garde.annoncerTeleport(p, origine); }
p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch()); @Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol. p.connection.teleport(x, y, z, yaw, pitch);
MOTEUR.apresSetback(p.getUUID(), p.server.getTickCount() * 50L);
ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")");
} }
} @Override public void deconnecter(String message) { p.connection.disconnect(Component.literal(message)); }
@Override public void journal(String ligne) { ecrireJournal(ligne); }
};
} }
} }
+15 -11
Voir le fichier
@@ -57,11 +57,16 @@ public final class GardeEvents {
@SubscribeEvent @SubscribeEvent
public static void onAttaque(AttackEntityEvent event) { public static void onAttaque(AttackEntityEvent event) {
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.moteur().estExpulse(p.getUUID())) { // C4 : expulsion en cours switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) {
event.setCanceled(true); case ANNULER -> { // C4 : expulsion en cours
return; event.setCanceled(true);
return;
}
case IGNORER -> {
return;
}
case EVALUER -> { }
} }
if (Garde.estExempteManuellement(p.getUUID())) return;
Entity cible = event.getTarget(); Entity cible = event.getTarget();
int tick = p.server.getTickCount(); 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). // (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. // L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
Entity racine = cible.getRootVehicle(); Entity racine = cible.getRootVehicle();
boolean mesurerPH = !Garde.estContraption(cible) && !SableAcces.surSousNiveau(cible) boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> Garde.estContraption(cible),
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine))); () -> 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) 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)); + 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 // #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); Sanction s = Garde.traiter(p, verdicts);
if (Garde.moteur().coupsBloques(p.getUUID(), tick * 50L)) event.setCanceled(true); // portée / hitbox ENFORCE // portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé
if (s.ordinal() >= Sanction.SETBACK.ordinal()) { if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true);
event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts);
}
} }
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */ /** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
+15 -2
Voir le fichier
@@ -121,11 +121,20 @@ public final class Moteur {
ajouter(verdicts, s, Controle.HITBOX, PorteeHitbox.pointsHitbox(manque, seuil), nowMs, ex, ajouter(verdicts, s, Controle.HITBOX, PorteeHitbox.pointsHitbox(manque, seuil), nowMs, ex,
String.format(Locale.ROOT, "regard hors boite de %.2f (seuil %.2f)", manque, seuil)); String.format(Locale.ROOT, "regard hors boite de %.2f (seuil %.2f)", manque, seuil));
} }
boolean setback = false;
for (Verdict v : verdicts) { for (Verdict v : verdicts) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) { if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
s.coupsBloquesJusqua = nowMs + DUREE_BLOCAGE_COUPS_MS; s.coupsBloquesJusqua = nowMs + DUREE_BLOCAGE_COUPS_MS;
} }
// D2 (0.3.2) : un setback de combat (coups annulés) compte comme un setback (C5) et remet le VL de ce
// contrôle à zéro, comme pour le vol (C2). Avant, le VL montait à 20 en ~5 s : expulsion directe, sans
// la règle « 4 setbacks en 60 s ».
if (v.applicable() == Sanction.SETBACK) {
s.vl.remettreAZero(v.controle());
setback = true;
}
} }
if (setback) s.noterSetback(nowMs);
return verdicts; return verdicts;
} }
@@ -341,6 +350,7 @@ public final class Moteur {
// 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…). // 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…).
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons())); s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
s.vol.vider(); s.vol.vider();
s.dyChute = 0;
// C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore. // C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore.
if (ex.raisons().contains("elytres")) { if (ex.raisons().contains("elytres")) {
s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L; s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L;
@@ -349,9 +359,11 @@ public final class Moteur {
} }
List<Verdict> verdicts = new ArrayList<>(3); List<Verdict> verdicts = new ArrayList<>(3);
if (noFall) { if (noFall) {
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m), nowMs, ex, ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m, s.dyChute), nowMs, ex,
"au sol declare sans bloc dessous pendant une chute"); NoFall.sansDeplacement(m) ? "au sol declare sans bloc dessous pendant une chute (paquet d'etat)"
: "au sol declare sans bloc dessous pendant une chute");
} }
s.dyChute = NoFall.dyApres(m, s.dyChute);
if (vitesse) { if (vitesse) {
s.vitesse.moyenne = cfg.vitesseMoyenne; // C15, désactivé par défaut s.vitesse.moyenne = cfg.vitesseMoyenne; // C15, désactivé par défaut
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs); double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
@@ -446,6 +458,7 @@ public final class Moteur {
Suivi s = suivi(joueur); Suivi s = suivi(joueur);
s.vol.vider(); s.vol.vider();
s.vitesse.vider(); s.vitesse.vider();
s.dyChute = 0;
s.graceElytresJusquaMs = Long.MIN_VALUE; s.graceElytresJusquaMs = Long.MIN_VALUE;
s.vl.remettreAZero(Controle.VOL); s.vl.remettreAZero(Controle.VOL);
s.vl.remettreAZero(Controle.VITESSE); s.vl.remettreAZero(Controle.VITESSE);
+21 -1
Voir le fichier
@@ -48,7 +48,27 @@ public final class NoFall {
} }
public static double points(EtatMouvement e) { public static double points(EtatMouvement e) {
if (e.auSolClient() && !e.auSolServeur() && e.dy() <= DY_CHUTE && !e.milieuSpecial()) return 0.5; return points(e, 0);
}
/**
* D3 (0.3.2) : idem, mais un paquet sans déplacement (paquet d'état « au sol » ajouté par un NoFall, dy = 0) est
* jugé avec la vitesse verticale du dernier paquet qui a bougé ({@code dyPrecedent}).
*/
public static double points(EtatMouvement e, double dyPrecedent) {
double dy = sansDeplacement(e) ? dyPrecedent : e.dy();
if (e.auSolClient() && !e.auSolServeur() && dy <= DY_CHUTE && !e.milieuSpecial()) return 0.5;
return 0; return 0;
} }
/** Paquet qui ne change pas la position (paquet d'état ou de rotation seule). */
public static boolean sansDeplacement(EtatMouvement e) {
return e.dy() == 0 && e.dxz() == 0;
}
/** Vitesse verticale de chute à retenir après ce paquet : remise à zéro au sol ou en milieu spécial. */
public static double dyApres(EtatMouvement e, double dyPrecedent) {
if (e.auSolServeur() || e.milieuSpecial()) return 0;
return sansDeplacement(e) ? dyPrecedent : e.dy();
}
} }
+2
Voir le fichier
@@ -30,6 +30,8 @@ public final class Suivi {
long coupsBloquesJusqua = Long.MIN_VALUE; long coupsBloquesJusqua = Long.MIN_VALUE;
/** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */ /** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */
long graceElytresJusquaMs = Long.MIN_VALUE; long graceElytresJusquaMs = Long.MIN_VALUE;
/** D3 (0.3.2) : vitesse verticale du dernier paquet qui a bougé pendant une chute (0 au sol). */
double dyChute;
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */ /** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>(); private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
+1 -1
Voir le fichier
@@ -67,7 +67,7 @@ public abstract class MovePacketMixin {
@Inject(method = "teleport(DDDFFLjava/util/Set;)V", at = @At("HEAD")) @Inject(method = "teleport(DDDFFLjava/util/Set;)V", at = @At("HEAD"))
private void gastinelgarde$marqueTeleport(double x, double y, double z, float yaw, float pitch, private void gastinelgarde$marqueTeleport(double x, double y, double z, float yaw, float pitch,
java.util.Set<?> relatifs, CallbackInfo ci) { java.util.Set<?> relatifs, CallbackInfo ci) {
if (player != null) Garde.teleportVanilla(player); if (player != null) Garde.teleportVanilla(player, x, y, z, yaw, pitch, relatifs);
} }
// Les 3 teleport() de handleMovePlayer (lit, « moved too quickly », « moved wrongly ») : refus d'un paquet, // Les 3 teleport() de handleMovePlayer (lit, « moved too quickly », « moved wrongly ») : refus d'un paquet,
+1 -1
Voir le fichier
@@ -4,7 +4,7 @@ license="MIT"
[[mods]] [[mods]]
modId="gastinelgarde" modId="gastinelgarde"
version="0.3.0" version="0.3.2"
displayName="GastinelGarde" displayName="GastinelGarde"
authors="Théo Gastinel" 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.''' 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.'''
+336
Voir le fichier
@@ -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);
}
}
}
+324
Voir le fichier
@@ -0,0 +1,324 @@
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));
}
// --- D1 (0.3.2) : position de retour après une téléportation ---
@Test
void D1_setbackApresTpRameneAuPointDArriveePasAvantLaTeleportation() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
GraceTeleport grace = new GraceTeleport();
moteur.suivi(ID).memoriserPosition(0.5, -60.0, 31.0, 0f, 0f, MONDE); // au sol avant le /tp (rapport T3)
// /tp en l'air (origine externe, aucune annonce)
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 100.5, 80.0, 200.5, 45f, 0f, MONDE);
// vol stationnaire, setback avant tout contact au sol
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertTrue(p.actions.contains("teleport 100.5 80.0 200.5 45 0"), p.actions.toString());
// Le teleport du setback lui-même (et un refus vanilla) ne changent pas le retour.
grace.annoncer(GraceTeleport.Origine.SETBACK);
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 7, 7, 7, 0f, 0f, MONDE);
grace.annoncer(GraceTeleport.Origine.REFUS_VANILLA);
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 8, 8, 8, 0f, 0f, MONDE);
assertEquals(100.5, moteur.suivi(ID).x(), 1e-9);
assertEquals(80.0, moteur.suivi(ID).y(), 1e-9);
}
}
+54
Voir le fichier
@@ -260,4 +260,58 @@ class Garde1015Test {
init(); init();
triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.ENFORCE); triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.ENFORCE);
} }
// --- D2 (0.3.2) : expulsion de combat seulement après 4 setbacks en 60 s (C5) ---
@Test
void D2_hitboxEnforceExpulseApresQuatreSetbacksPasAuBoutDe5s() {
GardeConfig c = new GardeConfig();
c.mode(Controle.HITBOX, Mode.ENFORCE);
Moteur m = new Moteur(c);
UUID j = UUID.randomUUID();
int setbacks = 0;
long expulsionMs = -1;
// Rapport T2 : regard décalé de 30° (manque 0,72 bloc), un coup toutes les 600 ms.
for (int i = 0; i < 200 && expulsionMs < 0; i++) {
long t = i * 600L;
Sanction s = Verdict.pire(m.porteeHitbox(j, t, EtatJoueur.normal(), 2.5, 0.72, 3.0, 0.0));
if (s == Sanction.SETBACK) setbacks++;
if (s == Sanction.EXPULSION) expulsionMs = t;
}
assertEquals(c.setbacksAvantExpulsion, setbacks, "4 setbacks avant l'expulsion");
assertTrue(expulsionMs > 5000, "expulsion trop tôt : " + expulsionMs + " ms");
assertTrue(expulsionMs <= c.fenetreSetbacksMs, "expulsion dans la fenêtre C5 : " + expulsionMs + " ms");
}
// --- D3 (0.3.2) : NoFall par paquet d'état ---
@Test
void D3_noFallVoitLePaquetDEtatAuSolPendantUneChute() {
GardeConfig c = new GardeConfig();
c.mode(Controle.NO_FALL, Mode.OBSERVE);
c.mode(Controle.VOL, Mode.OFF);
c.mode(Controle.VITESSE, Mode.OFF);
Moteur m = new Moteur(c);
UUID j = UUID.randomUUID();
int lignes = 0;
// Rapport T5 : à chaque tick de chute, un paquet de position (en l'air) puis un paquet d'état « au sol ».
double[] dys = {-0.08, -0.16, -0.23, -0.30, -0.38, -0.45, -0.52, -0.58};
for (int i = 0; i < dys.length; i++) {
long t = i * 50L;
lignes += m.mouvement(j, t, EtatJoueur.normal(), new EtatMouvement(0, dys[i], 1, false, false,
false, false, false, 0, 0, false, false)).size();
lignes += m.mouvement(j, t, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, false,
false, false, false, 0, 0, false, false)).size();
}
assertTrue(lignes >= 4, "paquets d'état au sol pendant la chute rapide : " + lignes);
// Honnête : posé au sol, puis paquets d'état « au sol » immobiles (bloc dessous) ; et saut au sommet.
Moteur h = new Moteur(c);
assertTrue(h.mouvement(j, 0, EtatJoueur.normal(), new EtatMouvement(0, -0.5, 1, true, true,
false, false, false, 0, 0, false, false)).isEmpty());
assertTrue(h.mouvement(j, 50, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, true,
false, false, false, 0, 0, false, false)).isEmpty());
assertTrue(h.mouvement(j, 100, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, false,
false, false, false, 0, 0, false, false)).isEmpty(), "après le sol, la chute est oubliée");
}
} }