Comparer les révisions

..
Auteur SHA1 Message Date

2026-10-25

gastineltetClaude Opus 5.5 c2a0d5403d 0.6.1-dev : correctifs revue M1-M4 (setback unique par tick, VL de la cause remis a zero, blocs fantomes, exemption nuker configurable)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 21:59:10 +01:00
gastineltetClaude Opus 5.5 67ddfff41a Version 0.6.0-dev
Build : 571 tests, 0 echec (525 + 46 nouveaux). Rien teste en jeu.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:10:10 +02:00
gastineltetClaude Opus 5.5 fad2bf0437 P3.5 phase (OBSERVE par defaut) : tests + test des reglages 0.6
- Vanilla refuse deja le passage dans un bloc : le controle compte les
  positions refusees dont la boite declaree chevauche un bloc solide alors
  que la derniere position acceptee est libre (5 en 10 s).
- Tests : PhaseP06Test (8), Reglages06Test (cles 0.6 = champs GardeConfig,
  memes defauts).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:08:52 +02:00
gastineltetClaude Opus 5.5 544f11dfa5 P3.4 blink (OBSERVE par defaut) : tests
- Trou >= 30 ticks entre deux mouvements pendant lequel d'autres paquets
  (coups, clics, conteneurs, completion) arrivent a >= 2 ticks distincts,
  plus de 21 ticks apres le dernier mouvement (TCP garde l'ordre : un
  vrai lag retient tout). Un blink qui retient tout n'est pas vu.
- Tests : BlinkP06Test (9) : immobile qui clique, vrai lag, gel client,
  blink, exemptions (teleport, connexion, vehicule, gel, TPS, mort).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:08:51 +02:00
gastineltetClaude Opus 5.5 ad436ac213 P3.2 scaffold horizontal (OBSERVE par defaut) : tests
- Pose de pont sous les pieds (Scaffold.estPont) jugee au paquet de
  mouvement suivant : hors-regard (> 50 deg de l'arc de rotation entre
  deux paquets) ou snap (aller-retour > 70 deg autour de la pose).
  4 anomalies sur 10 poses en 30 s ; en ENFORCE, poses de pont annulees
  pendant 2 s apres une anomalie au palier SETBACK.
- Tests : ScaffoldP06Test (10) : pont en reculant, retournement isole,
  sans rotation, rotation silencieuse, exemptions, ENFORCE.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:08:24 +02:00
gastineltetClaude Opus 5.5 a88e4409e4 P2.6 inventaire (OBSERVE par defaut) + socle 0.6 des controles scaffold, blink, phase
- Nouveau controle inventaire (mixin ContainerClickMixin apres
  ensureRunningOnSameThread, PlayerContainerEvent.Open/Close) :
  vol-de-coffre (reaction apres ouverture ping retire plafonne, prises
  d'objets differents a <= 1,5 tick en moyenne, double-clic shift exclu),
  regard-conteneur (rotation avec conteneur ouvert apres grace + ping :
  contre le stealer "silencieux" et l'InventoryMove), clic-en-rotation
  (InvCleaner / AutoArmor), clics sur conteneur ferme (journal seulement).
- Seuils de VL propres par controle (Paliers), sections de configuration
  [inventaire], [scaffold], [blink], [phase].
- Ce commit contient deja le cablage (Garde, Moteur, mixins) des trois
  autres controles 0.6 (fichiers partages) ; leurs tests suivent dans
  les commits suivants.
- Tests : InventaireP06Test (18), MixinsThreadTest etendu.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:05:53 +02:00
26 fichiers modifiés avec 1775 ajouts et 10 suppressions

Aucun fichier ne correspond à votre recherche

+11
Voir le fichier
@@ -1,5 +1,16 @@
# Journal des versions
## 0.6.0-dev (non publiée, branche feat/garde-0.6, dérivée de feat/garde-0.5)
Testé hors jeu seulement (JUnit) ; rien n'a été essayé sur un serveur Minecraft. Quatre nouveaux contrôles, tous en
OBSERVE par défaut, chacun avec sa section et ses seuils de VL propres (`[inventaire]`, `[scaffold]`, `[blink]`, `[phase]`) :
- `inventaire` : ChestStealer (réaction après l'ouverture, prises rapides d'objets différents), rotation avec un conteneur
ouvert (stealer silencieux, InventoryMove), clic sur l'inventaire pendant que la tête tourne (InvCleaner / AutoArmor).
Nouveau mixin `ContainerClickMixin` (après ensureRunningOnSameThread).
- `scaffold` : pont posé sous les pieds hors du regard, ou avec une rotation aller-retour (snap) autour de la pose.
- `blink` : trou de paquets de mouvement pendant que d'autres paquets arrivent.
- `phase` : positions refusées par vanilla dont la boîte est dans un bloc solide, en série (vanilla bloque déjà le passage).
## 0.4.0 (non publiée, branche feat/suspicion-score, dérivée de release/0.3.1 = jar déployé)
Testé hors jeu seulement (JUnit) ; rien n'a été essayé sur un serveur Minecraft. Aucun mode existant n'est modifié.
+1 -1
Voir le fichier
@@ -1,7 +1,7 @@
org.gradle.jvmargs=-Xmx2G
org.gradle.parallel=true
mod_version=0.5.0
mod_version=0.6.1-dev
mod_group_id=com.gastinelgarde
mod_id=gastinelgarde
+8 -2
Voir le fichier
@@ -225,19 +225,25 @@ final class Cablage {
p.journal(p.nom() + " EXPULSE (" + motif + ")");
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
} else if (s == Sanction.SETBACK) {
if (moteur.setbackDejaApplique(p.id(), p.tick() * 50L)) {
// 0.6.1 (revue M1) : même paquet, second contrôle : pas de second retour ni de second compte.
moteur.apresSetbackDuMemeTick(p.id(), verdicts);
p.journal(p.nom() + " SETBACK deja applique ce tick (" + motif + ") : ni second retour ni second compte");
return;
}
Suivi sv = moteur.suivi(p.id());
double[] sol;
if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) {
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
p.teleporter(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
moteur.apresSetback(p.id(), p.tick() * 50L);
moteur.apresSetback(p.id(), p.tick() * 50L, verdicts);
p.journal(p.nom() + " SETBACK (" + motif + ")");
} else if (!sv.aPositionValide() && moteur.config().setbackSolSiPasDePosition && (sol = p.solSous()) != null) {
// 0.5 (P1.2) : reconnexion en l'air (aucune position au sol connue) : retour au sol sous le joueur.
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
p.teleporter(sol[0], sol[1], sol[2], (float) sol[3], (float) sol[4]);
moteur.apresSetback(p.id(), p.tick() * 50L);
moteur.apresSetback(p.id(), p.tick() * 50L, verdicts);
p.journal(String.format(java.util.Locale.ROOT, "%s SETBACK au sol (%s) : pas de position de retour, y=%.2f",
p.nom(), motif, sol[1]));
} else {
+156 -2
Voir le fichier
@@ -92,6 +92,8 @@ public final class Garde {
// #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux)
double[] oeilDernier;
double[] oeilAvant;
// 0.6 (scaffold) : rotation des deux derniers paquets de mouvement acceptés
float yawDernier = Float.NaN, pitchDernier, yawAvant = Float.NaN, pitchAvant;
}
/** #92 : historique des boîtes d'une entité suivie (joueurs, et entités frappées récemment). */
@@ -415,6 +417,8 @@ public final class Garde {
* ligne de journal pour un ABORT sans START correspondant (message vanilla « Mismatch in destroy block pos »).
*/
public static void noterActionBloc(ServerPlayer p, boolean start, boolean abort, BlockPos pos, boolean annule) {
// 0.6.1 (revue M2) : bloc visé par un paquet de casse (pour nukerIgnorerCassesSansPaquet).
if (surThreadServeur(p)) MOTEUR.paquetCasse(p.getUUID(), pos.asLong(), p.server.getTickCount() * 50L);
if (!CONFIG.diagnosticActionsBloc || !surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
com.gastinelgarde.core.ActionsBloc a = MOTEUR.suivi(p.getUUID()).actionsBloc;
if (start) {
@@ -424,6 +428,22 @@ public final class Garde {
if (ligne != null) ecrireJournal("DIAGNOSTIC " + p.getGameProfile().getName() + " casse de bloc : " + ligne);
}
}
/**
* 0.6.1 (revue M3) : un bloc change (casse ou pose) : noté pour chaque joueur à moins de 16 blocs, dont l'auteur, car
* le client d'un voisin peut encore voir l'ancien bloc (lag) et cliquer dessus.
*/
private static void changementProche(ServerPlayer auteur, BlockPos pos) {
long cle = pos.asLong();
long ms = auteur.server.getTickCount() * 50L;
MOTEUR.changementBloc(auteur.getUUID(), cle, ms);
if (!(auteur.level() instanceof net.minecraft.server.level.ServerLevel niveau)) return;
for (ServerPlayer autre : niveau.players()) {
if (autre != auteur && autre.distanceToSqr(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5) <= 256) {
MOTEUR.changementBloc(autre.getUUID(), cle, ms);
}
}
}
/** 0.5 (P2.3) : START de casse accepté : début de la mesure fast-break. */
public static void noterDebutCasse(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face) {
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
@@ -444,10 +464,117 @@ public final class Garde {
// 0.5 (P3, revue) : joueur en cours d'expulsion : interaction annulée (comme les coups, C4). Avant, le doublon
// main secondaire d'un clic qui venait d'expulser se lisait « autorisé ».
if (MOTEUR.estExpulse(p.getUUID())) return true;
autrePaquet(p); // 0.6 (blink)
List<Verdict> v = verdictsInteraction(p, pos, face, impact, mainPrincipale ? 0 : 1);
Sanction s = traiter(p, v);
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
return Cablage.sanctionDeMouvement(s);
// 0.6.1 (revue M3) : case où ce clic pose un bloc ; si la pose est refusée, le client garde un bloc fantôme.
if (face != null) MOTEUR.changementBloc(p.getUUID(), pos.relative(face).asLong(), p.server.getTickCount() * 50L);
boolean annulerScaffold = poseScaffold(p, pos, face, impact, mainPrincipale);
return Cablage.sanctionDeMouvement(s) || annulerScaffold;
}
/**
* 0.6 (P3.2) : clic droit avec un bloc en main qui posera un bloc de pont sous les pieds. La pose est jugée au paquet
* de mouvement suivant ; vrai si elle doit être annulée (scaffold en ENFORCE, période suspecte). Non testé en jeu.
*/
private static boolean poseScaffold(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
net.minecraft.world.phys.Vec3 impact, boolean mainPrincipale) {
if (CONFIG.mode(Controle.SCAFFOLD) == Mode.OFF || impact == null || face == null
|| estExempteManuellement(p.getUUID())) return false;
net.minecraft.world.InteractionHand main = mainPrincipale ? net.minecraft.world.InteractionHand.MAIN_HAND
: net.minecraft.world.InteractionHand.OFF_HAND;
if (!(p.getItemInHand(main).getItem() instanceof net.minecraft.world.item.BlockItem)) return false;
if (!mainPrincipale && p.getMainHandItem().getItem() instanceof net.minecraft.world.item.BlockItem) return false;
BlockPos cible = p.level().getBlockState(pos).canBeReplaced() ? pos : pos.relative(face);
Marques m = marques(p.getUUID());
if (m.oeilDernier == null || m.oeilAvant == null || Float.isNaN(m.yawAvant)) return false;
double dx = m.oeilDernier[0] - m.oeilAvant[0], dz = m.oeilDernier[2] - m.oeilAvant[2];
double dy = m.oeilDernier[1] - m.oeilAvant[1];
if (!com.gastinelgarde.core.Scaffold.estPont(cible.getX(), cible.getY(), cible.getZ(), p.getX(), p.getY(), p.getZ(),
dy, Math.sqrt(dx * dx + dz * dz))) return false;
int tick = p.server.getTickCount();
boolean annuler = MOTEUR.scaffoldAnnuler(p.getUUID(), tick * 50L, tick);
net.minecraft.world.phys.Vec3 oeil = p.getEyePosition();
float[] dir = com.gastinelgarde.core.Scaffold.rotation(impact.x - oeil.x, impact.y - oeil.y, impact.z - oeil.z);
MOTEUR.poseScaffold(p.getUUID(), etat(p, true), dir[0], dir[1], m.yawAvant, m.pitchAvant, p.getYRot(), p.getXRot());
return annuler;
}
/** 0.6 (P3.4) : un paquet autre que de mouvement vient d'être traité sur le thread serveur (blink). */
public static void autrePaquet(ServerPlayer p) {
if (!surThreadServeur(p) || CONFIG.mode(Controle.BLINK) == Mode.OFF) return;
MOTEUR.autrePaquet(p.getUUID(), p.server.getTickCount());
}
/** 0.6 (P2.6) : le serveur ouvre (vrai) ou ferme un conteneur pour ce joueur (PlayerContainerEvent). */
public static void noterConteneur(ServerPlayer p, boolean ouvert) {
if (!surThreadServeur(p)) return;
if (ouvert) MOTEUR.ouvrirConteneur(p.getUUID(), p.server.getTickCount());
else MOTEUR.fermerConteneur(p.getUUID());
}
/**
* 0.6 (P2.6) : clic de conteneur (mixin, après ensureRunningOnSameThread). Vrai si le clic doit être ignoré
* (inventaire en ENFORCE au palier SETBACK, ou expulsion en cours) ; le menu est alors renvoyé au client.
*/
public static boolean noterClicConteneur(ServerPlayer p, int idConteneur, int numCase,
net.minecraft.world.inventory.ClickType type) {
if (!surThreadServeur(p)) return false;
if (MOTEUR.estExpulse(p.getUUID())) return true;
autrePaquet(p);
if (CONFIG.mode(Controle.INVENTAIRE) == Mode.OFF || estExempteManuellement(p.getUUID())) return false;
net.minecraft.world.inventory.AbstractContainerMenu menu = p.containerMenu;
boolean idValide = idConteneur == menu.containerId;
boolean menuConteneur = menu != p.inventoryMenu;
boolean caseConteneur = false;
int objet = 0;
if (idValide && numCase >= 0 && numCase < menu.slots.size()) {
net.minecraft.world.inventory.Slot c = menu.getSlot(numCase);
caseConteneur = !(c.container instanceof net.minecraft.world.entity.player.Inventory);
net.minecraft.world.item.ItemStack st = c.getItem();
if (!st.isEmpty()) objet = net.minecraft.core.registries.BuiltInRegistries.ITEM.getId(st.getItem()) + 1;
}
com.gastinelgarde.core.Inventaire.Clic clic = switch (type) {
case QUICK_MOVE, SWAP -> com.gastinelgarde.core.Inventaire.Clic.PRISE;
case THROW -> menuConteneur ? com.gastinelgarde.core.Inventaire.Clic.AUTRE : com.gastinelgarde.core.Inventaire.Clic.PRISE;
default -> com.gastinelgarde.core.Inventaire.Clic.AUTRE;
};
int tick = p.server.getTickCount();
List<Verdict> v = MOTEUR.clicConteneur(p.getUUID(), tick * 50L, tick, etat(p, false), idValide, menuConteneur,
clic, caseConteneur, objet);
Sanction s = traiter(p, v);
if (s == Sanction.EXPULSION) {
appliquerSanctionMouvement(p, s, v);
return true;
}
if (Cablage.sanctionDeMouvement(s)) {
menu.sendAllDataToRemote(); // le client a prédit le clic : on lui renvoie l'état réel
return true;
}
return false;
}
/**
* 0.6 (P3.5) : paquet de mouvement refusé par vanilla (mixin, juste avant le teleport() de refus). La boîte déclarée
* chevauche-t-elle un bloc solide, alors que celle de la dernière position acceptée est libre ? Non testé en jeu.
*/
public static void refusMouvement(ServerPlayer p, double x, double y, double z) {
if (!surThreadServeur(p) || CONFIG.mode(Controle.PHASE) == Mode.OFF || MOTEUR.estExpulse(p.getUUID())
|| estExempteManuellement(p.getUUID()) || p.isSleeping() || p.isPassenger()) return;
Marques m = marques(p.getUUID());
if (m.mouvementTick == Integer.MIN_VALUE || !Double.isFinite(x + y + z)) return;
double dist = Math.sqrt(Math.pow(x - m.mouvementX, 2) + Math.pow(y - m.mouvementY, 2) + Math.pow(z - m.mouvementZ, 2));
if (dist > 16) return; // lecture de blocs bornée (chunks peut-être non chargés) ; vanilla refuse déjà ce saut
net.minecraft.world.entity.EntityDimensions d = p.getDimensions(p.getPose());
net.minecraft.world.phys.AABB avant = d.makeBoundingBox(m.mouvementX, m.mouvementY, m.mouvementZ).deflate(1.0E-3);
net.minecraft.world.phys.AABB declaree = d.makeBoundingBox(x, y, z).deflate(1.0E-3);
// Déjà coincé dans un bloc (sable tombé, piston) : pas une tentative de phase.
boolean dansBloc = p.level().noCollision(p, avant) && !p.level().noCollision(p, declaree);
int tick = p.server.getTickCount();
List<Verdict> v = MOTEUR.refusPhase(p.getUUID(), tick * 50L, etat(p, true), dansBloc, dist);
Sanction s = traiter(p, v); // vanilla a déjà refusé la position : journal, VL et expulsion seulement
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
}
private static List<Verdict> verdictsInteraction(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
@@ -476,6 +603,7 @@ public final class Garde {
*/
public static boolean noterCasse(ServerPlayer p, BlockPos pos, BlockState state) {
if (!surThreadServeur(p)) return false;
changementProche(p, pos); // 0.6.1 (revue M3) : avant tout retour, pour tous les joueurs proches
if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, casse annulée (C4)
if (estExempteManuellement(p.getUUID())) return false;
int tick = p.server.getTickCount();
@@ -484,7 +612,8 @@ public final class Garde {
traiter(p, MOTEUR.casseXray(p.getUUID(), tick * 50L, etat(p, false), pos.getY(), rare, rare && expose(p, pos)));
}
boolean annulerNuker = false;
if (CONFIG.mode(Controle.NUKER) != Mode.OFF) { // 0.5 (P3.3)
if (CONFIG.mode(Controle.NUKER) != Mode.OFF // 0.5 (P3.3) ; 0.6.1 (M2) : casse en chaîne d'un mod ignorée si réglé
&& !MOTEUR.casseNukerSansPaquet(p.getUUID(), pos.asLong(), tick * 50L)) {
List<Verdict> vn = MOTEUR.casseNuker(p.getUUID(), tick * 50L, tick, etat(p, true));
Sanction sn = traiter(p, vn);
if (sn == Sanction.EXPULSION) {
@@ -508,6 +637,7 @@ public final class Garde {
*/
public static boolean noterCompletion(ServerPlayer p) {
if (!surThreadServeur(p)) return false;
autrePaquet(p); // 0.6 (blink)
if (CONFIG.mode(Controle.COMPLETION) == Mode.OFF) return false;
if (MOTEUR.estExpulse(p.getUUID())) return true;
List<Verdict> v = MOTEUR.completion(p.getUUID(), System.currentTimeMillis(), etat(p, false));
@@ -539,6 +669,7 @@ public final class Garde {
/** 0.5 (P2.4) : bloc posé par ce joueur. Vrai si la pose doit être annulée (ENFORCE, palier SETBACK ou plus). */
public static boolean noterPose(ServerPlayer p, BlockPos pos) {
if (!surThreadServeur(p)) return false;
changementProche(p, pos); // 0.6.1 (revue M3)
if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, pose annulée (C4)
if (estExempteManuellement(p.getUUID())) return false;
int tick = p.server.getTickCount();
@@ -840,6 +971,12 @@ public final class Garde {
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
Sanction s = traiter(p, v);
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
if (CONFIG.mode(Controle.BLINK) != Mode.OFF) { // 0.6 (P3.4)
int tick = p.server.getTickCount();
List<Verdict> vb = MOTEUR.mouvementBlink(p.getUUID(), tick * 50L, tick, etat, p.isAlive());
Sanction sb = traiter(p, vb);
if (Cablage.sanctionDeMouvement(sb)) appliquerSanctionMouvement(p, sb, vb);
}
}
/** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */
@@ -887,6 +1024,23 @@ public final class Garde {
// #92 : œil des deux derniers paquets, pour le prochain coup.
m.oeilAvant = m.oeilDernier;
m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z};
// 0.6 : inventaire (rotation avec un conteneur ouvert) et scaffold (pose de pont jugée sur ce regard).
if (CONFIG.mode(Controle.INVENTAIRE) != Mode.OFF) {
if (p.containerMenu == p.inventoryMenu) MOTEUR.fermerConteneur(p.getUUID());
List<Verdict> vi = MOTEUR.regardInventaire(p.getUUID(), tick * 50L, tick, etat(p, false),
p.getYRot(), p.getXRot());
Sanction si = traiter(p, vi);
if (si == Sanction.EXPULSION) appliquerSanctionMouvement(p, si, vi);
}
if (CONFIG.mode(Controle.SCAFFOLD) != Mode.OFF) {
List<Verdict> vs = MOTEUR.regardScaffold(p.getUUID(), tick * 50L, tick, p.getYRot(), p.getXRot());
Sanction ss = traiter(p, vs); // pose déjà faite : les suivantes sont annulées (scaffoldAnnuler)
if (ss == Sanction.EXPULSION) appliquerSanctionMouvement(p, ss, vs);
}
m.yawAvant = m.yawDernier;
m.pitchAvant = m.pitchDernier;
m.yawDernier = p.getYRot();
m.pitchDernier = p.getXRot();
}
// 0.4.0 : recul mesuré (anti-recul) et totem remis en main (auto-totem), sur les mêmes paquets.
if (!estExempteManuellement(p.getUUID()) && (CONFIG.mode(Controle.VELOCITE) != Mode.OFF
+13
Voir le fichier
@@ -57,6 +57,7 @@ public final class GardeEvents {
@SubscribeEvent
public static void onAttaque(AttackEntityEvent event) {
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
Garde.autrePaquet(p); // 0.6 (blink) : un coup est un paquet traité sur le thread serveur
switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) {
case ANNULER -> { // C4 : expulsion en cours
event.setCanceled(true);
@@ -135,6 +136,7 @@ public final class GardeEvents {
if (event.getLevel().isClientSide()) return;
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
var a = event.getAction();
Garde.autrePaquet(p); // 0.6 (blink)
// 0.5 (P2.3) : début de la mesure fast-break (START accepté par les autres mods).
if (a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START && !event.isCanceled()) {
Garde.noterDebutCasse(p, event.getPos(), event.getFace());
@@ -239,6 +241,17 @@ public final class GardeEvents {
}
}
/** 0.6 (P2.6) : conteneur ouvert / fermé côté serveur (inventaire : réaction, rotation écran ouvert). */
@SubscribeEvent
public static void onOuvertureConteneur(net.neoforged.neoforge.event.entity.player.PlayerContainerEvent.Open event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterConteneur(p, true);
}
@SubscribeEvent
public static void onFermetureConteneur(net.neoforged.neoforge.event.entity.player.PlayerContainerEvent.Close event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterConteneur(p, false);
}
@SubscribeEvent
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
if (event.getEntity() instanceof ServerPlayer p) {
+69
Voir le fichier
@@ -36,10 +36,14 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue FAST_BREAK_TICKS_MIN, FAST_BREAK_SERIE;
private static final ModConfigSpec.IntValue FAST_PLACE_SERIE, FAST_PLACE_INTERVALLE;
private static final ModConfigSpec.DoubleValue FAST_PLACE_REGULARITE, INTER_MARGE;
private static final ModConfigSpec.IntValue INTER_GRACE;
private static final ModConfigSpec.BooleanValue NUKER_SANS_PAQUET;
private static final ModConfigSpec.IntValue INTER_SERIE, TOTEM_ECHANT, TOTEM_ECART, TOTEM_REG_MAX;
// 0.5 (P3)
private static final ModConfigSpec.IntValue NUKER_MAX, NUKER_SERIE, CRISTAL_DELAI, CRISTAL_SERIE, TOWER_INTERVALLE, TOWER_SERIE,
COMPLETION_PAR_S, COMPLETION_RAFALE;
/** 0.6 : réglages des sections [inventaire], [scaffold], [blink], [phase] ; clé = nom du champ de GardeConfig. */
private static final java.util.Map<String, ModConfigSpec.ConfigValue<?>> V06 = new java.util.LinkedHashMap<>();
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
private static final ModConfigSpec.IntValue CIBLES_MAX;
@@ -320,6 +324,9 @@ public final class GardeSpec {
.defineInRange("autoTotemRegulierMaxMs", 300, 50, 2000);
INTER_SERIE = b.comment("Interaction-bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter.")
.defineInRange("interactionBlocSerieMin", 3, 1, 10);
INTER_GRACE = b.comment("0.6.1 (revue M3) interaction-bloc : un clic sur un bloc devenu de l'air depuis moins de ce délai (ms)",
"(casse, pose ou pose refusée : bloc fantôme côté client) ne compte pas comme « bloc-vide ».")
.defineInRange("interactionBlocGraceChangementMs", 500, 0, 5000);
b.pop();
b.comment("0.5 (P3) : contrôles lourds. Nouveaux contrôles en OBSERVE par défaut, valeurs prudentes.").push("p3");
@@ -329,6 +336,10 @@ public final class GardeSpec {
.defineInRange("nukerBlocsParTickMax", 3, 1, 64);
NUKER_SERIE = b.comment("Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter.")
.defineInRange("nukerSerieMin", 3, 1, 20);
NUKER_SANS_PAQUET = b.comment("0.6.1 (revue M2) nuker : true = ne compter que les casses visées par un paquet de casse du joueur",
"dans le même tick (ignore les blocs cassés en chaîne par un mod d'abattage d'arbres ou de minage de filon).",
"false par défaut (aucun mod de ce genre sur le serveur). Un nuker de client triche envoie un paquet par bloc : il reste vu.")
.define("nukerIgnorerCassesSansPaquet", false);
CRISTAL_DELAI = b.comment("0.5 (P3.1) auto-cristal : âge (ticks serveur) d'un cristal de l'End frappé sous lequel le coup est suspect.",
"2 = frappé dans le tick de sa pose ou le suivant. Cristaux d'âge inconnu (rechargés, posés avant) non mesurés.",
"Risque de faux positif élevé (PvP cristal rapide, paquets groupés) : longue observation avant tout ENFORCE.")
@@ -347,6 +358,51 @@ public final class GardeSpec {
.defineInRange("completionRafaleMax", 40, 5, 1000);
b.pop();
// 0.6 : une section par contrôle, avec ses propres seuils de VL (<= 0 : seuils globaux de [sanctions]).
b.comment("0.6 (P2.6) inventaire : ChestStealer, InventoryMove, InvCleaner / AutoArmor. OBSERVE par défaut.",
"Les mods d'inventaire côté client (Mouse Tweaks, Inventory Profiles) font des rafales de shift-clics : à observer avant ENFORCE.").push("inventaire");
V06.put("inventaireReactionMinMs", b.comment("Réaction minimale (ms, ping retiré) entre l'ouverture d'un conteneur et la première prise.")
.defineInRange("inventaireReactionMinMs", 100, 0, 1000));
V06.put("inventaireIntervalleMaxTicks", b.comment("Intervalle moyen (ticks) entre deux prises d'objets différents au-delà duquel la session n'est pas suspecte.")
.defineInRange("inventaireIntervalleMaxTicks", 1.5, 0.0, 20.0));
V06.put("inventairePrisesMin", b.comment("Prises d'objets différents dans la session avant de juger.")
.defineInRange("inventairePrisesMin", 4, 2, 54));
V06.put("inventairePingMaxMs", b.comment("Ping (ms) au plus retiré de la réaction (le ping est falsifiable).")
.defineInRange("inventairePingMaxMs", 300, 0, 2000));
V06.put("inventaireGraceRotationTicks", b.comment("Grâce (ticks) après l'ouverture avant de compter les rotations (plus ping / 50).")
.defineInRange("inventaireGraceRotationTicks", 10, 0, 200));
V06.put("inventaireRotationsMin", b.comment("Rotations avec un conteneur ouvert (une ouverture) avant que chacune compte.")
.defineInRange("inventaireRotationsMin", 3, 1, 100));
V06.put("inventaireSeuilSetback", b.defineInRange("inventaireSeuilSetback", 10.0, 0.0, 1000.0));
V06.put("inventaireSeuilExpulsion", b.defineInRange("inventaireSeuilExpulsion", 30.0, 0.0, 1000.0));
b.pop();
b.comment("0.6 (P3.2) scaffold horizontal : pont posé sous les pieds hors du regard ou avec des rotations aller-retour (snap). OBSERVE par défaut.").push("scaffold");
V06.put("scaffoldAngleMaxDeg", b.comment("Écart (degrés) entre le regard et le point cliqué au-delà duquel la pose est hors regard.")
.defineInRange("scaffoldAngleMaxDeg", 50.0, 10.0, 180.0));
V06.put("scaffoldSnapDeg", b.comment("Rotation (degrés) aller puis retour autour d'une pose au-delà de laquelle c'est un snap.")
.defineInRange("scaffoldSnapDeg", 70.0, 20.0, 180.0));
V06.put("scaffoldSerieMin", b.comment("Poses anormales parmi les 10 dernières poses de pont (30 s) avant de compter.")
.defineInRange("scaffoldSerieMin", 4, 1, 10));
V06.put("scaffoldSeuilSetback", b.defineInRange("scaffoldSeuilSetback", 10.0, 0.0, 1000.0));
V06.put("scaffoldSeuilExpulsion", b.defineInRange("scaffoldSeuilExpulsion", 30.0, 0.0, 1000.0));
b.pop();
b.comment("0.6 (P3.4) blink : trou de paquets de mouvement pendant que d'autres paquets arrivent. OBSERVE par défaut.",
"Un blink qui retient tous les paquets ressemble à un vrai lag : il n'est pas détecté ici.").push("blink");
V06.put("blinkTrouMinTicks", b.comment("Trou (ticks) sans mouvement à partir duquel il est mesuré (vanilla : un paquet au moins toutes les 20).")
.defineInRange("blinkTrouMinTicks", 30, 22, 600));
V06.put("blinkAutresMin", b.comment("Autres paquets (ticks distincts) reçus pendant le trou avant de le juger.")
.defineInRange("blinkAutresMin", 2, 1, 100));
V06.put("blinkSeuilSetback", b.defineInRange("blinkSeuilSetback", 10.0, 0.0, 1000.0));
V06.put("blinkSeuilExpulsion", b.defineInRange("blinkSeuilExpulsion", 30.0, 0.0, 1000.0));
b.pop();
b.comment("0.6 (P3.5) phase : positions refusées par vanilla dont la boîte est dans un bloc solide (tentatives de NoClip / VClip).",
"Vanilla refuse déjà le passage ; ce contrôle compte les tentatives. OBSERVE par défaut.").push("phase");
V06.put("phaseSerieMin", b.comment("Refus dans un bloc en 10 s avant que chacun compte.")
.defineInRange("phaseSerieMin", 5, 1, 32));
V06.put("phaseSeuilSetback", b.defineInRange("phaseSeuilSetback", 10.0, 0.0, 1000.0));
V06.put("phaseSeuilExpulsion", b.defineInRange("phaseSeuilExpulsion", 30.0, 0.0, 1000.0));
b.pop();
b.comment("0.5 (P2.10) x-ray statistique : alerte seulement, jamais de setback ni d'expulsion (même en ENFORCE).").push("xray");
XRAY_PCT = b.comment("Part (%) de minerais rares (diamant, débris antiques) parmi les blocs cassés en profondeur au-delà de laquelle on alerte.")
.defineInRange("xrayAlerteDiamantsParCent", 5.0, 0.5, 100.0);
@@ -545,17 +601,30 @@ public final class GardeSpec {
c.fastPlaceIntervalleMaxTicks = FAST_PLACE_INTERVALLE.get();
c.interactionBlocMarge = INTER_MARGE.get();
c.interactionBlocSerieMin = INTER_SERIE.get();
c.interactionBlocGraceChangementMs = INTER_GRACE.get();
c.autoTotemEchantillons = TOTEM_ECHANT.get();
c.autoTotemEcartTypeMinMs = TOTEM_ECART.get();
c.autoTotemRegulierMaxMs = TOTEM_REG_MAX.get();
c.nukerBlocsParTickMax = NUKER_MAX.get();
c.nukerSerieMin = NUKER_SERIE.get();
c.nukerIgnorerCassesSansPaquet = NUKER_SANS_PAQUET.get();
c.cristalDelaiMinTicks = CRISTAL_DELAI.get();
c.cristalSerieMin = CRISTAL_SERIE.get();
c.towerIntervalleMinTicks = TOWER_INTERVALLE.get();
c.towerSerie = TOWER_SERIE.get();
c.completionParSecondeMax = COMPLETION_PAR_S.get();
c.completionRafaleMax = COMPLETION_RAFALE.get();
// 0.6 : champs du même nom dans GardeConfig (vérifié par Reglages06Test).
for (java.util.Map.Entry<String, ModConfigSpec.ConfigValue<?>> e : V06.entrySet()) {
try {
java.lang.reflect.Field f = GardeConfig.class.getField(e.getKey());
Object val = e.getValue().get();
if (f.getType() == int.class) f.setInt(c, ((Number) val).intValue());
else f.setDouble(c, ((Number) val).doubleValue());
} catch (ReflectiveOperationException ex) {
throw new IllegalStateException("reglage 0.6 sans champ : " + e.getKey(), ex);
}
}
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
c.setbackSolSiPasDePosition = SETBACK_SOL.get();
c.graceReculTicks = GRACE_RECUL.get();
+66
Voir le fichier
@@ -0,0 +1,66 @@
package com.gastinelgarde.core;
/**
* 0.6 (P3.4) : Blink / FakeLag. Le client vanilla envoie un paquet de position au moins toutes les 20 ticks, même
* immobile ({@code positionReminder}, LocalPlayer). TCP garde l'ordre des paquets : pendant un vrai lag, <i>tous</i>
* les paquets attendent, puis arrivent ensemble dans l'ordre (mouvements et clics mêlés). Le Blink retient seulement
* les paquets de mouvement et laisse passer le reste (coups, clics, interactions) : le serveur reçoit alors d'autres
* paquets alors qu'aucun mouvement n'est arrivé depuis plus de 20 ticks.
*
* Signal : un trou d'au moins {@link GardeConfig#blinkTrouMinTicks} (30) ticks entre deux paquets de mouvement, pendant
* lequel d'autres paquets traités sur le thread serveur sont arrivés à au moins {@link GardeConfig#blinkAutresMin} (2)
* ticks distincts, chacun plus de 21 ticks après le dernier mouvement. Un gel du client (un seul tick de rattrapage :
* clic puis mouvement dans la même rafale) ne fait qu'un seul tick. Un Blink qui retient <b>tous</b> les paquets est
* indistinguable d'un vrai lag : seul le timer (solde de paquets) en voit une partie. OBSERVE par défaut.
*/
public final class Blink {
/** Au-delà, le rappel de position vanilla aurait dû arriver (20 ticks, plus un de gigue). */
public static final int RAPPEL_TICKS = 21;
private long dernierMouvTick = Long.MIN_VALUE;
private long dernierAutreTick = Long.MIN_VALUE;
private int autres;
private long dernierTrou;
private int dernierAutres;
/** Un autre paquet (coup, clic sur un bloc, clic de conteneur, complétion…) vient d'être traité. */
public void autrePaquet(long tick) {
if (dernierMouvTick == Long.MIN_VALUE || tick == dernierAutreTick) return;
if (tick - dernierMouvTick > RAPPEL_TICKS) {
autres++;
dernierAutreTick = tick;
}
}
/** Paquet de mouvement : renvoie les points du trou qui se termine. */
public double mouvement(long tick, GardeConfig cfg) {
double pts = 0;
if (dernierMouvTick != Long.MIN_VALUE) {
dernierTrou = tick - dernierMouvTick;
dernierAutres = autres;
if (dernierTrou >= Math.max(RAPPEL_TICKS + 1, cfg.blinkTrouMinTicks) && autres >= Math.max(1, cfg.blinkAutresMin)) {
pts = 2.0;
}
}
dernierMouvTick = tick;
dernierAutreTick = Long.MIN_VALUE;
autres = 0;
return pts;
}
/** Exemption (téléportation, véhicule, mort, gel du serveur…) : le prochain mouvement repart de zéro. */
public void vider() {
dernierMouvTick = Long.MIN_VALUE;
dernierAutreTick = Long.MIN_VALUE;
autres = 0;
}
public long dernierTrou() {
return dernierTrou;
}
public int dernierAutres() {
return dernierAutres;
}
}
+11 -2
Voir le fichier
@@ -53,7 +53,15 @@ public enum Controle {
/** 0.5 (P3.2) : pilier monté plus vite que le saut vanilla, blocs posés sous les pieds (Scaffold Tower). */
TOWER("tower"),
/** 0.5 (P3.7) : demandes de complétion de commande au-delà d'un débit humain (spam de Tab, paquets forgés). */
COMPLETION("completion");
COMPLETION("completion"),
/** 0.6 (P2.6) : ChestStealer, InventoryMove, InvCleaner / AutoArmor. */
INVENTAIRE("inventaire"),
/** 0.6 (P3.2) : pont posé sous les pieds hors du regard ou avec des rotations « snap » (Scaffold horizontal). */
SCAFFOLD("scaffold"),
/** 0.6 (P3.4) : trou de paquets de mouvement pendant que d'autres paquets arrivent (Blink / FakeLag). */
BLINK("blink"),
/** 0.6 (P3.5) : positions refusées par vanilla dans un bloc solide, en série (Phase / NoClip / VClip). */
PHASE("phase");
private final String id;
@@ -83,7 +91,8 @@ public enum Controle {
// 0.5 : nouveaux contrôles P1 au plafond « faible » tant qu'ils n'ont pas été validés en jeu.
case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS, ANTI_FAIM,
NO_SLOW, FAST_BREAK, FAST_PLACE, INTERACTION_BLOC, AUTO_TOTEM_REGULIER,
JESUS, OMNISPRINT, XRAY, NUKER, AUTO_CRISTAL, TOWER, COMPLETION -> 2; // 0.5 (P2) : idem
JESUS, OMNISPRINT, XRAY, NUKER, AUTO_CRISTAL, TOWER, COMPLETION,
INVENTAIRE, SCAFFOLD, BLINK, PHASE -> 2; // 0.5 (P2) : idem
};
}
+41
Voir le fichier
@@ -204,6 +204,8 @@ public final class GardeConfig {
public double interactionBlocMarge = 0.5;
/** Interaction de bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter. */
public int interactionBlocSerieMin = 3;
/** 0.6.1 (revue M3) : « bloc-vide » non compté si ce bloc a changé (casse, pose, clic de pose) depuis ce délai (ms). */
public int interactionBlocGraceChangementMs = 500;
/** Auto-totem régulier : délais (éclatement → totem en main) examinés. */
public int autoTotemEchantillons = 5;
/** Auto-totem régulier : écart type (ms) sous lequel ces délais sont ceux d'une machine. */
@@ -230,6 +232,11 @@ public final class GardeConfig {
public int nukerBlocsParTickMax = 3;
/** Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter. */
public int nukerSerieMin = 3;
/**
* 0.6.1 (revue M2) : vrai = le nuker ne compte que les casses visées par un paquet de casse du joueur dans le même
* tick ; les blocs cassés par un mod d'abattage / de minage de filon au nom du joueur sont ignorés. Faux par défaut.
*/
public boolean nukerIgnorerCassesSansPaquet = false;
/** Auto-cristal : âge (ticks serveur) d'un cristal de l'End frappé sous lequel le coup est suspect (2 : même tick ou suivant). */
public int cristalDelaiMinTicks = 2;
/** Auto-cristal : coups suspects parmi les 10 derniers coups sur un cristal récent (60 s) avant de compter. */
@@ -243,6 +250,40 @@ public final class GardeConfig {
/** Complétion : rafale permise (capacité du seau). */
public int completionRafaleMax = 40;
// --- 0.6 : inventaire, scaffold, blink, phase. OBSERVE par défaut, seuils de VL propres (<= 0 = seuil global) ---
/** Inventaire : réaction minimale (ms, ping retiré) entre l'ouverture d'un conteneur et la première prise. */
public int inventaireReactionMinMs = 100;
/** Inventaire : intervalle moyen (ticks) entre deux prises au-delà duquel la session n'est pas suspecte. */
public double inventaireIntervalleMaxTicks = 1.5;
/** Inventaire : prises d'objets différents dans la session avant de juger. */
public int inventairePrisesMin = 4;
/** Inventaire : ping (ms) au plus retiré de la réaction (le ping est falsifiable). */
public int inventairePingMaxMs = 300;
/** Inventaire : grâce (ticks) après l'ouverture avant de compter les rotations, plus ping / 50. */
public int inventaireGraceRotationTicks = 10;
/** Inventaire : rotations avec un conteneur ouvert (une ouverture) avant que chacune compte. */
public int inventaireRotationsMin = 3;
public double inventaireSeuilSetback = 10;
public double inventaireSeuilExpulsion = 30;
/** Scaffold : écart (degrés) entre le regard et le point cliqué au-delà duquel la pose est hors regard. */
public double scaffoldAngleMaxDeg = 50;
/** Scaffold : rotation (degrés) aller puis retour autour d'une pose, au-delà de laquelle c'est un « snap ». */
public double scaffoldSnapDeg = 70;
/** Scaffold : poses anormales parmi les 10 dernières poses de pont (30 s) avant de compter. */
public int scaffoldSerieMin = 4;
public double scaffoldSeuilSetback = 10;
public double scaffoldSeuilExpulsion = 30;
/** Blink : trou (ticks) sans paquet de mouvement au-delà duquel il est mesuré (vanilla : un paquet au moins toutes les 20). */
public int blinkTrouMinTicks = 30;
/** Blink : autres paquets (ticks distincts) reçus pendant le trou avant de le juger. */
public int blinkAutresMin = 2;
public double blinkSeuilSetback = 10;
public double blinkSeuilExpulsion = 30;
/** Phase : positions refusées dans un bloc solide en 10 s avant que chacune compte. */
public int phaseSerieMin = 5;
public double phaseSeuilSetback = 10;
public double phaseSeuilExpulsion = 30;
// --- 0.5 (P1.13, section [diagnostic]) : journal seulement, jamais de sanction ---
/** Journaliser les ABORT de casse de bloc sans START correspondant (« Mismatch in destroy block pos »). */
public boolean diagnosticActionsBloc = true;
+179
Voir le fichier
@@ -0,0 +1,179 @@
package com.gastinelgarde.core;
/**
* 0.6 (P2.6) : inventaire (ChestStealer, InventoryMove, InvCleaner / AutoArmor). Trois signaux, tous en ticks serveur.
*
* <ol>
* <li><b>vol-de-coffre</b> : dans une même ouverture de conteneur (coffre, tonneau…), des prises (shift-clic ou touche
* de hotbar sur une case du conteneur) d'objets <i>différents</i> commencent moins de {@link GardeConfig#inventaireReactionMinMs}
* après l'ouverture (ping retiré, plafonné) et s'enchaînent à moins de {@link GardeConfig#inventaireIntervalleMaxTicks}
* en moyenne sur au moins {@link GardeConfig#inventairePrisesMin} prises. Le double-clic shift vanilla (même objet,
* même tick) n'est pas compté. Un humain a besoin d'au moins 150 ms pour voir l'écran s'ouvrir et viser la première
* case ; un ChestStealer prend dès la réception. Une fois la session jugée suspecte, <b>chaque</b> prise rapide
* suivante compte (annulable en ENFORCE).</li>
* <li><b>regard-conteneur</b> (contre-contournement « ChestStealer silencieux » / InventoryMove) : le client vanilla ne
* tourne pas la tête quand un écran est ouvert (souris libérée). Une rotation reçue alors que le serveur voit un
* conteneur ouvert, au-delà d'une grâce après l'ouverture, est suspecte. Le stealer « silencieux » ferme l'écran côté
* client seulement : le serveur garde le conteneur ouvert et voit le joueur tourner.</li>
* <li><b>clic-en-rotation</b> (InvCleaner, AutoArmor) : un clic sur l'inventaire du joueur (pas de paquet d'ouverture
* en vanilla) alors que la tête tournait au paquet précédent et au tick d'avant : impossible avec l'écran ouvert.</li>
* </ol>
* Les clics sur un conteneur déjà fermé (identifiant différent, ignorés par vanilla) sont seulement comptés pour le
* journal. Les mods d'inventaire côté client (Mouse Tweaks, Inventory Profiles, Item Scroller) font des rafales de
* shift-clics : c'est pourquoi la réaction après l'ouverture est exigée, et pourquoi le contrôle reste en OBSERVE tant
* qu'il n'a pas été comparé à de vraies sessions. Le mod client InvMove (marcher écran ouvert) ne tourne pas la tête.
*/
public final class Inventaire {
/** Type de clic (sous-ensemble de {@code ClickType} utile ici). */
public enum Clic { PRISE, AUTRE }
// Session d'ouverture d'un conteneur
private boolean ouvert;
private long ouvertTick;
private long premierePriseTick = Long.MIN_VALUE;
private long dernierePriseTick = Long.MIN_VALUE;
private int prises;
private int dernierObjet;
private boolean sessionSuspecte;
private int reactionMs = -1;
// Rotation
private float yaw = Float.NaN, pitch = Float.NaN;
private long rotationTick = Long.MIN_VALUE;
private long rotationAvantTick = Long.MIN_VALUE;
private int rotationsConteneur;
private final SerieFenetre clicsFermes = new SerieFenetre(10, 10_000);
private int dernierCompteFermes;
private String dernierDetail = "";
/** Le serveur vient d'ouvrir un conteneur pour ce joueur (PlayerContainerEvent.Open). */
public void ouvrir(long tick) {
ouvert = true;
ouvertTick = tick;
premierePriseTick = Long.MIN_VALUE;
dernierePriseTick = Long.MIN_VALUE;
prises = 0;
dernierObjet = 0;
sessionSuspecte = false;
reactionMs = -1;
rotationsConteneur = 0;
}
public void fermer() {
ouvert = false;
sessionSuspecte = false;
rotationsConteneur = 0;
}
public boolean ouvert() {
return ouvert;
}
/**
* Clic sur un conteneur ouvert.
*
* @param caseConteneur la case cliquée appartient au conteneur (pas à l'inventaire du joueur)
* @param objet empreinte de l'objet de la case (type d'objet), 0 si vide
* @param pingMs ping mesuré (falsifiable : plafonné par {@link GardeConfig#inventairePingMaxMs})
* @param facteur tolérance (lag) : divise la réaction exigée et l'intervalle maximal
* @return points
*/
public double clicConteneur(long tick, Clic type, boolean caseConteneur, int objet, int pingMs, double facteur,
GardeConfig cfg) {
if (!ouvert || type != Clic.PRISE || !caseConteneur || objet == 0) return 0;
// Double-clic shift vanilla : même objet dans le même tick (toutes les cases de cet objet d'un coup).
if (tick == dernierePriseTick && objet == dernierObjet) return 0;
dernierObjet = objet;
if (prises == 0) {
premierePriseTick = tick;
int ping = Math.max(0, Math.min(pingMs, cfg.inventairePingMaxMs));
reactionMs = (int) Math.max(0, (tick - ouvertTick) * 50 - ping);
}
long ecart = dernierePriseTick == Long.MIN_VALUE ? Long.MAX_VALUE : tick - dernierePriseTick;
dernierePriseTick = tick;
prises++;
// Lag : paquets regroupés (intervalles comprimés) et ticks plus longs que 50 ms : les deux limites se resserrent.
double intervalleMax = cfg.inventaireIntervalleMaxTicks / Math.max(1, facteur);
double reactionMin = cfg.inventaireReactionMinMs / Math.max(1, facteur);
double moyenne = prises <= 1 ? 0 : (double) (tick - premierePriseTick) / (prises - 1);
dernierDetail = String.format(java.util.Locale.ROOT,
"vol-de-coffre : %d prises, reaction %d ms (min %.0f), intervalle moyen %.2f ticks (max %.1f)",
prises, reactionMs, reactionMin, moyenne, intervalleMax);
if (!sessionSuspecte) {
if (prises >= Math.max(2, cfg.inventairePrisesMin) && reactionMs < reactionMin && moyenne <= intervalleMax) {
sessionSuspecte = true;
return 1.0;
}
return 0;
}
// Session déjà suspecte : chaque prise rapide suivante compte.
return ecart <= Math.ceil(intervalleMax) ? 1.0 : 0;
}
/**
* Clic sur l'inventaire du joueur (aucun conteneur ouvert côté serveur) : InvCleaner / AutoArmor si la tête tourne.
*/
public double clicInventaire(long tick, Clic type) {
if (ouvert || type != Clic.PRISE) return 0;
boolean tourne = rotationTick != Long.MIN_VALUE && tick - rotationTick <= 1
&& rotationAvantTick != Long.MIN_VALUE && rotationTick - rotationAvantTick <= 2;
dernierDetail = "clic-en-rotation : clic sur l'inventaire pendant que la tete tourne (dernieres rotations a "
+ (rotationTick == Long.MIN_VALUE ? "?" : String.valueOf(tick - rotationTick)) + " tick(s))";
return tourne ? 0.5 : 0;
}
/** Clic sur un conteneur fermé (identifiant périmé) : journal seulement, quelques-uns arrivent avec le lag. */
public boolean clicFerme(long nowMs) {
dernierCompteFermes = clicsFermes.ajouter(nowMs, true);
return dernierCompteFermes >= 10;
}
public int clicsFermes() {
return dernierCompteFermes;
}
/**
* Rotation reçue (paquet de mouvement accepté).
*
* @param graceTicks grâce après l'ouverture (le client ne voit l'écran qu'après un aller-retour)
* @return points (regard-conteneur)
*/
public double regard(long tick, float nYaw, float nPitch, int graceTicks, GardeConfig cfg) {
boolean change = !Float.isNaN(yaw) && (angle(yaw, nYaw) > 0.5 || Math.abs(nPitch - pitch) > 0.5);
if (Float.isNaN(yaw) || change) {
if (change) {
rotationAvantTick = rotationTick;
rotationTick = tick;
}
yaw = nYaw;
pitch = nPitch;
}
if (!change || !ouvert || tick - ouvertTick <= graceTicks) return 0;
rotationsConteneur++;
dernierDetail = String.format(java.util.Locale.ROOT,
"regard-conteneur : %d rotation(s) avec un conteneur ouvert depuis %d ticks (grace %d)",
rotationsConteneur, tick - ouvertTick, graceTicks);
return rotationsConteneur >= Math.max(1, cfg.inventaireRotationsMin) ? 0.5 : 0;
}
/** Une grâce (téléportation, véhicule…) a remis le regard à zéro : la rotation suivante n'est pas comptée. */
public void oublierRegard() {
yaw = Float.NaN;
rotationsConteneur = 0;
}
public String detail() {
return dernierDetail;
}
public boolean sessionSuspecte() {
return sessionSuspecte;
}
static double angle(float a, float b) {
double d = Math.abs(((b - a) % 360 + 540) % 360 - 180);
return d;
}
}
+201
Voir le fichier
@@ -531,6 +531,28 @@ public final class Moteur {
return v;
}
/** 0.6.1 (revue M2) : paquet de casse (START/STOP/ABORT) du joueur sur ce bloc ({@code BlockPos.asLong}). */
public void paquetCasse(UUID joueur, long cleBloc, long nowMs) {
if (expulses.contains(joueur)) return;
suivi(joueur).paquetsCasse.noter(cleBloc, nowMs);
}
/**
* 0.6.1 (revue M2) : cette casse est-elle hors du nuker ? Vrai seulement si {@code nukerIgnorerCassesSansPaquet} est
* activé et qu'aucun paquet de casse du joueur n'a visé ce bloc dans le même tick (casse en chaîne d'un mod).
*/
public boolean casseNukerSansPaquet(UUID joueur, long cleBloc, long nowMs) {
if (!cfg.nukerIgnorerCassesSansPaquet) return false;
Suivi s = suivis.get(joueur);
return s == null || !s.paquetsCasse.contient(cleBloc, nowMs, 0);
}
/** 0.6.1 (revue M3) : un bloc proche de ce joueur vient de changer (casse, pose, cible d'un clic de pose). */
public void changementBloc(UUID joueur, long cleBloc, long nowMs) {
if (expulses.contains(joueur)) return;
suivi(joueur).changementsBloc.noter(cleBloc, nowMs);
}
/**
* 0.5 (P3.3) : bloc cassé par le joueur, pour le nuker (plusieurs blocs dans le même tick serveur). Exemptions de la
* famille MONDE (créatif, spectateur, contraption, vaisseau, gel) ; TPS bas : pas de mesure (paquets groupés).
@@ -608,6 +630,147 @@ public final class Moteur {
return v;
}
// --- 0.6 : inventaire, scaffold horizontal, blink, phase (OBSERVE par défaut) ---------------------------
private boolean actif(UUID joueur, Controle c) {
return !expulses.contains(joueur) && cfg.mode(c) != Mode.OFF;
}
/** 0.6 (P2.6) : le serveur ouvre un conteneur (coffre, tonneau…) pour ce joueur. */
public void ouvrirConteneur(UUID joueur, long tick) {
if (actif(joueur, Controle.INVENTAIRE)) suivi(joueur).inventaire.ouvrir(tick);
}
/** 0.6 (P2.6) : conteneur fermé (par le joueur, le serveur ou la distance). */
public void fermerConteneur(UUID joueur) {
Suivi s = suivis.get(joueur);
if (s != null) s.inventaire.fermer();
}
/**
* 0.6 (P2.6) : clic de conteneur reçu (après ensureRunningOnSameThread).
*
* @param idValide l'identifiant du paquet est celui du menu ouvert côté serveur (sinon vanilla l'ignore)
* @param menuConteneur un conteneur est ouvert côté serveur (pas l'inventaire du joueur)
* @param caseConteneur la case cliquée appartient au conteneur
* @param objet empreinte du type d'objet de la case (0 si vide)
*/
public List<Verdict> clicConteneur(UUID joueur, long nowMs, long tick, EtatJoueur etat, boolean idValide,
boolean menuConteneur, Inventaire.Clic type, boolean caseConteneur, int objet) {
if (!actif(joueur, Controle.INVENTAIRE)) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt()) return List.of();
double f = etat.tps() < cfg.tpsLag ? Math.max(ex.facteur(), cfg.facteurLag) : ex.facteur();
List<Verdict> v = new ArrayList<>(1);
if (!idValide) {
if (s.inventaire.clicFerme(nowMs)) {
// journal seulement (points minimes) : le lag après une fermeture en produit quelques-uns
ajouter(v, s, Controle.INVENTAIRE, 0.1, nowMs, ex, "clic-ferme : " + s.inventaire.clicsFermes()
+ " clics sur un conteneur deja ferme en 10 s (ignores par vanilla)");
}
return v;
}
double pts;
if (menuConteneur) {
pts = s.inventaire.clicConteneur(tick, type, caseConteneur, objet, etat.pingMs(), f, cfg);
} else {
Exemptions.Resultat exM = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
pts = exM.exempt() ? 0 : s.inventaire.clicInventaire(tick, type);
}
ajouter(v, s, Controle.INVENTAIRE, pts, nowMs, ex, s.inventaire.detail());
return v;
}
/** 0.6 (P2.6) : rotation acceptée ; compte celles reçues avec un conteneur ouvert (InventoryMove, stealer silencieux). */
public List<Verdict> regardInventaire(UUID joueur, long nowMs, long tick, EtatJoueur etat, float yaw, float pitch) {
if (!actif(joueur, Controle.INVENTAIRE)) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
Exemptions.Resultat exW = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt() || exW.exempt() || etat.tps() < cfg.tpsLag) {
s.inventaire.oublierRegard();
return List.of();
}
// Ping élevé : le client voit l'écran s'ouvrir un aller-retour plus tard (plafonné : le ping est falsifiable).
int grace = cfg.inventaireGraceRotationTicks + Math.min(Math.max(0, etat.pingMs()), cfg.inventairePingMaxMs * 2) / 50;
double pts = s.inventaire.regard(tick, yaw, pitch, grace, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.INVENTAIRE, pts, nowMs, ex, s.inventaire.detail());
return v;
}
/** 0.6 (P3.2) : pose d'un bloc de pont (voir {@link Scaffold#estPont}) ; jugée au paquet de mouvement suivant. */
public void poseScaffold(UUID joueur, EtatJoueur etat, float dirYaw, float dirPitch, float yawAvant,
float pitchAvant, float yawPose, float pitchPose) {
if (!actif(joueur, Controle.SCAFFOLD)) return;
Suivi s = suivi(joueur);
if (Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE).exempt()
|| Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT).exempt() || etat.tps() < cfg.tpsLag) {
s.scaffold.vider();
return;
}
s.scaffold.pose(dirYaw, dirPitch, yawAvant, pitchAvant, yawPose, pitchPose);
}
/** 0.6 (P3.2) : vrai si une pose de pont doit être annulée (ENFORCE, période suspecte, VL au palier SETBACK). */
public boolean scaffoldAnnuler(UUID joueur, long nowMs, long tick) {
if (cfg.mode(Controle.SCAFFOLD) != Mode.ENFORCE) return false;
Suivi s = suivis.get(joueur);
if (s == null || !s.scaffold.suspect(tick)) return false;
return Paliers.palier(s.vl.valeur(Controle.SCAFFOLD, nowMs), cfg, Controle.SCAFFOLD).ordinal() >= Sanction.SETBACK.ordinal();
}
/** 0.6 (P3.2) : paquet de mouvement accepté : juge la dernière pose de pont, s'il y en a une. */
public List<Verdict> regardScaffold(UUID joueur, long nowMs, long tick, float yaw, float pitch) {
if (!actif(joueur, Controle.SCAFFOLD)) return List.of();
Suivi s = suivis.get(joueur);
if (s == null) return List.of();
double pts = s.scaffold.regard(tick, nowMs, yaw, pitch, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.SCAFFOLD, pts, nowMs, new Exemptions.Resultat(false, 1.0, List.of()), s.scaffold.detail());
return v;
}
/** 0.6 (P3.4) : autre paquet traité sur le thread serveur (coup, clic sur un bloc, conteneur, complétion). */
public void autrePaquet(UUID joueur, long tick) {
if (!actif(joueur, Controle.BLINK)) return;
suivi(joueur).blink.autrePaquet(tick);
}
/** 0.6 (P3.4) : paquet de mouvement reçu (avant traitement). Exemptions TIMER, véhicule, mort, gel, TPS bas. */
public List<Verdict> mouvementBlink(UUID joueur, long nowMs, long tick, EtatJoueur etat, boolean vivant) {
if (!actif(joueur, Controle.BLINK)) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER);
if (ex.exempt() || !vivant || etat.enVehicule() || etat.ticksDepuisGel() <= cfg.graceGelTicks
|| etat.tps() < cfg.tpsLag) {
s.blink.vider();
return List.of();
}
double pts = s.blink.mouvement(tick, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.BLINK, pts, nowMs, ex, String.format(Locale.ROOT,
"trou de %d ticks sans mouvement, %d autre(s) paquet(s) recus pendant le trou (min %d, trou min %d)",
s.blink.dernierTrou(), s.blink.dernierAutres(), cfg.blinkAutresMin, cfg.blinkTrouMinTicks));
return v;
}
/** 0.6 (P3.5) : paquet de mouvement refusé par vanilla ; {@code dansBloc} si la boîte déclarée chevauche un bloc. */
public List<Verdict> refusPhase(UUID joueur, long nowMs, EtatJoueur etat, boolean dansBloc, double distance) {
if (!actif(joueur, Controle.PHASE)) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
Exemptions.Resultat exW = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt() || exW.exempt() || etat.tps() < cfg.tpsLag) return List.of();
double pts = s.phase.refus(nowMs, dansBloc, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.PHASE, pts, nowMs, ex, String.format(Locale.ROOT,
"position refusee par vanilla dans un bloc solide (%.2f bloc(s) de la position acceptee), %d en 10 s (min %d)",
distance, s.phase.compte(), cfg.phaseSerieMin));
return v;
}
/**
* 0.5 (P3.7) : demande de complétion de commande reçue (horloge réelle : plusieurs paquets par tick). Aucune
* exemption de jeu (rien ne dépend du mouvement). Voir {@link #completionAIgnorer}.
@@ -672,6 +835,12 @@ public final class Moteur {
Suivi s = suivi(joueur);
double marge = (cfg.interactionBlocMarge + Math.max(0, Math.min(deplacement, 5.0))) * ex.facteur();
String a = InteractionBloc.anomalie(oeil, boite, face, impact, air, plein, portee, marge);
// 0.6.1 (revue M3) : bloc fantôme (le client voit encore un bloc que le serveur vient de casser, ou une pose
// refusée) : « bloc-vide » n'est pas compté si ce bloc a changé il y a peu.
if ("bloc-vide".equals(a) && cleBloc != Long.MIN_VALUE
&& s.changementsBloc.contient(cleBloc, nowMs, Math.max(0, cfg.interactionBlocGraceChangementMs))) {
a = null;
}
// La vérification tourne toujours ; seul le comptage est sauté pour la main secondaire du même clic, et seulement
// si elle donne la même anomalie que la principale : elle reprend alors ses verdicts (même décision d'annulation).
if (cleBloc != Long.MIN_VALUE && s.interactionBloc.secondeMainDuMemeClic(nowMs, cleBloc, main, face, impact)
@@ -862,13 +1031,45 @@ public final class Moteur {
* paquet suivant sert de référence) et leurs VL sont remis à zéro ; le setback est compté pour l'escalade (C5).
*/
public void apresSetback(UUID joueur, long nowMs) {
apresSetback(joueur, nowMs, List.of());
}
/**
* 0.6.1 (revue M4) : idem, et le VL de chaque contrôle qui a demandé ce setback (verdict applicable ≥ SETBACK) est
* aussi remis à zéro. Avant, step, no-slow ou jesus restaient au-dessus du seuil et redonnaient un setback à chaque
* paquet, jusqu'à l'expulsion. Le setback est noté pour l'escalade et pour {@link #setbackDejaApplique} (M1).
*/
public void apresSetback(UUID joueur, long nowMs, List<Verdict> causes) {
Suivi s = suivi(joueur);
s.vol.vider();
s.vitesse.vider();
s.graceElytresJusquaMs = Long.MIN_VALUE;
s.vl.remettreAZero(Controle.VOL);
s.vl.remettreAZero(Controle.VITESSE);
remettreAZeroCauses(s, causes);
s.noterSetback(nowMs);
s.dernierSetbackMs = nowMs;
}
/**
* 0.6.1 (revue M1) : un setback a-t-il déjà été appliqué à cet instant (même tick serveur) ? Un même paquet peut
* donner SETBACK sur vol puis sur jesus/no-slow : un seul retour et un seul compte pour l'escalade.
*/
public boolean setbackDejaApplique(UUID joueur, long nowMs) {
Suivi s = suivis.get(joueur);
return s != null && s.dernierSetbackMs == nowMs;
}
/** 0.6.1 (revue M1/M4) : second setback du même tick : seuls les VL de ses causes sont remis à zéro. */
public void apresSetbackDuMemeTick(UUID joueur, List<Verdict> causes) {
remettreAZeroCauses(suivi(joueur), causes);
}
private static void remettreAZeroCauses(Suivi s, List<Verdict> causes) {
if (causes == null) return;
for (Verdict v : causes) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) s.vl.remettreAZero(v.controle());
}
}
/**
+16
Voir le fichier
@@ -20,6 +20,22 @@ public final class Paliers {
} else if (c == Controle.VELOCITE) {
if (cfg.velociteSeuilSetback > 0) setback = cfg.velociteSeuilSetback;
if (cfg.velociteSeuilExpulsion > 0) expulsion = cfg.velociteSeuilExpulsion;
} else if (c == Controle.INVENTAIRE || c == Controle.SCAFFOLD || c == Controle.BLINK || c == Controle.PHASE) {
// 0.6 : seuils propres (sections [inventaire], [scaffold], [blink], [phase]) ; <= 0 = seuil global.
double sb = switch (c) {
case INVENTAIRE -> cfg.inventaireSeuilSetback;
case SCAFFOLD -> cfg.scaffoldSeuilSetback;
case BLINK -> cfg.blinkSeuilSetback;
default -> cfg.phaseSeuilSetback;
};
double ex = switch (c) {
case INVENTAIRE -> cfg.inventaireSeuilExpulsion;
case SCAFFOLD -> cfg.scaffoldSeuilExpulsion;
case BLINK -> cfg.blinkSeuilExpulsion;
default -> cfg.phaseSeuilExpulsion;
};
if (sb > 0) setback = sb;
if (ex > 0) expulsion = ex;
}
setback = Math.min(setback, expulsion);
double alerte = Math.min(cfg.seuilAlerte, setback);
+36
Voir le fichier
@@ -0,0 +1,36 @@
package com.gastinelgarde.core;
/**
* 0.6 (P3.5) : Phase / NoClip / VClip. Vanilla (handleMovePlayer, sources NeoForge 21.1.234) refuse déjà d'entrer dans
* un bloc : le déplacement est rejoué avec collisions, et la position est refusée (« moved wrongly », ou
* {@code isPlayerCollidingWithAnythingNew}) avant d'être acceptée. Ce contrôle ne sanctionne donc pas un passage qui
* aurait réussi : il <b>compte les tentatives</b>, c'est-à-dire les positions refusées par vanilla dont la boîte
* déclarée chevauche un bloc solide (ou une entité solide). Un vrai joueur en provoque quelques-unes (porte qui se
* ferme, piston, bloc posé par un autre joueur pendant un lag) ; un client de phase en envoie en continu.
*
* Il faut {@link GardeConfig#phaseSerieMin} (5) refus dans un bloc en 10 s ; ensuite chaque refus compte. OBSERVE par
* défaut : le seuil n'a jamais été comparé à de vrais joueurs (Create, Sable et les ascenseurs peuvent en provoquer).
*/
public final class Phase {
public static final long FENETRE_MS = 10_000;
private final SerieFenetre serie = new SerieFenetre(32, FENETRE_MS);
private int compte;
/** Paquet de mouvement refusé par vanilla ; {@code dansBloc} : la boîte déclarée chevauche un bloc solide. */
public double refus(long nowMs, boolean dansBloc, GardeConfig cfg) {
if (!dansBloc) return 0;
compte = serie.ajouter(nowMs, true);
return compte >= Math.max(1, cfg.phaseSerieMin) ? 1.0 : 0;
}
public int compte() {
return compte;
}
public void vider() {
serie.vider();
compte = 0;
}
}
+131
Voir le fichier
@@ -0,0 +1,131 @@
package com.gastinelgarde.core;
import java.util.Locale;
/**
* 0.6 (P3.2, partie « Scaffold horizontal ») : pont posé sous les pieds pendant la marche. Le client vanilla ne pose un
* bloc que là où vise le réticule : le point cliqué est sur le rayon du regard, au moment du clic. Le clic part entre
* la rotation du dernier paquet de mouvement et celle du suivant (la souris bouge à chaque image). Deux anomalies :
* <ul>
* <li><b>hors-regard</b> : le point cliqué est à plus de {@link GardeConfig#scaffoldAngleMaxDeg} (50°) de toutes les
* rotations entre ces deux paquets (Scaffold sans rotation, pose « derrière soi ») ;</li>
* <li><b>snap</b> (Scaffold à rotation silencieuse) : la rotation fait un aller de plus de
* {@link GardeConfig#scaffoldSnapDeg} (70°) juste avant la pose, puis un retour d'autant juste après, vers le regard
* d'avant. Un pont humain (ninja, god-bridge, pont en reculant) garde le regard à peu près fixe.</li>
* </ul>
* Il faut {@link GardeConfig#scaffoldSerieMin} (4) poses anormales parmi les 10 dernières poses de pont en 30 s ; ensuite
* chaque pose anormale compte et, pendant 2 s, les poses de pont suivantes sont annulables en ENFORCE (l'anomalie
* n'est connue qu'au paquet de mouvement d'après, la pose a déjà eu lieu). Les clics « derrière soi » de vrais
* joueurs qui retournent la tête très vite (180° en une image) sont possibles : OBSERVE par défaut.
*/
public final class Scaffold {
public static final int SERIE = 10;
public static final long FENETRE_MS = 30_000;
public static final int ANNULATION_TICKS = 40;
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
private boolean attente;
private float dirYaw, dirPitch, yawAvant, pitchAvant, yawPose, pitchPose;
private long suspectJusquaTick = Long.MIN_VALUE;
private int compte;
private String detail = "";
/**
* Le bloc posé fait-il partie d'un pont sous les pieds ? Bloc juste sous le niveau des pieds, à côté de la colonne du
* joueur (pas dedans : c'est le tower), joueur qui ne monte ni ne descend et qui avance.
*/
public static boolean estPont(int bx, int by, int bz, double px, double py, double pz, double dy, double vitesseH) {
boolean sousPieds = py >= by + 1 - 0.01 && py < by + 1.6;
boolean colonne = (int) Math.floor(px) == bx && (int) Math.floor(pz) == bz;
double hx = bx + 0.5 - px, hz = bz + 0.5 - pz;
boolean proche = hx * hx + hz * hz <= 1.8 * 1.8;
return sousPieds && !colonne && proche && Math.abs(dy) < 0.1 && vitesseH >= 0.03;
}
/**
* Pose de pont : retenue jusqu'au paquet de mouvement suivant.
*
* @param dirYaw, dirPitch direction œil → point cliqué
* @param yawAvant, pitchAvant rotation du paquet d'avant le dernier
* @param yawPose, pitchPose rotation du dernier paquet (au moment de la pose)
*/
public void pose(float dirYaw, float dirPitch, float yawAvant, float pitchAvant, float yawPose, float pitchPose) {
this.attente = true;
this.dirYaw = dirYaw;
this.dirPitch = dirPitch;
this.yawAvant = yawAvant;
this.pitchAvant = pitchAvant;
this.yawPose = yawPose;
this.pitchPose = pitchPose;
}
/** Paquet de mouvement accepté après une pose de pont : juge la pose. */
public double regard(long tick, long nowMs, float yaw, float pitch, GardeConfig cfg) {
if (!attente) return 0;
attente = false;
double horsRegard = ecartArc(yawPose, pitchPose, yaw, pitch, dirYaw, dirPitch);
double aller = angle(yawAvant, pitchAvant, yawPose, pitchPose);
double retour = angle(yawPose, pitchPose, yaw, pitch);
double bilan = angle(yawAvant, pitchAvant, yaw, pitch);
boolean hors = horsRegard > cfg.scaffoldAngleMaxDeg;
boolean snap = aller >= cfg.scaffoldSnapDeg && retour >= cfg.scaffoldSnapDeg && bilan <= cfg.scaffoldSnapDeg / 2;
boolean anomalie = hors || snap;
compte = serie.ajouter(nowMs, anomalie);
detail = String.format(Locale.ROOT,
"pont : %s ecart au regard %.0f deg (max %.0f), aller %.0f / retour %.0f deg (snap %.0f), %d/%d anomalies",
hors ? "hors-regard," : snap ? "snap," : "", horsRegard, cfg.scaffoldAngleMaxDeg, aller, retour,
cfg.scaffoldSnapDeg, compte, SERIE);
if (anomalie && compte >= Math.max(1, cfg.scaffoldSerieMin)) {
suspectJusquaTick = tick + ANNULATION_TICKS;
return 1.0;
}
return 0;
}
/** Pendant la période suspecte, une pose de pont est annulable en ENFORCE. */
public boolean suspect(long tick) {
return tick <= suspectJusquaTick;
}
public String detail() {
return detail;
}
public void vider() {
attente = false;
serie.vider();
suspectJusquaTick = Long.MIN_VALUE;
}
/** Plus petit écart (degrés) entre la direction et les rotations sur l'arc le plus court de r0 à r1. */
static double ecartArc(float y0, float p0, float y1, float p1, float dy, float dp) {
double dyaw = ((y1 - y0) % 360 + 540) % 360 - 180;
double min = Double.MAX_VALUE;
for (int i = 0; i <= 8; i++) {
double t = i / 8.0;
min = Math.min(min, angle((float) (y0 + dyaw * t), (float) (p0 + (p1 - p0) * t), dy, dp));
}
return min;
}
/** Angle (degrés) entre deux regards (yaw, pitch Minecraft). */
static double angle(float y0, float p0, float y1, float p1) {
double[] a = vecteur(y0, p0), b = vecteur(y1, p1);
double c = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
return Math.toDegrees(Math.acos(Math.max(-1, Math.min(1, c))));
}
static double[] vecteur(float yaw, float pitch) {
double y = Math.toRadians(yaw), p = Math.toRadians(pitch);
return new double[] {-Math.sin(y) * Math.cos(p), -Math.sin(p), Math.cos(y) * Math.cos(p)};
}
/** Rotation Minecraft (yaw, pitch) d'une direction. */
public static float[] rotation(double dx, double dy, double dz) {
double h = Math.sqrt(dx * dx + dz * dz);
float yaw = (float) Math.toDegrees(Math.atan2(-dx, dz));
float pitch = (float) Math.toDegrees(Math.atan2(-dy, h));
return new float[] {yaw, pitch};
}
}
+37
Voir le fichier
@@ -33,6 +33,9 @@ public final class Suivi {
/** 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<>();
/** 0.6.1 (revue M1) : instant (ms) du dernier setback appliqué. */
long dernierSetbackMs = Long.MIN_VALUE;
void noterSetback(long nowMs) {
setbacks.addLast(nowMs);
while (setbacks.size() > 32) setbacks.removeFirst();
@@ -81,12 +84,46 @@ public final class Suivi {
public final Omnisprint omnisprint = new Omnisprint();
/** 0.5 (P2.10) : x-ray statistique. */
public final XrayStats xray = new XrayStats();
/** 0.6.1 (revue M3) : blocs récemment changés (casse, pose, cible d'un clic droit) près du joueur. */
public final PositionsRecentes changementsBloc = new PositionsRecentes();
/** 0.6.1 (revue M2) : blocs visés par un paquet de casse du joueur (START/STOP/ABORT). */
public final PositionsRecentes paquetsCasse = new PositionsRecentes();
/** 0.6.1 : petite mémoire circulaire (32 entrées) de positions de bloc ({@code BlockPos.asLong}) datées. */
public static final class PositionsRecentes {
private static final int TAILLE = 32;
private final long[] cles = new long[TAILLE];
private final long[] instants = new long[TAILLE];
private int suivant;
private int remplies;
public void noter(long cle, long nowMs) {
cles[suivant] = cle;
instants[suivant] = nowMs;
suivant = (suivant + 1) % TAILLE;
if (remplies < TAILLE) remplies++;
}
/** Vrai si {@code cle} a été notée dans les {@code fenetreMs} qui précèdent {@code nowMs} (bornes comprises). */
public boolean contient(long cle, long nowMs, long fenetreMs) {
for (int i = 0; i < remplies; i++) {
if (cles[i] == cle && nowMs >= instants[i] && nowMs - instants[i] <= fenetreMs) return true;
}
return false;
}
}
/** 0.5 (P3.3) : nuker. */
public final Nuker nuker = new Nuker();
/** 0.5 (P3.1) : auto-cristal. */
public final AutoCristal autoCristal = new AutoCristal();
/** 0.5 (P3.2) : tower. */
public final Tower tower = new Tower();
/** 0.6 : inventaire, scaffold horizontal, blink, phase (oubliés à la déconnexion avec le Suivi). */
public final Inventaire inventaire = new Inventaire();
public final Scaffold scaffold = new Scaffold();
public final Blink blink = new Blink();
public final Phase phase = new Phase();
/** 0.5 (P3.7) : complétion de commande. */
public final Completion completion = new Completion();
public boolean completionExces;
+35
Voir le fichier
@@ -0,0 +1,35 @@
package com.gastinelgarde.mixin;
import com.gastinelgarde.Garde;
import net.minecraft.network.protocol.game.ServerboundContainerClickPacket;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.server.network.ServerGamePacketListenerImpl;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
/**
* 0.6 (P2.6) : clics de conteneur (ChestStealer, InvCleaner, AutoArmor). Hors ENFORCE, rien ne change ; en ENFORCE au
* palier SETBACK, le clic est ignoré et le menu renvoyé au client.
*
* Règle (F01) : injecté juste APRÈS ensureRunningOnSameThread (MixinsThreadTest), donc sur le thread serveur.
*/
@Mixin(ServerGamePacketListenerImpl.class)
public abstract class ContainerClickMixin {
@Shadow public ServerPlayer player;
@Inject(method = "handleContainerClick",
at = @At(value = "INVOKE",
target = "Lnet/minecraft/network/protocol/PacketUtils;ensureRunningOnSameThread(Lnet/minecraft/network/protocol/Packet;Lnet/minecraft/network/PacketListener;Lnet/minecraft/server/level/ServerLevel;)V",
shift = At.Shift.AFTER),
cancellable = true)
private void gastinelgarde$clicConteneur(ServerboundContainerClickPacket packet, CallbackInfo ci) {
if (player != null && Garde.noterClicConteneur(player, packet.getContainerId(), packet.getSlotNum(),
packet.getClickType())) {
ci.cancel();
}
}
}
+4 -1
Voir le fichier
@@ -77,7 +77,10 @@ public abstract class MovePacketMixin {
target = "Lnet/minecraft/server/network/ServerGamePacketListenerImpl;teleport(DDDFF)V"))
private void gastinelgarde$refusVanilla(net.minecraft.network.protocol.game.ServerboundMovePlayerPacket packet,
CallbackInfo ci) {
if (player != null) Garde.annoncerTeleport(player, GraceTeleport.Origine.REFUS_VANILLA);
if (player == null) return;
// 0.6 (P3.5) : position déclarée dans un bloc solide ? (avant l'annonce, qui ne change pas la grâce de toute façon)
Garde.refusMouvement(player, packet.getX(player.getX()), packet.getY(player.getY()), packet.getZ(player.getZ()));
Garde.annoncerTeleport(player, GraceTeleport.Origine.REFUS_VANILLA);
}
// Renvoi d'une téléportation non confirmée au bout d'une seconde : garde l'origine de la précédente.
+1 -1
Voir le fichier
@@ -3,6 +3,6 @@
"minVersion": "0.8",
"package": "com.gastinelgarde.mixin",
"compatibilityLevel": "JAVA_21",
"mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin", "CompletionMixin"],
"mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin", "CompletionMixin", "ContainerClickMixin"],
"injectors": {"defaultRequire": 1}
}
+19
Voir le fichier
@@ -313,4 +313,23 @@ class CablageTest {
Cablage.CacheDetection c = new Cablage.CacheDetection();
assertFalse(c.lire(100, () -> false, 40));
}
// --- 0.6.1 (revue M1/M4) ---
@Test
void M1_deuxSetbacksDuMemePaquetUnSeulRetour() {
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.JESUS, 40, ms);
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.JESUS, Sanction.SETBACK)));
assertEquals(1, p.compte("teleport"));
assertEquals(1, p.compte("journal Tricheur SETBACK deja applique ce tick"));
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.JESUS, ms), 1e-9, "M4 : VL de jesus remis à zéro");
p.tick++;
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.JESUS, Sanction.SETBACK)));
assertEquals(2, p.compte("teleport"), "tick suivant : nouveau setback");
}
}
+1 -1
Voir le fichier
@@ -74,7 +74,7 @@ class MixinsThreadTest {
@Test
void F01_aucune_injection_HEAD_dans_un_handle() throws Exception {
for (String classe : new String[] {"com.gastinelgarde.mixin.MovePacketMixin", "com.gastinelgarde.mixin.RiptideMoveMixin",
"com.gastinelgarde.mixin.CompletionMixin"}) {
"com.gastinelgarde.mixin.CompletionMixin", "com.gastinelgarde.mixin.ContainerClickMixin"}) {
for (Injection i : injections(lire(classe))) {
if (!visePaquet(i) || i.at() == null) continue;
assertFalse("HEAD".equals(valeur(i.at(), "value")),
+31
Voir le fichier
@@ -0,0 +1,31 @@
package com.gastinelgarde;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.GardeConfig;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Test;
/** 0.6 : chaque réglage des sections [inventaire], [scaffold], [blink], [phase] a son champ dans GardeConfig. */
class Reglages06Test {
@Test
void chaqueCleA0nChampDuMemeNomEtLeMemeDefaut() throws Exception {
String src = Files.readString(Path.of(System.getProperty("gastinelgarde.projet", "."), "src/main/java/com/gastinelgarde/GardeSpec.java"));
Matcher m = Pattern.compile("V06\\.put\\(\"(\\w+)\".*?defineInRange\\(\"(\\w+)\", ([0-9.]+),", Pattern.DOTALL).matcher(src);
GardeConfig c = new GardeConfig();
int n = 0;
while (m.find()) {
assertEquals(m.group(1), m.group(2), "cle et champ");
java.lang.reflect.Field f = GardeConfig.class.getField(m.group(1));
double defaut = f.getType() == int.class ? f.getInt(c) : f.getDouble(c);
assertEquals(Double.parseDouble(m.group(3)), defaut, 1e-9, m.group(1));
n++;
}
assertTrue(n >= 19, "reglages trouves : " + n);
}
}
+132
Voir le fichier
@@ -0,0 +1,132 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.6, P3.4 : blink (trou de mouvements pendant que d'autres paquets arrivent). */
class BlinkP06Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private int mouv(Moteur m, long t, EtatJoueur e, boolean vivant) {
int n = 0;
for (Verdict v : m.mouvementBlink(joueur, t * 50L, t, e, vivant)) if (v.controle() == Controle.BLINK && v.points() > 0) n++;
return n;
}
private int mouv(Moteur m, long t) {
return mouv(m, t, EtatJoueur.normal(), true);
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.BLINK));
assertEquals(Controle.BLINK, Controle.parse("blink"));
}
@Test
void joueurImmobileQuiCliqueNonVu() {
// Immobile : un paquet de position toutes les 20 ticks ; il clique entre deux.
Moteur m = new Moteur(cfg);
int n = 0;
for (long t = 100; t < 1000; t += 20) {
n += mouv(m, t);
for (int k = 2; k < 20; k += 3) m.autrePaquet(joueur, t + k);
}
assertEquals(0, n);
}
@Test
void vraiLagNonVu() {
// Lag réseau : rien pendant 60 ticks, puis tout arrive dans le même tick (clics et mouvements mêlés, dans l'ordre).
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 160);
m.autrePaquet(joueur, 160);
assertEquals(0, mouv(m, 160));
}
@Test
void gelDuClientUnSeulTickNonVu() {
// Gel du client : au rattrapage, un clic part avant le mouvement du même tick client.
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 150);
assertEquals(0, mouv(m, 151));
}
@Test
void blinkVu() {
// Mouvements retenus 40 ticks, coups et clics envoyés pendant le trou.
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
m.autrePaquet(joueur, 135);
assertEquals(1, mouv(m, 140));
// le trou est soldé : le mouvement suivant normal ne compte pas
assertEquals(0, mouv(m, 141));
}
@Test
void autresPaquetsAvantLeRappelNonComptes() {
// Clics dans les 21 premiers ticks : le rappel de position vanilla n'était pas encore dû.
Moteur m = new Moteur(cfg);
mouv(m, 100);
for (long t = 101; t <= 121; t++) m.autrePaquet(joueur, t);
assertEquals(0, mouv(m, 140));
}
@Test
void blinkRepeteMonteAuPalier() {
cfg.mode(Controle.BLINK, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
boolean setback = false;
long t = 100;
mouv(m, t);
for (int i = 0; i < 10; i++) {
m.autrePaquet(joueur, t + 25);
m.autrePaquet(joueur, t + 28);
t += 32;
for (Verdict v : m.mouvementBlink(joueur, t * 50L, t, EtatJoueur.normal(), true)) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) setback = true;
}
}
assertTrue(setback);
}
@Test
void exemptions() {
EtatJoueur[] etats = {EtatJoueur.builder().ticksDepuisTeleport(10).build(),
EtatJoueur.builder().connexionRecente(true).build(), EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().ticksDepuisGel(50).build(), EtatJoueur.builder().tps(15).build(),
EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build()};
for (EtatJoueur e : etats) {
Moteur m = new Moteur(cfg);
mouv(m, 100, e, true);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
assertEquals(0, mouv(m, 140, e, true), e.toString());
}
// Mort : pas de mouvement sur l'écran de mort
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
assertEquals(0, mouv(m, 140, EtatJoueur.normal(), false));
}
@Test
void etatOublieALaDeconnexion() {
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
m.retirer(joueur);
assertEquals(0, mouv(m, 140)); // nouveau suivi : premier mouvement, rien à solder
}
}
+219
Voir le fichier
@@ -0,0 +1,219 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.6, P2.6 : inventaire (ChestStealer, InventoryMove, InvCleaner / AutoArmor). */
class InventaireP06Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private static EtatJoueur ping(int ms) {
return EtatJoueur.builder().pingMs(ms).build();
}
private static int compter(List<Verdict> v) {
int n = 0;
for (Verdict x : v) if (x.controle() == Controle.INVENTAIRE && x.points() > 0) n++;
return n;
}
/** Ouvre un coffre au tick 100 et prend n objets différents à partir de {@code debut}, un tous les {@code pas} ticks. */
private int session(Moteur m, EtatJoueur e, long debut, int pas, int n, boolean memeObjet) {
m.ouvrirConteneur(joueur, 100);
int verdicts = 0;
for (int i = 0; i < n; i++) {
long t = debut + (long) i * pas;
verdicts += compter(m.clicConteneur(joueur, t * 50L, t, e, true, true, Inventaire.Clic.PRISE, true,
memeObjet ? 7 : 10 + i));
}
return verdicts;
}
@Test
void observeParDefautEtSeuilsPropres() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.INVENTAIRE));
assertEquals(Controle.INVENTAIRE, Controle.parse("inventaire"));
cfg.inventaireSeuilSetback = 4;
assertEquals(Sanction.SETBACK, Paliers.palier(5, cfg, Controle.INVENTAIRE));
assertEquals(Sanction.ALERTE, Paliers.palier(5, cfg, Controle.TOWER)); // les autres gardent le seuil global
}
@Test
void humainRapideNonVu() {
// Réaction 300 ms (6 ticks, ping 50), puis un shift-clic tous les 2 ticks : très rapide mais humain.
assertEquals(0, session(new Moteur(cfg), ping(50), 106, 2, 27, false));
}
@Test
void doubleClicShiftVanillaNonVu() {
// Shift + double-clic : toutes les cases du même objet dans le même tick, dès 2 ticks après l'ouverture.
assertEquals(0, session(new Moteur(cfg), ping(0), 102, 0, 27, true));
}
@Test
void mouseTweaksApresReactionHumaineNonVu() {
// Glisser shift sur 9 cases en 2 ticks, mais 400 ms après l'ouverture : la réaction humaine sauve le joueur.
Moteur m = new Moteur(cfg);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int i = 0; i < 9; i++) {
long t = 108 + i / 5;
n += compter(m.clicConteneur(joueur, t * 50L, t, ping(0), true, true, Inventaire.Clic.PRISE, true, 10 + i));
}
assertEquals(0, n);
}
@Test
void pingEleveHonneteNonVu() {
// Ping 400 ms (plafonné à 300) : 650 ms après l'ouverture, réaction calculée 350 ms.
assertEquals(0, session(new Moteur(cfg), ping(400), 113, 1, 27, false));
}
@Test
void chestStealerVuEtChaquePriseSuivanteCompte() {
// Prises dès le tick suivant l'ouverture (ping 50 retiré : réaction 0), une par tick.
int v = session(new Moteur(cfg), ping(50), 101, 1, 27, false);
assertEquals(27 - cfg.inventairePrisesMin + 1, v);
}
@Test
void stealerQuiGonfleSonPingVuQuandMeme() {
// Ping déclaré 2000 ms : plafonné à 300, la réaction reste nulle.
assertTrue(session(new Moteur(cfg), ping(2000), 101, 1, 20, false) > 0);
}
@Test
void stealerLentNonVuLimiteConnue() {
// Délai aléatoire de 150 ms : intervalle moyen 3 ticks, pas vu (limite documentée).
assertEquals(0, session(new Moteur(cfg), ping(0), 101, 3, 27, false));
}
@Test
void creatifSpectateurEtGelServeurExemptes() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().ticksDepuisGel(5).build()}) {
assertEquals(0, session(new Moteur(cfg), e, 101, 1, 27, false), e.toString());
}
}
@Test
void lagServeurAssouplit() {
// TPS bas : paquets regroupés. Réaction exigée et intervalle maximal divisés par facteurLag (1,5) : réaction
// 66 ms au lieu de 100, intervalle 1,0 tick au lieu de 1,5. Première prise au tick 102 (100 ms) : jamais vue.
EtatJoueur lag = EtatJoueur.builder().tps(15).build();
assertTrue(session(new Moteur(cfg), EtatJoueur.normal(), 101, 1, 20, false) > 0);
assertEquals(0, session(new Moteur(cfg), lag, 102, 1, 20, false));
// Prises groupées 2 par tick (intervalle moyen 0,5) dès l'ouverture : vues même sous lag.
Moteur m = new Moteur(cfg);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int i = 0; i < 20; i++) {
long t = 100 + i / 2;
n += compter(m.clicConteneur(joueur, t * 50L, t, lag, true, true, Inventaire.Clic.PRISE, true, 10 + i));
}
assertTrue(n > 0);
}
@Test
void rotationEcranOuvertApresGraceVue() {
Moteur m = new Moteur(cfg);
m.regardInventaire(joueur, 0, 90, EtatJoueur.normal(), 0, 0);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int t = 101; t < 140; t++) {
n += compter(m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 3f, 10));
}
// grâce 10 ticks : rotations comptées à partir du tick 111, la 3e et les suivantes donnent des points
assertEquals(139 - 111 + 1 - (cfg.inventaireRotationsMin - 1), n);
}
@Test
void rotationPendantLaGraceOuSansConteneurNonVue() {
Moteur m = new Moteur(cfg);
m.regardInventaire(joueur, 0, 90, EtatJoueur.normal(), 0, 0);
m.ouvrirConteneur(joueur, 100);
int n = 0;
// le client n'a pas encore reçu l'écran (aller-retour) : il tourne encore
for (int t = 101; t <= 110; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 3f, 0));
m.fermerConteneur(joueur);
for (int t = 111; t < 200; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 3f, 0));
assertEquals(0, n);
}
@Test
void rotationEnVehiculeOuTeleportNonVue() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().ticksDepuisTeleport(0).build(), EtatJoueur.builder().elytres(true).build()}) {
Moteur m = new Moteur(cfg);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int t = 101; t < 160; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, e, t * 3f, 0));
assertEquals(0, n, e.toString());
}
}
@Test
void pingEleveAllongeLaGrace() {
Moteur m = new Moteur(cfg);
EtatJoueur e = ping(500); // grâce 10 + 10 ticks
m.regardInventaire(joueur, 0, 90, e, 0, 0);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int t = 101; t <= 120; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, e, t * 3f, 0));
assertEquals(0, n);
}
@Test
void invCleanerPendantRotationVu() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int t = 100; t < 120; t++) {
m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 5f, 0);
n += compter(m.clicConteneur(joueur, t * 50L, t, EtatJoueur.normal(), true, false, Inventaire.Clic.PRISE, false, 3));
}
assertTrue(n > 10);
}
@Test
void clicInventaireTeteImmobileNonVu() {
Moteur m = new Moteur(cfg);
m.regardInventaire(joueur, 0, 90, EtatJoueur.normal(), 0, 0);
int n = 0;
for (int t = 100; t < 160; t++) {
m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), 0, 0);
n += compter(m.clicConteneur(joueur, t * 50L, t, EtatJoueur.normal(), true, false, Inventaire.Clic.PRISE, false, 3));
}
assertEquals(0, n);
}
@Test
void clicsSurConteneurFermeJournalSeulementEnSerie() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 3; i++) n += m.clicConteneur(joueur, 1000 + i, 20, EtatJoueur.normal(), false, false,
Inventaire.Clic.PRISE, false, 0).size();
assertEquals(0, n);
for (int i = 3; i < 12; i++) n += m.clicConteneur(joueur, 1000 + i, 20, EtatJoueur.normal(), false, false,
Inventaire.Clic.PRISE, false, 0).size();
assertTrue(n > 0);
assertTrue(m.suivi(joueur).vl.valeur(Controle.INVENTAIRE, 1012) < cfg.seuilAlerte);
}
@Test
void etatOublieALaDeconnexion() {
Moteur m = new Moteur(cfg);
session(m, ping(0), 101, 1, 10, false);
Suivi avant = m.suivi(joueur);
assertTrue(avant.inventaire.sessionSuspecte());
m.retirer(joueur);
assertNotSame(avant, m.suivi(joueur));
assertTrue(!m.suivi(joueur).inventaire.sessionSuspecte() && !m.suivi(joueur).inventaire.ouvert());
}
}
+94
Voir le fichier
@@ -0,0 +1,94 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.6, P3.5 : phase (positions refusées par vanilla dans un bloc solide, en série). */
class PhaseP06Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private int refus(Moteur m, long nowMs, EtatJoueur e, boolean dansBloc) {
int n = 0;
for (Verdict v : m.refusPhase(joueur, nowMs, e, dansBloc, 0.5)) if (v.controle() == Controle.PHASE && v.points() > 0) n++;
return n;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.PHASE));
assertEquals(Controle.PHASE, Controle.parse("phase"));
}
@Test
void porteQuiSeFermeQuelquesRefusNonVu() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 4; i++) n += refus(m, 1000 + i * 500L, EtatJoueur.normal(), true);
assertEquals(0, n);
}
@Test
void refusHorsBlocNonComptes() {
// « moved too quickly » à cause du lag : refus, mais la position déclarée est libre.
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 50; i++) n += refus(m, 1000 + i * 100L, EtatJoueur.normal(), false);
assertEquals(0, n);
}
@Test
void refusEspacesNonVus() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 20; i++) n += refus(m, i * 15_000L, EtatJoueur.normal(), true);
assertEquals(0, n);
}
@Test
void clientDePhaseVu() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 20; i++) n += refus(m, 1000 + i * 100L, EtatJoueur.normal(), true);
assertEquals(20 - cfg.phaseSerieMin + 1, n);
}
@Test
void enforceMonteAuPalier() {
cfg.mode(Controle.PHASE, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
boolean setback = false;
for (int i = 0; i < 30; i++) {
for (Verdict v : m.refusPhase(joueur, 1000 + i * 100L, EtatJoueur.normal(), true, 1)) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) setback = true;
}
}
assertTrue(setback);
}
@Test
void exemptions() {
EtatJoueur[] etats = {EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build(),
EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().enVehicule(true).build(), EtatJoueur.builder().ticksDepuisTeleport(5).build(),
EtatJoueur.builder().ticksDepuisGel(5).build(), EtatJoueur.builder().tps(10).build()};
for (EtatJoueur e : etats) {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 20; i++) n += refus(m, 1000 + i * 100L, e, true);
assertEquals(0, n, e.toString());
}
}
@Test
void etatOublieALaDeconnexion() {
Moteur m = new Moteur(cfg);
for (int i = 0; i < 4; i++) refus(m, 1000 + i * 100L, EtatJoueur.normal(), true);
m.retirer(joueur);
assertEquals(0, refus(m, 1500, EtatJoueur.normal(), true));
}
}
+146
Voir le fichier
@@ -0,0 +1,146 @@
package com.gastinelgarde.core;
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 java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.6.1 : correctifs de la revue de sécurité du 25/10 (M1 à M4), côté moteur. */
class Revue061Test {
private final UUID joueur = UUID.randomUUID();
private static Verdict v(Controle c, Sanction s) {
return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of());
}
// --- M1 : un seul setback par tick ---
@Test
void M1_secondSetbackDuMemeTickReconnuEtNonCompte() {
Moteur m = new Moteur(new GardeConfig());
long t = 1000 * 50L;
assertFalse(m.setbackDejaApplique(joueur, t));
m.apresSetback(joueur, t, List.of(v(Controle.VOL, Sanction.SETBACK)));
assertTrue(m.setbackDejaApplique(joueur, t));
m.apresSetbackDuMemeTick(joueur, List.of(v(Controle.JESUS, Sanction.SETBACK)));
assertEquals(1, m.suivi(joueur).setbacksRecents(t, 60_000), "un seul compte pour l'escalade");
assertFalse(m.setbackDejaApplique(joueur, t + 50), "tick suivant : un nouveau setback est possible");
}
@Test
void M1_tricheurContinuEscaladeToujours() {
// Un setback par tick sur 4 ticks distincts : l'escalade compte bien 4 (la triche répétée reste sanctionnée).
Moteur m = new Moteur(new GardeConfig());
for (int i = 0; i < 4; i++) m.apresSetback(joueur, (1000 + i) * 50L, List.of(v(Controle.VOL, Sanction.SETBACK)));
assertEquals(4, m.suivi(joueur).setbacksRecents(1003 * 50L, 60_000));
}
// --- M4 : VL de la cause remis à zéro ---
@Test
void M4_vlDuControleCauseRemisAZero() {
Moteur m = new Moteur(new GardeConfig());
long t = 50_000;
Suivi s = m.suivi(joueur);
s.vl.ajouter(Controle.STEP, 40, t);
s.vl.ajouter(Controle.NO_SLOW, 30, t);
s.vl.ajouter(Controle.KILLAURA_CIBLES, 7, t);
m.apresSetback(joueur, t, List.of(v(Controle.STEP, Sanction.SETBACK), v(Controle.NO_SLOW, Sanction.ALERTE)));
assertEquals(0, s.vl.valeur(Controle.STEP, t), 1e-9);
assertEquals(30, s.vl.valeur(Controle.NO_SLOW, t), 1e-9, "verdict sous SETBACK : VL gardé");
assertEquals(7, s.vl.valeur(Controle.KILLAURA_CIBLES, t), 1e-9, "contrôle sans rapport : VL gardé");
}
@Test
void M4_ancienneSignatureInchangee() {
Moteur m = new Moteur(new GardeConfig());
Suivi s = m.suivi(joueur);
s.vl.ajouter(Controle.STEP, 40, 0);
s.vl.ajouter(Controle.VOL, 40, 0);
m.apresSetback(joueur, 0);
assertEquals(40, s.vl.valeur(Controle.STEP, 0), 1e-9);
assertEquals(0, s.vl.valeur(Controle.VOL, 0), 1e-9);
}
// --- M2 : casses en chaîne d'un mod (exemption configurable, désactivée par défaut) ---
@Test
void M2_desactiveParDefaut() {
GardeConfig cfg = new GardeConfig();
assertFalse(cfg.nukerIgnorerCassesSansPaquet);
assertFalse(new Moteur(cfg).casseNukerSansPaquet(joueur, 42L, 5000));
}
@Test
void M2_activee_cassesDUnModIgnoreesNukerAvecPaquetsVu() {
GardeConfig cfg = new GardeConfig();
cfg.nukerIgnorerCassesSansPaquet = true;
Moteur m = new Moteur(cfg);
long t = 100 * 50L;
// Abattage d'arbre : un paquet sur la bûche du bas, 12 bûches cassées par le mod.
m.paquetCasse(joueur, 1L, t);
assertFalse(m.casseNukerSansPaquet(joueur, 1L, t), "le bloc visé par le joueur compte");
for (long k = 2; k <= 12; k++) assertTrue(m.casseNukerSansPaquet(joueur, k, t), "bûche du mod ignorée");
// Nuker de client : un paquet par bloc, tous comptés.
for (long k = 100; k < 110; k++) m.paquetCasse(joueur, k, t + 50);
for (long k = 100; k < 110; k++) assertFalse(m.casseNukerSansPaquet(joueur, k, t + 50));
// Un paquet d'un tick précédent ne couvre pas la casse de ce tick.
assertTrue(m.casseNukerSansPaquet(joueur, 1L, t + 100));
}
// --- M3 : blocs fantômes ---
private static final double[] CUBE = {0, 64, 0, 1, 65, 1};
private static final double[] OEIL = {0.5, 66.62, 2};
private static final double[] IMPACT = {0.5, 65, 0.5};
private double clicsAir(Moteur m, long cle, long debut, boolean changerAvant) {
double pts = 0;
for (int i = 0; i < 10; i++) {
long t = debut + i * 500L;
if (changerAvant) m.changementBloc(joueur, cle + i, t - 100);
for (Verdict x : m.interactionBloc(joueur, t, cle + i, 0, EtatJoueur.normal(), OEIL, CUBE, 1, IMPACT,
true, true, 4.5, 0)) {
if (x.controle() == Controle.INTERACTION_BLOC) pts += x.points();
}
}
return pts;
}
@Test
void M3_blocFantomeApresCasseNonCompte() {
assertEquals(0, clicsAir(new Moteur(new GardeConfig()), 1000, 10_000, true), 1e-9);
}
@Test
void M3_airPlaceSurBlocJamaisChangeToujoursVu() {
assertTrue(clicsAir(new Moteur(new GardeConfig()), 1000, 10_000, false) > 0);
}
@Test
void M3_changementAncienNeCouvrePas() {
Moteur m = new Moteur(new GardeConfig());
double pts = 0;
for (int i = 0; i < 10; i++) {
long t = 10_000 + i * 500L;
m.changementBloc(joueur, 7, t - 2000); // changé il y a 2 s : plus un bloc fantôme
for (Verdict x : m.interactionBloc(joueur, t, 7, 0, EtatJoueur.normal(), OEIL, CUBE, 1, IMPACT, true, true, 4.5, 0)) {
if (x.controle() == Controle.INTERACTION_BLOC) pts += x.points();
}
}
assertTrue(pts > 0);
}
@Test
void M3_memoireCirculaire() {
Suivi.PositionsRecentes r = new Suivi.PositionsRecentes();
for (int i = 0; i < 40; i++) r.noter(i, 1000);
assertFalse(r.contient(0, 1000, 0), "entrée la plus ancienne écrasée");
assertTrue(r.contient(39, 1000, 0));
assertFalse(r.contient(39, 999, 10), "instant futur refusé");
}
}
+117
Voir le fichier
@@ -0,0 +1,117 @@
package com.gastinelgarde.core;
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 java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.6, P3.2 : scaffold horizontal (pont hors regard, rotations snap). */
class ScaffoldP06Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/**
* n poses de pont, une toutes les 5 ticks. Rotation au moment de la pose (yawPose, pitchPose), rotation du paquet
* d'avant (yawAvant), rotation du paquet d'après (yawApres) ; direction du point cliqué (dirYaw, dirPitch).
*/
private int pont(Moteur m, EtatJoueur e, int n, float dirYaw, float dirPitch, float yawAvant, float yawPose,
float pitchPose, float yawApres, float pitchApres) {
int verdicts = 0;
for (int i = 0; i < n; i++) {
long t = 100 + i * 5L;
m.poseScaffold(joueur, e, dirYaw, dirPitch, yawAvant, pitchApres, yawPose, pitchPose);
for (Verdict v : m.regardScaffold(joueur, (t + 1) * 50L, t + 1, yawApres, pitchApres)) {
if (v.controle() == Controle.SCAFFOLD) verdicts++;
}
}
return verdicts;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.SCAFFOLD));
assertEquals(Controle.SCAFFOLD, Controle.parse("scaffold"));
}
@Test
void geometrieDuPont() {
// joueur au bord d'un pont vers +x, bloc posé devant/sous ses pieds
assertTrue(Scaffold.estPont(11, 63, 20, 10.9, 64, 20.5, 0, 0.2));
// tower (dans la colonne), saut, immobile, trop loin : pas un pont
assertFalse(Scaffold.estPont(10, 63, 20, 10.5, 64, 20.5, 0, 0.2));
assertFalse(Scaffold.estPont(11, 63, 20, 10.9, 64, 20.5, 0.42, 0.2));
assertFalse(Scaffold.estPont(11, 63, 20, 10.9, 64, 20.5, 0, 0));
assertFalse(Scaffold.estPont(14, 63, 20, 10.9, 64, 20.5, 0, 0.2));
}
@Test
void rotationEtAngle() {
float[] r = Scaffold.rotation(0, -1, 0); // vers le bas
assertEquals(90, r[1], 1e-3);
r = Scaffold.rotation(0, 0, 1); // vers +z = yaw 0
assertEquals(0, r[0], 1e-3);
assertEquals(180, Scaffold.angle(0, 0, 180, 0), 1e-6);
assertEquals(0, Scaffold.angle(10, 90, 170, 90), 1e-3); // à la verticale, le yaw ne compte plus
}
@Test
void pontEnReculantHonneteNonVu() {
// Regard fixe vers l'arrière et le bas (yaw 180, pitch 78), point cliqué à 5° du regard.
assertEquals(0, pont(new Moteur(cfg), EtatJoueur.normal(), 60, 175, 80, 180, 180, 78, 180, 78));
}
@Test
void retournementRapideIsoleNonVu() {
// Un vrai joueur se retourne d'un coup pour poser derrière lui : une ou deux poses anormales, pas une série.
Moteur m = new Moteur(cfg);
int n = pont(m, EtatJoueur.normal(), 2, 180, 80, 0, 0, 0, 180, 80);
n += pont(m, EtatJoueur.normal(), 30, 175, 80, 180, 180, 78, 180, 78);
assertEquals(0, n);
}
@Test
void scaffoldSansRotationVu() {
// Regard devant (yaw 0, pitch 10), pose derrière sous les pieds (yaw 180, pitch 75) : hors regard en série.
int n = pont(new Moteur(cfg), EtatJoueur.normal(), 20, 180, 75, 0, 0, 10, 0, 10);
assertEquals(20 - cfg.scaffoldSerieMin + 1, n);
}
@Test
void scaffoldRotationSilencieuseSnapVu() {
// Rotation silencieuse : le paquet de la pose vise le bloc (yaw 180, pitch 80), celui d'avant et d'après
// regardent devant (yaw 0, pitch 5). Le point cliqué est dans le regard de la pose : seul le snap le trahit.
int n = pont(new Moteur(cfg), EtatJoueur.normal(), 20, 180, 80, 0, 180, 80, 0, 5);
assertEquals(20 - cfg.scaffoldSerieMin + 1, n);
}
@Test
void creatifElytresVolExemptes() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().elytres(true).build(), EtatJoueur.builder().peutVoler(true).build(),
EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().tps(12).build()}) {
assertEquals(0, pont(new Moteur(cfg), e, 30, 180, 75, 0, 0, 10, 0, 10), e.toString());
}
}
@Test
void enforceAnnuleLesPosesSuivantesSeulementQuandSuspect() {
cfg.mode(Controle.SCAFFOLD, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
assertFalse(m.scaffoldAnnuler(joueur, 0, 0));
pont(m, EtatJoueur.normal(), 40, 180, 75, 0, 0, 10, 0, 10);
long t = 100 + 40 * 5L;
assertTrue(m.scaffoldAnnuler(joueur, t * 50L, t));
// OBSERVE : jamais d'annulation
cfg.mode(Controle.SCAFFOLD, Mode.OBSERVE);
assertFalse(m.scaffoldAnnuler(joueur, t * 50L, t));
}
@Test
void sansPoseRienAJuger() {
Moteur m = new Moteur(cfg);
assertEquals(0, m.regardScaffold(joueur, 0, 0, 0, 0).size());
}
}