Comparer les révisions
6
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
c2a0d5403d | |||
|
|
67ddfff41a | |||
|
|
fad2bf0437 | |||
|
|
544f11dfa5 | |||
|
|
ad436ac213 | |||
|
|
a88e4409e4 | |||
Aucun fichier ne correspond à votre recherche
@@ -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,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
|
||||
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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};
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
|
||||
@@ -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}
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
@@ -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")),
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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é");
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur