Comparer les révisions

...
Auteur SHA1 Message Date

2026-10-25

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
23 fichiers modifiés avec 1468 ajouts et 7 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.0-dev
mod_group_id=com.gastinelgarde
mod_id=gastinelgarde
+132 -1
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). */
@@ -444,10 +446,115 @@ 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);
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,
@@ -508,6 +615,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));
@@ -840,6 +948,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 +1001,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) {
+58
Voir le fichier
@@ -40,6 +40,8 @@ public final class GardeSpec {
// 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;
@@ -347,6 +349,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);
@@ -556,6 +603,17 @@ public final class GardeSpec {
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
};
}
+34
Voir le fichier
@@ -243,6 +243,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;
}
}
+141
Voir le fichier
@@ -608,6 +608,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}.
+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};
}
}
+5
Voir le fichier
@@ -87,6 +87,11 @@ public final class Suivi {
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}
}
+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));
}
}
+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());
}
}