Comparer les révisions
39
Révisions
Aucun fichier ne correspond à votre recherche
+12
-12
@@ -1,18 +1,18 @@
|
||||
# Journal des versions
|
||||
|
||||
## 0.3.2 (19/10/2026)
|
||||
## 0.4.0 (non publiée, branche feat/suspicion-score, dérivée de release/0.3.1 = jar déployé)
|
||||
|
||||
Correctifs des défauts D1 à D3 trouvés aux essais en jeu du 19/10 (rapport-garde-test-1019). Modes et options
|
||||
inchangés. Testé hors jeu seulement (tests unitaires) ; rien n'a été rejoué en jeu.
|
||||
|
||||
- D1 : après une téléportation externe (/tp, TPA, perle, mod), une réapparition, un changement de dimension ou une
|
||||
connexion, le point d'arrivée devient la position de retour. Avant, un setback avant le premier contact au sol
|
||||
ramenait à la position d'avant la téléportation.
|
||||
- D2 : un setback `portee` / `hitbox` (coups annulés) remet le VL de ce contrôle à zéro et compte pour C5 : l'expulsion
|
||||
de combat vient après 4 setbacks en 60 s (avant : ~5 s, VL à 20 sans passer par C5). Les setbacks de combat et de
|
||||
mouvement sont comptés ensemble pour C5.
|
||||
- D3 : no-fall voit le NoFall « paquet d'état » : un paquet sans déplacement qui déclare « au sol » sans bloc dessous
|
||||
est jugé avec la vitesse verticale du dernier paquet de la chute.
|
||||
Testé hors jeu seulement (JUnit) ; rien n'a été essayé sur un serveur Minecraft. Aucun mode existant n'est modifié.
|
||||
- Score de suspicion 0-100 par joueur (section `[suspicion]`) : journal dès 25, message aux ops dès 50, dès 75 simple
|
||||
proposition « suspect_2 à valider dans le Portail ». Jamais de sanction ni de bannissement à partir du score.
|
||||
Historique des incidents par UUID sur 7 jours dans `gastinelgarde-suspicion/incidents.csv`. `/garde status <joueur>`
|
||||
affiche le score. Pas de signalement au Hub (absent de cette base, voir le rapport).
|
||||
- Vol : flottement prolongé (`volFlottementTicks` = 80, équivalent du « kicked for floating too long » vanilla), pour
|
||||
pouvoir passer `allow-flight=true`. Insensible aux paquets à 0 tick et aux trous de ticks.
|
||||
- Nouveaux contrôles, OBSERVE par défaut : `elytres` (Elytra Hack), `velocite` (Anti Knockback / Anti Push),
|
||||
`auto-totem` (section `[nouveauxControles]`).
|
||||
- Correctif : le motif écrit pour une sanction (journal, message d'expulsion) est celui du verdict qui sanctionne,
|
||||
plus celui du premier verdict de la liste.
|
||||
|
||||
## 0.3.1 (16/10/2026)
|
||||
|
||||
|
||||
@@ -44,6 +44,29 @@ test {
|
||||
testLogging { events 'passed', 'failed'; exceptionFormat 'full' }
|
||||
}
|
||||
|
||||
// 0.5 (P1.4) : une seule source de version (gradle.properties) : neoforge.mods.toml et le manifeste du jar.
|
||||
processResources {
|
||||
def props = [mod_version: project.mod_version]
|
||||
inputs.properties props
|
||||
filesMatching('META-INF/neoforge.mods.toml') { expand props }
|
||||
}
|
||||
|
||||
jar {
|
||||
manifest {
|
||||
attributes(
|
||||
'Implementation-Title': 'GastinelGarde',
|
||||
'Implementation-Version': project.mod_version,
|
||||
'Implementation-Vendor': 'Theo Gastinel'
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
test {
|
||||
// Le test de version compare le neoforge.mods.toml traité à gradle.properties.
|
||||
systemProperty 'gastinelgarde.version', project.mod_version
|
||||
systemProperty 'gastinelgarde.projet', project.projectDir.absolutePath
|
||||
}
|
||||
|
||||
tasks.withType(JavaCompile).configureEach {
|
||||
options.encoding = 'UTF-8'
|
||||
options.release = 21
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
org.gradle.jvmargs=-Xmx2G
|
||||
org.gradle.parallel=true
|
||||
|
||||
mod_version=0.3.2
|
||||
mod_version=0.5.0
|
||||
mod_group_id=com.gastinelgarde
|
||||
mod_id=gastinelgarde
|
||||
|
||||
|
||||
@@ -115,6 +115,27 @@ final class Cablage {
|
||||
}
|
||||
}
|
||||
|
||||
// --- 0.4.0 : grace de propulsion d'une fusee (plane en elytres) ---
|
||||
|
||||
/** Ticks de marge après la fin de vie de la fusée (dernier tick de poussée, retard d'état). */
|
||||
static final int MARGE_FUSEE_TICKS = 20;
|
||||
/** 0.4.1 : duree de vie vanilla d'une fusee : 10 x (1 + duree de vol) + 0..11, soit 20 a 51 ticks pour les durees 1 a 3. */
|
||||
static final int VIE_FUSEE_MAX = 60;
|
||||
|
||||
/**
|
||||
* Grâce de propulsion accordée à l'apparition d'une fusée : seulement si elle est réellement attachée au joueur
|
||||
* (propulsion en plané, pas une fusée d'arbalète ou posée au sol), si le joueur plane à cet instant, et si elle
|
||||
* ne vient pas d'être rechargée depuis le disque. Durée : vie restante réelle de la fusée + marge, au lieu de 6 s
|
||||
* fixes (un tricheur qui tire une fusée toutes les quelques secondes n'obtient jamais plus que la vie de la fusée).
|
||||
*
|
||||
* @return nombre de ticks de grâce (0 = aucune)
|
||||
*/
|
||||
static int graceFusee(boolean attacheeAuJoueur, boolean joueurPlane, boolean rechargeeDuDisque, int vie, int dureeDeVie) {
|
||||
if (!attacheeAuJoueur || !joueurPlane || rechargeeDuDisque) return 0;
|
||||
int restant = Math.max(0, dureeDeVie - Math.max(0, vie));
|
||||
return Math.min(restant, VIE_FUSEE_MAX) + MARGE_FUSEE_TICKS;
|
||||
}
|
||||
|
||||
// --- Position de retour (C3) ---
|
||||
|
||||
/** apresMouvement : la position de ce paquet devient-elle la position de retour ? */
|
||||
@@ -124,13 +145,23 @@ final class Cablage {
|
||||
&& moteur.positionDeRetourAdmise(solServeur, milieuSpecial);
|
||||
}
|
||||
|
||||
// --- 0.5 (P1.1) : journal des verdicts ---
|
||||
|
||||
/**
|
||||
* D1 (0.3.2) : après une téléportation externe (/tp, TPA, perle, réapparition, dimension), le point d'arrivée
|
||||
* devient la position de retour. Les autres (setback, refus vanilla) ne la changent pas.
|
||||
* Ligne de journal pour ce verdict ? Le journal est limité (une ligne par seconde et par contrôle, voir
|
||||
* Suivi.autoriserJournal) pour ne pas écrire une ligne par tick pendant une chute ; mais le verdict qui déclenche
|
||||
* un SETBACK ou une EXPULSION est toujours écrit si {@code toujoursSanctions} (diagnostic 0.4.0 : l'expulsion
|
||||
* arrivait sans la ligne du verdict qui l'avait causée). Paresseux : la limite n'est pas consommée pour un
|
||||
* verdict de sanction écrit d'office.
|
||||
*/
|
||||
static void retourApresTeleport(Suivi sv, boolean externe, double x, double y, double z, float yaw, float pitch,
|
||||
String dimension) {
|
||||
if (externe) sv.memoriserPosition(x, y, z, yaw, pitch, dimension);
|
||||
static boolean ecrireVerdict(Verdict v, boolean toujoursSanctions, BooleanSupplier limiteAutorise) {
|
||||
if (toujoursSanctions && v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) return true;
|
||||
return limiteAutorise.getAsBoolean();
|
||||
}
|
||||
|
||||
/** Délai (ms) entre deux lignes d'un même contrôle pour {@code lignesParSeconde} lignes par seconde (au moins 1). */
|
||||
static long delaiJournalMs(int lignesParSeconde) {
|
||||
return 1000L / Math.max(1, lignesParSeconde);
|
||||
}
|
||||
|
||||
// --- Sanctions (C2, C4) ---
|
||||
@@ -145,24 +176,76 @@ final class Cablage {
|
||||
void teleporter(double x, double y, double z, float yaw, float pitch);
|
||||
void deconnecter(String message);
|
||||
void journal(String ligne);
|
||||
|
||||
/**
|
||||
* 0.5 (P1.2) : position au sol juste SOUS le joueur (même x, z ; y du premier bloc solide en dessous, au plus
|
||||
* 64 blocs), {x, y, z, yaw, pitch}, ou null si rien trouvé ou place insuffisante. Jamais de déplacement
|
||||
* horizontal : le setback de secours ne peut pas servir à se téléporter.
|
||||
*/
|
||||
default double[] solSous() { return null; }
|
||||
}
|
||||
|
||||
/**
|
||||
* Motif écrit pour une sanction : le contrôle du verdict qui l'a déclenchée (applicable == sanction). Avant 0.4.0
|
||||
* c'était le premier de la liste, donc un contrôle en OBSERVE (vitesse) pouvait être accusé à la place du vol.
|
||||
* À défaut, le verdict le plus sévère, puis « anti-triche ».
|
||||
*/
|
||||
static String raison(List<Verdict> verdicts, Sanction s) {
|
||||
Verdict retenu = null;
|
||||
Verdict auPalier = null;
|
||||
for (Verdict v : verdicts) {
|
||||
// 0.5 (P1.3) : plusieurs verdicts au même palier : celui de plus fort VL (avant : le premier, ordre de l'enum).
|
||||
if (v.applicable() == s && (auPalier == null || v.vl() > auPalier.vl())) auPalier = v;
|
||||
if (retenu == null || v.applicable().ordinal() > retenu.applicable().ordinal()) retenu = v;
|
||||
}
|
||||
if (auPalier != null) return auPalier.controle().id();
|
||||
return retenu == null ? "anti-triche" : retenu.controle().id();
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P1.3) : motif complet pour le journal : le contrôle retenu, puis les autres contrôles au même palier
|
||||
* (« vol ; aussi : vitesse »). Le message d'expulsion au joueur garde le seul motif retenu.
|
||||
*/
|
||||
static String motifJournal(List<Verdict> verdicts, Sanction s) {
|
||||
String r = raison(verdicts, s);
|
||||
java.util.LinkedHashSet<String> autres = new java.util.LinkedHashSet<>();
|
||||
for (Verdict v : verdicts) {
|
||||
if (v.applicable() == s && !v.controle().id().equals(r)) autres.add(v.controle().id());
|
||||
}
|
||||
return autres.isEmpty() ? r : r + " ; aussi : " + String.join(", ", autres);
|
||||
}
|
||||
|
||||
/** Expulsion à usage unique (C4) ; setback vers la position de retour de la même dimension, puis remise à zéro (C2). */
|
||||
static void appliquerSanction(Moteur moteur, Joueur p, Sanction s, List<Verdict> verdicts) {
|
||||
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
|
||||
String raison = raison(verdicts, s);
|
||||
String motif = motifJournal(verdicts, s); // P1.3 : journal avec les autres contrôles du palier
|
||||
if (s == Sanction.EXPULSION) {
|
||||
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
|
||||
if (!moteur.expulser(p.id(), p.tick() * 50L)) return;
|
||||
p.journal(p.nom() + " EXPULSE (" + raison + ")");
|
||||
p.journal(p.nom() + " EXPULSE (" + motif + ")");
|
||||
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
|
||||
} else if (s == Sanction.SETBACK) {
|
||||
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);
|
||||
p.journal(p.nom() + " SETBACK (" + raison + ")");
|
||||
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);
|
||||
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 {
|
||||
// 0.5 (P1.1) : avant, rien n'était fait ni écrit (reconnexion en l'air) et le VL montait jusqu'à
|
||||
// l'expulsion sans trace du setback raté.
|
||||
String pourquoi = !sv.aPositionValide() ? "pas de position de retour valide"
|
||||
: "position de retour dans une autre dimension (" + sv.dimension() + ")";
|
||||
p.journal(p.nom() + " SETBACK impossible (" + motif + ") : " + pourquoi);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -60,6 +60,10 @@ public final class Garde {
|
||||
/** Marques propres à un joueur, côté adaptateur (ticks du serveur). */
|
||||
private static final class Marques {
|
||||
int teleportTick = Integer.MIN_VALUE;
|
||||
/** 0.5 (P1.2) : jusqu'à ce tick, grâce de connexion. */
|
||||
int connexionJusquaTick = Integer.MIN_VALUE;
|
||||
/** 0.4.0 : jusqu'à ce tick, une fusée a propulsé le joueur (plané non contrôlé). */
|
||||
int propulsionJusquaTick = Integer.MIN_VALUE;
|
||||
int reculTick = Integer.MIN_VALUE;
|
||||
int dernierVerdictTick = Integer.MIN_VALUE;
|
||||
int dernierTraceTick = Integer.MIN_VALUE;
|
||||
@@ -80,6 +84,8 @@ public final class Garde {
|
||||
final Cablage.CacheDetection contraption = new Cablage.CacheDetection();
|
||||
// C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
|
||||
int solServeurTick = Integer.MIN_VALUE;
|
||||
/** 0.5 (P1.6) : en plané au paquet de mouvement précédent. */
|
||||
boolean planeAvant;
|
||||
final Cablage.Elytres elytres = new Cablage.Elytres();
|
||||
// Cache de la détection d'un courant d'air (ventilateur Create), même principe
|
||||
final Cablage.CacheDetection courant = new Cablage.CacheDetection();
|
||||
@@ -141,8 +147,16 @@ public final class Garde {
|
||||
journal = jeu.resolve("logs").resolve("gastinelgarde.log");
|
||||
try {
|
||||
Files.createDirectories(journal.getParent());
|
||||
ecrireJournal("demarrage GastinelGarde " + GastinelGarde.version()); // 0.5 (P1.4) : version au journal
|
||||
traces = new TraceFichier(jeu.resolve("gastinelgarde-traces"), GardeSpec.tracesJours(), GardeSpec.tracesTailleOctets());
|
||||
tracesEnCours = GardeSpec.tracesActives();
|
||||
// Historique de suspicion : même dossier de jeu que les traces et les journaux (voir HistoriqueSuspicion).
|
||||
try {
|
||||
MOTEUR.historique().ouvrir(jeu.resolve("gastinelgarde-suspicion").resolve("incidents.csv"),
|
||||
System.currentTimeMillis(), CONFIG.suspicionHistoriqueJours);
|
||||
} catch (IOException | RuntimeException e) {
|
||||
GastinelGarde.LOGGER.warn("[GastinelGarde] historique de suspicion illisible, repart à vide : {}", e.toString());
|
||||
}
|
||||
} catch (IOException e) {
|
||||
GastinelGarde.LOGGER.error("[GastinelGarde] Impossible d'ouvrir le dossier de traces", e);
|
||||
traces = null;
|
||||
@@ -197,9 +211,18 @@ public final class Garde {
|
||||
m.vehiculeId = -1;
|
||||
m.oeilAvant = null;
|
||||
m.oeilDernier = null;
|
||||
// D1 (0.3.2) : réapparition, changement de dimension, connexion : la position actuelle devient le retour.
|
||||
Cablage.retourApresTeleport(MOTEUR.suivi(p.getUUID()), true, p.getX(), p.getY(), p.getZ(), p.getYRot(),
|
||||
p.getXRot(), p.level().dimension().location().toString());
|
||||
}
|
||||
|
||||
/** 0.5 (P1.2) : connexion : grâce de connexion (plus longue après une expulsion récente), en plus de la téléportation. */
|
||||
public static void noterConnexion(ServerPlayer p) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
noterTeleport(p);
|
||||
int tick = p.server.getTickCount();
|
||||
int grace = MOTEUR.graceConnexionTicks(p.getUUID(), tick * 50L);
|
||||
marques(p.getUUID()).connexionJusquaTick = tick + grace;
|
||||
if (grace > CONFIG.graceConnexionTicks) {
|
||||
ecrireJournal(p.getGameProfile().getName() + " reconnexion apres expulsion recente : grace de " + grace + " ticks");
|
||||
}
|
||||
}
|
||||
|
||||
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
|
||||
@@ -212,21 +235,10 @@ public final class Garde {
|
||||
* Tout teleport() du joueur (mixin) : la grâce ne s'ouvre que pour une origine externe (F05). Le mouvement
|
||||
* suivant n'est jamais comparé à la position d'avant la téléportation.
|
||||
*/
|
||||
public static void teleportVanilla(ServerPlayer p, double x, double y, double z, float yaw, float pitch,
|
||||
Set<?> relatifs) {
|
||||
public static void teleportVanilla(ServerPlayer p) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
Marques m = marques(p.getUUID());
|
||||
boolean externe = m.graceTeleport.teleport();
|
||||
if (externe) m.teleportTick = p.server.getTickCount();
|
||||
// D1 (0.3.2) : téléportation externe (/tp, TPA, perle, mod) : le point d'arrivée devient la position de
|
||||
// retour (avant : un setback ramenait à la position d'avant la téléportation).
|
||||
Cablage.retourApresTeleport(MOTEUR.suivi(p.getUUID()), externe,
|
||||
relatifs.contains(net.minecraft.world.entity.RelativeMovement.X) ? p.getX() + x : x,
|
||||
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Y) ? p.getY() + y : y,
|
||||
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Z) ? p.getZ() + z : z,
|
||||
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Y_ROT) ? p.getYRot() + yaw : yaw,
|
||||
relatifs.contains(net.minecraft.world.entity.RelativeMovement.X_ROT) ? p.getXRot() + pitch : pitch,
|
||||
p.level().dimension().location().toString());
|
||||
if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount();
|
||||
m.mouvementTick = Integer.MIN_VALUE;
|
||||
m.vehiculeId = -1;
|
||||
m.oeilAvant = null;
|
||||
@@ -349,6 +361,217 @@ public final class Garde {
|
||||
if (m.graceRecul.recul(tick, autoInflige)) m.reculTick = tick;
|
||||
}
|
||||
|
||||
/** Fusée de feu d'artifice tirée par ce joueur (propulsion en plané) : le plané n'est pas contrôlé pendant 6 s. */
|
||||
public static void noterFusee(ServerPlayer p, int ticks) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
Marques m = marques(p.getUUID());
|
||||
m.propulsionJusquaTick = Math.max(m.propulsionJusquaTick, p.server.getTickCount() + ticks);
|
||||
MOTEUR.nouvelleFusee(p.getUUID());
|
||||
}
|
||||
|
||||
/** 0.4.0 : recul appliqué par le serveur (direction du déplacement attendu, force avant résistance). */
|
||||
public static void noterVelocite(ServerPlayer p, double dirX, double dirZ, double force) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
double resistance = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.KNOCKBACK_RESISTANCE);
|
||||
// Le joueur est-il libre de reculer ? Boîte déplacée de 0,6 puis 1,2 bloc dans le sens du recul : un mur, un trou
|
||||
// d'un bloc ou un plafond bas (coup d'un tiers qui coince le joueur) annulent la mesure.
|
||||
double norme = Math.hypot(dirX, dirZ);
|
||||
boolean libre = norme > 1e-6;
|
||||
if (libre) {
|
||||
net.minecraft.world.phys.AABB b = p.getBoundingBox();
|
||||
double ux = dirX / norme, uz = dirZ / norme;
|
||||
libre = p.level().noCollision(p, b.move(ux * 0.6, 0, uz * 0.6)) && p.level().noCollision(p, b.move(ux * 1.2, 0, uz * 1.2));
|
||||
}
|
||||
MOTEUR.reculApplique(p.getUUID(), p.server.getTickCount() * 50L, dirX, dirZ,
|
||||
force * Math.max(0.0, 1.0 - resistance), libre);
|
||||
}
|
||||
|
||||
/** 0.4.0 : un totem d'immortalité vient d'éclater (hand = main qui le tenait). */
|
||||
public static void noterTotem(ServerPlayer p, net.minecraft.world.InteractionHand hand) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
net.minecraft.world.InteractionHand autre = hand == net.minecraft.world.InteractionHand.MAIN_HAND
|
||||
? net.minecraft.world.InteractionHand.OFF_HAND : net.minecraft.world.InteractionHand.MAIN_HAND;
|
||||
boolean reserve = p.getItemInHand(autre).is(Items.TOTEM_OF_UNDYING);
|
||||
MOTEUR.totemEclate(p.getUUID(), p.server.getTickCount() * 50L, reserve);
|
||||
// 0.4.1 : trace de diagnostic (rare : un totem qui eclate) ; explique l'absence de ligne auto-totem ensuite.
|
||||
ecrireJournal(String.format("%s auto-totem eclatement main=%s reserve=%s mode=%s expulse=%s exempte=%s",
|
||||
p.getGameProfile().getName(), hand, reserve, CONFIG.mode(Controle.AUTO_TOTEM),
|
||||
MOTEUR.estExpulse(p.getUUID()), estExempteManuellement(p.getUUID())));
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P1.10) : coup critique vanilla accordé à ce joueur. Renvoie vrai si le critique doit être annulé (contrôle
|
||||
* criticals en ENFORCE, palier SETBACK ou plus) ; une EXPULSION est appliquée ici.
|
||||
*/
|
||||
public static boolean noterCritique(ServerPlayer p) {
|
||||
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID()) || estExempteManuellement(p.getUUID())) return false;
|
||||
List<Verdict> v = MOTEUR.critique(p.getUUID(), p.server.getTickCount() * 50L, etat(p, true));
|
||||
Sanction s = traiter(p, v);
|
||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||
return Cablage.sanctionDeMouvement(s);
|
||||
}
|
||||
/**
|
||||
* 0.5 (P1.13) : action de casse de bloc reçue (événement LeftClickBlock, vu même annulé). Diagnostic seulement :
|
||||
* 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) {
|
||||
if (!CONFIG.diagnosticActionsBloc || !surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
|
||||
com.gastinelgarde.core.ActionsBloc a = MOTEUR.suivi(p.getUUID()).actionsBloc;
|
||||
if (start) {
|
||||
a.start(pos.getX(), pos.getY(), pos.getZ(), annule);
|
||||
} else if (abort) {
|
||||
String ligne = a.abort(pos.getX(), pos.getY(), pos.getZ(), System.currentTimeMillis());
|
||||
if (ligne != null) ecrireJournal("DIAGNOSTIC " + p.getGameProfile().getName() + " casse de bloc : " + ligne);
|
||||
}
|
||||
}
|
||||
/** 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;
|
||||
MOTEUR.debutCasse(p.getUUID(), p.server.getTickCount(), pos.getX(), pos.getY(), pos.getZ());
|
||||
// 0.5 (P2.5) : début de casse sans impact : face et portée seulement (journal, expulsion en ENFORCE).
|
||||
List<Verdict> v = verdictsInteraction(p, pos, face, null, -1);
|
||||
Sanction s = traiter(p, v);
|
||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P2.5) : clic droit sur un bloc (main principale). Vrai si l'interaction doit être annulée (interaction-bloc
|
||||
* en ENFORCE, palier SETBACK ou plus) ; une EXPULSION est appliquée ici. Câblage non testé en jeu.
|
||||
*/
|
||||
public static boolean noterInteractionBloc(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
|
||||
net.minecraft.world.phys.Vec3 impact, boolean mainPrincipale) {
|
||||
if (!surThreadServeur(p)) return false;
|
||||
// 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;
|
||||
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);
|
||||
}
|
||||
|
||||
private static List<Verdict> verdictsInteraction(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
|
||||
net.minecraft.world.phys.Vec3 impact, int main) {
|
||||
if (CONFIG.mode(Controle.INTERACTION_BLOC) == Mode.OFF || estExempteManuellement(p.getUUID())) return List.of();
|
||||
net.minecraft.world.level.Level l = p.level();
|
||||
BlockState st = l.getBlockState(pos);
|
||||
net.minecraft.world.phys.shapes.VoxelShape forme = st.getShape(l, pos);
|
||||
net.minecraft.world.phys.AABB b = forme.isEmpty() ? new net.minecraft.world.phys.AABB(pos) : forme.bounds().move(pos);
|
||||
net.minecraft.world.phys.Vec3 oeil = p.getEyePosition();
|
||||
Marques m = marques(p.getUUID());
|
||||
double deplacement = 0;
|
||||
if (m.oeilDernier != null && m.oeilAvant != null) {
|
||||
deplacement = Math.sqrt(Math.pow(m.oeilDernier[0] - m.oeilAvant[0], 2) + Math.pow(m.oeilDernier[1] - m.oeilAvant[1], 2)
|
||||
+ Math.pow(m.oeilDernier[2] - m.oeilAvant[2], 2));
|
||||
}
|
||||
return MOTEUR.interactionBloc(p.getUUID(), p.server.getTickCount() * 50L, pos.asLong(), main, etat(p, true),
|
||||
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ},
|
||||
face == null ? -1 : face.get3DDataValue(), impact == null ? null : new double[] {impact.x, impact.y, impact.z},
|
||||
st.isAir(), st.isCollisionShapeFullBlock(l, pos), p.blockInteractionRange(), deplacement);
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P2.3) : bloc cassé par ce joueur. Renvoie vrai si la casse doit être annulée (fast-break en ENFORCE, palier
|
||||
* SETBACK ou plus) ; une EXPULSION est appliquée ici.
|
||||
*/
|
||||
public static boolean noterCasse(ServerPlayer p, BlockPos pos, BlockState state) {
|
||||
if (!surThreadServeur(p)) return false;
|
||||
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();
|
||||
if (CONFIG.mode(Controle.XRAY) != Mode.OFF) { // 0.5 (P2.10) : alerte seulement
|
||||
boolean rare = state.is(Blocks.DIAMOND_ORE) || state.is(Blocks.DEEPSLATE_DIAMOND_ORE) || state.is(Blocks.ANCIENT_DEBRIS);
|
||||
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)
|
||||
List<Verdict> vn = MOTEUR.casseNuker(p.getUUID(), tick * 50L, tick, etat(p, true));
|
||||
Sanction sn = traiter(p, vn);
|
||||
if (sn == Sanction.EXPULSION) {
|
||||
appliquerSanctionMouvement(p, sn, vn);
|
||||
return true;
|
||||
}
|
||||
annulerNuker = Cablage.sanctionDeMouvement(sn) || MOTEUR.nukerAnnulerCasse(p.getUUID(), tick * 50L, tick);
|
||||
}
|
||||
if (CONFIG.mode(Controle.FAST_BREAK) == Mode.OFF) return annulerNuker;
|
||||
double progression = state.getDestroyProgress(p, p.level(), pos);
|
||||
List<Verdict> v = MOTEUR.casseBloc(p.getUUID(), tick * 50L, tick, etat(p, true), pos.getX(), pos.getY(),
|
||||
pos.getZ(), progression);
|
||||
Sanction s = traiter(p, v);
|
||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||
return annulerNuker || Cablage.sanctionDeMouvement(s);
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P3.7) : demande de complétion de commande (mixin, après ensureRunningOnSameThread). Vrai si le paquet doit
|
||||
* être ignoré (completion en ENFORCE et débit dépassé, ou expulsion en cours).
|
||||
*/
|
||||
public static boolean noterCompletion(ServerPlayer p) {
|
||||
if (!surThreadServeur(p)) return false;
|
||||
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));
|
||||
Sanction s = traiter(p, v);
|
||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||
return MOTEUR.completionAIgnorer(p.getUUID());
|
||||
}
|
||||
|
||||
// 0.5 (P3.1) : tick d'apparition des cristaux de l'End récents (id d'entité -> tick serveur). Thread serveur seulement.
|
||||
private static final java.util.Map<Integer, Integer> CRISTAUX = new java.util.HashMap<>();
|
||||
|
||||
/** 0.5 (P3.1) : un cristal de l'End vient d'apparaître (posé, pas rechargé). */
|
||||
public static void noterCristal(net.minecraft.world.entity.Entity c, int tick) {
|
||||
if (c.getServer() != null && !c.getServer().isSameThread()) return;
|
||||
if (CONFIG.mode(Controle.AUTO_CRISTAL) == Mode.OFF) return;
|
||||
if (CRISTAUX.size() > 256) {
|
||||
CRISTAUX.values().removeIf(t -> tick - t > com.gastinelgarde.core.AutoCristal.AGE_MAX_MESURE);
|
||||
}
|
||||
CRISTAUX.put(c.getId(), tick);
|
||||
}
|
||||
|
||||
/** 0.5 (P3.1) : âge (ticks) d'un cristal frappé, -1 si son apparition n'a pas été vue. */
|
||||
public static int ageCristal(net.minecraft.world.entity.Entity c, int tick) {
|
||||
Integer t = CRISTAUX.remove(c.getId());
|
||||
if (t == null || tick < t) return -1;
|
||||
return tick - t;
|
||||
}
|
||||
|
||||
/** 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;
|
||||
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();
|
||||
boolean annulerTower = false;
|
||||
if (CONFIG.mode(Controle.TOWER) != Mode.OFF) { // 0.5 (P3.2)
|
||||
Marques m = marques(p.getUUID());
|
||||
double dy = m.oeilDernier != null && m.oeilAvant != null ? m.oeilDernier[1] - m.oeilAvant[1] : 0;
|
||||
List<Verdict> vt = MOTEUR.poseTower(p.getUUID(), tick * 50L, tick, etat(p, true), pos.getX(), pos.getY(),
|
||||
pos.getZ(), p.getX(), p.getY(), p.getZ(), dy);
|
||||
Sanction st = traiter(p, vt);
|
||||
if (st == Sanction.EXPULSION) {
|
||||
appliquerSanctionMouvement(p, st, vt);
|
||||
return true;
|
||||
}
|
||||
annulerTower = Cablage.sanctionDeMouvement(st);
|
||||
}
|
||||
if (CONFIG.mode(Controle.FAST_PLACE) == Mode.OFF) return annulerTower;
|
||||
List<Verdict> v = MOTEUR.poseBloc(p.getUUID(), tick * 50L, tick, etat(p, true));
|
||||
Sanction s = traiter(p, v);
|
||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||
return annulerTower || Cablage.sanctionDeMouvement(s);
|
||||
}
|
||||
|
||||
/** 0.5 (P2.10) : une face du bloc touche l'air ou un fluide (minerai visible sans x-ray). */
|
||||
private static boolean expose(ServerPlayer p, BlockPos pos) {
|
||||
for (net.minecraft.core.Direction d : net.minecraft.core.Direction.values()) {
|
||||
BlockPos q = pos.relative(d);
|
||||
BlockState s = p.level().getBlockState(q);
|
||||
if (s.isAir() || !p.level().getFluidState(q).isEmpty() || !s.isCollisionShapeFullBlock(p.level(), q)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static void noterTickServeur(MinecraftServer server, long dureeNs) {
|
||||
double ms = dureeNs / 1_000_000.0;
|
||||
if (ms > 250.0) gelTick = server.getTickCount();
|
||||
@@ -419,6 +642,8 @@ public final class Garde {
|
||||
.ticksDepuisGel(depuis(tick, gelTick))
|
||||
.tps(tpsEstime)
|
||||
.pingMs(p.connection.latency())
|
||||
.propulsionRecente(tick <= m.propulsionJusquaTick)
|
||||
.connexionRecente(tick <= m.connexionJusquaTick)
|
||||
.build();
|
||||
}
|
||||
|
||||
@@ -529,8 +754,12 @@ public final class Garde {
|
||||
marques(p.getUUID()).dernierVerdictTick = p.server.getTickCount();
|
||||
long maintenant = System.currentTimeMillis();
|
||||
Suivi suivi = MOTEUR.suivi(p.getUUID());
|
||||
long delai = Cablage.delaiJournalMs(CONFIG.journalLignesParSeconde);
|
||||
for (Verdict v : verdicts) {
|
||||
if (suivi.autoriserJournal(v.controle(), maintenant, 1000)) { // au plus une ligne par seconde et par contrôle
|
||||
// Au plus journalLignesParSeconde lignes par seconde et par contrôle ; 0.5 (P1.1) : sauf le verdict qui
|
||||
// déclenche un SETBACK ou une EXPULSION, toujours écrit (journalToujoursSanctions).
|
||||
if (Cablage.ecrireVerdict(v, CONFIG.journalToujoursSanctions,
|
||||
() -> suivi.autoriserJournal(v.controle(), maintenant, delai))) {
|
||||
String ligne = String.format("%s %s mode=%s vl=%.1f (+%.1f) palier=%s applique=%s %s exemptions=%s",
|
||||
p.getGameProfile().getName(), v.controle().id(), v.mode(), v.vl(), v.points(),
|
||||
v.palier(), v.applicable(), v.details(), v.exemptions());
|
||||
@@ -538,9 +767,31 @@ public final class Garde {
|
||||
}
|
||||
if (v.notifier()) alerterOps(p, v);
|
||||
}
|
||||
reagirSuspicion(p);
|
||||
return Verdict.pire(verdicts);
|
||||
}
|
||||
|
||||
/**
|
||||
* Score de suspicion (0.4.0) : journal dès « à surveiller », message aux ops dès « suspect ». À « suspect fort »,
|
||||
* seulement une proposition de sanction à valider dans le Portail : le mod ne sanctionne jamais à partir du score.
|
||||
*/
|
||||
private static void reagirSuspicion(ServerPlayer p) {
|
||||
Moteur.AlerteSuspicion a = MOTEUR.alerteSuspicion(p.getUUID(), System.currentTimeMillis());
|
||||
if (a == null) return;
|
||||
String nom = p.getGameProfile().getName();
|
||||
ecrireJournal(String.format("SUSPICION %s (%s) score=%d niveau=%s incidents7j=%d contributions=[%s]",
|
||||
nom, p.getUUID(), a.score(), a.niveau(), a.incidents(), a.controles()));
|
||||
if (a.niveau().ordinal() < com.gastinelgarde.core.Suspicion.Niveau.SUSPECT.ordinal()) return;
|
||||
String texte = a.niveau() == com.gastinelgarde.core.Suspicion.Niveau.SUSPECT_FORT
|
||||
? String.format("[Garde] %s : suspect fort (score %d). Proposition de sanction suspect_2, à valider dans le Portail.",
|
||||
nom, a.score())
|
||||
: String.format("[Garde] %s : suspect (score %d, %d incident(s) sur 7 jours).", nom, a.score(), a.incidents());
|
||||
Component msg = Component.literal(texte).withStyle(ChatFormatting.RED);
|
||||
for (ServerPlayer op : p.server.getPlayerList().getPlayers()) {
|
||||
if (op.hasPermissions(2) && alertesActivesPour(op.getUUID())) op.sendSystemMessage(msg);
|
||||
}
|
||||
}
|
||||
|
||||
private static void alerterOps(ServerPlayer cible, Verdict v) {
|
||||
Component msg = Component.literal(String.format("[Garde] %s : %s VL=%.1f (%s, %s)",
|
||||
cible.getGameProfile().getName(), v.controle().id(), v.vl(), v.mode(), v.applicable()))
|
||||
@@ -614,9 +865,13 @@ public final class Garde {
|
||||
etatMouvement = etat(p, true);
|
||||
}
|
||||
if (controler && em != null) {
|
||||
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
|
||||
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em, hauteurPermise(p));
|
||||
Sanction s = traiter(p, v);
|
||||
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
|
||||
// 0.5 (P2) : no-slow… (OBSERVE par défaut). Câblage non testé en jeu.
|
||||
List<Verdict> v2 = MOTEUR.mouvementP2(p.getUUID(), tick * 50L, etatMouvement, em, faitsMouvement(p));
|
||||
Sanction s2 = traiter(p, v2);
|
||||
if (Cablage.sanctionDeMouvement(s2)) appliquerSanctionMouvement(p, s2, v2);
|
||||
}
|
||||
// F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup.
|
||||
if (!estExempteManuellement(p.getUUID())) {
|
||||
@@ -633,6 +888,32 @@ public final class Garde {
|
||||
m.oeilAvant = m.oeilDernier;
|
||||
m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z};
|
||||
}
|
||||
// 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
|
||||
|| CONFIG.mode(Controle.AUTO_TOTEM) != Mode.OFF || CONFIG.mode(Controle.AUTO_TOTEM_REGULIER) != Mode.OFF)) {
|
||||
EtatJoueur etatSup = etat(p, true);
|
||||
long maintenant = tick * 50L;
|
||||
if (m.mouvementTick != Integer.MIN_VALUE) {
|
||||
// milieuSpecial toujours calculé ici, indépendamment de em (nul quand vol/vitesse/no-fall sont coupés).
|
||||
List<Verdict> v = MOTEUR.mesureRecul(p.getUUID(), maintenant, etatSup, p.getX() - m.mouvementX,
|
||||
p.getZ() - m.mouvementZ, milieuSpecial(p, m, tick), (ux, uz) -> !p.level().noCollision(p,
|
||||
p.getBoundingBox().move(ux * 0.3, 0, uz * 0.3)));
|
||||
Sanction sv = traiter(p, v); // 0.4.2 : setback (retour en arrière) ou expulsion en ENFORCE
|
||||
if (Cablage.sanctionDeMouvement(sv)) appliquerSanctionMouvement(p, sv, v);
|
||||
}
|
||||
boolean totem = p.getMainHandItem().is(Items.TOTEM_OF_UNDYING) || p.getOffhandItem().is(Items.TOTEM_OF_UNDYING);
|
||||
List<Verdict> vt = MOTEUR.totemEnMain(p.getUUID(), maintenant, etatSup, totem);
|
||||
Sanction st = traiter(p, vt); // 0.4.2 : expulsion en ENFORCE (le palier SETBACK reste une alerte)
|
||||
if (st == Sanction.EXPULSION) appliquerSanctionMouvement(p, st, vt);
|
||||
}
|
||||
// 0.5 (P1.6) : passage en plané depuis le paquet précédent (ElytraFly « packet » : bascule permanente).
|
||||
boolean plane = p.isFallFlying();
|
||||
if (plane && !m.planeAvant && !estExempteManuellement(p.getUUID())) {
|
||||
List<Verdict> vd = MOTEUR.deploiementElytres(p.getUUID(), tick * 50L, etat(p, false));
|
||||
traiter(p, vd); // OBSERVE en production ; en ENFORCE, l'expulsion seulement
|
||||
if (Verdict.pire(vd) == Sanction.EXPULSION) appliquerSanctionMouvement(p, Sanction.EXPULSION, vd);
|
||||
}
|
||||
m.planeAvant = plane;
|
||||
m.mouvementTick = tick;
|
||||
m.mouvementX = p.getX();
|
||||
m.mouvementY = p.getY();
|
||||
@@ -778,7 +1059,52 @@ public final class Garde {
|
||||
|
||||
private static boolean mouvementControlesActifs() {
|
||||
return CONFIG.mode(Controle.NO_FALL) != Mode.OFF || CONFIG.mode(Controle.VITESSE) != Mode.OFF
|
||||
|| CONFIG.mode(Controle.VOL) != Mode.OFF;
|
||||
|| CONFIG.mode(Controle.VOL) != Mode.OFF || CONFIG.mode(Controle.STEP) != Mode.OFF
|
||||
|| CONFIG.mode(Controle.ANTI_FAIM) != Mode.OFF || CONFIG.mode(Controle.NO_SLOW) != Mode.OFF
|
||||
|| CONFIG.mode(Controle.JESUS) != Mode.OFF || CONFIG.mode(Controle.OMNISPRINT) != Mode.OFF
|
||||
|| CONFIG.mode(Controle.CRITICALS) != Mode.OFF; // criticals : suit la hauteur à chaque mouvement
|
||||
}
|
||||
|
||||
/** 0.5 (P2) : faits supplémentaires du paquet accepté pour {@link Moteur#mouvementP2}. */
|
||||
private static com.gastinelgarde.core.FaitsMouvement faitsMouvement(ServerPlayer p) {
|
||||
return new com.gastinelgarde.core.FaitsMouvement()
|
||||
.ticksUsage(p.isUsingItem() ? p.getTicksUsingItem() : -1)
|
||||
.fluide(CONFIG.mode(Controle.JESUS) != Mode.OFF && surFluide(p), CONFIG.mode(Controle.JESUS) != Mode.OFF && entiteSolideSous(p))
|
||||
.direction(p.getX() - marques(p.getUUID()).mouvementX, p.getZ() - marques(p.getUUID()).mouvementZ, p.getYRot());
|
||||
}
|
||||
|
||||
/** 0.5 (P2.11) : fluide au bloc des pieds ou juste dessous (pieds à moins d'un bloc au-dessus de sa surface). */
|
||||
private static boolean surFluide(ServerPlayer p) {
|
||||
net.minecraft.world.level.Level l = p.level();
|
||||
BlockPos pieds = BlockPos.containing(p.getX(), p.getY() - 0.05, p.getZ());
|
||||
return !l.getFluidState(pieds).isEmpty() || !l.getFluidState(pieds.below()).isEmpty() && p.getY() - pieds.getY() < 0.2;
|
||||
}
|
||||
|
||||
/** 0.5 (P2.11) : bateau, shulker, minecart… (entité sur laquelle on peut se tenir) ou vaisseau Sable sous les pieds. */
|
||||
private static boolean entiteSolideSous(ServerPlayer p) {
|
||||
if (SableAcces.surSousNiveau(p)) return true;
|
||||
net.minecraft.world.phys.AABB b = p.getBoundingBox();
|
||||
net.minecraft.world.phys.AABB sous = new net.minecraft.world.phys.AABB(b.minX - 0.1, b.minY - 0.6, b.minZ - 0.1,
|
||||
b.maxX + 0.1, b.minY + 0.1, b.maxZ + 0.1);
|
||||
return !p.level().getEntities(p, sous, e -> e.canBeCollidedWith() || e instanceof net.minecraft.world.entity.vehicle.VehicleEntity).isEmpty();
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P1.9) : hauteur de marche permise en un tick : max(attribut step_height, puissance de saut = jump_strength
|
||||
* + Saut amélioré). NaN (pas de mesure step) si un piston en mouvement touche la boîte du joueur élargie d'un
|
||||
* bloc : un piston peut soulever un joueur d'un bloc entre deux paquets [À VÉRIFIER en jeu].
|
||||
*/
|
||||
private static double hauteurPermise(ServerPlayer p) {
|
||||
if (CONFIG.mode(Controle.STEP) == Mode.OFF) return Double.NaN;
|
||||
net.minecraft.world.phys.AABB b = p.getBoundingBox().inflate(1.0);
|
||||
for (BlockPos q : BlockPos.betweenClosed(net.minecraft.util.Mth.floor(b.minX), net.minecraft.util.Mth.floor(b.minY),
|
||||
net.minecraft.util.Mth.floor(b.minZ), net.minecraft.util.Mth.floor(b.maxX),
|
||||
net.minecraft.util.Mth.floor(b.maxY), net.minecraft.util.Mth.floor(b.maxZ))) {
|
||||
if (p.level().getBlockState(q).is(Blocks.MOVING_PISTON)) return Double.NaN;
|
||||
}
|
||||
double marche = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.STEP_HEIGHT);
|
||||
double saut = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.JUMP_STRENGTH) + p.getJumpBoostPower();
|
||||
return Math.max(marche, saut);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -903,6 +1229,35 @@ public final class Garde {
|
||||
return sous.getBlock().getFriction() != 0.6F || sous.getBlock().getSpeedFactor() != 1.0F;
|
||||
}
|
||||
|
||||
/** Profondeur maximale (blocs) de la recherche du sol sous le joueur (setback de secours, P1.2). */
|
||||
private static final int SOL_SOUS_MAX_BLOCS = 64;
|
||||
|
||||
/**
|
||||
* 0.5 (P1.2) : sol juste sous le joueur, même x et z : premier bloc à forme de collision non vide (ou fluide) en
|
||||
* descendant, au plus 64 blocs, avec la place pour la boîte du joueur. Null sinon (vide, hors du monde).
|
||||
*/
|
||||
static double[] solSous(ServerPlayer p) {
|
||||
net.minecraft.world.level.Level l = p.level();
|
||||
BlockPos.MutableBlockPos q = p.blockPosition().mutable();
|
||||
for (int i = 0; i <= SOL_SOUS_MAX_BLOCS && q.getY() >= l.getMinBuildHeight(); i++, q.move(0, -1, 0)) {
|
||||
if (!l.hasChunkAt(q)) return null;
|
||||
BlockState s = l.getBlockState(q);
|
||||
double y;
|
||||
if (!l.getFluidState(q).isEmpty()) {
|
||||
y = q.getY(); // eau / lave : dans le fluide, la chute s'arrête ou ralentit
|
||||
} else {
|
||||
net.minecraft.world.phys.shapes.VoxelShape forme = s.getCollisionShape(l, q);
|
||||
if (forme.isEmpty()) continue;
|
||||
y = q.getY() + forme.max(net.minecraft.core.Direction.Axis.Y);
|
||||
}
|
||||
if (y > p.getY() + 1e-6) return null; // jamais vers le haut
|
||||
net.minecraft.world.phys.AABB b = p.getBoundingBox().move(0, y - p.getY(), 0);
|
||||
if (!l.noCollision(p, b)) return null;
|
||||
return new double[] {p.getX(), y, p.getZ(), p.getYRot(), p.getXRot()};
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
|
||||
Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts);
|
||||
}
|
||||
@@ -920,6 +1275,7 @@ public final class Garde {
|
||||
}
|
||||
@Override public void deconnecter(String message) { p.connection.disconnect(Component.literal(message)); }
|
||||
@Override public void journal(String ligne) { ecrireJournal(ligne); }
|
||||
@Override public double[] solSous() { return Garde.solSous(p); }
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -73,7 +73,7 @@ public final class GardeCommands {
|
||||
|
||||
private static int status(CommandContext<CommandSourceStack> ctx) {
|
||||
GardeConfig c = Garde.config();
|
||||
StringBuilder sb = new StringBuilder("GastinelGarde :");
|
||||
StringBuilder sb = new StringBuilder("GastinelGarde " + GastinelGarde.version() + " :");
|
||||
for (Controle k : Controle.values()) sb.append("\n ").append(k.id()).append(" = ").append(c.mode(k));
|
||||
sb.append("\n sanction max = ").append(c.sanctionMax)
|
||||
.append(" | traces = ").append(Garde.tracesEnCours() ? "on" : "off")
|
||||
@@ -91,6 +91,8 @@ public final class GardeCommands {
|
||||
sb.append("\n ").append(k.id()).append(" VL=")
|
||||
.append(String.format(java.util.Locale.ROOT, "%.1f", suivi.vl.valeur(k, now)));
|
||||
}
|
||||
sb.append(String.format(java.util.Locale.ROOT, "\n suspicion = %.0f (%s)", Garde.moteur().scoreSuspicion(p.getUUID()),
|
||||
suivi.suspicion.niveau(System.currentTimeMillis())));
|
||||
if (Garde.estExempteManuellement(p.getUUID())) sb.append("\n (exempté manuellement)");
|
||||
ok(ctx, sb.toString());
|
||||
return 1;
|
||||
|
||||
@@ -108,12 +108,75 @@ public final class GardeEvents {
|
||||
visible ? null : "non-visible"));
|
||||
}
|
||||
|
||||
// 0.5 (P3.1) : cristal de l'End frappé (auto-cristal), âge vu à son apparition.
|
||||
if (cible instanceof net.minecraft.world.entity.boss.enderdragon.EndCrystal) {
|
||||
verdicts.addAll(Garde.moteur().frappeCristal(p.getUUID(), tick * 50L, etat, Garde.ageCristal(cible, tick)));
|
||||
}
|
||||
|
||||
Sanction s = Garde.traiter(p, verdicts);
|
||||
// portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé
|
||||
if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true);
|
||||
if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
|
||||
}
|
||||
|
||||
/** 0.5 (P1.10) : coup critique vanilla (Criticals) ; en ENFORCE au palier SETBACK, le critique est annulé. */
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||
public static void onCritique(net.neoforged.neoforge.event.entity.player.CriticalHitEvent event) {
|
||||
if (!event.isVanillaCritical()) return;
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.noterCritique(p)) {
|
||||
event.setCriticalHit(false);
|
||||
event.setDamageMultiplier(1.0F);
|
||||
}
|
||||
}
|
||||
/** 0.5 (P1.13) : diagnostic « Mismatch in destroy block pos » (vu après les autres mods, même annulé). */
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST, receiveCanceled = true)
|
||||
public static void onClicGaucheBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock event) {
|
||||
if (event.getLevel().isClientSide()) return;
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
var a = event.getAction();
|
||||
// 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());
|
||||
}
|
||||
Garde.noterActionBloc(p, a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START,
|
||||
a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.ABORT,
|
||||
event.getPos(), event.isCanceled());
|
||||
}
|
||||
/**
|
||||
* 0.5 (P2.3) : bloc cassé par un joueur (fast-break). En ENFORCE au palier SETBACK, la casse est annulée (le bloc
|
||||
* reste) ; l'expulsion s'applique comme ailleurs. Câblage non testé en jeu.
|
||||
*/
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||
public static void onCasse(net.neoforged.neoforge.event.level.BlockEvent.BreakEvent event) {
|
||||
if (event.getLevel().isClientSide()) return;
|
||||
if (!(event.getPlayer() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.noterCasse(p, event.getPos(), event.getState())) event.setCanceled(true);
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P2.5) : clic droit sur un bloc, les deux mains (un client forgé peut n'envoyer que la main secondaire). Le
|
||||
* client vanilla envoie main principale puis secondaire au même tick sur le même bloc : compté une fois par le
|
||||
* moteur, la main secondaire reprenant la décision (annulation) de la principale.
|
||||
*/
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||
public static void onClicDroitBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.RightClickBlock event) {
|
||||
if (event.getLevel().isClientSide()) return;
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.noterInteractionBloc(p, event.getPos(), event.getFace(), event.getHitVec().getLocation(),
|
||||
event.getHand() == net.minecraft.world.InteractionHand.MAIN_HAND)) {
|
||||
event.setCanceled(true);
|
||||
}
|
||||
}
|
||||
|
||||
/** 0.5 (P2.4) : bloc posé par un joueur (fast-place). En ENFORCE au palier SETBACK, la pose est annulée. */
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||
public static void onPose(net.neoforged.neoforge.event.level.BlockEvent.EntityPlaceEvent event) {
|
||||
if (event.getLevel().isClientSide()) return;
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.noterPose(p, event.getPos())) event.setCanceled(true);
|
||||
}
|
||||
|
||||
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
|
||||
@SubscribeEvent
|
||||
public static void onRelache(LivingEntityUseItemEvent.Stop event) {
|
||||
@@ -129,7 +192,11 @@ public final class GardeEvents {
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||
public static void onRecul(LivingKnockBackEvent event) {
|
||||
if (event.isCanceled() || event.getStrength() <= 0.0F) return;
|
||||
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterRecul(p, false);
|
||||
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
|
||||
Garde.noterRecul(p, false);
|
||||
// Vanilla retire (ratioX, ratioZ) x force à la vitesse du joueur : il part à l'opposé.
|
||||
Garde.noterVelocite(p, -event.getRatioX(), -event.getRatioZ(), event.getStrength());
|
||||
}
|
||||
}
|
||||
|
||||
/** Explosion, charge de vent (Wind Charge) : poussée vers le joueur. Celle qu'il s'inflige est limitée (GraceRecul). */
|
||||
@@ -139,13 +206,44 @@ public final class GardeEvents {
|
||||
if (!(event.getAffectedEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
boolean auto = event.getExplosion().getIndirectSourceEntity() == p || event.getExplosion().getDirectSourceEntity() == p;
|
||||
Garde.noterRecul(p, auto);
|
||||
Vec3 v = event.getKnockbackVelocity();
|
||||
Garde.noterVelocite(p, v.x, v.z, Math.hypot(v.x, v.z));
|
||||
}
|
||||
|
||||
/** Fusée de feu d'artifice tirée par un joueur : propulsion en plané, donc plané non contrôlé un moment. */
|
||||
@SubscribeEvent
|
||||
public static void onFusee(net.neoforged.neoforge.event.entity.EntityJoinLevelEvent event) {
|
||||
if (!(event.getEntity() instanceof net.minecraft.world.entity.projectile.FireworkRocketEntity f)) return;
|
||||
// Champ privé attachedToEntity lu via l'Access Transformer (META-INF/accesstransformer.cfg) : seule une fusée
|
||||
// attachée au joueur le propulse (FireworkRocketEntity.tick), jamais une fusée d'arbalète ou posée au sol.
|
||||
if (f.attachedToEntity instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
|
||||
int ticks = Cablage.graceFusee(true, p.isFallFlying(), event.loadedFromDisk(), f.life, f.lifetime);
|
||||
if (ticks > 0) Garde.noterFusee(p, ticks);
|
||||
}
|
||||
}
|
||||
|
||||
/** 0.5 (P3.1) : apparition d'un cristal de l'End (pas un rechargement depuis le disque) : début de son âge. */
|
||||
@SubscribeEvent
|
||||
public static void onCristal(net.neoforged.neoforge.event.entity.EntityJoinLevelEvent event) {
|
||||
if (event.getLevel().isClientSide() || event.loadedFromDisk()) return;
|
||||
if (event.getEntity() instanceof net.minecraft.world.entity.boss.enderdragon.EndCrystal c && c.getServer() != null) {
|
||||
Garde.noterCristal(c, c.getServer().getTickCount());
|
||||
}
|
||||
}
|
||||
|
||||
/** Totem éclaté : début de la mesure du délai de remise (auto-totem). */
|
||||
@SubscribeEvent
|
||||
public static void onTotem(net.neoforged.neoforge.event.entity.living.LivingUseTotemEvent event) {
|
||||
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
|
||||
Garde.noterTotem(p, event.getHandHolding());
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
|
||||
if (event.getEntity() instanceof ServerPlayer p) {
|
||||
Garde.moteur().oublierExpulsion(p.getUUID()); // C4 : la marque d'expulsion vaut jusqu'à la reconnexion
|
||||
Garde.noterTeleport(p);
|
||||
Garde.noterConnexion(p); // téléportation + 0.5 (P1.2) grâce de connexion
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -22,6 +22,25 @@ public final class GardeSpec {
|
||||
private static final ModConfigSpec.DoubleValue SEUIL_EXPULSION;
|
||||
private static final ModConfigSpec.EnumValue<Sanction> SANCTION_MAX;
|
||||
|
||||
private static final ModConfigSpec.BooleanValue JOURNAL_TOUJOURS, SETBACK_SOL, DIAG_ACTIONS;
|
||||
private static final ModConfigSpec.IntValue GRACE_CONNEXION, GRACE_APRES_EXPULSION;
|
||||
private static final ModConfigSpec.DoubleValue STEP_HAUTEUR, STEP_MARGE, CRIT_MICRO;
|
||||
private static final ModConfigSpec.IntValue CRIT_SERIE, ANTI_FAIM_TICKS, ELY_DEPLOIEMENTS;
|
||||
private static final ModConfigSpec.IntValue JOURNAL_LIMITE;
|
||||
// 0.5 (P2)
|
||||
private static final ModConfigSpec.DoubleValue NO_SLOW_FACTEUR;
|
||||
private static final ModConfigSpec.IntValue NO_SLOW_GRACE, NO_SLOW_TICKS, JESUS_TICKS, OMNI_TICKS;
|
||||
private static final ModConfigSpec.DoubleValue OMNI_ANGLE, XRAY_PCT, XRAY_CACHES;
|
||||
private static final ModConfigSpec.IntValue XRAY_Y, XRAY_RARES;
|
||||
private static final ModConfigSpec.DoubleValue FAST_BREAK_FACTEUR;
|
||||
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_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;
|
||||
|
||||
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
|
||||
private static final ModConfigSpec.IntValue CIBLES_MAX;
|
||||
private static final ModConfigSpec.IntValue FENETRE_CIBLES_MS;
|
||||
@@ -50,7 +69,13 @@ public final class GardeSpec {
|
||||
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
|
||||
private static final ModConfigSpec.IntValue SERIE_PING_MAX;
|
||||
private static final ModConfigSpec.IntValue SERIE_PING_MARGE;
|
||||
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX;
|
||||
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX, TIMER_DETTE_MAX;
|
||||
private static final ModConfigSpec.IntValue ELY_MONTEE, ELY_STATIONNAIRE, VEL_FENETRE, VEL_SERIE, TOTEM_DELAI, TOTEM_PING;
|
||||
private static final ModConfigSpec.DoubleValue VEL_RAPPORT, VEL_FORCE, VEL_POINTS, TOTEM_SEUIL_SB, TOTEM_SEUIL_EXP, VEL_SEUIL_SB, VEL_SEUIL_EXP;
|
||||
private static final ModConfigSpec.BooleanValue SUSP_ACTIVE;
|
||||
private static final ModConfigSpec.DoubleValue SUSP_SURVEILLER, SUSP_SUSPECT, SUSP_FORT, SUSP_DEMI_VIE,
|
||||
SUSP_PLAFOND_FIABLE, SUSP_PLAFOND_MOYEN, SUSP_PLAFOND_FAIBLE, SUSP_DIVERSITE_FENETRE;
|
||||
private static final ModConfigSpec.IntValue SUSP_DIVERSITE, SUSP_JOURS, VOL_FLOTTEMENT;
|
||||
private static final ModConfigSpec.BooleanValue VOL_FENETRE_GLISSANTE;
|
||||
private static final ModConfigSpec.BooleanValue VITESSE_MOYENNE;
|
||||
private static final ModConfigSpec.BooleanValue ELYTRES_STRICTE;
|
||||
@@ -104,6 +129,13 @@ public final class GardeSpec {
|
||||
.defineEnum("sanctionMax", Sanction.EXPULSION);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 : journal logs/gastinelgarde.log.").push("journal");
|
||||
JOURNAL_TOUJOURS = b.comment("Le verdict qui déclenche un SETBACK ou une EXPULSION est toujours écrit, malgré la limite ci-dessous.")
|
||||
.define("toujoursEcrireSanctions", true);
|
||||
JOURNAL_LIMITE = b.comment("Lignes au plus par seconde et par contrôle (évite une ligne par tick pendant une chute).")
|
||||
.defineInRange("limiteLignesParSeconde", 1, 1, 20);
|
||||
b.pop();
|
||||
|
||||
b.push("combat");
|
||||
ANGLE_MAX = b.comment("Excédent d'angle maximal entre le regard et la silhouette de la cible (degrés).")
|
||||
.defineInRange("angleMaxDegres", 60.0, 5.0, 180.0);
|
||||
@@ -125,6 +157,11 @@ public final class GardeSpec {
|
||||
.defineInRange("pingLatenceMaxMs", 300, 0, 1000);
|
||||
VITESSE_CIBLE_MAX = b.comment("Cible plus rapide (blocs/tick) : portée et hitbox ne mesurent pas (élytres, recul, téléportation).")
|
||||
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
|
||||
CRIT_MICRO = b.comment("0.5 (P1.10) criticals : critique suspect si, depuis le dernier « au sol » du client, le joueur n'est ni monté",
|
||||
"ni descendu de plus de cette valeur (blocs). Vrai saut : ~1,25 ; micro-saut de cheat : 0,0625.")
|
||||
.defineInRange("criticalsMicroSautMax", 0.1, 0.01, 1.0);
|
||||
CRIT_SERIE = b.comment("Criticals : critiques suspects, parmi les 10 derniers en 60 s, avant qu'un critique suspect compte.")
|
||||
.defineInRange("criticalsSerieMin", 3, 1, 10);
|
||||
b.pop();
|
||||
|
||||
b.comment("Contrôle coups-hors-boite (#92) : le regard est testé contre toutes les positions où le client a pu",
|
||||
@@ -151,11 +188,71 @@ public final class GardeSpec {
|
||||
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
|
||||
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
|
||||
TIMER_SOLDE_MAX = b.comment("C15 : solde de paquets (reçus - ticks écoulés) au-delà duquel le timer compte (timer 1,05-1,10).",
|
||||
"0 = désactivé (défaut). Essai conseillé : 20, en OBSERVE.")
|
||||
.defineInRange("timerSoldeMax", 0, 0, 1000);
|
||||
"0 = désactivé. 0.5 : 20 par défaut (un fichier existant garde sa valeur).")
|
||||
.defineInRange("timerSoldeMax", 20, 0, 1000);
|
||||
TIMER_DETTE_MAX = b.comment("0.5 : crédit au plus (paquets en retard pendant un lag) remboursable par la rafale de rattrapage.")
|
||||
.defineInRange("timerDetteMax", 40, 0, 1000);
|
||||
b.pop();
|
||||
|
||||
b.comment("Score de suspicion de 0 à 100 par joueur (0.4.0). INFORMATION POUR LES HUMAINS : aucune sanction n'en découle.",
|
||||
"Chaque contrôle (même en OBSERVE) contribue (VL / seuilExpulsion, au plus 1) x son plafond selon sa fiabilité ;",
|
||||
"le pic décroît avec une demi-vie. Journal dès seuilSurveiller ; message aux ops dès seuilSuspect ;",
|
||||
"dès seuilFort, proposition de sanction suspect_2 à valider dans le Portail (jamais appliquée par le mod).")
|
||||
.push("suspicion");
|
||||
SUSP_ACTIVE = b.define("actif", true);
|
||||
SUSP_SURVEILLER = b.defineInRange("seuilSurveiller", 25.0, 1.0, 100.0);
|
||||
SUSP_SUSPECT = b.defineInRange("seuilSuspect", 50.0, 1.0, 100.0);
|
||||
SUSP_FORT = b.defineInRange("seuilFort", 75.0, 1.0, 100.0);
|
||||
SUSP_DEMI_VIE = b.comment("Demi-vie du score, en minutes de jeu (le suivi est libéré à la déconnexion).")
|
||||
.defineInRange("demiVieMinutes", 10.0, 0.5, 1440.0);
|
||||
SUSP_PLAFOND_FIABLE = b.comment("Plafond de contribution : vol, vitesse, no-fall, portee, hitbox, regularite.")
|
||||
.defineInRange("plafondFiable", 50.0, 0.0, 100.0);
|
||||
SUSP_PLAFOND_MOYEN = b.comment("Plafond : coups-hors-boite, killaura-angle, killaura-cibles, cadence.")
|
||||
.defineInRange("plafondMoyen", 30.0, 0.0, 100.0);
|
||||
SUSP_PLAFOND_FAIBLE = b.comment("Plafond : timer, rotation, attaque-impossible, vehicule-vitesse, vehicule-vol (faux positifs).")
|
||||
.defineInRange("plafondFaible", 15.0, 0.0, 100.0);
|
||||
SUSP_DIVERSITE = b.comment("Ce nombre de contrôles distincts au palier SETBACK dans la fenêtre = suspect fort ; 0 = coupé.")
|
||||
.defineInRange("diversiteControles", 3, 0, 20);
|
||||
SUSP_DIVERSITE_FENETRE = b.defineInRange("diversiteFenetreMinutes", 10.0, 0.5, 1440.0);
|
||||
SUSP_JOURS = b.comment("Historique des incidents par UUID (gastinelgarde-suspicion/incidents.csv), en jours.")
|
||||
.defineInRange("historiqueJours", 7, 1, 365);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.4.0 : plané en élytres (Elytra Hack), recul absent après un coup subi (Anti Knockback / Anti Push),",
|
||||
"totem remis en main sans délai humain (Auto Totem). Contrôles 'elytres', 'velocite' et 'auto-totem' : OBSERVE par défaut.")
|
||||
.push("nouveauxControles");
|
||||
ELY_MONTEE = b.comment("Ticks de montée sans perte de vitesse en plané avant infraction ; 0 = coupé.")
|
||||
.defineInRange("elytresMonteeTicks", 20, 0, 600);
|
||||
ELY_STATIONNAIRE = b.comment("Ticks de plané presque immobile sans chute avant infraction ; 0 = coupé.")
|
||||
.defineInRange("elytresStationnaireTicks", 20, 0, 600);
|
||||
ELY_DEPLOIEMENTS = b.comment("0.5 (P1.6) : déploiements d'élytres au plus par seconde ; au-delà, ElytraFly « packet » (un START_FALL_FLYING",
|
||||
"pendant le plané l'arrête, le suivant le relance). 0 = coupé.")
|
||||
.defineInRange("elytresDeploiementsMax", 5, 0, 20);
|
||||
VEL_FENETRE = b.defineInRange("velociteFenetreTicks", 6, 2, 20);
|
||||
VEL_RAPPORT = b.comment("Recul absent si le déplacement dans le sens du recul est sous cette part du recul vanilla.")
|
||||
.defineInRange("velociteRapportMin", 0.15, 0.0, 1.0);
|
||||
VEL_SERIE = b.comment("Reculs absents (sur les 6 derniers en 2 minutes) avant infraction.")
|
||||
.defineInRange("velociteSerieMin", 3, 1, 6);
|
||||
VEL_FORCE = b.defineInRange("velociteForceMin", 0.15, 0.0, 5.0);
|
||||
VEL_POINTS = b.comment("0.4.1 : points ajoutes par recul absent (en serie). 4 : 6 reculs absents espaces de 3 s depassent le SETBACK (10).")
|
||||
.defineInRange("velocitePoints", 4.0, 0.0, 20.0);
|
||||
TOTEM_SEUIL_SB = b.comment("0.4.2 : seuils propres (0 = seuil global de [sanctions]). Auto-totem : le palier SETBACK reste une alerte.")
|
||||
.defineInRange("autoTotemSeuilSetback", 0.0, 0.0, 1000.0);
|
||||
TOTEM_SEUIL_EXP = b.comment("Auto-totem : expulsion en ENFORCE (9 = trois detections rapprochees a +3).")
|
||||
.defineInRange("autoTotemSeuilExpulsion", 9.0, 0.0, 1000.0);
|
||||
VEL_SEUIL_SB = b.comment("Velocite : retour en arriere (setback) en ENFORCE.")
|
||||
.defineInRange("velociteSeuilSetback", 8.0, 0.0, 1000.0);
|
||||
VEL_SEUIL_EXP = b.comment("Velocite : expulsion en ENFORCE.")
|
||||
.defineInRange("velociteSeuilExpulsion", 16.0, 0.0, 1000.0);
|
||||
TOTEM_DELAI = b.comment("Réaction humaine minimale (ms) entre l'éclatement et le totem remis en main, ping en plus.")
|
||||
.defineInRange("totemDelaiMinMs", 150, 0, 2000);
|
||||
TOTEM_PING = b.defineInRange("totemPingMaxMs", 200, 0, 1000);
|
||||
b.pop();
|
||||
|
||||
b.push("mouvement");
|
||||
VOL_FLOTTEMENT = b.comment("Vol : ticks consécutifs en l'air sans chute avant infraction (vanilla : 80, 'kicked for floating too long').",
|
||||
"Remplace ce contrôle vanilla si allow-flight=true. 0 = coupé.")
|
||||
.defineInRange("volFlottementTicks", 80, 0, 1200);
|
||||
EXCES_VITESSE = b.comment("Total d'excès de vitesse horizontale (blocs) sur 20 ticks avant une infraction.",
|
||||
"Valeurs de départ généreuses, à resserrer avec les traces réelles.")
|
||||
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
|
||||
@@ -173,6 +270,108 @@ public final class GardeSpec {
|
||||
COMBAT_VEHICULE = b.comment("C8 : le combat d'un passager de véhicule (bateau, cheval, minecart) est mesuré comme à pied.",
|
||||
"Désactivé par défaut : à essayer en OBSERVE (portée, hitbox, killaura).")
|
||||
.define("combatMesureEnVehicule", false);
|
||||
STEP_HAUTEUR = b.comment("0.5 (P1.9) step : hauteur de marche au moins permise en un tick (vanilla : attribut step_height 0,6).",
|
||||
"L'attribut réel du joueur et sa puissance de saut (0,42 + Saut amélioré) relèvent le seuil.")
|
||||
.defineInRange("stepHauteurMax", 0.6, 0.5, 10.0);
|
||||
STEP_MARGE = b.comment("Step : marge (blocs) au-dessus de la hauteur permise.")
|
||||
.defineInRange("stepMargeBlocs", 0.1, 0.0, 2.0);
|
||||
ANTI_FAIM_TICKS = b.comment("0.5 (P1.8) anti-faim : paquets consécutifs de course au sol (vu par le serveur, sans déplacement vertical)",
|
||||
"déclarée « en l'air » par le client avant infraction. Vanilla ne compte la faim de course qu'au sol.")
|
||||
.defineInRange("antiFaimTicks", 20, 5, 1200);
|
||||
OMNI_ANGLE = b.comment("0.5 (P2.14) omnisprint : angle (degrés) déplacement / regard au-delà duquel un sprint est impossible en vanilla",
|
||||
"(le sprint s'arrête sans entrée vers l'avant).")
|
||||
.defineInRange("omnisprintAngleDegres", 100.0, 60.0, 180.0);
|
||||
OMNI_TICKS = b.comment("Omnisprint : paquets consécutifs au sol avant infraction.")
|
||||
.defineInRange("omnisprintTicks", 10, 3, 200);
|
||||
JESUS_TICKS = b.comment("0.5 (P2.11) jesus : paquets consécutifs « au sol » (client) sur un fluide, sans bloc ni entité dessous, sans chute.")
|
||||
.defineInRange("jesusTicks", 10, 3, 200);
|
||||
NO_SLOW_FACTEUR = b.comment("0.5 (P2.1) no-slow : vitesse au sol permise en utilisant un objet = ce facteur × course (0,30 bloc/tick) × effets.",
|
||||
"Vanilla ralentit à ×0,2 (≈0,06 bloc/tick en courant) : 0,5 laisse une marge large.")
|
||||
.defineInRange("noSlowFacteur", 0.5, 0.2, 2.0);
|
||||
NO_SLOW_GRACE = b.comment("No-slow : ticks d'usage d'objet avant de mesurer (élan de la course).")
|
||||
.defineInRange("noSlowGraceTicks", 3, 0, 40);
|
||||
NO_SLOW_TICKS = b.comment("No-slow : paquets suspects consécutifs avant infraction.")
|
||||
.defineInRange("noSlowTicks", 10, 2, 200);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 (P2) : casse et pose de blocs. Nouveaux contrôles en OBSERVE par défaut.").push("monde");
|
||||
FAST_BREAK_FACTEUR = b.comment("0.5 (P2.3) fast-break : rapport (progression par tick × ticks depuis le START) sous lequel une casse est suspecte.",
|
||||
"Vanilla accepte la casse dès 0,7 ; un client honnête casse vers 1,0.")
|
||||
.defineInRange("fastBreakFacteur", 0.8, 0.7, 1.0);
|
||||
FAST_BREAK_TICKS_MIN = b.comment("Fast-break : blocs plus rapides que ce nombre de ticks non mesurés.")
|
||||
.defineInRange("fastBreakTicksMin", 6, 2, 200);
|
||||
FAST_BREAK_SERIE = b.comment("Fast-break : casses suspectes parmi les 10 dernières mesurées (60 s) avant de compter.")
|
||||
.defineInRange("fastBreakSerieMin", 4, 1, 10);
|
||||
FAST_PLACE_SERIE = b.comment("0.5 (P2.4) fast-place : intervalles entre poses examinés (poses du même tick regroupées).",
|
||||
"Les clics rapides humains (drag-click) dépassent 20/s mais jamais avec une régularité au tick près.")
|
||||
.defineInRange("fastPlaceSerie", 40, 5, 64);
|
||||
FAST_PLACE_REGULARITE = b.comment("Fast-place : part des intervalles qui valent exactement le même nombre de ticks.")
|
||||
.defineInRange("fastPlaceRegularite", 0.9, 0.5, 1.0);
|
||||
FAST_PLACE_INTERVALLE = b.comment("Fast-place : cet intervalle commun (ticks) au plus. Vanilla au clic maintenu : 4. 2 = attrape aussi le délai 1.")
|
||||
.defineInRange("fastPlaceIntervalleMaxTicks", 1, 1, 3);
|
||||
INTER_MARGE = b.comment("0.5 (P2.5) interaction-bloc : marge (blocs) de portée et de face cachée, en plus du déplacement du dernier tick.",
|
||||
"Signale : clic sur de l'air (AirPlace), face vue de derrière, impact hors de la face d'un bloc plein, portée de bloc.")
|
||||
.defineInRange("interactionBlocMarge", 0.5, 0.0, 3.0);
|
||||
TOTEM_ECHANT = b.comment("0.5 (P2.7) auto-totem-regulier : délais éclatement -> totem en main examinés (section [monde] par commodité).")
|
||||
.defineInRange("autoTotemEchantillons", 5, 3, 16);
|
||||
TOTEM_ECART = b.comment("Auto-totem-regulier : écart type (ms) sous lequel ces délais sont ceux d'une machine (délais quantifiés à 50 ms).")
|
||||
.defineInRange("autoTotemEcartTypeMinMs", 30, 0, 500);
|
||||
TOTEM_REG_MAX = b.comment("Auto-totem-regulier : tous les délais examinés sous cette valeur (ms).")
|
||||
.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);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 (P3) : contrôles lourds. Nouveaux contrôles en OBSERVE par défaut, valeurs prudentes.").push("p3");
|
||||
NUKER_MAX = b.comment("0.5 (P3.3) nuker : blocs cassés par un joueur dans un même tick serveur au-delà desquels le tick est suspect.",
|
||||
"Vanilla : 1 par tick client ; 3 couvre les paquets groupés par la gigue réseau. Un mod d'abattage / de minage de filon",
|
||||
"côté serveur casse aussi plusieurs blocs au nom du joueur : à vérifier avant tout ENFORCE.")
|
||||
.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);
|
||||
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.")
|
||||
.defineInRange("cristalDelaiMinTicks", 2, 1, 10);
|
||||
CRISTAL_SERIE = b.comment("Auto-cristal : coups suspects parmi les 10 derniers coups sur un cristal récent (60 s) avant de compter.")
|
||||
.defineInRange("cristalSerieMin", 6, 1, 10);
|
||||
TOWER_INTERVALLE = b.comment("0.5 (P3.2) tower : intervalle (ticks) entre deux poses en pilier sous les pieds sous lequel il est court.",
|
||||
"Vanilla : saut + retombée sur le bloc = 9 ticks, 10 espace maintenu ; le module Tower pose toutes les 2 à 4 ticks.")
|
||||
.defineInRange("towerIntervalleMinTicks", 6, 2, 9);
|
||||
TOWER_SERIE = b.comment("Tower : intervalles courts de suite avant que chaque pose rapide suivante compte (et soit annulable en ENFORCE).")
|
||||
.defineInRange("towerSerie", 5, 1, 50);
|
||||
COMPLETION_PAR_S = b.comment("0.5 (P3.7) completion : demandes de complétion de commande par seconde soutenues permises.",
|
||||
"Vanilla analyse chaque demande sans limite de débit ; le client vanilla en envoie une par frappe. En ENFORCE l'excès est ignoré.")
|
||||
.defineInRange("completionParSecondeMax", 20, 5, 1000);
|
||||
COMPLETION_RAFALE = b.comment("Completion : rafale permise (capacité du seau à jetons).")
|
||||
.defineInRange("completionRafaleMax", 40, 5, 1000);
|
||||
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);
|
||||
XRAY_CACHES = b.comment("Part des minerais rares cassés sans face à l'air, à un fluide ou à un bloc non plein.")
|
||||
.defineInRange("xrayAlerteNonExposesPart", 0.8, 0.0, 1.0);
|
||||
XRAY_Y = b.comment("Seuls les blocs cassés à cette hauteur ou plus bas comptent.")
|
||||
.defineInRange("xrayAlerteYMax", 16, -64, 320);
|
||||
XRAY_RARES = b.comment("Minerais rares dans la fenêtre (400 derniers blocs) avant toute alerte.")
|
||||
.defineInRange("xrayRaresMin", 12, 1, 400);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 : diagnostics (journal seulement, jamais de sanction).").push("diagnostic");
|
||||
DIAG_ACTIONS = b.comment("Journaliser les ABORT de casse de bloc sans START correspondant (message vanilla « Mismatch in destroy block pos »),",
|
||||
"au plus une ligne toutes les 10 s par joueur.")
|
||||
.define("actionsBlocIncoherentes", true);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 : grâces à la connexion (reconnexion en l'air, expulsion récente).").push("graces");
|
||||
GRACE_CONNEXION = b.comment("Ticks sans contrôle de mouvement ni timer après la connexion (la téléportation de connexion en donne déjà graceTeleportTicks).")
|
||||
.defineInRange("graceConnexionTicks", 100, 0, 1200);
|
||||
GRACE_APRES_EXPULSION = b.comment("Idem si le joueur a été expulsé il y a moins de 10 minutes.")
|
||||
.defineInRange("graceApresExpulsionTicks", 200, 0, 2400);
|
||||
SETBACK_SOL = b.comment("Sans position de retour valide (reconnexion en l'air), le SETBACK ramène au sol juste sous le joueur.",
|
||||
"Jamais de déplacement horizontal. false = ancien comportement (setback impossible, seulement journalisé).")
|
||||
.define("setbackSolSiPasDePosition", true);
|
||||
b.pop();
|
||||
|
||||
b.push("exemptions");
|
||||
@@ -261,6 +460,9 @@ public final class GardeSpec {
|
||||
c.seuilSetback = Math.max(SEUIL_SETBACK.get(), c.seuilAlerte);
|
||||
c.seuilExpulsion = Math.max(SEUIL_EXPULSION.get(), c.seuilSetback);
|
||||
c.sanctionMax = SANCTION_MAX.get();
|
||||
c.journalToujoursSanctions = JOURNAL_TOUJOURS.get();
|
||||
c.journalLignesParSeconde = JOURNAL_LIMITE.get();
|
||||
c.diagnosticActionsBloc = DIAG_ACTIONS.get();
|
||||
c.angleMaxDegres = ANGLE_MAX.get();
|
||||
c.ciblesMax = CIBLES_MAX.get();
|
||||
c.fenetreCiblesMs = FENETRE_CIBLES_MS.get();
|
||||
@@ -280,6 +482,33 @@ public final class GardeSpec {
|
||||
c.seriePingMaxMs = SERIE_PING_MAX.get();
|
||||
c.seriePingMargeMs = SERIE_PING_MARGE.get();
|
||||
c.timerSoldeMax = TIMER_SOLDE_MAX.get();
|
||||
c.timerDetteMax = TIMER_DETTE_MAX.get();
|
||||
c.suspicionActive = SUSP_ACTIVE.get();
|
||||
c.suspicionSeuilSurveiller = SUSP_SURVEILLER.get();
|
||||
c.suspicionSeuilSuspect = Math.max(SUSP_SUSPECT.get(), c.suspicionSeuilSurveiller);
|
||||
c.suspicionSeuilFort = Math.max(SUSP_FORT.get(), c.suspicionSeuilSuspect);
|
||||
c.suspicionDemiVieMinutes = SUSP_DEMI_VIE.get();
|
||||
c.suspicionPlafondFiable = SUSP_PLAFOND_FIABLE.get();
|
||||
c.suspicionPlafondMoyen = SUSP_PLAFOND_MOYEN.get();
|
||||
c.suspicionPlafondFaible = SUSP_PLAFOND_FAIBLE.get();
|
||||
c.suspicionDiversiteControles = SUSP_DIVERSITE.get();
|
||||
c.suspicionDiversiteFenetreMinutes = SUSP_DIVERSITE_FENETRE.get();
|
||||
c.suspicionHistoriqueJours = SUSP_JOURS.get();
|
||||
c.volFlottementTicks = VOL_FLOTTEMENT.get();
|
||||
c.elytresMonteeTicks = ELY_MONTEE.get();
|
||||
c.elytresStationnaireTicks = ELY_STATIONNAIRE.get();
|
||||
c.elytresDeploiementsMax = ELY_DEPLOIEMENTS.get();
|
||||
c.velociteFenetreTicks = VEL_FENETRE.get();
|
||||
c.velociteRapportMin = VEL_RAPPORT.get();
|
||||
c.velociteSerieMin = VEL_SERIE.get();
|
||||
c.velociteForceMin = VEL_FORCE.get();
|
||||
c.velocitePoints = VEL_POINTS.get();
|
||||
c.autoTotemSeuilSetback = TOTEM_SEUIL_SB.get();
|
||||
c.autoTotemSeuilExpulsion = TOTEM_SEUIL_EXP.get();
|
||||
c.velociteSeuilSetback = VEL_SEUIL_SB.get();
|
||||
c.velociteSeuilExpulsion = VEL_SEUIL_EXP.get();
|
||||
c.totemDelaiMinMs = TOTEM_DELAI.get();
|
||||
c.totemPingMaxMs = TOTEM_PING.get();
|
||||
c.volFenetreGlissante = VOL_FENETRE_GLISSANTE.get();
|
||||
c.vitesseMoyenne = VITESSE_MOYENNE.get();
|
||||
c.elytresExemptionStricte = ELYTRES_STRICTE.get();
|
||||
@@ -292,6 +521,43 @@ public final class GardeSpec {
|
||||
c.serieFenetreMs = SERIE_FENETRE_MS.get();
|
||||
c.seriePoints = SERIE_POINTS.get();
|
||||
c.graceTeleportTicks = GRACE_TELEPORT.get();
|
||||
c.graceConnexionTicks = GRACE_CONNEXION.get();
|
||||
c.stepHauteurMax = STEP_HAUTEUR.get();
|
||||
c.stepMargeBlocs = STEP_MARGE.get();
|
||||
c.criticalsMicroSautMax = CRIT_MICRO.get();
|
||||
c.criticalsSerieMin = CRIT_SERIE.get();
|
||||
c.antiFaimTicks = ANTI_FAIM_TICKS.get();
|
||||
c.noSlowFacteur = NO_SLOW_FACTEUR.get();
|
||||
c.noSlowGraceTicks = NO_SLOW_GRACE.get();
|
||||
c.noSlowTicks = NO_SLOW_TICKS.get();
|
||||
c.jesusTicks = JESUS_TICKS.get();
|
||||
c.omnisprintAngleDegres = OMNI_ANGLE.get();
|
||||
c.omnisprintTicks = OMNI_TICKS.get();
|
||||
c.xrayAlerteDiamantsParCent = XRAY_PCT.get();
|
||||
c.xrayAlerteNonExposesPart = XRAY_CACHES.get();
|
||||
c.xrayAlerteYMax = XRAY_Y.get();
|
||||
c.xrayRaresMin = XRAY_RARES.get();
|
||||
c.fastBreakFacteur = FAST_BREAK_FACTEUR.get();
|
||||
c.fastBreakTicksMin = FAST_BREAK_TICKS_MIN.get();
|
||||
c.fastBreakSerieMin = FAST_BREAK_SERIE.get();
|
||||
c.fastPlaceSerie = FAST_PLACE_SERIE.get();
|
||||
c.fastPlaceRegularite = FAST_PLACE_REGULARITE.get();
|
||||
c.fastPlaceIntervalleMaxTicks = FAST_PLACE_INTERVALLE.get();
|
||||
c.interactionBlocMarge = INTER_MARGE.get();
|
||||
c.interactionBlocSerieMin = INTER_SERIE.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.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();
|
||||
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
|
||||
c.setbackSolSiPasDePosition = SETBACK_SOL.get();
|
||||
c.graceReculTicks = GRACE_RECUL.get();
|
||||
c.graceGelTicks = GRACE_GEL.get();
|
||||
c.tpsLag = TPS_LAG.get();
|
||||
|
||||
@@ -15,7 +15,15 @@ public class GastinelGarde {
|
||||
public static final String MOD_ID = "gastinelgarde";
|
||||
public static final Logger LOGGER = LoggerFactory.getLogger(GastinelGarde.class);
|
||||
|
||||
/** 0.5 (P1.4) : version du mod (neoforge.mods.toml, rempli depuis gradle.properties au build). */
|
||||
private static String version = "?";
|
||||
|
||||
public static String version() {
|
||||
return version;
|
||||
}
|
||||
|
||||
public GastinelGarde(IEventBus modEventBus, ModContainer modContainer) {
|
||||
version = modContainer.getModInfo().getVersion().toString();
|
||||
// Config rechargeable : config/gastinelgarde-server.toml (décision D8), plus /garde reload.
|
||||
modContainer.registerConfig(ModConfig.Type.COMMON, GardeSpec.SPEC, "gastinelgarde-server.toml");
|
||||
modEventBus.addListener(ModConfigEvent.Loading.class, GardeSpec::onConfig);
|
||||
@@ -25,6 +33,6 @@ public class GastinelGarde {
|
||||
NeoForge.EVENT_BUS.register(GardeCommands.class);
|
||||
NeoForge.EVENT_BUS.register(GardeAntiCrash.class); // anti-crash entités (16/10), toujours actif
|
||||
|
||||
LOGGER.info("[GastinelGarde] Anti-triche chargé (tous les contrôles démarrent en observe).");
|
||||
LOGGER.info("[GastinelGarde] Anti-triche {} chargé (tous les contrôles démarrent en observe).", version);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P1.13) : diagnostic du message vanilla « Mismatch in destroy block pos: (0,0,0) … ». D'après
|
||||
* ServerPlayerGameMode.handleBlockBreakAction (sources NeoForge 21.1.234) : {@code destroyPos} vaut (0,0,0) au départ
|
||||
* et n'est mis à jour qu'à un START_DESTROY_BLOCK accepté (événement LeftClickBlock non annulé, à portée, interaction
|
||||
* permise, pas créatif, pas de casse instantanée). Un ABORT sur une autre position donne le message. Causes
|
||||
* possibles : START annulé par un mod (protection de zone), START refusé (trop loin), casse instantanée, ou client
|
||||
* qui envoie ABORT sans START (FastBreak, Nuker, mod client) [À VÉRIFIER avec ces lignes de journal].
|
||||
*
|
||||
* Aucun contrôle, aucune sanction : une ligne de journal par incohérence, au plus une toutes les 10 s par joueur.
|
||||
*/
|
||||
public final class ActionsBloc {
|
||||
|
||||
public static final long DELAI_JOURNAL_MS = 10_000;
|
||||
|
||||
private boolean startVu;
|
||||
private long startX, startY, startZ;
|
||||
private boolean startAnnule;
|
||||
private long dernierJournalMs = Long.MIN_VALUE;
|
||||
private int incoherences;
|
||||
|
||||
/** START_DESTROY_BLOCK reçu ; {@code annule} : l'événement a été annulé par un mod. */
|
||||
public void start(long x, long y, long z, boolean annule) {
|
||||
startVu = true;
|
||||
startX = x;
|
||||
startY = y;
|
||||
startZ = z;
|
||||
startAnnule = annule;
|
||||
}
|
||||
|
||||
/**
|
||||
* ABORT_DESTROY_BLOCK reçu : texte de diagnostic s'il ne correspond pas au dernier START accepté (null sinon, ou si
|
||||
* une ligne a déjà été écrite il y a moins de {@link #DELAI_JOURNAL_MS}).
|
||||
*/
|
||||
public String abort(long x, long y, long z, long nowMs) {
|
||||
boolean memePos = startVu && startX == x && startY == y && startZ == z;
|
||||
if (memePos && !startAnnule) return null;
|
||||
incoherences++;
|
||||
if (dernierJournalMs != Long.MIN_VALUE && nowMs - dernierJournalMs < DELAI_JOURNAL_MS && nowMs >= dernierJournalMs) {
|
||||
return null;
|
||||
}
|
||||
dernierJournalMs = nowMs;
|
||||
String start = !startVu ? "aucun START vu"
|
||||
: String.format("dernier START (%d,%d,%d)%s", startX, startY, startZ, startAnnule ? " annule par un mod" : "");
|
||||
return String.format("ABORT (%d,%d,%d) sans START correspondant : %s, %d incoherence(s) depuis la connexion",
|
||||
x, y, z, start, incoherences);
|
||||
}
|
||||
|
||||
public int incoherences() {
|
||||
return incoherences;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P1.8) : anti-faim (AntiHunger). Vanilla 1.21.1 (ServerPlayer.checkMovementStatistics, vérifié dans les
|
||||
* sources NeoForge 21.1.234) ne fait perdre de la faim à la course (0,1 par bloc) que si {@code onGround()}, drapeau
|
||||
* recopié du paquet du CLIENT. Le cheat déclare « pas au sol » en courant sur un sol plat : aucune faim perdue.
|
||||
*
|
||||
* Signal : {@link GardeConfig#antiFaimTicks} paquets consécutifs où le serveur voit le joueur courir (sprint) au sol,
|
||||
* sans aucun déplacement vertical, avec un vrai déplacement horizontal, alors que le client se dit en l'air. Un
|
||||
* joueur honnête qui court sur du plat se déclare au sol à chaque paquet ; un saut a toujours dy ≠ 0. Plusieurs
|
||||
* ticks entre deux paquets ou un milieu spécial coupent la série. OBSERVE par défaut.
|
||||
*/
|
||||
public final class AntiFaim {
|
||||
|
||||
/** Déplacement horizontal minimal par tick pour compter (la marche lente ne coûte rien de toute façon). */
|
||||
static final double DXZ_MIN = 0.1;
|
||||
|
||||
private int serie;
|
||||
|
||||
public double enregistrer(EtatMouvement m, GardeConfig cfg) {
|
||||
boolean suspect = m.sprint() && !m.auSolClient() && m.auSolServeur() && Math.abs(m.dy()) < 1e-6
|
||||
&& m.ticks() == 1 && m.dxz() >= DXZ_MIN && !m.milieuSpecial();
|
||||
if (!suspect) {
|
||||
serie = 0;
|
||||
return 0;
|
||||
}
|
||||
if (++serie < Math.max(1, cfg.antiFaimTicks)) return 0;
|
||||
serie = 0; // une infraction par série complète
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
serie = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P3.1) : AutoCrystal / CrystalAura. Le module pose un cristal de l'End et le frappe aussitôt, souvent dans le
|
||||
* même tick serveur. Un joueur humain enchaîne « clic droit, clic gauche » en au moins un ou deux ticks ; la gigue
|
||||
* réseau peut toutefois regrouper ses deux paquets. Signal : âge du cristal (ticks serveur depuis son apparition, vue à
|
||||
* {@code EntityJoinLevelEvent}, jamais pour un cristal rechargé depuis le disque) au moment du coup. Âge inférieur à
|
||||
* {@link GardeConfig#cristalDelaiMinTicks} = coup suspect ; points seulement en série
|
||||
* ({@link GardeConfig#cristalSerieMin} sur les {@link #SERIE} derniers coups sur un cristal récent, 60 s). Cristaux
|
||||
* d'âge inconnu (posés avant, rechargés, autre mod) : non mesurés. Risque de faux positif élevé selon le rapport de
|
||||
* recherche (PvP cristal rapide) : OBSERVE par défaut, plafond « faible » du score.
|
||||
*/
|
||||
public final class AutoCristal {
|
||||
|
||||
public static final int SERIE = 10;
|
||||
public static final long FENETRE_MS = 60_000;
|
||||
/** Au-delà de cet âge (ticks), le coup n'est pas mesuré (cristal ancien : rien à dire). */
|
||||
public static final int AGE_MAX_MESURE = 40;
|
||||
|
||||
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
|
||||
private int dernierCompte;
|
||||
|
||||
/** @param ageTicks âge du cristal frappé, négatif si inconnu. @return points d'infraction */
|
||||
public double frappe(long nowMs, int ageTicks, GardeConfig cfg) {
|
||||
if (ageTicks < 0 || ageTicks > AGE_MAX_MESURE) return 0;
|
||||
boolean suspect = ageTicks < Math.max(1, cfg.cristalDelaiMinTicks);
|
||||
dernierCompte = serie.ajouter(nowMs, suspect);
|
||||
if (!suspect || dernierCompte < Math.max(1, cfg.cristalSerieMin)) return 0;
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
public int dernierCompte() {
|
||||
return dernierCompte;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
serie.vider();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* Contrôle « auto-totem » (0.4.0). Le cheat remet un totem en main dès l'éclatement, sans délai de réaction. Le
|
||||
* serveur voit l'éclatement (LivingUseTotemEvent) puis le contenu des mains à chaque paquet de mouvement : le délai
|
||||
* entre les deux ne peut pas être inférieur à l'aller-retour réseau (le client apprend l'éclatement après ping/2, sa
|
||||
* demande arrive après ping/2 de plus) plus la réaction humaine (~150 ms, arrondi au tick de 50 ms). Le ping est
|
||||
* falsifiable (F07) : il n'entre que borné à {@link GardeConfig#totemPingMaxMs}, donc un joueur qui gonfle son ping
|
||||
* ne gagne qu'une marge limitée. Un totem de réserve déjà en main à l'éclatement annule la mesure.
|
||||
*/
|
||||
public final class AutoTotem {
|
||||
|
||||
/** Mesure abandonnée si aucun totem n'est remis dans ce délai. */
|
||||
public static final long EXPIRATION_MS = 10_000;
|
||||
|
||||
private boolean actif;
|
||||
private long eclatMs;
|
||||
/** 0.5 (P2.7) : dernier délai mesuré (ms), -1 si aucun depuis la dernière lecture. */
|
||||
private long dernierDelai = -1;
|
||||
|
||||
/** 0.5 (P2.7) : délai mesuré au dernier appel de {@link #mains}, puis oublié ; -1 si aucun. */
|
||||
public long prendreDelai() {
|
||||
long d = dernierDelai;
|
||||
dernierDelai = -1;
|
||||
return d;
|
||||
}
|
||||
|
||||
/** @param reserveEnMain un autre totem était déjà dans l'autre main : rien à mesurer */
|
||||
public void eclatement(long nowMs, boolean reserveEnMain) {
|
||||
actif = !reserveEnMain;
|
||||
eclatMs = nowMs;
|
||||
}
|
||||
|
||||
/**
|
||||
* Contenu des mains à un paquet de mouvement.
|
||||
*
|
||||
* @return points d'infraction (0 si rien)
|
||||
*/
|
||||
public double mains(long nowMs, boolean totemEnMain, int pingMs, GardeConfig cfg) {
|
||||
if (!actif) return 0;
|
||||
if (nowMs - eclatMs > EXPIRATION_MS) {
|
||||
actif = false;
|
||||
return 0;
|
||||
}
|
||||
if (!totemEnMain || nowMs <= eclatMs) return 0;
|
||||
actif = false;
|
||||
long delai = nowMs - eclatMs;
|
||||
dernierDelai = delai;
|
||||
long minimum = cfg.totemDelaiMinMs + Math.min(Math.max(0, pingMs), cfg.totemPingMaxMs);
|
||||
return delai < minimum ? 3.0 : 0;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
actif = false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P3.7) : spam de demandes de complétion de commande (ServerboundCommandSuggestionPacket, touche Tab et frappe
|
||||
* dans le chat après « / »). Vanilla 1.21.1 (ServerGamePacketListenerImpl.handleCustomCommandSuggestions, sources
|
||||
* NeoForge 21.1.234) analyse la commande complète (jusqu'à 32 500 caractères) à chaque paquet, sans aucune limite de
|
||||
* débit : un client forgé peut faire tirer le serveur. Le client vanilla en envoie une par frappe de touche.
|
||||
*
|
||||
* Seau à jetons : capacité {@link GardeConfig#completionRafaleMax} (40), rempli à
|
||||
* {@link GardeConfig#completionParSecondeMax} (20) jetons par seconde. Un paquet sans jeton est en excès : 0,25 point
|
||||
* chacun ; en ENFORCE il est ignoré (pas de réponse), quel que soit le palier.
|
||||
*/
|
||||
public final class Completion {
|
||||
|
||||
private double jetons = Double.NaN;
|
||||
private long dernierMs;
|
||||
private int excesTotal;
|
||||
|
||||
/** Une demande de complétion reçue. @return vrai si elle est en excès */
|
||||
public boolean demande(long nowMs, GardeConfig cfg) {
|
||||
double capacite = Math.max(1, cfg.completionRafaleMax);
|
||||
if (Double.isNaN(jetons)) {
|
||||
jetons = capacite;
|
||||
} else if (nowMs > dernierMs) {
|
||||
jetons = Math.min(capacite, jetons + (nowMs - dernierMs) * Math.max(1, cfg.completionParSecondeMax) / 1000.0);
|
||||
}
|
||||
dernierMs = Math.max(dernierMs, nowMs);
|
||||
if (jetons >= 1) {
|
||||
jetons -= 1;
|
||||
return false;
|
||||
}
|
||||
excesTotal++;
|
||||
return true;
|
||||
}
|
||||
|
||||
public int excesTotal() {
|
||||
return excesTotal;
|
||||
}
|
||||
}
|
||||
@@ -17,7 +17,43 @@ public enum Controle {
|
||||
VITESSE("vitesse"),
|
||||
VOL("vol"),
|
||||
VEHICULE_VITESSE("vehicule-vitesse"),
|
||||
VEHICULE_VOL("vehicule-vol");
|
||||
VEHICULE_VOL("vehicule-vol"),
|
||||
/** 0.4.0 : plané en élytres (Elytra Hack) : montée sans perte de vitesse, plané immobile. */
|
||||
ELYTRES("elytres"),
|
||||
/** 0.4.0 : recul absent après un coup subi (Anti Knockback, Anti Push). */
|
||||
VELOCITE("velocite"),
|
||||
/** 0.4.0 : totem remis en main sans délai humain après l'éclatement (Auto Totem). */
|
||||
AUTO_TOTEM("auto-totem"),
|
||||
/** 0.5 (P1.9) : marche plus haute que la hauteur permise en un tick, au sol avant et après (Step / HighStep). */
|
||||
STEP("step"),
|
||||
/** 0.5 (P1.10) : coups critiques en série sans vrai saut ni vraie chute (Criticals, micro-sauts fictifs). */
|
||||
CRITICALS("criticals"),
|
||||
/** 0.5 (P1.8) : course au sol déclarée « en l'air » par le client pour ne pas perdre de faim (AntiHunger). */
|
||||
ANTI_FAIM("anti-faim"),
|
||||
/** 0.5 (P2.1) : vitesse de marche ou de course gardée pendant un usage d'objet (NoSlow). */
|
||||
NO_SLOW("no-slow"),
|
||||
/** 0.5 (P2.3) : blocs cassés en série avant la fin de leur temps de casse (FastBreak, la marge vanilla de 30 %). */
|
||||
FAST_BREAK("fast-break"),
|
||||
/** 0.5 (P2.4) : poses de blocs à chaque tick avec une régularité de machine (FastPlace). */
|
||||
FAST_PLACE("fast-place"),
|
||||
/** 0.5 (P2.5) : clic sur un bloc impossible pour le rayon vanilla (AirPlace, face cachée, portée, impact forgé). */
|
||||
INTERACTION_BLOC("interaction-bloc"),
|
||||
/** 0.5 (P2.7) : délais de remise du totem trop réguliers sur plusieurs éclatements (AutoTotem à délai fixe). */
|
||||
AUTO_TOTEM_REGULIER("auto-totem-regulier"),
|
||||
/** 0.5 (P2.11) : au sol déclaré sur un fluide, sans bloc ni entité dessous, sans chute (Jesus). */
|
||||
JESUS("jesus"),
|
||||
/** 0.5 (P2.14) : sprint en reculant ou de côté, soutenu au sol (Omnisprint). */
|
||||
OMNISPRINT("omnisprint"),
|
||||
/** 0.5 (P2.10) : part anormale de minerais rares non exposés (X-Ray) ; alerte seulement, jamais de sanction. */
|
||||
XRAY("xray"),
|
||||
/** 0.5 (P3.3) : plusieurs blocs cassés dans le même tick serveur, en série (Nuker). */
|
||||
NUKER("nuker"),
|
||||
/** 0.5 (P3.1) : cristaux de l'End frappés en série dès leur apparition (AutoCrystal / CrystalAura). */
|
||||
AUTO_CRISTAL("auto-cristal"),
|
||||
/** 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");
|
||||
|
||||
private final String id;
|
||||
|
||||
@@ -39,6 +75,18 @@ public enum Controle {
|
||||
|| this == COUPS_HORS_BOITE;
|
||||
}
|
||||
|
||||
/** Fiabilité du contrôle pour le score de suspicion : 0 = fiable, 1 = moyen, 2 = sujet aux faux positifs. */
|
||||
public int fiabilite() {
|
||||
return switch (this) {
|
||||
case VOL, VITESSE, NO_FALL, PORTEE, HITBOX, REGULARITE, AUTO_TOTEM -> 0; // AUTO_TOTEM : 0.4.1
|
||||
case COUPS_HORS_BOITE, KILLAURA_ANGLE, KILLAURA_CIBLES, CADENCE -> 1;
|
||||
// 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
|
||||
};
|
||||
}
|
||||
|
||||
public static Controle parse(String texte) {
|
||||
if (texte == null) return null;
|
||||
for (Controle c : values()) {
|
||||
|
||||
@@ -0,0 +1,78 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P1.10) : auto-criticals. Vanilla 1.21.1 (Player.attack, vérifié dans les sources NeoForge 21.1.234) donne un
|
||||
* coup critique si {@code fallDistance > 0}, onGround faux (drapeau du CLIENT), pas d'échelle, pas d'eau, pas
|
||||
* d'aveuglement, pas de véhicule, pas de sprint et barre d'attaque > 0,9. Le cheat envoie juste avant le coup un
|
||||
* ou deux paquets « en l'air » avec un micro-saut (+0,0625 puis retour, ou onGround toujours faux) : le serveur
|
||||
* compte une chute et accorde le critique sans vrai saut.
|
||||
*
|
||||
* Signal : au coup critique vanilla, depuis le dernier paquet où le client se disait au sol, le joueur n'est
|
||||
* jamais monté de plus de {@link GardeConfig#criticalsMicroSautMax} ni descendu de plus de cette valeur. Un vrai
|
||||
* saut monte d'environ 1,25 bloc ; une chute d'un rebord descend de plus de 0,1 dès le 2e tick. Un coup isolé ne
|
||||
* compte pas : seulement une série ({@link GardeConfig#criticalsSerieMin} sur les {@link #SERIE} derniers critiques
|
||||
* en {@link #FENETRE_MS}).
|
||||
*
|
||||
* Cas limite connu [À VÉRIFIER en jeu] : coup critique au tout premier tick de chute après avoir quitté un rebord
|
||||
* (descente de 0,078 seulement) : vu comme suspect, d'où la série.
|
||||
*/
|
||||
public final class Criticals {
|
||||
|
||||
static final int SERIE = 10;
|
||||
static final long FENETRE_MS = 60_000;
|
||||
/** Au-delà, la référence au sol est abandonnée (longue chute, plané) : pas suspect. */
|
||||
static final int PAQUETS_AIR_MAX = 40;
|
||||
|
||||
private boolean solConnu;
|
||||
private double hauteur, haut, bas;
|
||||
private int paquetsAir;
|
||||
|
||||
private final long[] instants = new long[SERIE];
|
||||
private final boolean[] suspects = new boolean[SERIE];
|
||||
private int n, prochain;
|
||||
private int dernierCompte;
|
||||
|
||||
/** Chaque mouvement accepté (avant les exemptions : on suit seulement la hauteur). */
|
||||
public void mouvement(EtatMouvement m) {
|
||||
if (m.milieuSpecial()) {
|
||||
solConnu = false; // eau, échelle : vanilla refuse le critique, et la hauteur n'a plus de sens
|
||||
return;
|
||||
}
|
||||
if (m.auSolClient()) {
|
||||
solConnu = true;
|
||||
hauteur = haut = bas = 0;
|
||||
paquetsAir = 0;
|
||||
} else if (solConnu) {
|
||||
hauteur += m.dy();
|
||||
haut = Math.max(haut, hauteur);
|
||||
bas = Math.min(bas, hauteur);
|
||||
if (++paquetsAir > PAQUETS_AIR_MAX) solConnu = false;
|
||||
}
|
||||
}
|
||||
|
||||
/** Le critique en cours ne vient d'aucun vrai saut ni d'une vraie chute ? */
|
||||
public boolean suspect(GardeConfig cfg) {
|
||||
double s = cfg.criticalsMicroSautMax;
|
||||
return solConnu && paquetsAir > 0 && haut < s && bas > -s;
|
||||
}
|
||||
|
||||
/** Un coup critique vanilla : points si suspect et en série. */
|
||||
public double coup(long nowMs, GardeConfig cfg) {
|
||||
boolean s = suspect(cfg);
|
||||
instants[prochain] = nowMs;
|
||||
suspects[prochain] = s;
|
||||
prochain = (prochain + 1) % SERIE;
|
||||
n = Math.min(SERIE, n + 1);
|
||||
int compte = 0;
|
||||
for (int i = 0; i < n; i++) if (suspects[i] && nowMs - instants[i] <= FENETRE_MS) compte++;
|
||||
dernierCompte = compte;
|
||||
return s && compte >= Math.max(1, cfg.criticalsSerieMin) ? 2.0 : 0;
|
||||
}
|
||||
|
||||
public int dernierCompte() {
|
||||
return dernierCompte;
|
||||
}
|
||||
|
||||
public double haut() { return haut; }
|
||||
public double bas() { return bas; }
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P1.6) : déploiements d'élytres répétés (ElytraFly « packet »). Vanilla 1.21.1
|
||||
* (ServerGamePacketListenerImpl.handlePlayerCommand, START_FALL_FLYING, et Player.tryToStartFallFlying, vérifiés
|
||||
* dans les sources NeoForge 21.1.234) : un START_FALL_FLYING reçu pendant le plané ARRÊTE le plané
|
||||
* ({@code stopFallFlying}), le suivant le relance. Le cheat qui en envoie un à chaque tick fait donc basculer le
|
||||
* drapeau sans cesse, ce que le serveur voit (passage de « pas en plané » à « en plané » d'un paquet de mouvement au
|
||||
* suivant). Un joueur qui redéploie ses élytres à la main le fait au plus quelques fois par seconde.
|
||||
*
|
||||
* Seuil : plus de {@link GardeConfig#elytresDeploiementsMax} déploiements sur la dernière seconde (20 ticks).
|
||||
*/
|
||||
public final class DeploiementsElytres {
|
||||
|
||||
static final long FENETRE_MS = 1000;
|
||||
private static final int TAILLE = 64;
|
||||
|
||||
private final long[] instants = new long[TAILLE];
|
||||
private int n, prochain;
|
||||
private int dernierCompte;
|
||||
|
||||
/** Un déploiement vu (transition vers le plané) : points si trop de déploiements dans la fenêtre. */
|
||||
public double deploiement(long nowMs, GardeConfig cfg) {
|
||||
instants[prochain] = nowMs;
|
||||
prochain = (prochain + 1) % TAILLE;
|
||||
n = Math.min(TAILLE, n + 1);
|
||||
int compte = 0;
|
||||
for (int i = 0; i < n; i++) if (nowMs - instants[i] < FENETRE_MS && nowMs >= instants[i]) compte++;
|
||||
dernierCompte = compte;
|
||||
int max = cfg.elytresDeploiementsMax;
|
||||
if (max <= 0 || compte <= max) return 0;
|
||||
return 1.0 + Math.min(3.0, (compte - max) * 0.5);
|
||||
}
|
||||
|
||||
public int dernierCompte() {
|
||||
return dernierCompte;
|
||||
}
|
||||
}
|
||||
@@ -20,7 +20,9 @@ public record EtatJoueur(
|
||||
int ticksDepuisRecul,
|
||||
int ticksDepuisGel,
|
||||
double tps,
|
||||
int pingMs) {
|
||||
int pingMs,
|
||||
boolean propulsionRecente,
|
||||
boolean connexionRecente) {
|
||||
|
||||
public static final int JAMAIS = Integer.MAX_VALUE;
|
||||
|
||||
@@ -39,6 +41,8 @@ public record EtatJoueur(
|
||||
private int ticksDepuisTeleport = JAMAIS, ticksDepuisRecul = JAMAIS, ticksDepuisGel = JAMAIS;
|
||||
private double tps = 20.0;
|
||||
private int pingMs = 30;
|
||||
private boolean propulsionRecente;
|
||||
private boolean connexionRecente;
|
||||
|
||||
public Builder creatif(boolean v) { creatif = v; return this; }
|
||||
public Builder spectateur(boolean v) { spectateur = v; return this; }
|
||||
@@ -57,11 +61,16 @@ public record EtatJoueur(
|
||||
public Builder ticksDepuisGel(int v) { ticksDepuisGel = v; return this; }
|
||||
public Builder tps(double v) { tps = v; return this; }
|
||||
public Builder pingMs(int v) { pingMs = v; return this; }
|
||||
/** 0.4.0 : fusée de feu d'artifice (ou autre poussée connue du serveur) récente : plané non contrôlé. */
|
||||
public Builder propulsionRecente(boolean v) { propulsionRecente = v; return this; }
|
||||
|
||||
/** 0.5 (P1.2) : connexion récente (graceConnexionTicks, plus long après une expulsion récente). */
|
||||
public Builder connexionRecente(boolean v) { connexionRecente = v; return this; }
|
||||
|
||||
public EtatJoueur build() {
|
||||
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
|
||||
enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect, ticksDepuisTeleport, ticksDepuisRecul,
|
||||
ticksDepuisGel, tps, pingMs);
|
||||
ticksDepuisGel, tps, pingMs, propulsionRecente, connexionRecente);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -9,7 +9,7 @@ import java.util.List;
|
||||
*/
|
||||
public final class Exemptions {
|
||||
|
||||
public enum Famille { COMBAT, MOUVEMENT, TIMER, VEHICULE }
|
||||
public enum Famille { COMBAT, MOUVEMENT, TIMER, VEHICULE, MONDE }
|
||||
|
||||
/**
|
||||
* @param exempt le contrôle ne doit pas s'appliquer
|
||||
@@ -44,6 +44,8 @@ public final class Exemptions {
|
||||
if (e.pocheContraption()) raisons.add("contraption");
|
||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
|
||||
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul");
|
||||
// 0.5 (P1.2) : reconnexion (souvent en l'air, sans position de retour) : grâce plus longue.
|
||||
if (e.connexionRecente()) raisons.add("connexion");
|
||||
}
|
||||
case VEHICULE -> {
|
||||
// F20 : le véhicule piloté. Pas d'exemption « véhicule » ici, évidemment.
|
||||
@@ -51,9 +53,18 @@ public final class Exemptions {
|
||||
if (e.pocheContraption()) raisons.add("contraption");
|
||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
|
||||
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul");
|
||||
if (e.connexionRecente()) raisons.add("connexion");
|
||||
}
|
||||
case MONDE -> {
|
||||
// 0.5 (P2) : casse et pose de blocs. Vaisseau Sable / contraption : coordonnées de sous-niveau, et
|
||||
// gel du serveur : les paquets arrivent groupés, les temps mesurés ne veulent rien dire.
|
||||
if (e.pocheContraption()) raisons.add("contraption");
|
||||
if (e.ticksDepuisGel() <= cfg.graceGelTicks) raisons.add("gel-serveur");
|
||||
if (e.connexionRecente()) raisons.add("connexion");
|
||||
}
|
||||
case TIMER -> {
|
||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
|
||||
if (e.connexionRecente()) raisons.add("connexion"); // rafale de paquets du chargement
|
||||
if (e.ticksDepuisGel() <= cfg.graceGelTicks) raisons.add("gel-serveur");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2) : faits supplémentaires d'un paquet de mouvement accepté, lus par l'adaptateur pour les contrôles P2
|
||||
* (no-slow, jesus, omnisprint). Classe à champs publics plutôt qu'un record : chaque contrôle P2 y ajoute ce dont il
|
||||
* a besoin sans casser les appels existants (tests, rejeu). Valeurs par défaut = « inconnu » : le contrôle concerné ne
|
||||
* mesure pas.
|
||||
*/
|
||||
public final class FaitsMouvement {
|
||||
|
||||
/** Ticks depuis le début de l'usage d'objet en cours, vus par le serveur ({@code getTicksUsingItem}) ; -1 = inconnu. */
|
||||
public int ticksUsage = -1;
|
||||
/** P2.11 : fluide (eau, lave) au bloc des pieds ou juste dessous. */
|
||||
public boolean surFluide;
|
||||
/** P2.11 : entité solide (bateau, shulker…) ou vaisseau sous les pieds : on peut s'y tenir. */
|
||||
public boolean entiteSolideSous;
|
||||
/** P2.14 : déplacement horizontal signé depuis le paquet précédent ; NaN = inconnu. */
|
||||
public double dx = Double.NaN, dz = Double.NaN;
|
||||
/** P2.14 : regard horizontal (yaw Minecraft) ; NaN = inconnu. */
|
||||
public float yaw = Float.NaN;
|
||||
|
||||
public FaitsMouvement ticksUsage(int v) {
|
||||
ticksUsage = v;
|
||||
return this;
|
||||
}
|
||||
|
||||
public FaitsMouvement fluide(boolean surFluide, boolean entiteSolideSous) {
|
||||
this.surFluide = surFluide;
|
||||
this.entiteSolideSous = entiteSolideSous;
|
||||
return this;
|
||||
}
|
||||
|
||||
public FaitsMouvement direction(double dx, double dz, float yaw) {
|
||||
this.dx = dx;
|
||||
this.dz = dz;
|
||||
this.yaw = yaw;
|
||||
return this;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2.3) : FastBreak. Vanilla 1.21.1 (ServerPlayerGameMode.handleBlockBreakAction, vérifié dans les sources
|
||||
* NeoForge 21.1.234) accepte un STOP_DESTROY_BLOCK dès que {@code getDestroyProgress × (ticks depuis START + 1) ≥ 0,7} :
|
||||
* le serveur laisse 30 % d'avance au client. Les modules FastBreak s'arrêtent juste au-dessus de 0,7 ; un client
|
||||
* honnête envoie STOP quand sa propre progression atteint 1, donc un rapport proche de 1 (au jitter réseau près).
|
||||
*
|
||||
* Mesure, à la casse effective (BlockEvent.BreakEvent) d'un bloc dont le START a été vu au même endroit :
|
||||
* {@code rapport = progression par tick (serveur, outil et effets du moment) × (ticks écoulés + 1)}. Un rapport sous
|
||||
* {@link GardeConfig#fastBreakFacteur} (0,8) est suspect. Les blocs qui demandent moins de
|
||||
* {@link GardeConfig#fastBreakTicksMin} ticks ne sont pas mesurés (un tick de jitter y pèse trop) ; les blocs cassés
|
||||
* d'un coup (progression ≥ 1) non plus. Un START retardé par le réseau raccourcit la mesure (faux positif possible) :
|
||||
* points seulement en série ({@link GardeConfig#fastBreakSerieMin} casses suspectes sur les {@link #SERIE} dernières
|
||||
* mesurées, en {@link #FENETRE_MS} ms). OBSERVE par défaut.
|
||||
*/
|
||||
public final class FastBreak {
|
||||
|
||||
public static final int SERIE = 10;
|
||||
public static final long FENETRE_MS = 60_000;
|
||||
|
||||
private boolean debut;
|
||||
private int x, y, z;
|
||||
private long debutTick;
|
||||
private double dernierRapport = Double.NaN;
|
||||
private int dernierCompte;
|
||||
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
|
||||
|
||||
/** START_DESTROY_BLOCK accepté (non annulé) sur ce bloc, au tick serveur donné. */
|
||||
public void debut(long tick, int x, int y, int z) {
|
||||
debut = true;
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
debutTick = tick;
|
||||
}
|
||||
|
||||
/**
|
||||
* Le bloc vient d'être cassé par le joueur.
|
||||
*
|
||||
* @param progression progression de casse par tick vue par le serveur ({@code getDestroyProgress}) ; NaN = inconnue
|
||||
* @return points d'infraction (0 si rien)
|
||||
*/
|
||||
public double casse(long nowMs, long tick, int x, int y, int z, double progression, GardeConfig cfg) {
|
||||
boolean memeBloc = debut && this.x == x && this.y == y && this.z == z;
|
||||
debut = false;
|
||||
dernierRapport = Double.NaN;
|
||||
if (!memeBloc || Double.isNaN(progression) || progression <= 0 || progression >= 1.0) return 0;
|
||||
long ticks = tick - debutTick;
|
||||
if (ticks < 0) return 0;
|
||||
double attendus = Math.ceil(1.0 / progression);
|
||||
if (attendus < cfg.fastBreakTicksMin) return 0;
|
||||
dernierRapport = progression * (ticks + 1);
|
||||
boolean suspect = dernierRapport < cfg.fastBreakFacteur;
|
||||
dernierCompte = serie.ajouter(nowMs, suspect);
|
||||
if (!suspect || dernierCompte < Math.max(1, cfg.fastBreakSerieMin)) return 0;
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
public double dernierRapport() {
|
||||
return dernierRapport;
|
||||
}
|
||||
|
||||
public int dernierCompte() {
|
||||
return dernierCompte;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
debut = false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2.4) : FastPlace. Vanilla 1.21.1 (Minecraft.handleKeybinds, client) : clic droit maintenu = une pose toutes les
|
||||
* 4 ticks ({@code rightClickDelay}), soit 5 par seconde, parfaitement régulière. Des clics rapides (butterfly,
|
||||
* drag-click) passent outre ce délai et peuvent dépasser 20 clics par seconde : un simple plafond de poses par seconde
|
||||
* ferait de fausses alertes. Le module FastPlace (délai 0) pose à chaque tick, avec une régularité qu'aucun clic humain
|
||||
* n'a : c'est elle qui est mesurée.
|
||||
*
|
||||
* Signal : sur les {@link GardeConfig#fastPlaceSerie} derniers intervalles entre deux poses (en ticks serveur, poses du
|
||||
* même tick regroupées), au moins {@link GardeConfig#fastPlaceRegularite} (90 %) valent exactement le même intervalle
|
||||
* d, avec {@code d ≤} {@link GardeConfig#fastPlaceIntervalleMaxTicks} (1 par défaut : une pose à chaque tick). Une
|
||||
* pause de plus d'une seconde remet la série à zéro. Le jitter réseau casse la régularité : il fait manquer un
|
||||
* tricheur, jamais accuser un joueur honnête. OBSERVE par défaut.
|
||||
*/
|
||||
public final class FastPlace {
|
||||
|
||||
public static final int TAILLE_MAX = 64;
|
||||
/** Pause (ticks) qui termine une série. */
|
||||
public static final int PAUSE_TICKS = 20;
|
||||
|
||||
private final int[] intervalles = new int[TAILLE_MAX];
|
||||
private int taille;
|
||||
private int tete;
|
||||
private long dernierTick = Long.MIN_VALUE;
|
||||
private int dernierIntervalle;
|
||||
|
||||
/** Une pose de bloc par le joueur au tick serveur donné. @return points d'infraction */
|
||||
public double pose(long tick, GardeConfig cfg) {
|
||||
if (dernierTick != Long.MIN_VALUE && tick == dernierTick) return 0; // même tick : une seule pose comptée
|
||||
long ecart = dernierTick == Long.MIN_VALUE ? Long.MAX_VALUE : tick - dernierTick;
|
||||
dernierTick = tick;
|
||||
if (ecart <= 0 || ecart > PAUSE_TICKS) {
|
||||
vider();
|
||||
dernierTick = tick;
|
||||
return 0;
|
||||
}
|
||||
intervalles[tete] = (int) ecart;
|
||||
tete = (tete + 1) % TAILLE_MAX;
|
||||
if (taille < TAILLE_MAX) taille++;
|
||||
int n = Math.max(2, Math.min(TAILLE_MAX, cfg.fastPlaceSerie));
|
||||
if (taille < n) return 0;
|
||||
// intervalle le plus fréquent parmi les n derniers
|
||||
int[] compte = new int[PAUSE_TICKS + 1];
|
||||
int mode = 0;
|
||||
for (int k = 0; k < n; k++) {
|
||||
int v = intervalles[((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX];
|
||||
if (++compte[v] > compte[mode]) mode = v;
|
||||
}
|
||||
dernierIntervalle = mode;
|
||||
if (mode > cfg.fastPlaceIntervalleMaxTicks || compte[mode] < cfg.fastPlaceRegularite * n) return 0;
|
||||
vider(); // une infraction par série complète
|
||||
dernierTick = tick;
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
public int dernierIntervalle() {
|
||||
return dernierIntervalle;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
taille = 0;
|
||||
tete = 0;
|
||||
dernierTick = Long.MIN_VALUE;
|
||||
}
|
||||
}
|
||||
@@ -26,6 +26,59 @@ public final class GardeConfig {
|
||||
/** C1 (16/10) : ticks de grâce du contrôle vol après la fin du plané en élytres (fin à l'atterrissage). */
|
||||
public int graceFinElytresTicks = 50;
|
||||
|
||||
// --- 0.5 (P1.1, section [journal]) ---
|
||||
/** Le verdict qui déclenche un SETBACK ou une EXPULSION est toujours écrit, malgré la limite de lignes. */
|
||||
public boolean journalToujoursSanctions = true;
|
||||
/** Lignes de journal au plus par seconde et par contrôle (hors verdicts de sanction ci-dessus). */
|
||||
public int journalLignesParSeconde = 1;
|
||||
|
||||
// --- Score de suspicion (0.4.0, section [suspicion]) : information pour les humains, jamais de sanction ---
|
||||
public boolean suspicionActive = true;
|
||||
public double suspicionSeuilSurveiller = 25;
|
||||
public double suspicionSeuilSuspect = 50;
|
||||
public double suspicionSeuilFort = 75;
|
||||
/** Demi-vie du score, en minutes de jeu (le suivi du joueur est libéré à la déconnexion). */
|
||||
public double suspicionDemiVieMinutes = 10;
|
||||
/** Plafonds de contribution par fiabilité du contrôle (fiable / moyen / sujet aux faux positifs). */
|
||||
public double suspicionPlafondFiable = 50;
|
||||
public double suspicionPlafondMoyen = 30;
|
||||
public double suspicionPlafondFaible = 15;
|
||||
/** Diversité : ce nombre de contrôles distincts au palier SETBACK ou plus dans la fenêtre = suspect fort. */
|
||||
public int suspicionDiversiteControles = 3;
|
||||
public double suspicionDiversiteFenetreMinutes = 10;
|
||||
public int suspicionHistoriqueJours = 7;
|
||||
|
||||
// --- Vol : flottement (0.4.0), équivalent du « kicked for floating too long » vanilla (80 ticks) ---
|
||||
/** Ticks consécutifs en l'air sans chute (dy par tick >= -0,03125, comme vanilla) avant infraction ; 0 = coupé. */
|
||||
public int volFlottementTicks = 80;
|
||||
|
||||
// --- 0.4.0 : plané (elytres), vélocité (recul), auto-totem. OBSERVE par défaut, valeurs à valider en jeu ---
|
||||
/** Ticks de montée sans perte de vitesse en plané avant infraction ; 0 = coupé. */
|
||||
public int elytresMonteeTicks = 20;
|
||||
/** Ticks de plané presque immobile et sans chute avant infraction ; 0 = coupé. */
|
||||
public int elytresStationnaireTicks = 20;
|
||||
/** 0.5 (P1.6) : déploiements d'élytres au plus par seconde (au-delà : ElytraFly « packet ») ; 0 = coupé. */
|
||||
public int elytresDeploiementsMax = 5;
|
||||
/** Ticks sur lesquels le recul est mesuré après un coup subi. */
|
||||
public int velociteFenetreTicks = 6;
|
||||
/** Recul absent si le déplacement dans le sens du recul est sous cette part du recul vanilla. */
|
||||
public double velociteRapportMin = 0.15;
|
||||
/** Reculs absents (sur les 6 derniers en 2 min) avant infraction. */
|
||||
public int velociteSerieMin = 3;
|
||||
/** Force de recul effective (après résistance) en dessous de laquelle on ne mesure pas. */
|
||||
public double velociteForceMin = 0.15;
|
||||
/** 0.4.1 : points par recul absent compte (en serie). 2 en dur en 0.4.0 : la decroissance (0,5/s) plafonnait le VL vers 5. */
|
||||
public double velocitePoints = 4.0;
|
||||
/** 0.4.2 : seuils propres a un controle ; valeur <= 0 = seuil global de [sanctions]. */
|
||||
public double autoTotemSeuilSetback = 0;
|
||||
public double autoTotemSeuilExpulsion = 9;
|
||||
public double velociteSeuilSetback = 8;
|
||||
public double velociteSeuilExpulsion = 16;
|
||||
/** Réaction humaine minimale (ms) entre l'éclatement d'un totem et un totem remis en main, hors ping. */
|
||||
public int totemDelaiMinMs = 150;
|
||||
/** Ping (ms) au plus ajouté à ce délai (le ping est falsifiable). */
|
||||
public int totemPingMaxMs = 200;
|
||||
|
||||
// --- Killaura ---
|
||||
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
|
||||
public double angleMaxDegres = 60.0;
|
||||
@@ -108,11 +161,99 @@ public final class GardeConfig {
|
||||
public int elytresAirMinTicks = 2;
|
||||
/** C8 : le combat d'un passager de véhicule (bateau, cheval, minecart…) est mesuré comme à pied. */
|
||||
public boolean combatMesureEnVehicule = false;
|
||||
/** C15 : solde de paquets de mouvement (reçus - ticks écoulés) au-delà duquel le timer compte ; 0 = désactivé. */
|
||||
public int timerSoldeMax = 0;
|
||||
/**
|
||||
* C15 : solde de paquets de mouvement (reçus - ticks écoulés) au-delà duquel le timer compte ; 0 = désactivé.
|
||||
* 0.5 (P1.12) : 20 par défaut (avant 0). Un fichier de configuration existant garde sa valeur.
|
||||
*/
|
||||
public int timerSoldeMax = 20;
|
||||
/** 0.5 (P1.12) : crédit (paquets en retard) au plus remboursable par une rafale de rattrapage après un lag. */
|
||||
public int timerDetteMax = 40;
|
||||
|
||||
// --- 0.5 (P1) : nouveaux contrôles, OBSERVE par défaut, valeurs prudentes à valider en jeu ---
|
||||
/** Step : hauteur de marche au moins permise (vanilla : attribut step_height, 0,6) ; l'attribut réel du joueur et sa puissance de saut s'ajoutent (maximum). */
|
||||
public double stepHauteurMax = 0.6;
|
||||
/** Step : marge (blocs) au-dessus de la hauteur permise. */
|
||||
public double stepMargeBlocs = 0.1;
|
||||
/** Criticals : coup critique suspect si, depuis le dernier « au sol » du client, ni montée ni descente au-delà (blocs). */
|
||||
public double criticalsMicroSautMax = 0.1;
|
||||
/** Criticals : coups critiques suspects, parmi les 10 derniers en 60 s, à partir desquels un critique suspect compte. */
|
||||
public int criticalsSerieMin = 3;
|
||||
/** Anti-faim : paquets consécutifs de course au sol déclarée « en l'air » avant infraction (1 s à 20 paquets/s). */
|
||||
public int antiFaimTicks = 20;
|
||||
|
||||
// --- 0.5 (P2) : nouveaux contrôles, OBSERVE par défaut, valeurs prudentes à valider en jeu ---
|
||||
/** NoSlow : vitesse au sol permise pendant un usage d'objet = ce facteur × course (0,30) × effets ; vanilla ~0,2. */
|
||||
public double noSlowFacteur = 0.5;
|
||||
/** NoSlow : ticks d'usage d'objet (serveur) avant de mesurer (élan de la course, latence du début d'usage). */
|
||||
public int noSlowGraceTicks = 3;
|
||||
/** NoSlow : paquets suspects consécutifs avant infraction. */
|
||||
public int noSlowTicks = 10;
|
||||
/** FastBreak : rapport progression × ticks sous lequel une casse est suspecte (vanilla accepte dès 0,7). */
|
||||
public double fastBreakFacteur = 0.8;
|
||||
/** FastBreak : blocs plus rapides que ce nombre de ticks non mesurés (un tick de jitter y pèse trop). */
|
||||
public int fastBreakTicksMin = 6;
|
||||
/** FastBreak : casses suspectes parmi les 10 dernières mesurées (60 s) avant de compter. */
|
||||
public int fastBreakSerieMin = 4;
|
||||
/** FastPlace : intervalles entre poses examinés (poses du même tick regroupées). */
|
||||
public int fastPlaceSerie = 40;
|
||||
/** FastPlace : part de ces intervalles qui doivent valoir exactement le même nombre de ticks. */
|
||||
public double fastPlaceRegularite = 0.9;
|
||||
/** FastPlace : cet intervalle commun (ticks) au plus ; vanilla au clic maintenu : 4. */
|
||||
public int fastPlaceIntervalleMaxTicks = 1;
|
||||
/** Interaction de bloc : marge (blocs) de portée et de face, en plus du déplacement du dernier tick. */
|
||||
public double interactionBlocMarge = 0.5;
|
||||
/** Interaction de bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter. */
|
||||
public int interactionBlocSerieMin = 3;
|
||||
/** 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. */
|
||||
public int autoTotemEcartTypeMinMs = 30;
|
||||
/** Auto-totem régulier : tous les délais examinés sous cette valeur (ms). */
|
||||
public int autoTotemRegulierMaxMs = 300;
|
||||
/** Jesus : paquets consécutifs « au sol » sur un fluide sans appui avant infraction. */
|
||||
public int jesusTicks = 10;
|
||||
/** Omnisprint : angle (degrés) entre déplacement et regard au-delà duquel un sprint est impossible en vanilla. */
|
||||
public double omnisprintAngleDegres = 100;
|
||||
/** Omnisprint : paquets consécutifs avant infraction. */
|
||||
public int omnisprintTicks = 10;
|
||||
/** X-Ray : part (%) de minerais rares parmi les blocs cassés en profondeur au-delà de laquelle on alerte. */
|
||||
public double xrayAlerteDiamantsParCent = 5;
|
||||
/** X-Ray : part des minerais rares cassés sans face à l'air ni à un fluide. */
|
||||
public double xrayAlerteNonExposesPart = 0.8;
|
||||
/** X-Ray : seuls les blocs cassés à cette hauteur ou plus bas comptent. */
|
||||
public int xrayAlerteYMax = 16;
|
||||
/** X-Ray : minerais rares dans la fenêtre avant toute alerte (un filon chanceux ne suffit pas). */
|
||||
public int xrayRaresMin = 12;
|
||||
|
||||
// --- 0.5 (P3) : nouveaux contrôles, OBSERVE par défaut, valeurs prudentes à valider en jeu ---
|
||||
/** Nuker : blocs cassés dans un même tick serveur au-delà desquels le tick est suspect (vanilla : 1, gigue comprise : 3). */
|
||||
public int nukerBlocsParTickMax = 3;
|
||||
/** Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter. */
|
||||
public int nukerSerieMin = 3;
|
||||
/** 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. */
|
||||
public int cristalSerieMin = 6;
|
||||
/** Tower : intervalle (ticks) entre deux poses en pilier sous lequel il est court (vanilla : 9 à 10 au mieux). */
|
||||
public int towerIntervalleMinTicks = 6;
|
||||
/** Tower : intervalles courts de suite avant que chaque pose rapide suivante compte. */
|
||||
public int towerSerie = 5;
|
||||
/** Complétion : demandes par seconde soutenues permises (le client vanilla en envoie une par frappe). */
|
||||
public int completionParSecondeMax = 20;
|
||||
/** Complétion : rafale permise (capacité du seau). */
|
||||
public int completionRafaleMax = 40;
|
||||
|
||||
// --- 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;
|
||||
|
||||
// --- Exemptions ---
|
||||
public int graceTeleportTicks = 40;
|
||||
/** 0.5 (P1.2) : grâce de mouvement / timer après la connexion (ticks) ; plus longue après une expulsion récente. */
|
||||
public int graceConnexionTicks = 100;
|
||||
public int graceApresExpulsionTicks = 200;
|
||||
/** 0.5 (P1.2) : sans position de retour valide, le SETBACK ramène au sol juste sous le joueur (jamais à côté). */
|
||||
public boolean setbackSolSiPasDePosition = true;
|
||||
public int graceReculTicks = 20;
|
||||
public int graceGelTicks = 100;
|
||||
public double tpsLag = 18.0;
|
||||
|
||||
@@ -0,0 +1,86 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.StandardOpenOption;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Incidents de suspicion par UUID sur N jours (par défaut 7). Un incident = un franchissement vers « suspect » ou
|
||||
* « suspect fort ». Persistance : un fichier texte, une ligne par incident, en ajout seulement (une coupure ne
|
||||
* peut pas le corrompre au-delà d'une ligne, aucune dépendance, lisible à la main). Les lignes trop vieilles ou
|
||||
* illisibles sont ignorées au chargement, et le fichier est réécrit compact si quelque chose a été écarté.
|
||||
* Format : {@code epochMs;uuid;niveau;score;controles}.
|
||||
*/
|
||||
public final class HistoriqueSuspicion {
|
||||
|
||||
public record Incident(long epochMs, Suspicion.Niveau niveau, int score, String controles) { }
|
||||
|
||||
private final Map<UUID, List<Incident>> incidents = new HashMap<>();
|
||||
private Path fichier;
|
||||
|
||||
/** Charge le fichier (s'il existe), ignore ce qui a plus de {@code jours} jours, et mémorise le chemin. */
|
||||
public synchronized void ouvrir(Path chemin, long nowEpochMs, int jours) throws IOException {
|
||||
this.fichier = chemin;
|
||||
incidents.clear();
|
||||
if (!Files.exists(chemin)) return;
|
||||
long limite = nowEpochMs - jours * 86_400_000L;
|
||||
boolean ecarte = false;
|
||||
for (String ligne : Files.readAllLines(chemin, StandardCharsets.UTF_8)) {
|
||||
if (ligne.isBlank()) continue;
|
||||
String[] t = ligne.split(";", 5);
|
||||
try {
|
||||
if (t.length < 4) throw new IllegalArgumentException();
|
||||
long ts = Long.parseLong(t[0]);
|
||||
if (ts < limite) {
|
||||
ecarte = true;
|
||||
continue;
|
||||
}
|
||||
incidents.computeIfAbsent(UUID.fromString(t[1]), k -> new ArrayList<>()).add(new Incident(ts,
|
||||
Suspicion.Niveau.valueOf(t[2]), Integer.parseInt(t[3]), t.length > 4 ? t[4] : ""));
|
||||
} catch (RuntimeException e) {
|
||||
ecarte = true;
|
||||
}
|
||||
}
|
||||
if (ecarte) reecrire();
|
||||
}
|
||||
|
||||
public synchronized void enregistrer(UUID joueur, long epochMs, Suspicion.Niveau niveau, int score, String controles) {
|
||||
String ctl = controles == null ? "" : controles.replace(';', ',').replace('\n', ' ');
|
||||
List<Incident> l = incidents.computeIfAbsent(joueur, k -> new ArrayList<>());
|
||||
Incident i = new Incident(epochMs, niveau, score, ctl);
|
||||
l.add(i);
|
||||
if (fichier == null) return;
|
||||
try {
|
||||
if (fichier.getParent() != null) Files.createDirectories(fichier.getParent());
|
||||
Files.writeString(fichier, ligne(joueur, i), StandardCharsets.UTF_8,
|
||||
StandardOpenOption.CREATE, StandardOpenOption.APPEND);
|
||||
} catch (IOException e) {
|
||||
// la mémoire reste juste ; le fichier sera réécrit compact au prochain chargement
|
||||
}
|
||||
}
|
||||
|
||||
/** Nombre d'incidents des {@code jours} derniers jours. */
|
||||
public synchronized int incidents(UUID joueur, long nowEpochMs, int jours) {
|
||||
long limite = nowEpochMs - jours * 86_400_000L;
|
||||
int n = 0;
|
||||
for (Incident i : incidents.getOrDefault(joueur, List.of())) if (i.epochMs() >= limite) n++;
|
||||
return n;
|
||||
}
|
||||
|
||||
private static String ligne(UUID id, Incident i) {
|
||||
return i.epochMs() + ";" + id + ";" + i.niveau() + ";" + i.score() + ";" + i.controles() + System.lineSeparator();
|
||||
}
|
||||
|
||||
private void reecrire() throws IOException {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
incidents.forEach((id, l) -> l.forEach(i -> sb.append(ligne(id, i))));
|
||||
Files.writeString(fichier, sb.toString(), StandardCharsets.UTF_8);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,143 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2.5) : interaction avec un bloc impossible pour le lancer de rayon du client vanilla (AirPlace, Scaffold
|
||||
* simple, casse ou pose à travers un bloc, portée de bloc). Le client vanilla n'envoie un clic sur un bloc que si son
|
||||
* rayon (depuis l'œil, longueur = attribut {@code block_interaction_range}, 4,5 en survie) touche la forme de contour
|
||||
* du bloc, sur la face par laquelle il entre. Le serveur (handleUseItemOn, vérifié dans les sources NeoForge
|
||||
* 21.1.234) n'exige que : œil à moins de portée + 1 de la boîte du bloc, impact à moins d'un bloc du centre.
|
||||
*
|
||||
* Anomalies (une seule rapportée, la première) :
|
||||
* <ul>
|
||||
* <li>{@code bloc-vide} : le bloc cliqué est de l'air (AirPlace : le rayon vanilla ne touche jamais l'air) ;</li>
|
||||
* <li>{@code face-cachee} : l'œil est derrière le plan de la face cliquée (plus de marge) : le rayon n'a pas pu y
|
||||
* entrer ;</li>
|
||||
* <li>{@code hors-portee} : impact (ou boîte du bloc, sans impact) à plus de portée + marge de l'œil ;</li>
|
||||
* <li>{@code impact-hors-face} : bloc plein, impact pas sur le plan de la face cliquée (vecteur forgé).</li>
|
||||
* </ul>
|
||||
* La marge ({@link GardeConfig#interactionBlocMarge} 0,5) s'ajoute au déplacement du dernier tick : le rayon du client
|
||||
* part de l'œil interpolé entre deux ticks. Au-delà de portée + 1, vanilla refuse déjà : si l'adaptateur voit plus
|
||||
* loin, un mod a transformé les coordonnées (vaisseau Sable) et rien n'est mesuré.
|
||||
*/
|
||||
public final class InteractionBloc {
|
||||
|
||||
public static final int SERIE = 10;
|
||||
public static final long FENETRE_MS = 60_000;
|
||||
/** Tolérance (blocs) de l'impact sur le plan d'une face de bloc plein (flottants du paquet). */
|
||||
public static final double TOLERANCE_PLAN = 0.01;
|
||||
|
||||
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
|
||||
private int dernierCompte;
|
||||
|
||||
/**
|
||||
* @param oeil œil du joueur (x, y, z)
|
||||
* @param boite boîte de contour du bloc en coordonnées absolues (minX, minY, minZ, maxX, maxY, maxZ) ; pour un bloc
|
||||
* sans contour, le cube unité
|
||||
* @param face face cliquée, ordre de {@code Direction.get3DDataValue} : 0 bas, 1 haut, 2 nord (−z), 3 sud (+z),
|
||||
* 4 ouest (−x), 5 est (+x) ; -1 = inconnue
|
||||
* @param impact point d'impact envoyé par le client, null s'il n'y en a pas (début de casse)
|
||||
* @param air le bloc cliqué est de l'air
|
||||
* @param plein le bloc a une forme de cube plein
|
||||
* @param portee portée d'interaction de bloc du joueur (attribut)
|
||||
* @param marge marge (blocs), déplacement du dernier tick compris
|
||||
* @return la première anomalie, null si aucune ou si les coordonnées ne sont pas mesurables
|
||||
*/
|
||||
public static String anomalie(double[] oeil, double[] boite, int face, double[] impact, boolean air, boolean plein,
|
||||
double portee, double marge) {
|
||||
double dBoite = Math.sqrt(distanceCarreeBoite(oeil, boite));
|
||||
if (dBoite > portee + 1.0 + 1e-3) return null; // vanilla refuse ou un mod a transformé les coordonnées
|
||||
if (air) return "bloc-vide";
|
||||
if (face >= 0 && face <= 5) {
|
||||
double[] plan = {boite[1], boite[4], boite[2], boite[5], boite[0], boite[3]};
|
||||
int axe = face <= 1 ? 1 : face <= 3 ? 2 : 0;
|
||||
boolean positive = face == 1 || face == 3 || face == 5;
|
||||
double ecart = positive ? oeil[axe] - plan[face] : plan[face] - oeil[axe];
|
||||
if (ecart < -marge) return "face-cachee";
|
||||
if (impact != null && plein) {
|
||||
boolean horsPlan = Math.abs(impact[axe] - plan[face]) > TOLERANCE_PLAN;
|
||||
boolean horsBoite = false;
|
||||
for (int a = 0; a < 3; a++) {
|
||||
if (a == axe) continue;
|
||||
if (impact[a] < boite[a] - TOLERANCE_PLAN || impact[a] > boite[a + 3] + TOLERANCE_PLAN) horsBoite = true;
|
||||
}
|
||||
if (horsPlan || horsBoite) return "impact-hors-face";
|
||||
}
|
||||
}
|
||||
double d = impact != null ? Math.sqrt(carre(impact[0] - oeil[0]) + carre(impact[1] - oeil[1]) + carre(impact[2] - oeil[2]))
|
||||
: dBoite;
|
||||
if (d > portee + marge) return "hors-portee";
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Une interaction mesurée ; {@code anomalie} null = normale. @return points d'infraction */
|
||||
public double enregistrer(long nowMs, String anomalie, GardeConfig cfg) {
|
||||
dernierCompte = serie.ajouter(nowMs, anomalie != null);
|
||||
if (anomalie == null || dernierCompte < Math.max(1, cfg.interactionBlocSerieMin)) return 0;
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
// Dernier événement évalué (seconde revue : dédoublonnage du seul clic vanilla MAIN puis OFF).
|
||||
private long dernierMs = Long.MIN_VALUE;
|
||||
private long derniereCle;
|
||||
private int derniereMain = -1;
|
||||
private int derniereFace;
|
||||
private double[] dernierImpact;
|
||||
private long dedoublonneMs = Long.MIN_VALUE;
|
||||
private java.util.List<Verdict> derniersVerdicts = java.util.List.of();
|
||||
private String derniereAnomalie;
|
||||
|
||||
/** Anomalie du dernier événement évalué (null si aucune). */
|
||||
public String derniereAnomalie() {
|
||||
return derniereAnomalie;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vrai si cet événement est la main secondaire du clic vanilla qui vient d'être évalué en main principale : même
|
||||
* instant, même bloc, même face, même point d'impact, et au plus une fois par instant. Tout le reste (deuxième
|
||||
* événement identique de la même main, autre face, autre impact, troisième événement) est évalué normalement.
|
||||
*
|
||||
* @param main 0 = principale, 1 = secondaire
|
||||
*/
|
||||
public boolean secondeMainDuMemeClic(long nowMs, long cleBloc, int main, int face, double[] impact) {
|
||||
return main == 1 && derniereMain == 0 && nowMs == dernierMs && cleBloc == derniereCle && face == derniereFace
|
||||
&& java.util.Arrays.equals(impact, dernierImpact) && dedoublonneMs != nowMs;
|
||||
}
|
||||
|
||||
/** La main secondaire dédoublonnée reprend la décision (verdicts) de la principale ; non recomptée. */
|
||||
public java.util.List<Verdict> reprendre(long nowMs) {
|
||||
dedoublonneMs = nowMs;
|
||||
derniereMain = 1;
|
||||
return derniersVerdicts;
|
||||
}
|
||||
|
||||
/** Mémorise l'événement évalué et ses verdicts. */
|
||||
public void memoriser(long nowMs, long cleBloc, int main, int face, double[] impact, String anomalie,
|
||||
java.util.List<Verdict> verdicts) {
|
||||
derniereAnomalie = anomalie;
|
||||
dernierMs = nowMs;
|
||||
derniereCle = cleBloc;
|
||||
derniereMain = main;
|
||||
derniereFace = face;
|
||||
dernierImpact = impact == null ? null : impact.clone();
|
||||
derniersVerdicts = java.util.List.copyOf(verdicts);
|
||||
}
|
||||
|
||||
public int dernierCompte() {
|
||||
return dernierCompte;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
serie.vider();
|
||||
}
|
||||
|
||||
static double distanceCarreeBoite(double[] p, double[] b) {
|
||||
double dx = Math.max(0, Math.max(b[0] - p[0], p[0] - b[3]));
|
||||
double dy = Math.max(0, Math.max(b[1] - p[1], p[1] - b[4]));
|
||||
double dz = Math.max(0, Math.max(b[2] - p[2], p[2] - b[5]));
|
||||
return dx * dx + dy * dy + dz * dz;
|
||||
}
|
||||
|
||||
private static double carre(double v) {
|
||||
return v * v;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2.11) : Jesus (marcher sur l'eau ou la lave). Le client vanilla calcule {@code onGround} par collision ; un
|
||||
* fluide n'a pas de forme de collision : un joueur dans ou sur un fluide, sans bloc ni entité solide sous lui, ne se
|
||||
* déclare jamais au sol. Le cheat (mode « solide ») se déclare au sol à la surface, sans chute (dy nul).
|
||||
*
|
||||
* Le contrôle vol (en ENFORCE en production) attrape déjà la variante tenue au-dessus de la surface (pas de milieu
|
||||
* spécial, gravité violée) ; celui-ci couvre surtout la variante qui garde les pieds dans le fluide (milieu spécial :
|
||||
* vol et vitesse ne mesurent pas). Signal : {@link GardeConfig#jesusTicks} (10) paquets d'un tick de suite, au sol
|
||||
* selon le client, pas au sol selon le serveur, fluide aux pieds ou juste dessous, aucune entité solide sous les pieds
|
||||
* (bateau, shulker, vaisseau), |dy| < 0,01. Nénuphars, glace (Semelles givrantes), bord du bassin : sol serveur, donc
|
||||
* rien. OBSERVE par défaut.
|
||||
*/
|
||||
public final class Jesus {
|
||||
|
||||
private int serie;
|
||||
|
||||
public double enregistrer(EtatMouvement m, FaitsMouvement f, GardeConfig cfg) {
|
||||
boolean suspect = f.surFluide && !f.entiteSolideSous && m.auSolClient() && !m.auSolServeur() && m.ticks() == 1
|
||||
&& Math.abs(m.dy()) < 0.01;
|
||||
if (!suspect) {
|
||||
serie = 0;
|
||||
return 0;
|
||||
}
|
||||
if (++serie < Math.max(1, cfg.jesusTicks)) return 0;
|
||||
serie = 0;
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
serie = 0;
|
||||
}
|
||||
}
|
||||
@@ -24,6 +24,45 @@ public final class Moteur {
|
||||
/** C4 : joueurs déjà expulsés (jusqu'à leur reconnexion). */
|
||||
private final java.util.Set<UUID> expulses = new java.util.HashSet<>();
|
||||
|
||||
private java.util.function.LongSupplier horloge = System::currentTimeMillis;
|
||||
private final HistoriqueSuspicion historique = new HistoriqueSuspicion();
|
||||
|
||||
/** Horloge du score de suspicion (ms) ; remplaçable dans les tests. */
|
||||
public void horloge(java.util.function.LongSupplier h) {
|
||||
this.horloge = h;
|
||||
}
|
||||
|
||||
public HistoriqueSuspicion historique() {
|
||||
return historique;
|
||||
}
|
||||
|
||||
/** Alerte de suspicion : franchissement vers le haut d'un palier. */
|
||||
public record AlerteSuspicion(Suspicion.Niveau niveau, int score, int incidents, String controles) { }
|
||||
|
||||
/**
|
||||
* Franchissement de palier en attente pour ce joueur (null sinon). À partir de « suspect », l'incident est ajouté à
|
||||
* l'historique. Aucune sanction ici : c'est une information pour les humains.
|
||||
*/
|
||||
public AlerteSuspicion alerteSuspicion(UUID joueur, long epochMs) {
|
||||
Suivi s = suivis.get(joueur);
|
||||
if (s == null) return null;
|
||||
Suspicion.Niveau n = s.suspicion.prendreTransition();
|
||||
if (n == null) return null;
|
||||
long now = horloge.getAsLong();
|
||||
int score = (int) Math.round(s.suspicion.score(now));
|
||||
String ctl = s.suspicion.resume(now);
|
||||
if (n.ordinal() >= Suspicion.Niveau.SUSPECT.ordinal()) {
|
||||
historique.enregistrer(joueur, epochMs, n, score, ctl);
|
||||
}
|
||||
return new AlerteSuspicion(n, score, historique.incidents(joueur, epochMs, cfg.suspicionHistoriqueJours), ctl);
|
||||
}
|
||||
|
||||
/** Score courant d'un joueur suivi (0 si inconnu). */
|
||||
public double scoreSuspicion(UUID joueur) {
|
||||
Suivi s = suivis.get(joueur);
|
||||
return s == null ? 0 : s.suspicion.score(horloge.getAsLong());
|
||||
}
|
||||
|
||||
public Moteur(GardeConfig cfg) {
|
||||
this.cfg = cfg;
|
||||
}
|
||||
@@ -33,7 +72,7 @@ public final class Moteur {
|
||||
}
|
||||
|
||||
public Suivi suivi(UUID joueur) {
|
||||
return suivis.computeIfAbsent(joueur, k -> new Suivi(cfg.vlDecroissanceParSeconde));
|
||||
return suivis.computeIfAbsent(joueur, k -> new Suivi(cfg.vlDecroissanceParSeconde, cfg));
|
||||
}
|
||||
|
||||
public void retirer(UUID joueur) {
|
||||
@@ -121,20 +160,11 @@ public final class Moteur {
|
||||
ajouter(verdicts, s, Controle.HITBOX, PorteeHitbox.pointsHitbox(manque, seuil), nowMs, ex,
|
||||
String.format(Locale.ROOT, "regard hors boite de %.2f (seuil %.2f)", manque, seuil));
|
||||
}
|
||||
boolean setback = false;
|
||||
for (Verdict v : verdicts) {
|
||||
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
|
||||
s.coupsBloquesJusqua = nowMs + DUREE_BLOCAGE_COUPS_MS;
|
||||
}
|
||||
// D2 (0.3.2) : un setback de combat (coups annulés) compte comme un setback (C5) et remet le VL de ce
|
||||
// contrôle à zéro, comme pour le vol (C2). Avant, le VL montait à 20 en ~5 s : expulsion directe, sans
|
||||
// la règle « 4 setbacks en 60 s ».
|
||||
if (v.applicable() == Sanction.SETBACK) {
|
||||
s.vl.remettreAZero(v.controle());
|
||||
setback = true;
|
||||
}
|
||||
}
|
||||
if (setback) s.noterSetback(nowMs);
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
@@ -338,32 +368,53 @@ public final class Moteur {
|
||||
* Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout.
|
||||
*/
|
||||
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m) {
|
||||
return mouvement(joueur, nowMs, etat, m, Double.NaN);
|
||||
}
|
||||
|
||||
/**
|
||||
* Idem, avec la hauteur de marche permise du joueur pour le contrôle step (0.5, P1.9) : max(attribut step_height,
|
||||
* puissance de saut). NaN = inconnue (traces, rejeu, piston proche) : step ne mesure pas.
|
||||
*/
|
||||
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m, double hauteurPermise) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF;
|
||||
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
|
||||
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
|
||||
if (!noFall && !vitesse && !vol) return List.of();
|
||||
boolean step = cfg.mode(Controle.STEP) != Mode.OFF;
|
||||
boolean criticals = cfg.mode(Controle.CRITICALS) != Mode.OFF;
|
||||
boolean antiFaim = cfg.mode(Controle.ANTI_FAIM) != Mode.OFF;
|
||||
if (!noFall && !vitesse && !vol && !step && !criticals && !antiFaim) return List.of();
|
||||
|
||||
Suivi s = suivi(joueur);
|
||||
if (criticals) s.criticals.mouvement(m); // 0.5 (P1.10) : hauteur suivie même pendant une exemption
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
|
||||
if (ex.exempt()) {
|
||||
s.step.vider();
|
||||
s.antiFaim.vider();
|
||||
// 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…).
|
||||
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
|
||||
s.vol.vider();
|
||||
s.dyChute = 0;
|
||||
// 0.4.0 : plané seul exempté -> contrôle « elytres » (Elytra Hack). Toute autre exemption l'écarte.
|
||||
List<Verdict> plane = new ArrayList<>(1);
|
||||
if (ex.raisons().size() == 1 && ex.raisons().get(0).equals("elytres")
|
||||
&& cfg.mode(Controle.ELYTRES) != Mode.OFF) {
|
||||
ajouter(plane, s, Controle.ELYTRES, s.plane.enregistrer(m, etat.propulsionRecente(), cfg), nowMs, ex,
|
||||
String.format(Locale.ROOT, "plane dxz=%.3f dy=%.3f ticks=%d", m.dxz(), m.dy(), m.ticks()));
|
||||
} else {
|
||||
s.plane.vider();
|
||||
}
|
||||
// C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore.
|
||||
if (ex.raisons().contains("elytres")) {
|
||||
s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L;
|
||||
}
|
||||
return List.of();
|
||||
return plane;
|
||||
}
|
||||
s.plane.vider(); // plus en plané (atterrissage, fin des élytres) : ni référence de vitesse ni compteur gardés
|
||||
List<Verdict> verdicts = new ArrayList<>(3);
|
||||
if (noFall) {
|
||||
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m, s.dyChute), nowMs, ex,
|
||||
NoFall.sansDeplacement(m) ? "au sol declare sans bloc dessous pendant une chute (paquet d'etat)"
|
||||
: "au sol declare sans bloc dessous pendant une chute");
|
||||
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m), nowMs, ex,
|
||||
"au sol declare sans bloc dessous pendant une chute");
|
||||
}
|
||||
s.dyChute = NoFall.dyApres(m, s.dyChute);
|
||||
if (vitesse) {
|
||||
s.vitesse.moyenne = cfg.vitesseMoyenne; // C15, désactivé par défaut
|
||||
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
|
||||
@@ -381,19 +432,268 @@ public final class Moteur {
|
||||
s.vol.vider(); // le paquet qui suit la grâce sert de référence
|
||||
} else if (vol) {
|
||||
s.vol.fenetreGlissante = cfg.volFenetreGlissante; // C10, désactivé par défaut
|
||||
s.vol.flottementMax = cfg.volFlottementTicks; // 0.4.0 : flottement prolongé (80 ticks comme vanilla)
|
||||
double pts = s.vol.enregistrer(m, false);
|
||||
ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy()));
|
||||
}
|
||||
if (step) {
|
||||
double pts = s.step.enregistrer(m, hauteurPermise, cfg);
|
||||
ajouter(verdicts, s, Controle.STEP, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"marche de %.3f en un tick au sol (seuil %.2f)", m.dy(), Step.seuil(hauteurPermise, cfg)));
|
||||
}
|
||||
if (antiFaim) {
|
||||
ajouter(verdicts, s, Controle.ANTI_FAIM, s.antiFaim.enregistrer(m, cfg), nowMs, ex, String.format(Locale.ROOT,
|
||||
"course au sol declaree en l'air %d paquets de suite (dxz=%.3f)", cfg.antiFaimTicks, m.dxz()));
|
||||
}
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P2) : contrôles de mouvement ajoutés en P2 (no-slow…), sur le même paquet accepté que {@link #mouvement},
|
||||
* avec les faits supplémentaires lus par l'adaptateur. Appel séparé pour ne pas toucher la signature de
|
||||
* {@link #mouvement} (traces, rejeu). Mêmes exemptions de mouvement : créatif, spectateur, vol permis, élytres,
|
||||
* riptide, véhicule, contraption Create / vaisseau Sable, téléportation, recul, connexion ; seuils × facteurLag si
|
||||
* le serveur tire.
|
||||
*/
|
||||
public List<Verdict> mouvementP2(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m, FaitsMouvement f) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
boolean noSlow = cfg.mode(Controle.NO_SLOW) != Mode.OFF;
|
||||
boolean jesus = cfg.mode(Controle.JESUS) != Mode.OFF;
|
||||
boolean omni = cfg.mode(Controle.OMNISPRINT) != Mode.OFF;
|
||||
if (!noSlow && !jesus && !omni) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
|
||||
if (ex.exempt() || etat.ticksDepuisGel() <= cfg.graceGelTicks) {
|
||||
s.noSlow.vider();
|
||||
s.jesus.vider();
|
||||
s.omnisprint.vider();
|
||||
return List.of();
|
||||
}
|
||||
List<Verdict> verdicts = new ArrayList<>(2);
|
||||
if (jesus) {
|
||||
ajouter(verdicts, s, Controle.JESUS, s.jesus.enregistrer(m, f, cfg), nowMs, ex, String.format(Locale.ROOT,
|
||||
"au sol declare sur un fluide sans appui %d paquets de suite (dy=%.3f)", cfg.jesusTicks, m.dy()));
|
||||
}
|
||||
if (omni) {
|
||||
ajouter(verdicts, s, Controle.OMNISPRINT, s.omnisprint.enregistrer(m, f, cfg), nowMs, ex, String.format(Locale.ROOT,
|
||||
"sprint a %.0f deg du regard %d paquets de suite (max %.0f)", s.omnisprint.dernierAngle(),
|
||||
cfg.omnisprintTicks, cfg.omnisprintAngleDegres));
|
||||
}
|
||||
if (noSlow) {
|
||||
double pts = s.noSlow.enregistrer(m, f.ticksUsage, cfg, ex.facteur());
|
||||
ajouter(verdicts, s, Controle.NO_SLOW, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"vitesse %.3f au sol en utilisant un objet %d paquets de suite (seuil %.3f)",
|
||||
s.noSlow.derniereVitesse(), cfg.noSlowTicks, NoSlow.seuil(m, cfg)));
|
||||
}
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
// --- 0.5 (P2) : casse et pose de blocs -------------------------------------------------------------
|
||||
|
||||
/** START_DESTROY_BLOCK accepté (non annulé par un mod) : début de la mesure fast-break. */
|
||||
public void debutCasse(UUID joueur, long tick, int x, int y, int z) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.FAST_BREAK) == Mode.OFF) return;
|
||||
suivi(joueur).fastBreak.debut(tick, x, y, z);
|
||||
}
|
||||
|
||||
/**
|
||||
* Un bloc vient d'être cassé par le joueur (BlockEvent.BreakEvent).
|
||||
*
|
||||
* @param progression {@code getDestroyProgress} du bloc pour ce joueur (par tick) ; NaN si inconnue
|
||||
*/
|
||||
public List<Verdict> casseBloc(UUID joueur, long nowMs, long tick, EtatJoueur etat, int x, int y, int z, double progression) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.FAST_BREAK) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
|
||||
if (ex.exempt() || etat.tps() < cfg.tpsLag) {
|
||||
s.fastBreak.vider();
|
||||
return List.of();
|
||||
}
|
||||
double pts = s.fastBreak.casse(nowMs, tick, x, y, z, progression, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.FAST_BREAK, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"bloc casse a %.2f du temps vanilla (seuil %.2f), %d casses suspectes sur %d",
|
||||
s.fastBreak.dernierRapport(), cfg.fastBreakFacteur, s.fastBreak.dernierCompte(), FastBreak.SERIE));
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P2.10) : bloc cassé, pour la statistique x-ray (alerte seulement). Pas d'exemption de lag : rien n'y est
|
||||
* mesuré en temps ; créatif et spectateur exemptés.
|
||||
*/
|
||||
public List<Verdict> casseXray(UUID joueur, long nowMs, EtatJoueur etat, int y, boolean rare, boolean expose) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.XRAY) == Mode.OFF) return List.of();
|
||||
if (etat.creatif() || etat.spectateur()) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
double pts = s.xray.casse(y, rare, expose, cfg);
|
||||
if (pts > 0) ajouter(v, s, Controle.XRAY, pts, nowMs, Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE), s.xray.resume());
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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).
|
||||
*/
|
||||
public List<Verdict> casseNuker(UUID joueur, long nowMs, long tick, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.NUKER) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
|
||||
if (ex.exempt() || etat.tps() < cfg.tpsLag) {
|
||||
s.nuker.vider();
|
||||
return List.of();
|
||||
}
|
||||
double pts = s.nuker.casse(nowMs, tick, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.NUKER, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"%d blocs casses dans le meme tick (max %d), %d ticks suspects sur %d", s.nuker.casses(),
|
||||
cfg.nukerBlocsParTickMax, s.nuker.dernierCompte(), Nuker.SERIE));
|
||||
for (Verdict x : v) {
|
||||
if (x.applicable().ordinal() >= Sanction.SETBACK.ordinal()) s.nuker.marquerAnnulation();
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P3.3, revue de sécurité) : la casse qui vient d'être mesurée par {@link #casseNuker} doit-elle être annulée ?
|
||||
* Vrai pour chaque casse excédentaire du tick (pas seulement la première) quand ce tick a donné une sanction
|
||||
* ≥ SETBACK applicable, ou quand le contrôle est en ENFORCE et que le VL nuker est déjà au palier SETBACK. Jamais
|
||||
* en OBSERVE.
|
||||
*/
|
||||
public boolean nukerAnnulerCasse(UUID joueur, long nowMs, long tick) {
|
||||
if (cfg.mode(Controle.NUKER) != Mode.ENFORCE) return false;
|
||||
Suivi s = suivis.get(joueur);
|
||||
if (s == null || !s.nuker.excedent(tick, cfg)) return false;
|
||||
if (s.nuker.annulerTick()) return true;
|
||||
Sanction palier = Paliers.palier(s.vl.valeur(Controle.NUKER, nowMs), cfg, Controle.NUKER);
|
||||
return Paliers.applicable(palier, Mode.ENFORCE).ordinal() >= Sanction.SETBACK.ordinal();
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P3.1) : coup sur un cristal de l'End d'âge connu ({@code ageTicks} négatif = inconnu, non mesuré).
|
||||
* Exemptions de la famille COMBAT ; TPS bas : pas de mesure (paquets groupés).
|
||||
*/
|
||||
public List<Verdict> frappeCristal(UUID joueur, long nowMs, EtatJoueur etat, int ageTicks) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.AUTO_CRISTAL) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
|
||||
if (ex.exempt() || etat.tps() < cfg.tpsLag || etat.ticksDepuisGel() <= cfg.graceGelTicks) return List.of();
|
||||
double pts = s.autoCristal.frappe(nowMs, ageTicks, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.AUTO_CRISTAL, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"cristal frappe a %d tick(s) de son apparition (min %d), %d coups suspects sur %d", ageTicks,
|
||||
cfg.cristalDelaiMinTicks, s.autoCristal.dernierCompte(), AutoCristal.SERIE));
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P3.2) : bloc posé, pour le tower. Exemptions MONDE et MOUVEMENT (lévitation, vol permis, élytres, riptide,
|
||||
* véhicule, recul, téléportation…) : une montée qui ne vient pas du saut n'est pas mesurée.
|
||||
*/
|
||||
public List<Verdict> poseTower(UUID joueur, long nowMs, long tick, EtatJoueur etat, int bx, int by, int bz,
|
||||
double px, double py, double pz, double dy) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.TOWER) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
|
||||
Exemptions.Resultat exM = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
|
||||
if (ex.exempt() || exM.exempt() || etat.tps() < cfg.tpsLag) {
|
||||
s.tower.vider();
|
||||
return List.of();
|
||||
}
|
||||
double pts = s.tower.pose(tick, bx, by, bz, px, py, pz, dy, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.TOWER, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"pilier : pose a %d tick(s) de la precedente (min %d), %d intervalles courts de suite",
|
||||
s.tower.dernierIntervalle(), cfg.towerIntervalleMinTicks, s.tower.courts()));
|
||||
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}.
|
||||
*/
|
||||
public List<Verdict> completion(UUID joueur, long nowMs, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.COMPLETION) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
boolean exces = s.completion.demande(nowMs, cfg);
|
||||
s.completionExces = exces;
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.COMPLETION, exces ? 0.25 : 0, nowMs, Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER),
|
||||
String.format(Locale.ROOT, "demande de completion au-dela de %d/s (rafale %d), %d en exces depuis la connexion",
|
||||
cfg.completionParSecondeMax, cfg.completionRafaleMax, s.completion.excesTotal()));
|
||||
return v;
|
||||
}
|
||||
|
||||
/** La dernière demande de complétion était en excès et le contrôle est en ENFORCE : le paquet est ignoré. */
|
||||
public boolean completionAIgnorer(UUID joueur) {
|
||||
if (expulses.contains(joueur)) return true;
|
||||
Suivi s = suivis.get(joueur);
|
||||
return s != null && s.completionExces && cfg.mode(Controle.COMPLETION) == Mode.ENFORCE;
|
||||
}
|
||||
|
||||
/** Un bloc vient d'être posé par le joueur (BlockEvent.EntityPlaceEvent) : fast-place. */
|
||||
public List<Verdict> poseBloc(UUID joueur, long nowMs, long tick, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.FAST_PLACE) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
|
||||
if (ex.exempt()) {
|
||||
s.fastPlace.vider();
|
||||
return List.of();
|
||||
}
|
||||
double pts = s.fastPlace.pose(tick, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.FAST_PLACE, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"%d poses a intervalle regulier de %d tick(s) (vanilla au clic maintenu : 4)", cfg.fastPlaceSerie,
|
||||
s.fastPlace.dernierIntervalle()));
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clic sur un bloc (RightClickBlock, ou début de casse sans impact) : interaction-bloc. Voir
|
||||
* {@link InteractionBloc#anomalie} pour les paramètres géométriques.
|
||||
*/
|
||||
public List<Verdict> interactionBloc(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] boite, int face,
|
||||
double[] impact, boolean air, boolean plein, double portee, double deplacement) {
|
||||
return interactionBloc(joueur, nowMs, Long.MIN_VALUE, -1, etat, oeil, boite, face, impact, air, plein, portee, deplacement);
|
||||
}
|
||||
|
||||
/**
|
||||
* Idem, avec la position du bloc ({@code BlockPos.asLong}) et la main (0 principale, 1 secondaire, -1 inconnue).
|
||||
* Seconde revue de sécurité : seul le clic vanilla « main principale puis secondaire » (même instant, bloc, face et
|
||||
* impact, une fois par instant) n'est compté qu'une fois ; la main secondaire reprend alors les verdicts de la
|
||||
* principale, donc la même décision d'annulation. Tout autre événement est évalué normalement.
|
||||
*/
|
||||
public List<Verdict> interactionBloc(UUID joueur, long nowMs, long cleBloc, int main, EtatJoueur etat, double[] oeil,
|
||||
double[] boite, int face, double[] impact, boolean air, boolean plein, double portee,
|
||||
double deplacement) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.INTERACTION_BLOC) == Mode.OFF) return List.of();
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
|
||||
if (ex.exempt()) return List.of();
|
||||
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);
|
||||
// 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)
|
||||
&& java.util.Objects.equals(a, s.interactionBloc.derniereAnomalie())) {
|
||||
return new ArrayList<>(s.interactionBloc.reprendre(nowMs));
|
||||
}
|
||||
double pts = s.interactionBloc.enregistrer(nowMs, a, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.INTERACTION_BLOC, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"%s (%s), %d anomalies sur %d interactions", a, impact == null ? "debut de casse" : "clic droit",
|
||||
s.interactionBloc.dernierCompte(), InteractionBloc.SERIE));
|
||||
s.interactionBloc.memoriser(nowMs, cleBloc, main, face, impact, a, v);
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* L'exemption tient-elle à un état dont la fin arrive en retard côté serveur (élytres, riptide, véhicule, vol,
|
||||
* contraption, lévitation, chute lente, mode de jeu) ? Une grâce seule (téléportation, recul) : non.
|
||||
*/
|
||||
static boolean sortieDEtat(List<String> raisons) {
|
||||
for (String r : raisons) {
|
||||
if (!r.equals("teleportation") && !r.equals("recul")) return true;
|
||||
if (!r.equals("teleportation") && !r.equals("recul") && !r.equals("connexion")) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -448,6 +748,113 @@ public final class Moteur {
|
||||
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
|
||||
}
|
||||
|
||||
// --- 0.4.0 : vélocité (recul) et auto-totem ---
|
||||
|
||||
/**
|
||||
* Le serveur applique un recul au joueur (coup, explosion, charge de vent).
|
||||
*
|
||||
* @param dirX,dirZ direction du déplacement attendu ; {@code force} effective, résistance déduite
|
||||
*/
|
||||
public void reculApplique(UUID joueur, long nowMs, double dirX, double dirZ, double force, boolean libre) {
|
||||
if (cfg.mode(Controle.VELOCITE) == Mode.OFF || expulses.contains(joueur)) return;
|
||||
// Joueur coincé (mur, trou, plafond) : le recul n'a pas pu avoir lieu, rien à mesurer.
|
||||
if (!libre) {
|
||||
suivi(joueur).velocite.abandonner();
|
||||
return;
|
||||
}
|
||||
suivi(joueur).velocite.recul(nowMs, dirX, dirZ, force, cfg);
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P1.6) : le joueur vient de passer en plané (transition vue par le serveur entre deux paquets de
|
||||
* mouvement). Contrôle « elytres » : déploiements trop fréquents (ElytraFly « packet »).
|
||||
*/
|
||||
public List<Verdict> deploiementElytres(UUID joueur, long nowMs, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.ELYTRES) == Mode.OFF) return List.of();
|
||||
if (etat.creatif() || etat.spectateur() || etat.peutVoler()) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
double pts = s.deploiements.deploiement(nowMs, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.ELYTRES, pts, nowMs, Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT),
|
||||
String.format(Locale.ROOT, "%d deploiements d'elytres en 1 s (max %d)", s.deploiements.dernierCompte(),
|
||||
cfg.elytresDeploiementsMax));
|
||||
return v;
|
||||
}
|
||||
/** Nouvelle fusée tirée en plané par ce joueur : le gain de vitesse est mesuré depuis zéro. */
|
||||
public void nouvelleFusee(UUID joueur) {
|
||||
suivi(joueur).plane.nouvelleFusee();
|
||||
}
|
||||
|
||||
/** Déplacement horizontal de ce paquet accepté (dx, dz signés), pour mesurer le recul en cours. */
|
||||
public List<Verdict> mesureRecul(UUID joueur, long nowMs, EtatJoueur etat, double dx, double dz, boolean milieuSpecial,
|
||||
java.util.function.BiPredicate<Double, Double> bloqueDansLeSens) {
|
||||
if (cfg.mode(Controle.VELOCITE) == Mode.OFF || expulses.contains(joueur)) return List.of();
|
||||
Suivi s = suivis.get(joueur);
|
||||
if (s == null) return List.of();
|
||||
boolean neutre = milieuSpecial || etat.ticksDepuisGel() <= cfg.graceGelTicks
|
||||
|| etat.tps() < cfg.tpsLag || etat.creatif() || etat.spectateur() || etat.peutVoler() || etat.elytres()
|
||||
|| etat.enVehicule() || etat.riptide() || etat.pocheContraption()
|
||||
|| etat.ticksDepuisTeleport() <= cfg.graceTeleportTicks;
|
||||
// Collision testée seulement dans le sens du recul (le prédicat n'est évalué que pendant une mesure) : se coller
|
||||
// à un mur ailleurs n'annule rien.
|
||||
boolean bloque = s.velocite.actif() && bloqueDansLeSens.test(s.velocite.dirX(), s.velocite.dirZ());
|
||||
double pts = s.velocite.mouvement(nowMs, dx, dz, neutre, bloque, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.VELOCITE, pts, nowMs, Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT),
|
||||
"recul absent apres un coup subi (serie)");
|
||||
return v;
|
||||
}
|
||||
|
||||
/** Un totem vient d'éclater ; {@code reserveEnMain} : un autre totem est déjà dans l'autre main. */
|
||||
public void totemEclate(UUID joueur, long nowMs, boolean reserveEnMain) {
|
||||
if (!totemMesure() || expulses.contains(joueur)) return;
|
||||
suivi(joueur).totem.eclatement(nowMs, reserveEnMain);
|
||||
}
|
||||
|
||||
/** Contenu des mains (au moins un totem ?) à un paquet de mouvement après un éclatement. */
|
||||
public List<Verdict> totemEnMain(UUID joueur, long nowMs, EtatJoueur etat, boolean totemEnMain) {
|
||||
if (!totemMesure() || expulses.contains(joueur)) return List.of();
|
||||
Suivi s = suivis.get(joueur);
|
||||
if (s == null) return List.of();
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
|
||||
double pts = s.totem.mains(nowMs, totemEnMain, etat.pingMs(), cfg);
|
||||
if (cfg.mode(Controle.AUTO_TOTEM) != Mode.OFF) {
|
||||
ajouter(v, s, Controle.AUTO_TOTEM, pts, nowMs, ex, "totem remis en main trop vite apres l'eclatement");
|
||||
}
|
||||
// 0.5 (P2.7) : distribution des délais (contrôle séparé, OBSERVE par défaut).
|
||||
long delai = s.totem.prendreDelai();
|
||||
if (delai >= 0 && cfg.mode(Controle.AUTO_TOTEM_REGULIER) != Mode.OFF) {
|
||||
double p2 = s.totemRegulier.delai(delai, cfg);
|
||||
ajouter(v, s, Controle.AUTO_TOTEM_REGULIER, p2, nowMs, ex, String.format(Locale.ROOT,
|
||||
"%d derniers totems remis en %.0f ms en moyenne, ecart type %.1f ms (min %d)", cfg.autoTotemEchantillons,
|
||||
s.totemRegulier.derniereMoyenne(), s.totemRegulier.dernierEcartType(), cfg.autoTotemEcartTypeMinMs));
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
/** Auto-totem ou sa variante « régulier » (P2.7) actifs : l'éclatement est suivi. */
|
||||
private boolean totemMesure() {
|
||||
return cfg.mode(Controle.AUTO_TOTEM) != Mode.OFF || cfg.mode(Controle.AUTO_TOTEM_REGULIER) != Mode.OFF;
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P1.10) : coup critique vanilla accordé par le serveur (CriticalHitEvent). Suspect s'il ne vient d'aucun
|
||||
* vrai saut ni d'aucune vraie chute (voir {@link Criticals}). En ENFORCE, l'adaptateur annule le critique au palier
|
||||
* SETBACK ; l'expulsion s'applique comme pour les autres contrôles de combat.
|
||||
*/
|
||||
public List<Verdict> critique(UUID joueur, long nowMs, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.CRITICALS) == Mode.OFF) return List.of();
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
|
||||
if (ex.exempt()) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
double pts = s.criticals.coup(nowMs, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.CRITICALS, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"critique sans vrai saut (montee %.3f, descente %.3f), %d critiques suspects sur %d",
|
||||
s.criticals.haut(), -s.criticals.bas(), s.criticals.dernierCompte(), Criticals.SERIE));
|
||||
return v;
|
||||
}
|
||||
// --- Setback, expulsion, position de retour (16/10, incident VOL) ----------------------------------------
|
||||
|
||||
/**
|
||||
@@ -458,7 +865,6 @@ public final class Moteur {
|
||||
Suivi s = suivi(joueur);
|
||||
s.vol.vider();
|
||||
s.vitesse.vider();
|
||||
s.dyChute = 0;
|
||||
s.graceElytresJusquaMs = Long.MIN_VALUE;
|
||||
s.vl.remettreAZero(Controle.VOL);
|
||||
s.vl.remettreAZero(Controle.VITESSE);
|
||||
@@ -470,7 +876,25 @@ public final class Moteur {
|
||||
* jusqu'à sa reconnexion ({@link #oublierExpulsion}). La marque survit à {@link #retirer} (C6).
|
||||
*/
|
||||
public boolean expulser(UUID joueur, long nowMs) {
|
||||
return expulses.add(joueur);
|
||||
boolean premiere = expulses.add(joueur);
|
||||
if (premiere) derniereExpulsionMs.put(joueur, nowMs);
|
||||
return premiere;
|
||||
}
|
||||
|
||||
/** 0.5 (P1.2) : une expulsion compte comme « récente » pour la grâce de reconnexion pendant cette durée. */
|
||||
public static final long EXPULSION_RECENTE_MS = 10 * 60_000L;
|
||||
/** Instant (ms, horloge des ticks) de la dernière expulsion de chaque joueur ; survit à la reconnexion. */
|
||||
private final Map<UUID, Long> derniereExpulsionMs = new HashMap<>();
|
||||
|
||||
/**
|
||||
* 0.5 (P1.2) : durée de la grâce de connexion (ticks) : {@code graceApresExpulsionTicks} si le joueur a été
|
||||
* expulsé il y a moins de {@link #EXPULSION_RECENTE_MS}, sinon {@code graceConnexionTicks}.
|
||||
*/
|
||||
public int graceConnexionTicks(UUID joueur, long nowMs) {
|
||||
derniereExpulsionMs.values().removeIf(t -> nowMs - t > EXPULSION_RECENTE_MS || nowMs < t);
|
||||
Long t = derniereExpulsionMs.get(joueur);
|
||||
int base = Math.max(0, cfg.graceConnexionTicks);
|
||||
return t != null ? Math.max(base, cfg.graceApresExpulsionTicks) : base;
|
||||
}
|
||||
|
||||
public boolean estExpulse(UUID joueur) {
|
||||
@@ -499,13 +923,21 @@ public final class Moteur {
|
||||
if (points <= 0) return;
|
||||
Mode mode = cfg.mode(c);
|
||||
double vl = s.vl.ajouter(c, points, nowMs);
|
||||
Sanction palier = Paliers.palier(vl, cfg);
|
||||
Sanction palier = Paliers.palier(vl, cfg, c); // 0.4.2 : seuils propres a auto-totem et velocite
|
||||
// C5 (16/10) : après un setback, le VL repart de zéro ; l'expulsion vient après plusieurs setbacks récents.
|
||||
if (palier == Sanction.SETBACK && cfg.setbacksAvantExpulsion > 0
|
||||
&& s.setbacksRecents(nowMs, cfg.fenetreSetbacksMs) >= cfg.setbacksAvantExpulsion) {
|
||||
palier = Sanction.min(Sanction.EXPULSION, cfg.sanctionMax);
|
||||
}
|
||||
Sanction applicable = Paliers.applicable(palier, mode);
|
||||
// 0.4.0 : vélocité et auto-totem sont bridés dans le code (un tiers peut provoquer de faux positifs) : jamais de
|
||||
// setback ni d'expulsion, même si la configuration les passe en ENFORCE. Ils nourrissent le score de suspicion.
|
||||
// 0.4.2 (decision de Theo) : vraies sanctions en ENFORCE. Auto-totem n'a pas de retour en arriere qui ait un
|
||||
// sens : son palier SETBACK reste une ALERTE, l'expulsion s'applique. Velocite : SETBACK = retour en arriere.
|
||||
if (c == Controle.AUTO_TOTEM && applicable == Sanction.SETBACK) applicable = Sanction.ALERTE;
|
||||
// 0.5 (P2.10) : x-ray statistique, jamais au-delà de l'alerte (un minage chanceux reste possible).
|
||||
if (c == Controle.XRAY) applicable = Sanction.min(applicable, Sanction.ALERTE);
|
||||
s.suspicion.noter(c, vl, palier.ordinal() >= Sanction.SETBACK.ordinal(), horloge.getAsLong());
|
||||
boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal()
|
||||
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
|
||||
sortie.add(new Verdict(c, mode, points, vl, palier, applicable, notifier, details, ex.raisons()));
|
||||
|
||||
@@ -48,27 +48,7 @@ public final class NoFall {
|
||||
}
|
||||
|
||||
public static double points(EtatMouvement e) {
|
||||
return points(e, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* D3 (0.3.2) : idem, mais un paquet sans déplacement (paquet d'état « au sol » ajouté par un NoFall, dy = 0) est
|
||||
* jugé avec la vitesse verticale du dernier paquet qui a bougé ({@code dyPrecedent}).
|
||||
*/
|
||||
public static double points(EtatMouvement e, double dyPrecedent) {
|
||||
double dy = sansDeplacement(e) ? dyPrecedent : e.dy();
|
||||
if (e.auSolClient() && !e.auSolServeur() && dy <= DY_CHUTE && !e.milieuSpecial()) return 0.5;
|
||||
if (e.auSolClient() && !e.auSolServeur() && e.dy() <= DY_CHUTE && !e.milieuSpecial()) return 0.5;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** Paquet qui ne change pas la position (paquet d'état ou de rotation seule). */
|
||||
public static boolean sansDeplacement(EtatMouvement e) {
|
||||
return e.dy() == 0 && e.dxz() == 0;
|
||||
}
|
||||
|
||||
/** Vitesse verticale de chute à retenir après ce paquet : remise à zéro au sol ou en milieu spécial. */
|
||||
public static double dyApres(EtatMouvement e, double dyPrecedent) {
|
||||
if (e.auSolServeur() || e.milieuSpecial()) return 0;
|
||||
return sansDeplacement(e) ? dyPrecedent : e.dy();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2.1) : NoSlow. Vanilla 1.21.1 (LocalPlayer.aiStep, côté client) multiplie l'entrée de déplacement par 0,2 tant
|
||||
* que le joueur utilise un objet (manger, boire, bander un arc ou une arbalète, bloquer au bouclier, charger un
|
||||
* trident, longue-vue…). Le serveur ne ralentit rien lui-même : le cheat garde sa vitesse de marche ou de course.
|
||||
*
|
||||
* Ordres de grandeur au sol (friction 0,6) : marche 0,216 bloc/tick, course 0,281 ; en usage d'objet ×0,2, soit
|
||||
* ~0,043 en marchant et ~0,056 si le sprint continue (vanilla ne coupe pas un sprint déjà lancé). Le seuil par défaut
|
||||
* ({@link GardeConfig#noSlowFacteur} 0,5 × course 0,30 = 0,15 bloc/tick, multiplié par les effets de vitesse) laisse
|
||||
* donc une marge de plus de ×2,5 au joueur honnête ; le cheat (0,22 à 0,28) le dépasse.
|
||||
*
|
||||
* Ne mesure que des paquets d'un tick, au sol serveur, sans déplacement vertical (un saut en mangeant garde l'élan du
|
||||
* sprint-saut), hors milieu spécial et friction anormale (glace, slime, âmes), après {@link GardeConfig#noSlowGraceTicks}
|
||||
* ticks d'usage (l'élan de la course décroît en 2 ou 3 ticks) et au moins {@link #SOL_MIN} paquets au sol de suite
|
||||
* (atterrissage). Infraction après {@link GardeConfig#noSlowTicks} paquets suspects consécutifs. OBSERVE par défaut.
|
||||
*/
|
||||
public final class NoSlow {
|
||||
|
||||
/** Paquets au sol consécutifs exigés avant de mesurer (élan d'un atterrissage). */
|
||||
static final int SOL_MIN = 3;
|
||||
|
||||
private int serie;
|
||||
private int solConsecutifs;
|
||||
private double derniereVitesse;
|
||||
|
||||
/**
|
||||
* @param ticksUsage ticks d'usage d'objet vus par le serveur (-1 inconnu)
|
||||
* @param facteur tolérance (serveur qui tire : facteurLag)
|
||||
* @return points d'infraction (0 si rien)
|
||||
*/
|
||||
public double enregistrer(EtatMouvement m, int ticksUsage, GardeConfig cfg, double facteur) {
|
||||
boolean solPlat = m.auSolServeur() && m.ticks() == 1 && Math.abs(m.dy()) < 1e-6;
|
||||
solConsecutifs = solPlat ? solConsecutifs + 1 : 0;
|
||||
boolean mesurable = m.ralentiParObjet() && ticksUsage >= 0 && ticksUsage > cfg.noSlowGraceTicks && solPlat
|
||||
&& solConsecutifs >= SOL_MIN && !m.milieuSpecial() && !m.frictionAnormale();
|
||||
if (!mesurable || m.dxz() <= seuil(m, cfg) * Math.max(1.0, facteur)) {
|
||||
serie = 0;
|
||||
return 0;
|
||||
}
|
||||
derniereVitesse = m.dxz();
|
||||
if (++serie < Math.max(1, cfg.noSlowTicks)) return 0;
|
||||
serie = 0; // une infraction par série complète
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
/** Vitesse au sol permise pendant un usage d'objet (blocs/tick), effets de vitesse compris. */
|
||||
public static double seuil(EtatMouvement m, GardeConfig cfg) {
|
||||
double effets = 1.0 + 0.2 * Math.max(0, m.amplificateurVitesse());
|
||||
double f = m.facteurVitesse();
|
||||
if (!Double.isNaN(f) && !Double.isInfinite(f) && f > effets) effets = f;
|
||||
return cfg.noSlowFacteur * VitesseHorizontale.COURSE * effets;
|
||||
}
|
||||
|
||||
public double derniereVitesse() {
|
||||
return derniereVitesse;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
serie = 0;
|
||||
solConsecutifs = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P3.3) : Nuker (casse de plusieurs blocs par tick). Client vanilla 1.21.1 (MultiPlayerGameMode, vérifié dans les
|
||||
* sources NeoForge 21.1.234) : une casse au plus par tick client, puis {@code destroyDelay = 5} ticks après un bloc qui
|
||||
* n'est pas instantané ; même les blocs instantanés (herbe, fleurs) ne partent qu'un par tick au clic maintenu.
|
||||
*
|
||||
* Signal : nombre de blocs cassés par le joueur pendant un même tick serveur (BlockEvent.BreakEvent). Des paquets de
|
||||
* deux ou trois ticks client peuvent arriver groupés dans un tick serveur (gigue réseau) : le plafond
|
||||
* {@link GardeConfig#nukerBlocsParTickMax} (3) le couvre ; un Nuker en casse en général des dizaines. Points seulement en
|
||||
* série : {@link GardeConfig#nukerSerieMin} ticks au-delà du plafond parmi les {@link #SERIE} derniers ticks de casse
|
||||
* (60 s). Un mod serveur qui casse plusieurs blocs « au nom » du joueur (abattage d'arbre, minage de filon) déclenche
|
||||
* aussi BreakEvent : [À VÉRIFIER] sur la liste des mods du serveur ; OBSERVE par défaut.
|
||||
*/
|
||||
public final class Nuker {
|
||||
|
||||
public static final int SERIE = 20;
|
||||
public static final long FENETRE_MS = 60_000;
|
||||
|
||||
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
|
||||
private long tickCourant = Long.MIN_VALUE;
|
||||
private int casses;
|
||||
private boolean signale;
|
||||
private int dernierCompte;
|
||||
/** Le tick courant a donné une sanction ≥ SETBACK applicable : toutes ses casses excédentaires sont annulées. */
|
||||
private boolean annulerTick;
|
||||
|
||||
/** Un bloc cassé au tick serveur donné. @return points d'infraction */
|
||||
public double casse(long nowMs, long tick, GardeConfig cfg) {
|
||||
if (tick != tickCourant) {
|
||||
tickCourant = tick;
|
||||
casses = 0;
|
||||
signale = false;
|
||||
annulerTick = false;
|
||||
dernierCompte = serie.ajouter(nowMs, false); // un tick de casse ordinaire
|
||||
}
|
||||
casses++;
|
||||
// Comptabilité seulement : un tick suspect compte une fois dans la série. L'annulation des casses excédentaires
|
||||
// suivantes du même tick est décidée à part (excedent / annulerTick, revue de sécurité P3).
|
||||
if (signale || casses <= Math.max(1, cfg.nukerBlocsParTickMax)) return 0;
|
||||
signale = true; // un tick suspect compté une fois
|
||||
dernierCompte = serie.ajouter(nowMs, true);
|
||||
if (dernierCompte < Math.max(1, cfg.nukerSerieMin)) return 0;
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
/** La casse courante dépasse le plafond du tick (première excédentaire comprise). */
|
||||
public boolean excedent(long tick, GardeConfig cfg) {
|
||||
return tick == tickCourant && casses > Math.max(1, cfg.nukerBlocsParTickMax);
|
||||
}
|
||||
|
||||
public void marquerAnnulation() {
|
||||
annulerTick = true;
|
||||
}
|
||||
|
||||
public boolean annulerTick() {
|
||||
return annulerTick;
|
||||
}
|
||||
|
||||
public int casses() {
|
||||
return casses;
|
||||
}
|
||||
|
||||
public int dernierCompte() {
|
||||
return dernierCompte;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
serie.vider();
|
||||
tickCourant = Long.MIN_VALUE;
|
||||
casses = 0;
|
||||
signale = false;
|
||||
annulerTick = false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2.14) : Omnisprint (courir en reculant ou de côté). Vanilla 1.21.1 (LocalPlayer.aiStep, vérifié dans les
|
||||
* sources NeoForge 21.1.234) coupe le sprint dès que l'entrée vers l'avant est nulle ({@code hasForwardImpulse}) : un
|
||||
* joueur qui court se déplace au plus à ~45° de son regard (avant + côté). Un déplacement à plus de
|
||||
* {@link GardeConfig#omnisprintAngleDegres} (100°) du regard en courant n'est possible que par élan (demi-tour de la
|
||||
* souris, recul) : il disparaît en 2 ou 3 ticks au sol (friction 0,546 par tick).
|
||||
*
|
||||
* Signal : {@link GardeConfig#omnisprintTicks} (10) paquets d'un tick de suite, au sol serveur, sprint, au moins
|
||||
* {@link #DXZ_MIN} bloc par tick, hors milieu spécial et friction anormale (glace), à plus de l'angle du regard.
|
||||
* Recul, téléportation, véhicule… : exemptions de mouvement. OBSERVE par défaut.
|
||||
*/
|
||||
public final class Omnisprint {
|
||||
|
||||
static final double DXZ_MIN = 0.15;
|
||||
|
||||
private int serie;
|
||||
private double dernierAngle;
|
||||
|
||||
public double enregistrer(EtatMouvement m, FaitsMouvement f, GardeConfig cfg) {
|
||||
if (Double.isNaN(f.dx) || Double.isNaN(f.dz) || Float.isNaN(f.yaw)) {
|
||||
serie = 0;
|
||||
return 0;
|
||||
}
|
||||
double angle = angle(f.dx, f.dz, f.yaw);
|
||||
boolean suspect = m.sprint() && m.auSolServeur() && m.ticks() == 1 && m.dxz() >= DXZ_MIN && !m.milieuSpecial()
|
||||
&& !m.frictionAnormale() && angle > cfg.omnisprintAngleDegres;
|
||||
if (!suspect) {
|
||||
serie = 0;
|
||||
return 0;
|
||||
}
|
||||
dernierAngle = angle;
|
||||
if (++serie < Math.max(1, cfg.omnisprintTicks)) return 0;
|
||||
serie = 0;
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
/** Angle (degrés, 0 à 180) entre le déplacement (dx, dz) et le regard horizontal (yaw Minecraft). */
|
||||
public static double angle(double dx, double dz, float yaw) {
|
||||
double r = Math.toRadians(yaw);
|
||||
double fx = -Math.sin(r), fz = Math.cos(r);
|
||||
double n = Math.hypot(dx, dz);
|
||||
if (n < 1e-9) return 0;
|
||||
double c = (dx * fx + dz * fz) / n;
|
||||
return Math.toDegrees(Math.acos(Math.max(-1, Math.min(1, c))));
|
||||
}
|
||||
|
||||
public double dernierAngle() {
|
||||
return dernierAngle;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
serie = 0;
|
||||
}
|
||||
}
|
||||
@@ -7,11 +7,32 @@ public final class Paliers {
|
||||
|
||||
/** Sanction que mériterait ce nombre de points, plafonnée par {@code sanctionMax}. */
|
||||
public static Sanction palier(double vl, GardeConfig cfg) {
|
||||
return palier(vl, cfg.seuilAlerte, cfg.seuilSetback, cfg.seuilExpulsion, cfg);
|
||||
}
|
||||
|
||||
/** 0.4.2 : palier avec les seuils propres au contrôle (auto-totem, vélocité) quand ils sont définis (> 0). */
|
||||
public static Sanction palier(double vl, GardeConfig cfg, Controle c) {
|
||||
double setback = cfg.seuilSetback;
|
||||
double expulsion = cfg.seuilExpulsion;
|
||||
if (c == Controle.AUTO_TOTEM) {
|
||||
if (cfg.autoTotemSeuilSetback > 0) setback = cfg.autoTotemSeuilSetback;
|
||||
if (cfg.autoTotemSeuilExpulsion > 0) expulsion = cfg.autoTotemSeuilExpulsion;
|
||||
} else if (c == Controle.VELOCITE) {
|
||||
if (cfg.velociteSeuilSetback > 0) setback = cfg.velociteSeuilSetback;
|
||||
if (cfg.velociteSeuilExpulsion > 0) expulsion = cfg.velociteSeuilExpulsion;
|
||||
}
|
||||
setback = Math.min(setback, expulsion);
|
||||
double alerte = Math.min(cfg.seuilAlerte, setback);
|
||||
return palier(vl, alerte, setback, expulsion, cfg);
|
||||
}
|
||||
|
||||
private static Sanction palier(double vl, double seuilAlerte, double seuilSetback, double seuilExpulsion,
|
||||
GardeConfig cfg) {
|
||||
Sanction s;
|
||||
if (vl <= 0) s = Sanction.AUCUNE;
|
||||
else if (vl < cfg.seuilAlerte) s = Sanction.JOURNAL;
|
||||
else if (vl < cfg.seuilSetback) s = Sanction.ALERTE;
|
||||
else if (vl < cfg.seuilExpulsion) s = Sanction.SETBACK;
|
||||
else if (vl < seuilAlerte) s = Sanction.JOURNAL;
|
||||
else if (vl < seuilSetback) s = Sanction.ALERTE;
|
||||
else if (vl < seuilExpulsion) s = Sanction.SETBACK;
|
||||
else s = Sanction.EXPULSION;
|
||||
return Sanction.min(s, cfg.sanctionMax);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,175 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* Contrôle « elytres » (0.4.0) : le plané est exempté de vitesse, de vol et de no-fall (Exemptions, famille
|
||||
* mouvement). Le « Elytra Hack » de CheatUtils (méthode VanillaFly) donne au plané l'accélération verticale et
|
||||
* horizontale du vol créatif : on monte à vitesse constante ou on reste sur place. Le vanilla ne le permet pas :
|
||||
* <ul>
|
||||
* <li>monter coûte de la vitesse horizontale (l'énergie vient de la piqué) : une montée de plus de
|
||||
* {@link GardeConfig#elytresMonteeTicks} ticks sans perte de vitesse est impossible sans fusée ;</li>
|
||||
* <li>rester presque immobile sans chute ({@link GardeConfig#elytresStationnaireTicks} ticks) est impossible :
|
||||
* à faible vitesse la portance est nulle et le joueur tombe.</li>
|
||||
* </ul>
|
||||
* Aucune des deux règles ne s'applique après une fusée (propulsion récente), dans un milieu spécial (courant d'air
|
||||
* Create, colonne à bulles, eau…), ni quand une autre exemption est active (le moteur n'appelle ce contrôle que si
|
||||
* « elytres » est la seule raison d'exemption). Les valeurs sont à confirmer en jeu : OBSERVE par défaut.
|
||||
*
|
||||
* <p>Pourquoi l'option C7 ({@code elytresExemptionStricte}) ne suffit pas : elle retire seulement l'exemption quand
|
||||
* le plané démarre sans ticks en l'air côté serveur (onGround falsifié). Un tricheur qui saute puis déploie ses
|
||||
* élytres normalement reste exempté de tout, et C7 ne regarde jamais ce que le plané fait ensuite.
|
||||
*/
|
||||
public final class PlaneElytres {
|
||||
|
||||
/** Montée franche (blocs par tick) ; en dessous, c'est du plané à plat. */
|
||||
public static final double MONTEE_MIN = 0.05;
|
||||
/** Une montée qui garde au moins cette part de la vitesse horizontale du début est suspecte. */
|
||||
public static final double VITESSE_GARDEE = 0.9;
|
||||
/** Vitesse horizontale (blocs par tick) en dessous de laquelle le plané ne porte plus. */
|
||||
public static final double VITESSE_STATIONNAIRE = 0.15;
|
||||
/** Chute (blocs par tick) en dessous de laquelle on ne tombe pas vraiment. */
|
||||
public static final double CHUTE_MIN = -0.04;
|
||||
/** Paquets au-delà de ce nombre de ticks : pas de mesure fiable (retard réseau). */
|
||||
public static final int TICKS_MAX = 3;
|
||||
|
||||
/** Ticks de grâce après lesquels on exige que la fusée ait fait gagner de la vitesse. */
|
||||
public static final int GAIN_TICKS = 10;
|
||||
/** Gain de vitesse horizontale (blocs par tick) attendu d'une fusée réelle. */
|
||||
public static final double GAIN_MIN = 0.05;
|
||||
/** Au-dessus de cette vitesse (blocs par tick) la fusée n'a plus de gain possible : grâce maintenue. */
|
||||
public static final double VITESSE_FUSEE = 1.6;
|
||||
|
||||
private int graceTicks;
|
||||
private int fenetreGrace;
|
||||
private double vitesseGrace;
|
||||
/** Dernière vitesse mesurée HORS grâce de fusée ; invalide tant que {@link #vitesseConnue} est faux. */
|
||||
private double derniereVitesse;
|
||||
private boolean vitesseConnue;
|
||||
/** Une fenêtre de grâce a échoué au test de gain : pas de nouvelle grâce avant {@link #PAUSE_APRES_REFUS} ticks hors grâce. */
|
||||
private boolean graceRefusee;
|
||||
private int horsGraceTicks;
|
||||
/** Ticks sans fusée exigés après une grâce refusée (≈ une durée de vie de fusée) avant d'en accepter une autre. */
|
||||
public static final int PAUSE_APRES_REFUS = 40;
|
||||
private final double[] fenetre = new double[GAIN_TICKS];
|
||||
/** 0.4.1 : vitesse 3D (horizontale et verticale) des memes ticks : une fusee pousse dans le sens du regard. */
|
||||
private final double[] fenetre3d = new double[GAIN_TICKS];
|
||||
private int monteeTicks;
|
||||
private double vitesseDebut;
|
||||
private int stationnaireTicks;
|
||||
|
||||
/**
|
||||
* @param m déplacement accepté
|
||||
* @param propulsion une fusée (ou autre poussée connue du serveur) est récente
|
||||
* @return points d'infraction (0 si rien)
|
||||
*/
|
||||
public double enregistrer(EtatMouvement m, boolean propulsion, GardeConfig cfg) {
|
||||
int n = m.ticks();
|
||||
if (m.milieuSpecial() || m.auSolServeur()) {
|
||||
vider();
|
||||
return 0;
|
||||
}
|
||||
if (propulsion) {
|
||||
// Grâce de fusée : les compteurs sont SUSPENDUS (ni remis à zéro, ni avancés), pas effacés : tirer une fusée
|
||||
// ne blanchit pas une montée ou un plané immobile déjà en cours. Grâce révoquée tôt si la fusée ne
|
||||
// pousse pas réellement (vitesse horizontale sans gain au bout de GAIN_TICKS ticks).
|
||||
if (n >= 1 && n <= TICKS_MAX) {
|
||||
double vh = m.dxz() / n;
|
||||
if (graceRefusee) return mesurer(m, n, cfg); // grâce déjà refusée : pas de nouvelle fenêtre tout de suite
|
||||
if (graceTicks == 0) {
|
||||
// référence = dernière vitesse mesurée hors grâce ; inconnue (atterrissage, milieu spécial,
|
||||
// première mesure) : la vitesse courante, donc le gain exigé part de ce qu'on voit (pessimiste)
|
||||
vitesseGrace = vitesseConnue ? derniereVitesse : vh;
|
||||
fenetreGrace = 0;
|
||||
}
|
||||
graceTicks += n;
|
||||
fenetre3d[fenetreGrace % GAIN_TICKS] = Math.hypot(m.dxz(), m.dy()) / n;
|
||||
fenetre[fenetreGrace++ % GAIN_TICKS] = vh;
|
||||
if (!graceTenue()) {
|
||||
graceRefusee = true;
|
||||
horsGraceTicks = 0;
|
||||
// la fusée ne pousse pas (ou un pic isolé a masqué une vitesse plate) : contrôle comme sans fusée
|
||||
return mesurer(m, n, cfg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
} else {
|
||||
graceTicks = 0;
|
||||
fenetreGrace = 0;
|
||||
if (graceRefusee && n >= 1 && (horsGraceTicks += n) >= PAUSE_APRES_REFUS) graceRefusee = false;
|
||||
if (n >= 1 && n <= TICKS_MAX) {
|
||||
derniereVitesse = m.dxz() / n; // seulement hors grâce
|
||||
vitesseConnue = true;
|
||||
}
|
||||
}
|
||||
return mesurer(m, n, cfg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Nouvelle fusée tirée en plané. Ne remet RIEN à zéro : des fusées enchaînées cumulent leurs ticks de grâce dans la
|
||||
* même fenêtre (sinon un tricheur ne sortirait jamais de la grâce et le test de gain ne serait jamais évalué) et la
|
||||
* référence de vitesse reste celle d'avant la première fusée. La fenêtre ne se ferme que quand le drapeau de
|
||||
* propulsion tombe (paquet hors grâce). Gardée pour le journal d'appel et les tests.
|
||||
*/
|
||||
public void nouvelleFusee() {
|
||||
// volontairement vide
|
||||
}
|
||||
|
||||
/**
|
||||
* La grâce tient tant que la fusée pousse réellement : avant {@link #GAIN_TICKS} ticks, oui ; ensuite la MÉDIANE
|
||||
* des {@link #GAIN_TICKS} derniers ticks (insensible à un pic isolé) doit dépasser d'au moins {@link #GAIN_MIN}
|
||||
* la vitesse d'avant la fusée, ou tous ces ticks doivent rester proches de {@link #VITESSE_FUSEE} (vitesse où la
|
||||
* fusée ne peut plus faire gagner).
|
||||
*/
|
||||
private boolean graceTenue() {
|
||||
if (graceTicks < GAIN_TICKS || fenetreGrace < GAIN_TICKS) return true;
|
||||
double[] v = fenetre.clone();
|
||||
java.util.Arrays.sort(v);
|
||||
double mediane = (v[GAIN_TICKS / 2 - 1] + v[GAIN_TICKS / 2]) / 2.0;
|
||||
double min = v[0];
|
||||
if (mediane >= vitesseGrace + GAIN_MIN || min >= VITESSE_FUSEE * 0.9) return true;
|
||||
// 0.4.1 (faux positif totoche10, dxz 1,3-1,5 dy 0,66-1,04) : en montee avec fusee, la poussee (~1,5-1,7 bloc/tick)
|
||||
// part dans le sens du regard ; la vitesse HORIZONTALE peut rester sous la reference sans que la fusee soit fausse.
|
||||
double min3d = Double.MAX_VALUE;
|
||||
for (double x : fenetre3d) min3d = Math.min(min3d, x);
|
||||
return min3d >= VITESSE_FUSEE * 0.9;
|
||||
}
|
||||
|
||||
private double mesurer(EtatMouvement m, int n, GardeConfig cfg) {
|
||||
if (n < 1 || n > TICKS_MAX) return 0; // neutre : ni remise à zéro ni ajout
|
||||
double vh = m.dxz() / n;
|
||||
double vy = m.dy() / n;
|
||||
double points = 0;
|
||||
|
||||
if (vh < VITESSE_STATIONNAIRE && vy > CHUTE_MIN) stationnaireTicks += n;
|
||||
else stationnaireTicks = 0;
|
||||
if (cfg.elytresStationnaireTicks > 0 && stationnaireTicks > cfg.elytresStationnaireTicks) {
|
||||
points = 1.5;
|
||||
stationnaireTicks = 0; // 0.4.1 : au plus 1,5 point par periode, pas 1,5 par paquet (+30 VL/s en 0.4.0)
|
||||
}
|
||||
|
||||
if (vy > MONTEE_MIN) {
|
||||
if (monteeTicks == 0) vitesseDebut = vh;
|
||||
monteeTicks += n;
|
||||
if (cfg.elytresMonteeTicks > 0 && monteeTicks > cfg.elytresMonteeTicks
|
||||
&& vh >= vitesseDebut * VITESSE_GARDEE) {
|
||||
points = Math.max(points, 1.5);
|
||||
monteeTicks = 0; // 0.4.1 : idem, la periode suivante repart de la vitesse courante
|
||||
}
|
||||
} else if (vy < 0) {
|
||||
monteeTicks = 0;
|
||||
}
|
||||
return points;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
graceTicks = 0;
|
||||
fenetreGrace = 0;
|
||||
derniereVitesse = 0;
|
||||
vitesseConnue = false;
|
||||
graceRefusee = false;
|
||||
horsGraceTicks = 0;
|
||||
monteeTicks = 0;
|
||||
vitesseDebut = 0;
|
||||
stationnaireTicks = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2) : série générique « k suspects parmi les n dernières mesures, dans une fenêtre de temps », comme
|
||||
* {@link SerieCoups} mais sans réglage lu dans la configuration. Tampon de taille fixe, aucune allocation.
|
||||
*/
|
||||
public final class SerieFenetre {
|
||||
|
||||
private final int n;
|
||||
private final long fenetreMs;
|
||||
private final long[] instants;
|
||||
private final boolean[] suspects;
|
||||
private int taille;
|
||||
private int tete;
|
||||
|
||||
public SerieFenetre(int n, long fenetreMs) {
|
||||
this.n = Math.max(1, n);
|
||||
this.fenetreMs = fenetreMs;
|
||||
this.instants = new long[this.n];
|
||||
this.suspects = new boolean[this.n];
|
||||
}
|
||||
|
||||
/** Ajoute une mesure ; renvoie le nombre de suspectes parmi les n dernières encore dans la fenêtre. */
|
||||
public int ajouter(long nowMs, boolean suspect) {
|
||||
instants[tete] = nowMs;
|
||||
suspects[tete] = suspect;
|
||||
tete = (tete + 1) % n;
|
||||
if (taille < n) taille++;
|
||||
int compte = 0;
|
||||
for (int k = 0; k < taille; k++) {
|
||||
int i = ((tete - 1 - k) % n + n) % n;
|
||||
if (nowMs - instants[i] > fenetreMs || instants[i] > nowMs) break;
|
||||
if (suspects[i]) compte++;
|
||||
}
|
||||
return compte;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
taille = 0;
|
||||
tete = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P1.9) : Step / HighStep. Un joueur au sol (vu par le serveur) au paquet précédent et à celui-ci, qui a gagné
|
||||
* en un seul tick plus que la hauteur de marche permise.
|
||||
*
|
||||
* Valeurs vanilla 1.21.1 (vérifiées dans les sources décompilées de NeoForge 21.1.234, Attributes.java et
|
||||
* LivingEntity.getJumpPower) : attribut {@code generic.step_height} 0,6 par défaut ; saut = attribut
|
||||
* {@code generic.jump_strength} (0,42) × facteur de saut du bloc + 0,1 par niveau de Saut amélioré. Un saut ne
|
||||
* donne jamais plus que sa puissance en un tick : la hauteur permise est le maximum des deux (fournie par
|
||||
* l'adaptateur), plus une marge. Escaliers, dalles, chemins, lits (≤ 0,6) ne comptent donc jamais.
|
||||
*
|
||||
* Ce que le contrôle ne voit pas (volontairement) : plusieurs ticks entre deux paquets (le gain est réparti),
|
||||
* milieux spéciaux (échelle, eau…), hauteur permise inconnue (piston en mouvement à proximité : l'adaptateur passe
|
||||
* NaN). OBSERVE par défaut.
|
||||
*/
|
||||
public final class Step {
|
||||
|
||||
private boolean connu;
|
||||
private boolean solAvant;
|
||||
private double dernierGain;
|
||||
|
||||
/**
|
||||
* @param hauteurPermise max(step_height, puissance de saut) du joueur ; NaN = inconnue, pas de mesure
|
||||
* @return points d'infraction (0 si rien)
|
||||
*/
|
||||
public double enregistrer(EtatMouvement m, double hauteurPermise, GardeConfig cfg) {
|
||||
boolean avant = connu && solAvant;
|
||||
connu = true;
|
||||
solAvant = m.auSolServeur();
|
||||
if (!avant || !m.auSolServeur() || m.ticks() != 1 || m.milieuSpecial() || Double.isNaN(hauteurPermise)) return 0;
|
||||
double seuil = seuil(hauteurPermise, cfg);
|
||||
if (m.dy() <= seuil) return 0;
|
||||
dernierGain = m.dy();
|
||||
// 2 points par marche anormale, jusqu'à 5 pour un gain d'un bloc et plus au-delà du seuil.
|
||||
return 2.0 + Math.min(3.0, (m.dy() - seuil) * 3.0);
|
||||
}
|
||||
|
||||
public static double seuil(double hauteurPermise, GardeConfig cfg) {
|
||||
return Math.max(cfg.stepHauteurMax, hauteurPermise) + Math.max(0, cfg.stepMargeBlocs);
|
||||
}
|
||||
|
||||
public double dernierGain() {
|
||||
return dernierGain;
|
||||
}
|
||||
|
||||
/** Période exemptée, téléportation : le paquet suivant sert de référence. */
|
||||
public void vider() {
|
||||
connu = false;
|
||||
solAvant = false;
|
||||
}
|
||||
}
|
||||
@@ -30,8 +30,6 @@ public final class Suivi {
|
||||
long coupsBloquesJusqua = Long.MIN_VALUE;
|
||||
/** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */
|
||||
long graceElytresJusquaMs = Long.MIN_VALUE;
|
||||
/** D3 (0.3.2) : vitesse verticale du dernier paquet qui a bougé pendant une chute (0 au sol). */
|
||||
double dyChute;
|
||||
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
|
||||
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
|
||||
|
||||
@@ -55,8 +53,55 @@ public final class Suivi {
|
||||
|
||||
private final Map<Controle, Long> derniereAlerte = new EnumMap<>(Controle.class);
|
||||
|
||||
/** Score de suspicion (0.4.0). */
|
||||
public final Suspicion suspicion;
|
||||
/** 0.4.0 : plané, recul, totem. */
|
||||
public final PlaneElytres plane = new PlaneElytres();
|
||||
public final Velocite velocite = new Velocite();
|
||||
public final AutoTotem totem = new AutoTotem();
|
||||
/** 0.5 (P1) : step. */
|
||||
public final Step step = new Step();
|
||||
/** 0.5 (P1.10) : criticals. */
|
||||
public final Criticals criticals = new Criticals();
|
||||
/** 0.5 (P1.8) : anti-faim. */
|
||||
public final AntiFaim antiFaim = new AntiFaim();
|
||||
/** 0.5 (P2.1) : no-slow. */
|
||||
public final NoSlow noSlow = new NoSlow();
|
||||
/** 0.5 (P2.3) : fast-break. */
|
||||
public final FastBreak fastBreak = new FastBreak();
|
||||
/** 0.5 (P2.4) : fast-place. */
|
||||
public final FastPlace fastPlace = new FastPlace();
|
||||
/** 0.5 (P2.5) : interaction-bloc. */
|
||||
public final InteractionBloc interactionBloc = new InteractionBloc();
|
||||
/** 0.5 (P2.7) : auto-totem régulier. */
|
||||
public final TotemRegulier totemRegulier = new TotemRegulier();
|
||||
/** 0.5 (P2.11) : jesus. */
|
||||
public final Jesus jesus = new Jesus();
|
||||
/** 0.5 (P2.14) : omnisprint. */
|
||||
public final Omnisprint omnisprint = new Omnisprint();
|
||||
/** 0.5 (P2.10) : x-ray statistique. */
|
||||
public final XrayStats xray = new XrayStats();
|
||||
/** 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.5 (P3.7) : complétion de commande. */
|
||||
public final Completion completion = new Completion();
|
||||
public boolean completionExces;
|
||||
/** 0.5 (P1.6) : déploiements d'élytres répétés. */
|
||||
public final DeploiementsElytres deploiements = new DeploiementsElytres();
|
||||
/** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */
|
||||
public final ActionsBloc actionsBloc = new ActionsBloc();
|
||||
|
||||
public Suivi(double decroissanceParSeconde) {
|
||||
this(decroissanceParSeconde, new GardeConfig());
|
||||
}
|
||||
|
||||
public Suivi(double decroissanceParSeconde, GardeConfig cfg) {
|
||||
this.vl = new VlCompteur(decroissanceParSeconde);
|
||||
this.suspicion = new Suspicion(cfg);
|
||||
}
|
||||
|
||||
public void memoriserPosition(double x, double y, double z, float yaw, float pitch, String dimension) {
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import java.util.EnumMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Score de suspicion d'un joueur, de 0 à 100 (0.4.0). Information pour les humains : ne sanctionne jamais.
|
||||
*
|
||||
* <p>Par contrôle, on garde le plus haut rapport {@code VL / seuilExpulsion} vu (borné à 1), qui décroît avec une
|
||||
* demi-vie ({@link GardeConfig#suspicionDemiVieMinutes}). Le score est la somme de ces rapports multipliés par le
|
||||
* plafond de fiabilité du contrôle (50 / 30 / 15), plafonnée à 100. Les contrôles en OBSERVE comptent. Le VL
|
||||
* lui-même retombe vite (0,5 point/s) et un setback le remet à zéro : on garde donc un pic à part.
|
||||
*
|
||||
* <p>Diversité : au moins {@link GardeConfig#suspicionDiversiteControles} contrôles distincts au palier SETBACK
|
||||
* (mérité, quel que soit le mode) dans la fenêtre = au moins « suspect fort » tant que la fenêtre dure.
|
||||
*
|
||||
* <p>Le temps est fourni par l'appelant (ms, horloge unique par moteur), jamais lu ici.
|
||||
*/
|
||||
public final class Suspicion {
|
||||
|
||||
public enum Niveau { NORMAL, A_SURVEILLER, SUSPECT, SUSPECT_FORT }
|
||||
|
||||
private final GardeConfig cfg;
|
||||
private final Map<Controle, Double> pics = new EnumMap<>(Controle.class);
|
||||
private final Map<Controle, Long> dernierSetback = new EnumMap<>(Controle.class);
|
||||
private long dernierMs = Long.MIN_VALUE;
|
||||
private Niveau notifie = Niveau.NORMAL;
|
||||
private Niveau enAttente;
|
||||
|
||||
public Suspicion(GardeConfig cfg) {
|
||||
this.cfg = cfg;
|
||||
}
|
||||
|
||||
/** Plafond de contribution du contrôle selon sa fiabilité. */
|
||||
public static double plafond(Controle c, GardeConfig cfg) {
|
||||
return switch (c.fiabilite()) {
|
||||
case 0 -> cfg.suspicionPlafondFiable;
|
||||
case 1 -> cfg.suspicionPlafondMoyen;
|
||||
default -> cfg.suspicionPlafondFaible;
|
||||
};
|
||||
}
|
||||
|
||||
public static Niveau niveau(double score, GardeConfig cfg) {
|
||||
if (score >= cfg.suspicionSeuilFort) return Niveau.SUSPECT_FORT;
|
||||
if (score >= cfg.suspicionSeuilSuspect) return Niveau.SUSPECT;
|
||||
if (score >= cfg.suspicionSeuilSurveiller) return Niveau.A_SURVEILLER;
|
||||
return Niveau.NORMAL;
|
||||
}
|
||||
|
||||
private double facteur(long nowMs) {
|
||||
if (dernierMs == Long.MIN_VALUE || nowMs <= dernierMs) return 1.0;
|
||||
double demiVieMs = Math.max(1, cfg.suspicionDemiVieMinutes * 60_000.0);
|
||||
return Math.pow(0.5, (nowMs - dernierMs) / demiVieMs);
|
||||
}
|
||||
|
||||
private void avancer(long nowMs) {
|
||||
double f = facteur(nowMs);
|
||||
if (f != 1.0) pics.replaceAll((k, v) -> v * f);
|
||||
if (dernierMs == Long.MIN_VALUE || nowMs > dernierMs) dernierMs = nowMs;
|
||||
}
|
||||
|
||||
/**
|
||||
* Un verdict est tombé.
|
||||
*
|
||||
* @param vl VL du contrôle après ajout
|
||||
* @param palierSetbackOuPlus le palier mérité est SETBACK ou EXPULSION (mode ignoré)
|
||||
*/
|
||||
public void noter(Controle c, double vl, boolean palierSetbackOuPlus, long nowMs) {
|
||||
if (!cfg.suspicionActive) return;
|
||||
avancer(nowMs);
|
||||
// réarmement avec hystérésis (80 % du premier seuil) : un score qui oscille autour de 25 ne re-notifie pas
|
||||
if (score(nowMs) < cfg.suspicionSeuilSurveiller * 0.8) notifie = Niveau.NORMAL;
|
||||
double ratio = Math.max(0, Math.min(1, vl / Math.max(0.1, cfg.seuilExpulsion)));
|
||||
pics.merge(c, ratio, Math::max);
|
||||
if (palierSetbackOuPlus) dernierSetback.put(c, nowMs);
|
||||
Niveau n = niveau(score(nowMs), cfg);
|
||||
if (n.ordinal() > notifie.ordinal()) {
|
||||
notifie = n;
|
||||
enAttente = n;
|
||||
}
|
||||
}
|
||||
|
||||
/** Nombre de contrôles distincts au palier SETBACK ou plus dans la fenêtre de diversité. */
|
||||
public int controlesDivers(long nowMs) {
|
||||
long fenetre = (long) (cfg.suspicionDiversiteFenetreMinutes * 60_000.0);
|
||||
int n = 0;
|
||||
for (long t : dernierSetback.values()) if (nowMs - t <= fenetre) n++;
|
||||
return n;
|
||||
}
|
||||
|
||||
/** Score courant (0 à 100), diversité comprise. */
|
||||
public double score(long nowMs) {
|
||||
double somme = 0;
|
||||
for (Controle c : pics.keySet()) somme += contribution(c, nowMs);
|
||||
double s = Math.min(100.0, somme);
|
||||
if (cfg.suspicionDiversiteControles > 0 && controlesDivers(nowMs) >= cfg.suspicionDiversiteControles) {
|
||||
s = Math.max(s, cfg.suspicionSeuilFort);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
public Niveau niveau(long nowMs) {
|
||||
return niveau(score(nowMs), cfg);
|
||||
}
|
||||
|
||||
/** Contribution actuelle d'un contrôle (points de score). */
|
||||
public double contribution(Controle c, long nowMs) {
|
||||
Double p = pics.get(c);
|
||||
return p == null ? 0 : p * facteur(nowMs) * plafond(c, cfg);
|
||||
}
|
||||
|
||||
/** Nouveau niveau franchi vers le haut depuis le dernier appel (une seule fois), ou null. */
|
||||
public Niveau prendreTransition() {
|
||||
Niveau n = enAttente;
|
||||
enAttente = null;
|
||||
return n;
|
||||
}
|
||||
|
||||
/** Texte « vol:40 vitesse:12 » des contributions non nulles, pour le journal. */
|
||||
public String resume(long nowMs) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (Controle c : Controle.values()) {
|
||||
double v = contribution(c, nowMs);
|
||||
if (v >= 0.5) sb.append(sb.length() == 0 ? "" : " ").append(c.id()).append(':').append(Math.round(v));
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
@@ -19,9 +19,9 @@ public final class TimerPaquets {
|
||||
/**
|
||||
* C15 (16/10) : solde de paquets (reçus - ticks écoulés), option {@link GardeConfig#timerSoldeMax} (0 = désactivé).
|
||||
* Un timer à 1,09 (21,8 paquets/s) restait sous le seuil de 22 paquets/s ; son solde, lui, grandit sans fin. Le
|
||||
* crédit accumulé pendant un lag (paquets en retard, puis rafale de rattrapage) est borné à {@link #CREDIT_MAX}.
|
||||
* crédit accumulé pendant un lag (paquets en retard, puis rafale de rattrapage) est borné à
|
||||
* {@link GardeConfig#timerDetteMax} (0.5, P1.12 : réglable ; 40 en dur avant).
|
||||
*/
|
||||
static final double CREDIT_MAX = 40;
|
||||
private double solde;
|
||||
private long dernierMs = Long.MIN_VALUE;
|
||||
|
||||
@@ -33,7 +33,7 @@ public final class TimerPaquets {
|
||||
return 0;
|
||||
}
|
||||
solde += 1.0 - Math.max(0, nowMs - dernierMs) / (double) TRANCHE_MS;
|
||||
solde = Math.max(-CREDIT_MAX, solde);
|
||||
solde = Math.max(-Math.max(0, cfg.timerDetteMax), solde);
|
||||
dernierMs = Math.max(dernierMs, nowMs);
|
||||
double max = cfg.timerSoldeMax * facteur;
|
||||
if (solde <= max) return 0;
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2.7) : auto-totem, contre-contournement. Les modules AutoTotem récents attendent un délai fixe (souvent 200 à
|
||||
* 300 ms, parfois avec une petite variation) pour passer au-dessus du seuil minimal de {@link AutoTotem}. Un humain qui
|
||||
* remet un totem (inventaire ou touche d'échange de main) varie de plusieurs centaines de millisecondes d'un
|
||||
* éclatement à l'autre. On regarde donc la distribution des délais mesurés : sur les
|
||||
* {@link GardeConfig#autoTotemEchantillons} derniers (5), tous sous {@link GardeConfig#autoTotemRegulierMaxMs} (300 ms)
|
||||
* et un écart type sous {@link GardeConfig#autoTotemEcartTypeMinMs} (30 ms) : machine.
|
||||
*
|
||||
* Les délais sont quantifiés au tick (50 ms) : un écart type sous 30 ms veut dire presque toujours le même tick.
|
||||
* Contrôle séparé d'auto-totem (en ENFORCE en production) : nouveau, donc OBSERVE par défaut.
|
||||
*/
|
||||
public final class TotemRegulier {
|
||||
|
||||
public static final int TAILLE_MAX = 16;
|
||||
|
||||
private final long[] delais = new long[TAILLE_MAX];
|
||||
private int taille;
|
||||
private int tete;
|
||||
private double dernierEcartType = Double.NaN;
|
||||
private double derniereMoyenne = Double.NaN;
|
||||
|
||||
/** Un délai éclatement → totem en main vient d'être mesuré (ms). @return points d'infraction */
|
||||
public double delai(long delaiMs, GardeConfig cfg) {
|
||||
delais[tete] = delaiMs;
|
||||
tete = (tete + 1) % TAILLE_MAX;
|
||||
if (taille < TAILLE_MAX) taille++;
|
||||
int n = Math.max(3, Math.min(TAILLE_MAX, cfg.autoTotemEchantillons));
|
||||
if (taille < n) return 0;
|
||||
double somme = 0;
|
||||
long max = Long.MIN_VALUE;
|
||||
for (int k = 0; k < n; k++) {
|
||||
long d = delais[((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX];
|
||||
somme += d;
|
||||
max = Math.max(max, d);
|
||||
}
|
||||
double moyenne = somme / n;
|
||||
double variance = 0;
|
||||
for (int k = 0; k < n; k++) {
|
||||
long d = delais[((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX];
|
||||
variance += (d - moyenne) * (d - moyenne);
|
||||
}
|
||||
dernierEcartType = Math.sqrt(variance / n);
|
||||
derniereMoyenne = moyenne;
|
||||
return max < cfg.autoTotemRegulierMaxMs && dernierEcartType < cfg.autoTotemEcartTypeMinMs ? 2.0 : 0;
|
||||
}
|
||||
|
||||
public double dernierEcartType() {
|
||||
return dernierEcartType;
|
||||
}
|
||||
|
||||
public double derniereMoyenne() {
|
||||
return derniereMoyenne;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
taille = 0;
|
||||
tete = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P3.2, partie « Tower » du Scaffold) : montée en pilier plus rapide que le saut vanilla. Calcul vanilla 1.21.1
|
||||
* (saut 0,42, puis v = (v − 0,08) × 0,98 par tick) : le joueur dépasse +1 bloc au 3e tick, retombe sur le bloc posé
|
||||
* au 9e ; espace maintenu, {@code noJumpDelay} impose de toute façon 10 ticks entre deux sauts (LivingEntity, sources
|
||||
* NeoForge 21.1.234). Un pilier honnête monte donc d'un bloc toutes les 9 à 10 ticks au mieux (Saut amélioré : plus
|
||||
* lent, le saut est plus haut). Le module Tower pose un bloc toutes les 2 à 4 ticks.
|
||||
*
|
||||
* Signal : poses « en pilier » (bloc dans la colonne du joueur, juste sous ses pieds, chaque bloc un cran au-dessus du
|
||||
* précédent, joueur en montée) séparées de moins de {@link GardeConfig#towerIntervalleMinTicks} (6) ticks. Après
|
||||
* {@link GardeConfig#towerSerie} (5) intervalles courts de suite, <b>chaque</b> pose rapide suivante donne des points
|
||||
* (donc un verdict, annulable en ENFORCE) : pas de « signalé une fois, le reste passe ». Toute autre pose, une pause
|
||||
* ou un intervalle normal remet la chaîne à zéro. Le scaffold horizontal (pont) n'est pas couvert : face cachée et
|
||||
* AirPlace le sont par interaction-bloc. OBSERVE par défaut.
|
||||
*/
|
||||
public final class Tower {
|
||||
|
||||
private long dernierTick = Long.MIN_VALUE;
|
||||
private int dernierY;
|
||||
private int courts;
|
||||
private int dernierIntervalle;
|
||||
|
||||
/**
|
||||
* @param bx, by, bz bloc posé
|
||||
* @param px, py, pz position (pieds) du joueur
|
||||
* @param dy déplacement vertical du dernier paquet de mouvement (montée > 0)
|
||||
* @return points d'infraction
|
||||
*/
|
||||
public double pose(long tick, int bx, int by, int bz, double px, double py, double pz, double dy, GardeConfig cfg) {
|
||||
boolean pilier = (int) Math.floor(px) == bx && (int) Math.floor(pz) == bz && py >= by + 1 - 0.01
|
||||
&& py < by + 2.5 && dy > 0;
|
||||
if (!pilier) {
|
||||
vider();
|
||||
return 0;
|
||||
}
|
||||
boolean suite = dernierTick != Long.MIN_VALUE && by == dernierY + 1 && tick > dernierTick;
|
||||
long ecart = suite ? tick - dernierTick : Long.MAX_VALUE;
|
||||
dernierTick = tick;
|
||||
dernierY = by;
|
||||
if (!suite) {
|
||||
courts = 0;
|
||||
return 0;
|
||||
}
|
||||
dernierIntervalle = (int) Math.min(Integer.MAX_VALUE, ecart);
|
||||
if (ecart >= Math.max(1, cfg.towerIntervalleMinTicks)) {
|
||||
courts = 0;
|
||||
return 0;
|
||||
}
|
||||
courts++;
|
||||
return courts >= Math.max(1, cfg.towerSerie) ? 1.5 : 0;
|
||||
}
|
||||
|
||||
public int dernierIntervalle() {
|
||||
return dernierIntervalle;
|
||||
}
|
||||
|
||||
public int courts() {
|
||||
return courts;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
dernierTick = Long.MIN_VALUE;
|
||||
courts = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import java.util.ArrayDeque;
|
||||
|
||||
/**
|
||||
* Contrôle « velocite » (0.4.0) : anti-recul (Anti Knockback) et anti-poussée (Anti Push) de CheatUtils annulent côté
|
||||
* client la vitesse que le serveur vient de donner. Le serveur sait quand il applique un recul (LivingKnockBackEvent,
|
||||
* explosions) et sa force ; il voit ensuite les paquets de mouvement. Vanilla : la vitesse est posée d'un coup
|
||||
* (0,4 de base, plus avec un coup en courant ou Recul) et le joueur recule d'environ 4,5 x la force en 6 ticks. Un
|
||||
* joueur honnête peut contrer en marchant (au plus ~0,22 bloc par tick) ou être arrêté par un mur : un recul
|
||||
* absent n'est donc compté que s'il manque presque tout ({@link GardeConfig#velociteRapportMin}) et seulement
|
||||
* en série ({@link GardeConfig#velociteSerieMin} sur les {@link #HISTORIQUE} derniers reculs de 2 minutes).
|
||||
*
|
||||
* <p>Un second recul pendant la fenêtre, un changement de milieu (eau, véhicule, vol…) ou toute exemption annule la
|
||||
* mesure en cours. Ni sanction ni VL à partir d'un recul isolé.
|
||||
*/
|
||||
public final class Velocite {
|
||||
|
||||
/** Recul vanilla : distance parcourue en 6 ticks / force (frottement 0,91 en l'air : somme des 6 termes ~ 4,8). */
|
||||
public static final double DISTANCE_PAR_FORCE = 4.5;
|
||||
public static final int HISTORIQUE = 6;
|
||||
public static final long VALIDITE_MS = 120_000;
|
||||
|
||||
/** Ticks où le sens du recul est bloqué au-delà desquels la mesure est abandonnée. */
|
||||
public static final int TICKS_BLOQUES_ABANDON = 2;
|
||||
|
||||
private boolean actif;
|
||||
private int ticksBloques;
|
||||
private boolean ambigu;
|
||||
private long debutMs;
|
||||
private double dirX, dirZ, force, parcouru;
|
||||
/** {instant (ms), 1 si le recul est absent}. */
|
||||
private final ArrayDeque<long[]> resultats = new ArrayDeque<>();
|
||||
|
||||
/**
|
||||
* Le serveur vient d'appliquer un recul.
|
||||
*
|
||||
* @param dirX,dirZ direction du déplacement attendu (vecteur unitaire horizontal)
|
||||
* @param force force effective (après résistance au recul)
|
||||
*/
|
||||
public void recul(long nowMs, double dirX, double dirZ, double force, GardeConfig cfg) {
|
||||
if (force < cfg.velociteForceMin) return;
|
||||
double norme = Math.hypot(dirX, dirZ);
|
||||
if (norme < 1e-6) return;
|
||||
if (actif) {
|
||||
ambigu = true; // deuxième recul dans la fenêtre : la mesure ne veut plus rien dire
|
||||
return;
|
||||
}
|
||||
actif = true;
|
||||
ticksBloques = 0;
|
||||
ambigu = false;
|
||||
debutMs = nowMs;
|
||||
this.dirX = dirX / norme;
|
||||
this.dirZ = dirZ / norme;
|
||||
this.force = force;
|
||||
parcouru = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Un paquet de mouvement accepté.
|
||||
*
|
||||
* @param neutre exemption ou milieu qui rend la mesure invalide : la mesure en cours est abandonnée
|
||||
* @return points d'infraction (0 si rien)
|
||||
*/
|
||||
public double mouvement(long nowMs, double dx, double dz, boolean neutre, boolean bloque, GardeConfig cfg) {
|
||||
if (!actif) return 0;
|
||||
if (neutre) {
|
||||
actif = false;
|
||||
return 0;
|
||||
}
|
||||
// Obstacle dans le SENS du recul : un seul tick ne suffit pas à annuler la mesure (un mur latéral, ou un
|
||||
// contact d'un tick, ne l'annule jamais) ; deux ticks bloqués ou plus l'abandonnent.
|
||||
if (bloque && ++ticksBloques >= TICKS_BLOQUES_ABANDON) {
|
||||
actif = false;
|
||||
return 0;
|
||||
}
|
||||
parcouru += dx * dirX + dz * dirZ;
|
||||
if (nowMs - debutMs < cfg.velociteFenetreTicks * 50L) return 0;
|
||||
actif = false;
|
||||
if (ambigu) return 0;
|
||||
boolean absent = parcouru < cfg.velociteRapportMin * DISTANCE_PAR_FORCE * force;
|
||||
resultats.addLast(new long[] {nowMs, absent ? 1 : 0});
|
||||
while (resultats.size() > HISTORIQUE || (!resultats.isEmpty() && nowMs - resultats.peekFirst()[0] > VALIDITE_MS)) {
|
||||
resultats.removeFirst();
|
||||
}
|
||||
if (!absent) return 0;
|
||||
int n = 0;
|
||||
for (long[] r : resultats) n += (int) r[1];
|
||||
return n >= cfg.velociteSerieMin ? cfg.velocitePoints : 0;
|
||||
}
|
||||
|
||||
public boolean actif() { return actif; }
|
||||
|
||||
public double dirX() { return dirX; }
|
||||
|
||||
public double dirZ() { return dirZ; }
|
||||
|
||||
/** Mesure impossible (joueur coincé) : rien n'est compté. */
|
||||
public void abandonner() {
|
||||
actif = false;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
actif = false;
|
||||
resultats.clear();
|
||||
}
|
||||
}
|
||||
@@ -60,10 +60,12 @@ public final class VolVertical {
|
||||
*/
|
||||
public double enregistrer(EtatMouvement e, boolean exempt) {
|
||||
int n = e.ticks();
|
||||
// Flottement : évalué avant tout retour anticipé, pour qu'un trou de ticks ne le remette pas à zéro.
|
||||
double ptsFlottement = flottement(exempt || e.milieuSpecial() || e.auSolServeur(), e.dy(), n);
|
||||
if (n > TICKS_MAX || n < 0) {
|
||||
aVitesse = false;
|
||||
avance = 0;
|
||||
return 0;
|
||||
return ptsFlottement;
|
||||
}
|
||||
boolean enAir = !e.auSolServeur();
|
||||
double dy = e.dy();
|
||||
@@ -106,6 +108,8 @@ public final class VolVertical {
|
||||
}
|
||||
}
|
||||
|
||||
points = Math.max(points, ptsFlottement);
|
||||
|
||||
derniereVitesse = vitesseFin;
|
||||
aVitesse = true;
|
||||
etaitEnAir = enAir;
|
||||
@@ -138,6 +142,42 @@ public final class VolVertical {
|
||||
return points;
|
||||
}
|
||||
|
||||
// --- 0.4.0 : flottement (remplace le « kicked for floating too long » vanilla, coupé par allow-flight=true) ---
|
||||
/** Vanilla : un paquet dont le dy est >= -0,03125 sans appui est « flottant » (ServerGamePacketListenerImpl). */
|
||||
public static final double DY_FLOTTANT = -0.03125;
|
||||
/** Ticks flottants consécutifs avant infraction (80 comme vanilla) ; 0 = coupé. Réglé par le moteur. */
|
||||
int flottementMax;
|
||||
private int flottementTicks;
|
||||
|
||||
/**
|
||||
* Ticks consécutifs en l'air (sol serveur, hors milieu spécial et exemption) sans vraie chute : un joueur qui
|
||||
* hover, monte lentement ou reste immobile en l'air. Compté en ticks écoulés et non en paquets : un joueur
|
||||
* immobile n'envoie qu'un paquet toutes les 20 ticks. Une vraie chute (dy par tick sous le seuil), le sol, un
|
||||
* milieu spécial ou une exemption remettent le compteur à zéro.
|
||||
*/
|
||||
private double flottement(boolean neutre, double dy, int ticks) {
|
||||
if (flottementMax <= 0) {
|
||||
flottementTicks = 0;
|
||||
return 0;
|
||||
}
|
||||
// Remise à zéro seulement sur une preuve : sol confirmé par le serveur, milieu spécial, exemption.
|
||||
if (neutre) {
|
||||
flottementTicks = 0;
|
||||
return 0;
|
||||
}
|
||||
// Paquet à 0 tick (doublon, rotation seule) : neutre, ni remise à zéro ni ajout (anti-contournement).
|
||||
if (ticks <= 0) return 0;
|
||||
// Vraie chute (dy par tick sous le seuil vanilla) : preuve que le joueur ne flotte pas.
|
||||
if (dy / ticks < DY_FLOTTANT) {
|
||||
flottementTicks = 0;
|
||||
return 0;
|
||||
}
|
||||
// Un trou de plus de TICKS_MAX ticks (lag réel ou simulé) ne remet pas à zéro : il ajoute les ticks écoulés,
|
||||
// au plus TICKS_MAX par paquet (un seul trou, que rien ne confirme, ne suffit pas ; plusieurs, oui).
|
||||
flottementTicks = Math.min(100_000, flottementTicks + Math.min(ticks, TICKS_MAX));
|
||||
return flottementTicks > flottementMax ? 1.5 : 0;
|
||||
}
|
||||
|
||||
private void viderFenetre() {
|
||||
java.util.Arrays.fill(fenetre, false);
|
||||
fenetreIndex = 0;
|
||||
@@ -152,6 +192,7 @@ public final class VolVertical {
|
||||
etaitEnAir = false;
|
||||
anormauxConsecutifs = 0;
|
||||
avance = 0;
|
||||
flottementTicks = 0;
|
||||
viderFenetre();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2.10) : X-Ray statistique, alerte seulement (jamais de setback ni d'expulsion, même en ENFORCE). Un joueur
|
||||
* qui voit les minerais à travers la pierre casse une part anormale de minerais rares (diamant, débris antiques) parmi
|
||||
* les blocs cassés en profondeur, et surtout les atteint sans les avoir vus : le minerai n'a aucune face à l'air ou à un
|
||||
* fluide au moment de la casse. Un minage en branche honnête trouve ses minerais dans les parois du tunnel (exposés),
|
||||
* et seul le premier bloc d'un filon peut être caché (les suivants touchent le trou).
|
||||
*
|
||||
* Sur les {@link #FENETRE} derniers blocs cassés sous {@link GardeConfig#xrayAlerteYMax} : au moins
|
||||
* {@link GardeConfig#xrayRaresMin} rares, plus de {@link GardeConfig#xrayAlerteDiamantsParCent} % de rares, et une part
|
||||
* de rares non exposés d'au moins {@link GardeConfig#xrayAlerteNonExposesPart}. Après une alerte, la fenêtre repart de
|
||||
* zéro. Valeurs prudentes [À VÉRIFIER avec les journaux] : un filon chanceux ne suffit pas (seuil de rares).
|
||||
*/
|
||||
public final class XrayStats {
|
||||
|
||||
public static final int FENETRE = 400;
|
||||
|
||||
/** 0 = bloc ordinaire, 1 = rare exposé, 2 = rare non exposé. */
|
||||
private final byte[] blocs = new byte[FENETRE];
|
||||
private int taille;
|
||||
private int tete;
|
||||
private int rares;
|
||||
private int caches;
|
||||
|
||||
/** Un bloc cassé. @param y hauteur ; @param rare minerai rare ; @param expose une face à l'air ou à un fluide */
|
||||
public double casse(int y, boolean rare, boolean expose, GardeConfig cfg) {
|
||||
if (y > cfg.xrayAlerteYMax) return 0;
|
||||
byte v = (byte) (rare ? (expose ? 1 : 2) : 0);
|
||||
if (taille == FENETRE) {
|
||||
byte ancien = blocs[tete];
|
||||
if (ancien > 0) rares--;
|
||||
if (ancien == 2) caches--;
|
||||
} else {
|
||||
taille++;
|
||||
}
|
||||
blocs[tete] = v;
|
||||
tete = (tete + 1) % FENETRE;
|
||||
if (v > 0) rares++;
|
||||
if (v == 2) caches++;
|
||||
if (!rare || rares < Math.max(1, cfg.xrayRaresMin)) return 0;
|
||||
boolean taux = rares * 100.0 / taille > cfg.xrayAlerteDiamantsParCent;
|
||||
boolean masques = partCachee() >= cfg.xrayAlerteNonExposesPart;
|
||||
if (!taux || !masques) return 0;
|
||||
resume = String.format(java.util.Locale.ROOT, "%d minerais rares sur %d blocs casses sous y=%d, %.0f %% non exposes",
|
||||
rares, taille, cfg.xrayAlerteYMax, partCachee() * 100);
|
||||
vider();
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
private String resume = "";
|
||||
|
||||
/** Résumé de la dernière alerte (pour le journal). */
|
||||
public String resume() {
|
||||
return resume;
|
||||
}
|
||||
|
||||
public int rares() {
|
||||
return rares;
|
||||
}
|
||||
|
||||
public int taille() {
|
||||
return taille;
|
||||
}
|
||||
|
||||
public double partCachee() {
|
||||
return rares == 0 ? 0 : (double) caches / rares;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
taille = 0;
|
||||
tete = 0;
|
||||
rares = 0;
|
||||
caches = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package com.gastinelgarde.mixin;
|
||||
|
||||
import com.gastinelgarde.Garde;
|
||||
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.5 (P3.7) : débit des demandes de complétion de commande. Vanilla analyse chaque demande sans limite de débit.
|
||||
* En ENFORCE, une demande en excès est ignorée (pas de réponse) ; sinon rien ne change.
|
||||
*
|
||||
* Règle (F01) : injecté juste APRÈS ensureRunningOnSameThread (cible unique dans la méthode, sources NeoForge
|
||||
* 21.1.234), donc une seule fois, sur le thread serveur.
|
||||
*/
|
||||
@Mixin(ServerGamePacketListenerImpl.class)
|
||||
public abstract class CompletionMixin {
|
||||
|
||||
@Shadow public ServerPlayer player;
|
||||
|
||||
@Inject(method = "handleCustomCommandSuggestions",
|
||||
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$completion(net.minecraft.network.protocol.game.ServerboundCommandSuggestionPacket packet,
|
||||
CallbackInfo ci) {
|
||||
if (player != null && Garde.noterCompletion(player)) ci.cancel();
|
||||
}
|
||||
}
|
||||
@@ -67,7 +67,7 @@ public abstract class MovePacketMixin {
|
||||
@Inject(method = "teleport(DDDFFLjava/util/Set;)V", at = @At("HEAD"))
|
||||
private void gastinelgarde$marqueTeleport(double x, double y, double z, float yaw, float pitch,
|
||||
java.util.Set<?> relatifs, CallbackInfo ci) {
|
||||
if (player != null) Garde.teleportVanilla(player, x, y, z, yaw, pitch, relatifs);
|
||||
if (player != null) Garde.teleportVanilla(player);
|
||||
}
|
||||
|
||||
// Les 3 teleport() de handleMovePlayer (lit, « moved too quickly », « moved wrongly ») : refus d'un paquet,
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
# 0.4.0 : lecture seule des champs prives de la fusee de feu d'artifice, pour n'accorder la grace de propulsion
|
||||
# qu'a une fusee REELLEMENT attachee au joueur en plane (voir GardeEvents.onFusee). Aucune ecriture, aucun comportement change.
|
||||
public net.minecraft.world.entity.projectile.FireworkRocketEntity attachedToEntity
|
||||
public net.minecraft.world.entity.projectile.FireworkRocketEntity lifetime
|
||||
public net.minecraft.world.entity.projectile.FireworkRocketEntity life
|
||||
@@ -4,7 +4,7 @@ license="MIT"
|
||||
|
||||
[[mods]]
|
||||
modId="gastinelgarde"
|
||||
version="0.3.2"
|
||||
version="${mod_version}"
|
||||
displayName="GastinelGarde"
|
||||
authors="Théo Gastinel"
|
||||
description='''Anti-triche maison : combat, cadence, rotation, timer (phase 1), no-fall, vitesse, vol et véhicules (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
|
||||
|
||||
@@ -3,6 +3,6 @@
|
||||
"minVersion": "0.8",
|
||||
"package": "com.gastinelgarde.mixin",
|
||||
"compatibilityLevel": "JAVA_21",
|
||||
"mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin"],
|
||||
"mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin", "CompletionMixin"],
|
||||
"injectors": {"defaultRequire": 1}
|
||||
}
|
||||
@@ -201,7 +201,7 @@ class CablageMinecraftTest {
|
||||
assertEquals(c.volFenetreGlissante, defaut("VOL_FENETRE_GLISSANTE"));
|
||||
assertEquals(false, defaut("VITESSE_MOYENNE"));
|
||||
assertEquals(c.vitesseMoyenne, defaut("VITESSE_MOYENNE"));
|
||||
assertEquals(0, (int) defaut("TIMER_SOLDE_MAX"));
|
||||
assertEquals(20, (int) defaut("TIMER_SOLDE_MAX")); // 0.5 (P1.12) : 20 par défaut (avant 0)
|
||||
assertEquals(c.timerSoldeMax, (int) defaut("TIMER_SOLDE_MAX"));
|
||||
assertEquals(c.seriePingMargeMs, (int) defaut("SERIE_PING_MARGE"));
|
||||
assertEquals(false, defaut("AC_EMPILEMENT_MOUVEMENT"));
|
||||
@@ -242,7 +242,7 @@ class CablageMinecraftTest {
|
||||
assertFalse(vide.combatMesureEnVehicule);
|
||||
assertFalse(vide.volFenetreGlissante);
|
||||
assertFalse(vide.vitesseMoyenne);
|
||||
assertEquals(0, vide.timerSoldeMax);
|
||||
assertEquals(20, vide.timerSoldeMax); // 0.5 (P1.12)
|
||||
for (com.gastinelgarde.core.Controle k : com.gastinelgarde.core.Controle.values()) {
|
||||
assertEquals(new GardeConfig().mode(k), vide.mode(k), "mode par défaut inchangé : " + k);
|
||||
}
|
||||
@@ -252,7 +252,7 @@ class CablageMinecraftTest {
|
||||
((ModConfigSpec.BooleanValue) valeur("COMBAT_VEHICULE")).set(true);
|
||||
((ModConfigSpec.BooleanValue) valeur("VOL_FENETRE_GLISSANTE")).set(true);
|
||||
((ModConfigSpec.BooleanValue) valeur("VITESSE_MOYENNE")).set(true);
|
||||
((ModConfigSpec.IntValue) valeur("TIMER_SOLDE_MAX")).set(20);
|
||||
((ModConfigSpec.IntValue) valeur("TIMER_SOLDE_MAX")).set(35);
|
||||
GardeConfig c = new GardeConfig();
|
||||
GardeSpec.appliquer(c);
|
||||
assertTrue(c.elytresExemptionStricte, "C7");
|
||||
@@ -260,7 +260,7 @@ class CablageMinecraftTest {
|
||||
assertTrue(c.combatMesureEnVehicule, "C8");
|
||||
assertTrue(c.volFenetreGlissante, "C10");
|
||||
assertTrue(c.vitesseMoyenne, "C15");
|
||||
assertEquals(20, c.timerSoldeMax, "C15");
|
||||
assertEquals(35, c.timerSoldeMax, "C15");
|
||||
} finally {
|
||||
dechargerEnMemoire();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,157 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import com.gastinelgarde.core.Controle;
|
||||
import com.gastinelgarde.core.EtatJoueur;
|
||||
import com.gastinelgarde.core.GardeConfig;
|
||||
import com.gastinelgarde.core.Mode;
|
||||
import com.gastinelgarde.core.Moteur;
|
||||
import com.gastinelgarde.core.Sanction;
|
||||
import com.gastinelgarde.core.Suivi;
|
||||
import com.gastinelgarde.core.Verdict;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** Défauts (a) et (b) du 23/10 : analyse reproduite en test, et correctif (b) du motif de sanction. */
|
||||
class CablageSuspicionTest {
|
||||
|
||||
private static Verdict verdict(Controle c, Mode m, Sanction palier, Sanction applicable) {
|
||||
return new Verdict(c, m, 1, 5, palier, applicable, false, "", List.of());
|
||||
}
|
||||
|
||||
// --- (b) motif de la sanction ---
|
||||
|
||||
@Test
|
||||
void b_leMotifEstCeluiDuVerdictQuiSanctionneEtPasLePremierDeLaListe() {
|
||||
// Cas du 23/10 : vitesse en OBSERVE (alerte) en tête de liste, le vol (ENFORCE) déclenche le setback.
|
||||
List<Verdict> vs = List.of(
|
||||
verdict(Controle.VITESSE, Mode.OBSERVE, Sanction.SETBACK, Sanction.ALERTE),
|
||||
verdict(Controle.VOL, Mode.ENFORCE, Sanction.SETBACK, Sanction.SETBACK));
|
||||
assertEquals("vol", Cablage.raison(vs, Sanction.SETBACK));
|
||||
assertEquals("vitesse", Cablage.raison(vs, Sanction.ALERTE));
|
||||
assertEquals("vol", Cablage.raison(vs, Verdict.pire(vs)));
|
||||
}
|
||||
|
||||
@Test
|
||||
void b_journalEtDeconnexionPortentLeBonMotif() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
CablageTest.FauxJoueur p = new CablageTest.FauxJoueur();
|
||||
List<Verdict> vs = List.of(
|
||||
verdict(Controle.VITESSE, Mode.OBSERVE, Sanction.EXPULSION, Sanction.ALERTE),
|
||||
verdict(Controle.REGULARITE, Mode.ENFORCE, Sanction.EXPULSION, Sanction.EXPULSION));
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, vs);
|
||||
assertEquals("journal Tricheur EXPULSE (regularite)", p.actions.get(0));
|
||||
assertEquals("deconnexion Expulsé par l'anti-triche (regularite).", p.actions.get(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
void b_sansVerdictOuSansCorrespondanceExacteRienNeCasse() {
|
||||
assertEquals("anti-triche", Cablage.raison(List.of(), Sanction.EXPULSION));
|
||||
List<Verdict> vs = List.of(verdict(Controle.VOL, Mode.ENFORCE, Sanction.ALERTE, Sanction.ALERTE));
|
||||
assertEquals("vol", Cablage.raison(vs, Sanction.SETBACK), "à défaut, le plus sévère");
|
||||
}
|
||||
|
||||
private static Verdict verdictVl(Controle c, double vl, Sanction s) {
|
||||
return new Verdict(c, Mode.ENFORCE, 1, vl, s, s, false, "", List.of());
|
||||
}
|
||||
|
||||
@Test
|
||||
void b_P13_egaliteDePalierLePlusFortVlGagne() {
|
||||
// VITESSE est avant VOL dans l'enum : avant 0.5, le premier gagnait.
|
||||
List<Verdict> vs = List.of(verdictVl(Controle.VITESSE, 11, Sanction.SETBACK),
|
||||
verdictVl(Controle.VOL, 18, Sanction.SETBACK));
|
||||
assertEquals("vol", Cablage.raison(vs, Sanction.SETBACK));
|
||||
assertEquals("vol ; aussi : vitesse", Cablage.motifJournal(vs, Sanction.SETBACK));
|
||||
// À VL égal, le premier reste retenu (stable).
|
||||
List<Verdict> egaux = List.of(verdictVl(Controle.VITESSE, 12, Sanction.SETBACK),
|
||||
verdictVl(Controle.VOL, 12, Sanction.SETBACK));
|
||||
assertEquals("vitesse", Cablage.raison(egaux, Sanction.SETBACK));
|
||||
}
|
||||
|
||||
@Test
|
||||
void b_P13_journalListeLesAutresControlesMaisPasLeMessageAuJoueur() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
CablageTest.FauxJoueur p = new CablageTest.FauxJoueur();
|
||||
List<Verdict> vs = List.of(verdictVl(Controle.CADENCE, 21, Sanction.EXPULSION),
|
||||
verdictVl(Controle.REGULARITE, 30, Sanction.EXPULSION),
|
||||
verdictVl(Controle.VITESSE, 5, Sanction.ALERTE));
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, vs);
|
||||
assertEquals("journal Tricheur EXPULSE (regularite ; aussi : cadence)", p.actions.get(0));
|
||||
assertEquals("deconnexion Expulsé par l'anti-triche (regularite).", p.actions.get(1));
|
||||
// Même contrôle deux fois au palier (deux verdicts killaura-angle) : pas de doublon.
|
||||
List<Verdict> doubles = List.of(verdictVl(Controle.KILLAURA_ANGLE, 21, Sanction.EXPULSION),
|
||||
verdictVl(Controle.KILLAURA_ANGLE, 22, Sanction.EXPULSION));
|
||||
assertEquals("killaura-angle", Cablage.motifJournal(doubles, Sanction.EXPULSION));
|
||||
}
|
||||
|
||||
// --- (a) expulsion « au premier score » après reconnexion : mécanisme prouvé ---
|
||||
|
||||
@Test
|
||||
void a_apresReconnexionLEtatEstNeufMaisLeJournalNeMontrePasLesVerdictsIntermediaires() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.mode(Controle.REGULARITE, Mode.ENFORCE);
|
||||
Moteur moteur = new Moteur(cfg);
|
||||
UUID id = UUID.randomUUID();
|
||||
// Première session terminée par une expulsion, puis reconnexion (GardeEvents.onConnexion).
|
||||
assertTrue(moteur.expulser(id, 0));
|
||||
moteur.oublierExpulsion(id);
|
||||
|
||||
// Reconnexion : Moteur.oublierExpulsion a vidé le suivi (VL à zéro, pas de setback en mémoire).
|
||||
Suivi neuf = moteur.suivi(id);
|
||||
assertEquals(0, neuf.vl.total(0));
|
||||
assertFalse(moteur.estExpulse(id));
|
||||
|
||||
// Le client triche toujours : mêmes coups à 20 par seconde, parfaitement réguliers.
|
||||
Verdict premier = null;
|
||||
Verdict expulsion = null;
|
||||
int nPremier = 0;
|
||||
int n = 0;
|
||||
long debut = 1_000_000;
|
||||
List<Verdict> tous = new ArrayList<>();
|
||||
while (expulsion == null && n < 200) {
|
||||
n++;
|
||||
long now = debut + n * 50L;
|
||||
for (Verdict v : moteur.attaque(id, now, EtatJoueur.normal(), -1, 1, true)) {
|
||||
if (v.controle() != Controle.REGULARITE) continue;
|
||||
tous.add(v);
|
||||
if (premier == null) {
|
||||
premier = v;
|
||||
nPremier = n;
|
||||
}
|
||||
if (v.applicable() == Sanction.EXPULSION) expulsion = v;
|
||||
}
|
||||
}
|
||||
assertTrue(premier != null && expulsion != null);
|
||||
// Ce que Théo a lu dans le journal : un premier score de 2,0 au palier JOURNAL...
|
||||
assertEquals(2.0, premier.vl(), 1e-9);
|
||||
assertEquals(Sanction.JOURNAL, premier.palier());
|
||||
// ... puis l'expulsion moins d'une seconde plus tard (10 coups), sans autre ligne de journal car
|
||||
// Suivi.autoriserJournal limite à une ligne par seconde et par contrôle.
|
||||
assertTrue(n - nPremier <= 12, "expulsion " + (n - nPremier) * 50 + " ms après le premier score");
|
||||
long tPremier = debut + nPremier * 50L;
|
||||
long tExpulsion = debut + n * 50L;
|
||||
assertTrue(neuf.autoriserJournal(Controle.REGULARITE, tPremier, 1000));
|
||||
assertFalse(neuf.autoriserJournal(Controle.REGULARITE, tExpulsion, 1000),
|
||||
"la ligne du verdict qui expulse n'est pas écrite");
|
||||
}
|
||||
|
||||
@Test
|
||||
void a_unJoueurReconnecteEnLAirNAPasDePositionDeRetourDoncPasDeSetback() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
CablageTest.FauxJoueur p = new CablageTest.FauxJoueur();
|
||||
UUID id = p.id();
|
||||
moteur.oublierExpulsion(id); // reconnexion
|
||||
assertFalse(moteur.suivi(id).aPositionValide());
|
||||
List<Verdict> vs = List.of(verdict(Controle.VOL, Mode.ENFORCE, Sanction.SETBACK, Sanction.SETBACK));
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, vs);
|
||||
assertEquals(0, p.compte("teleport"), "pas de position valide : aucun setback possible");
|
||||
// 0.5 (P1.1) : le setback raté est désormais écrit (avant : aucune ligne).
|
||||
assertEquals(1, p.compte("journal Tricheur SETBACK impossible (vol)"));
|
||||
// Le VL de vol n'est donc pas remis à zéro (apresSetback non appelé) et continue vers l'expulsion.
|
||||
}
|
||||
}
|
||||
@@ -26,11 +26,11 @@ import org.junit.jupiter.api.Test;
|
||||
*/
|
||||
class CablageTest {
|
||||
|
||||
private static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
|
||||
static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
|
||||
private static final String MONDE = "minecraft:overworld";
|
||||
|
||||
/** Doublure de ServerPlayer : enregistre ce que la sanction lui fait, dans l'ordre. */
|
||||
static final class FauxJoueur implements Cablage.Joueur {
|
||||
static class FauxJoueur implements Cablage.Joueur {
|
||||
final List<String> actions = new ArrayList<>();
|
||||
String dimension = MONDE;
|
||||
int tick = 1000;
|
||||
@@ -120,6 +120,19 @@ class CablageTest {
|
||||
|
||||
// --- Setback (C2, C3) ---
|
||||
|
||||
@Test
|
||||
void v042_setbackVelociteRameneLaPositionEtExpulsionAutoTotemDeconnecte() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
FauxJoueur p = new FauxJoueur();
|
||||
moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE);
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VELOCITE, Sanction.SETBACK)));
|
||||
assertEquals(List.of("annonce SETBACK", "teleport 10.5 64.0 -3.5 90 10", "journal Tricheur SETBACK (velocite)"),
|
||||
p.actions);
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, List.of(verdict(Controle.AUTO_TOTEM, Sanction.EXPULSION)));
|
||||
assertEquals(1, p.compte("deconnexion"));
|
||||
assertTrue(moteur.estExpulse(ID));
|
||||
}
|
||||
|
||||
@Test
|
||||
void C2_setbackVersLaPositionAuSolPuisRemiseAZeroDuVol() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
@@ -146,11 +159,14 @@ class CablageTest {
|
||||
FauxJoueur p = new FauxJoueur();
|
||||
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.SETBACK));
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
|
||||
assertTrue(p.actions.isEmpty(), "aucune position de retour : rien");
|
||||
// 0.5 (P1.1) : aucun téléport, mais le setback raté est journalisé.
|
||||
assertEquals(0, p.compte("teleport"), "aucune position de retour : pas de teleport");
|
||||
assertEquals(1, p.compte("journal Tricheur SETBACK impossible"));
|
||||
|
||||
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
|
||||
assertTrue(p.actions.isEmpty(), "position dans une autre dimension : jamais de teleport inter-dimension");
|
||||
assertEquals(0, p.compte("teleport"), "position dans une autre dimension : jamais de teleport inter-dimension");
|
||||
assertEquals(2, p.compte("journal Tricheur SETBACK impossible"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -297,28 +313,4 @@ class CablageTest {
|
||||
Cablage.CacheDetection c = new Cablage.CacheDetection();
|
||||
assertFalse(c.lire(100, () -> false, 40));
|
||||
}
|
||||
|
||||
// --- D1 (0.3.2) : position de retour après une téléportation ---
|
||||
|
||||
@Test
|
||||
void D1_setbackApresTpRameneAuPointDArriveePasAvantLaTeleportation() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
FauxJoueur p = new FauxJoueur();
|
||||
GraceTeleport grace = new GraceTeleport();
|
||||
moteur.suivi(ID).memoriserPosition(0.5, -60.0, 31.0, 0f, 0f, MONDE); // au sol avant le /tp (rapport T3)
|
||||
|
||||
// /tp en l'air (origine externe, aucune annonce)
|
||||
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 100.5, 80.0, 200.5, 45f, 0f, MONDE);
|
||||
// vol stationnaire, setback avant tout contact au sol
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertTrue(p.actions.contains("teleport 100.5 80.0 200.5 45 0"), p.actions.toString());
|
||||
|
||||
// Le teleport du setback lui-même (et un refus vanilla) ne changent pas le retour.
|
||||
grace.annoncer(GraceTeleport.Origine.SETBACK);
|
||||
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 7, 7, 7, 0f, 0f, MONDE);
|
||||
grace.annoncer(GraceTeleport.Origine.REFUS_VANILLA);
|
||||
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 8, 8, 8, 0f, 0f, MONDE);
|
||||
assertEquals(100.5, moteur.suivi(ID).x(), 1e-9);
|
||||
assertEquals(80.0, moteur.suivi(ID).y(), 1e-9);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** Grâce de propulsion d'une fusée (0.4.0, revue de sécurité) : seulement attachée, en plané, vie réelle. */
|
||||
class FuseeElytresTest {
|
||||
|
||||
@Test
|
||||
void fuseeNonAttacheeArbaleteOuPoseeAuSolPasDeGrace() {
|
||||
assertEquals(0, Cablage.graceFusee(false, true, false, 0, 30));
|
||||
assertEquals(0, Cablage.graceFusee(false, false, false, 0, 30));
|
||||
}
|
||||
|
||||
@Test
|
||||
void fuseeAttacheeSansPlanePasDeGrace() {
|
||||
assertEquals(0, Cablage.graceFusee(true, false, false, 0, 30));
|
||||
}
|
||||
|
||||
@Test
|
||||
void fuseeRechargeeDuDisquePasDeGrace() {
|
||||
assertEquals(0, Cablage.graceFusee(true, true, true, 0, 30));
|
||||
}
|
||||
|
||||
@Test
|
||||
void fuseeAttacheeEnPlaneGraceLimiteeALaDureeDeVie() {
|
||||
assertEquals(30 + Cablage.MARGE_FUSEE_TICKS, Cablage.graceFusee(true, true, false, 0, 30));
|
||||
assertEquals(10 + Cablage.MARGE_FUSEE_TICKS, Cablage.graceFusee(true, true, false, 20, 30), "vie restante");
|
||||
assertEquals(Cablage.MARGE_FUSEE_TICKS, Cablage.graceFusee(true, true, false, 50, 30), "déjà finie");
|
||||
assertTrue(Cablage.graceFusee(true, true, false, 0, 100_000) <= Cablage.VIE_FUSEE_MAX + Cablage.MARGE_FUSEE_TICKS, "durée de vie aberrante bornée");
|
||||
}
|
||||
|
||||
@Test
|
||||
void uneFuseeParSecondeNeDonneJamaisPlusQueLaVieDeLaFusee() {
|
||||
int graceMax = 0;
|
||||
for (int i = 0; i < 20; i++) graceMax = Math.max(graceMax, Cablage.graceFusee(true, true, false, 0, 30));
|
||||
assertTrue(graceMax <= 30 + Cablage.MARGE_FUSEE_TICKS, "chaque grâce vaut la vie de la fusée (~30 ticks) + marge (0.4.1 : 20), pas 120 ticks fixes");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import com.gastinelgarde.core.Controle;
|
||||
import com.gastinelgarde.core.EtatJoueur;
|
||||
import com.gastinelgarde.core.GardeConfig;
|
||||
import com.gastinelgarde.core.Mode;
|
||||
import com.gastinelgarde.core.Moteur;
|
||||
import com.gastinelgarde.core.Sanction;
|
||||
import com.gastinelgarde.core.Suivi;
|
||||
import com.gastinelgarde.core.Verdict;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P1.1 : tout verdict de SETBACK / EXPULSION est écrit, et le setback raté aussi. */
|
||||
class JournalP1Test {
|
||||
|
||||
private static Verdict verdict(Controle c, Sanction applicable) {
|
||||
return new Verdict(c, Mode.ENFORCE, 1, 5, applicable, applicable, false, "", List.of());
|
||||
}
|
||||
|
||||
/** Ce que fait Garde.traiter pour le journal, sans serveur : lignes écrites pour une suite de verdicts. */
|
||||
private static List<Verdict> ecrits(Suivi s, GardeConfig cfg, List<Verdict> vs, long nowMs) {
|
||||
List<Verdict> out = new ArrayList<>();
|
||||
long delai = Cablage.delaiJournalMs(cfg.journalLignesParSeconde);
|
||||
for (Verdict v : vs) {
|
||||
if (Cablage.ecrireVerdict(v, cfg.journalToujoursSanctions,
|
||||
() -> s.autoriserJournal(v.controle(), nowMs, delai))) out.add(v);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
@Test
|
||||
void dixVerdictsDansLaMemeSecondeLaLigneDeLExpulsionExiste() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.mode(Controle.REGULARITE, Mode.ENFORCE);
|
||||
Moteur moteur = new Moteur(cfg);
|
||||
UUID id = UUID.randomUUID();
|
||||
Suivi s = moteur.suivi(id);
|
||||
List<Verdict> tous = new ArrayList<>();
|
||||
Verdict expulsion = null;
|
||||
long debut = 1_000_000;
|
||||
for (int n = 1; n <= 200 && expulsion == null; n++) {
|
||||
long now = debut + n * 50L;
|
||||
List<Verdict> vs = new ArrayList<>();
|
||||
for (Verdict v : moteur.attaque(id, now, EtatJoueur.normal(), -1, 1, true)) {
|
||||
if (v.controle() == Controle.REGULARITE) vs.add(v);
|
||||
}
|
||||
for (Verdict v : ecrits(s, cfg, vs, now)) tous.add(v);
|
||||
for (Verdict v : vs) if (v.applicable() == Sanction.EXPULSION) expulsion = v;
|
||||
}
|
||||
assertTrue(expulsion != null);
|
||||
assertTrue(tous.contains(expulsion), "la ligne du verdict qui expulse est écrite");
|
||||
assertTrue(tous.stream().anyMatch(v -> v.applicable() == Sanction.SETBACK), "le setback aussi");
|
||||
}
|
||||
|
||||
@Test
|
||||
void limiteToujoursAppliqueeAuxVerdictsOrdinaires() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
Suivi s = new Suivi(0.5, cfg);
|
||||
List<Verdict> vs = new ArrayList<>();
|
||||
for (int i = 0; i < 10; i++) vs.add(verdict(Controle.VOL, Sanction.ALERTE));
|
||||
assertEquals(1, ecrits(s, cfg, vs, 5000).size());
|
||||
// Plusieurs lignes par seconde si réglé ainsi
|
||||
cfg.journalLignesParSeconde = 4;
|
||||
assertEquals(250, Cablage.delaiJournalMs(4));
|
||||
assertEquals(1000, Cablage.delaiJournalMs(0), "borne basse");
|
||||
}
|
||||
|
||||
@Test
|
||||
void optionCoupeeAncienComportement() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.journalToujoursSanctions = false;
|
||||
Suivi s = new Suivi(0.5, cfg);
|
||||
List<Verdict> vs = List.of(verdict(Controle.VOL, Sanction.ALERTE), verdict(Controle.VOL, Sanction.EXPULSION));
|
||||
assertEquals(1, ecrits(s, cfg, vs, 5000).size());
|
||||
cfg.journalToujoursSanctions = true;
|
||||
Suivi s2 = new Suivi(0.5, cfg);
|
||||
assertEquals(2, ecrits(s2, cfg, vs, 5000).size());
|
||||
}
|
||||
|
||||
@Test
|
||||
void verdictDeSanctionNeConsommePasLaLimite() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
Suivi s = new Suivi(0.5, cfg);
|
||||
List<Verdict> vs = List.of(verdict(Controle.VOL, Sanction.SETBACK), verdict(Controle.VOL, Sanction.ALERTE));
|
||||
assertEquals(2, ecrits(s, cfg, vs, 5000).size(), "l'alerte suivante a encore sa ligne");
|
||||
}
|
||||
|
||||
@Test
|
||||
void setbackImpossibleEcritAvecLaRaison() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
CablageTest.FauxJoueur p = new CablageTest.FauxJoueur();
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals(List.of("journal Tricheur SETBACK impossible (vol) : pas de position de retour valide"), p.actions);
|
||||
|
||||
// Position mémorisée dans une autre dimension
|
||||
moteur.suivi(p.id()).memoriserPosition(1, 64, 1, 0, 0, "minecraft:the_nether");
|
||||
CablageTest.FauxJoueur p2 = new CablageTest.FauxJoueur();
|
||||
Cablage.appliquerSanction(moteur, p2, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals(0, p2.compte("teleport"));
|
||||
assertTrue(p2.actions.get(0).contains("autre dimension (minecraft:the_nether)"));
|
||||
assertFalse(p2.actions.get(0).contains("pas de position"));
|
||||
}
|
||||
}
|
||||
@@ -73,7 +73,8 @@ 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"}) {
|
||||
for (String classe : new String[] {"com.gastinelgarde.mixin.MovePacketMixin", "com.gastinelgarde.mixin.RiptideMoveMixin",
|
||||
"com.gastinelgarde.mixin.CompletionMixin"}) {
|
||||
for (Injection i : injections(lire(classe))) {
|
||||
if (!visePaquet(i) || i.at() == null) continue;
|
||||
assertFalse("HEAD".equals(valeur(i.at(), "value")),
|
||||
@@ -82,6 +83,16 @@ class MixinsThreadTest {
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void F01_completion_apres_ensureRunningOnSameThread() throws Exception {
|
||||
Injection i = injections(lire("com.gastinelgarde.mixin.CompletionMixin")).stream()
|
||||
.filter(x -> x.methode().equals("gastinelgarde$completion")).findFirst().orElseThrow();
|
||||
assertEquals("INVOKE", valeur(i.at(), "value"));
|
||||
assertEquals(ENSURE, valeur(i.at(), "target"));
|
||||
Object shift = valeur(i.at(), "shift");
|
||||
assertTrue(shift instanceof String[] s && s.length == 2 && "AFTER".equals(s[1]), "shift = AFTER");
|
||||
}
|
||||
|
||||
@Test
|
||||
void F01_debut_du_mouvement_apres_ensureRunningOnSameThread() throws Exception {
|
||||
Injection avant = injections(lire("com.gastinelgarde.mixin.MovePacketMixin")).stream()
|
||||
|
||||
@@ -0,0 +1,112 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import com.gastinelgarde.core.Controle;
|
||||
import com.gastinelgarde.core.EtatJoueur;
|
||||
import com.gastinelgarde.core.EtatMouvement;
|
||||
import com.gastinelgarde.core.Exemptions;
|
||||
import com.gastinelgarde.core.GardeConfig;
|
||||
import com.gastinelgarde.core.Mode;
|
||||
import com.gastinelgarde.core.Moteur;
|
||||
import com.gastinelgarde.core.Sanction;
|
||||
import com.gastinelgarde.core.Verdict;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P1.2 : grâce de connexion, plus longue après une expulsion récente ; setback au sol sans position. */
|
||||
class ReconnexionP1Test {
|
||||
|
||||
private static Verdict verdict(Controle c, Sanction s) {
|
||||
return new Verdict(c, Mode.ENFORCE, 1, 15, s, s, false, "", List.of());
|
||||
}
|
||||
|
||||
@Test
|
||||
void dureeDeLaGraceSelonLExpulsionRecente() {
|
||||
Moteur m = new Moteur(new GardeConfig());
|
||||
UUID id = UUID.randomUUID();
|
||||
assertEquals(100, m.graceConnexionTicks(id, 0));
|
||||
assertTrue(m.expulser(id, 1_000));
|
||||
m.oublierExpulsion(id); // reconnexion
|
||||
assertEquals(200, m.graceConnexionTicks(id, 2_000), "expulsé il y a 1 s");
|
||||
assertEquals(200, m.graceConnexionTicks(id, 1_000 + Moteur.EXPULSION_RECENTE_MS));
|
||||
assertEquals(100, m.graceConnexionTicks(id, 2_000 + Moteur.EXPULSION_RECENTE_MS), "plus de 10 min après");
|
||||
}
|
||||
|
||||
@Test
|
||||
void connexionRecenteExempteMouvementVehiculeEtTimerPasLeCombat() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
EtatJoueur e = EtatJoueur.builder().connexionRecente(true).build();
|
||||
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.MOUVEMENT).raisons().contains("connexion"));
|
||||
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.VEHICULE).raisons().contains("connexion"));
|
||||
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.TIMER).raisons().contains("connexion"));
|
||||
assertTrue(!Exemptions.evaluer(e, cfg, Exemptions.Famille.COMBAT).exempt(), "le combat reste mesuré");
|
||||
}
|
||||
|
||||
@Test
|
||||
void suiviNeufEnLAirPasDExpulsionPendantLaGrace() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.mode(Controle.VOL, Mode.ENFORCE);
|
||||
Moteur m = new Moteur(cfg);
|
||||
UUID id = UUID.randomUUID();
|
||||
EtatJoueur enGrace = EtatJoueur.builder().connexionRecente(true).build();
|
||||
// Flottement immobile en l'air (dy = 0) pendant 100 ticks : en vrai, vol ; ici, grâce de connexion.
|
||||
for (int t = 0; t < 100; t++) {
|
||||
EtatMouvement em = new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
assertTrue(m.mouvement(id, t * 50L, enGrace, em).isEmpty(), "tick " + t);
|
||||
}
|
||||
// Après la grâce, le contrôle reprend (référence remise à zéro, puis infraction).
|
||||
boolean vu = false;
|
||||
for (int t = 100; t < 400 && !vu; t++) {
|
||||
EtatMouvement em = new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
vu = !m.mouvement(id, t * 50L, EtatJoueur.normal(), em).isEmpty();
|
||||
}
|
||||
assertTrue(vu, "le vol est de nouveau contrôlé après la grâce");
|
||||
}
|
||||
|
||||
/** Doublure qui trouve le sol 12 blocs plus bas. */
|
||||
static final class JoueurAuDessusDuSol extends CablageTest.FauxJoueur {
|
||||
double[] sol = {10.5, 52.0, -3.5, 90, 0};
|
||||
@Override public double[] solSous() { return sol; }
|
||||
}
|
||||
|
||||
@Test
|
||||
void setbackAuSolSansPositionDeRetour() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals("annonce SETBACK", p.actions.get(0));
|
||||
assertEquals("teleport 10.5 52.0 -3.5 90 0", p.actions.get(1));
|
||||
assertEquals("journal Tricheur SETBACK au sol (vol) : pas de position de retour, y=52.00", p.actions.get(2));
|
||||
assertEquals(0.0, moteur.suivi(p.id()).vl.valeur(Controle.VOL, p.tick() * 50L), 1e-9, "VL de vol remis à zéro");
|
||||
}
|
||||
|
||||
@Test
|
||||
void setbackAuSolDesactiveOuSolIntrouvable() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.setbackSolSiPasDePosition = false;
|
||||
Moteur moteur = new Moteur(cfg);
|
||||
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals(0, p.compte("teleport"));
|
||||
assertEquals(1, p.compte("journal Tricheur SETBACK impossible"));
|
||||
|
||||
Moteur m2 = new Moteur(new GardeConfig());
|
||||
JoueurAuDessusDuSol vide = new JoueurAuDessusDuSol();
|
||||
vide.sol = null; // vide sous le joueur
|
||||
Cablage.appliquerSanction(m2, vide, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals(0, vide.compte("teleport"));
|
||||
assertEquals(1, vide.compte("journal Tricheur SETBACK impossible"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void autreDimensionJamaisDeSetbackAuSol() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
moteur.suivi(CablageTest.ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
|
||||
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals(0, p.compte("teleport"), "une position existe (autre dimension) : pas de secours au sol");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.Properties;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P1.4 : la version du neoforge.mods.toml traité est celle de gradle.properties (une seule source). */
|
||||
class VersionP1Test {
|
||||
|
||||
/** Dossier du projet (le répertoire de travail des tests unitaires NeoForge n'est pas la racine). */
|
||||
private static Path projet() {
|
||||
return Path.of(System.getProperty("gastinelgarde.projet", "."));
|
||||
}
|
||||
|
||||
private static String versionGradle() throws Exception {
|
||||
Properties p = new Properties();
|
||||
try (InputStream in = Files.newInputStream(projet().resolve("gradle.properties"))) {
|
||||
p.load(in);
|
||||
}
|
||||
return p.getProperty("mod_version");
|
||||
}
|
||||
|
||||
@Test
|
||||
void modsTomlTraiteAVersionDeGradleProperties() throws Exception {
|
||||
String attendu = versionGradle();
|
||||
assertNotNull(attendu);
|
||||
assertEquals(attendu, System.getProperty("gastinelgarde.version", attendu));
|
||||
String toml;
|
||||
try (InputStream in = VersionP1Test.class.getClassLoader().getResourceAsStream("META-INF/neoforge.mods.toml")) {
|
||||
assertNotNull(in, "neoforge.mods.toml absent des ressources traitées");
|
||||
toml = new String(in.readAllBytes(), StandardCharsets.UTF_8);
|
||||
}
|
||||
assertFalse(toml.contains("${"), "expansion non faite");
|
||||
Matcher m = Pattern.compile("(?m)^version=\"([^\"]+)\"").matcher(toml);
|
||||
assertTrue(m.find());
|
||||
assertEquals(attendu, m.group(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
void sourceDuTomlNEcritPasLaVersionEnDur() throws Exception {
|
||||
String source = Files.readString(projet().resolve("src/main/resources/META-INF/neoforge.mods.toml"), StandardCharsets.UTF_8);
|
||||
assertTrue(source.contains("version=\"${mod_version}\""), "double source de vérité");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P1.13 : automate START / ABORT de casse de bloc (diagnostic « Mismatch in destroy block pos »). */
|
||||
class ActionsBlocP1Test {
|
||||
|
||||
@Test
|
||||
void startPuisAbortMemePositionRien() {
|
||||
ActionsBloc a = new ActionsBloc();
|
||||
a.start(1, 64, 2, false);
|
||||
assertNull(a.abort(1, 64, 2, 1000));
|
||||
assertEquals(0, a.incoherences());
|
||||
}
|
||||
|
||||
@Test
|
||||
void abortSansStartCommeLeMessageVanilla() {
|
||||
ActionsBloc a = new ActionsBloc();
|
||||
String l = a.abort(5, 70, -3, 1000);
|
||||
assertTrue(l.contains("ABORT (5,70,-3)") && l.contains("aucun START vu"), l);
|
||||
}
|
||||
|
||||
@Test
|
||||
void startAnnuleParUnModEstSignale() {
|
||||
ActionsBloc a = new ActionsBloc();
|
||||
a.start(5, 70, -3, true); // protection de zone : destroyPos vanilla pas mis à jour
|
||||
String l = a.abort(5, 70, -3, 1000);
|
||||
assertTrue(l.contains("annule par un mod"), l);
|
||||
}
|
||||
|
||||
@Test
|
||||
void autrePositionEtLimiteDeJournal() {
|
||||
ActionsBloc a = new ActionsBloc();
|
||||
a.start(0, 64, 0, false);
|
||||
assertTrue(a.abort(1, 64, 0, 1000) != null);
|
||||
assertNull(a.abort(2, 64, 0, 5000), "moins de 10 s : compté, pas écrit");
|
||||
String l = a.abort(3, 64, 0, 1000 + ActionsBloc.DELAI_JOURNAL_MS);
|
||||
assertTrue(l.contains("3 incoherence(s)"), l);
|
||||
}
|
||||
|
||||
@Test
|
||||
void diagnosticActifParDefaut() {
|
||||
assertTrue(new GardeConfig().diagnosticActionsBloc);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
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.5, P1.8 : anti-faim (course au sol déclarée « en l'air »). */
|
||||
class AntiFaimP1Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** Course à 0,28 bloc/tick sur du plat (sprint vanilla), sol serveur vrai. */
|
||||
private static EtatMouvement course(boolean solClient, double dy) {
|
||||
return new EtatMouvement(0.28, dy, 1, solClient, true, true, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
private double total(Moteur m, int paquets, java.util.function.IntFunction<EtatMouvement> f) {
|
||||
double pts = 0;
|
||||
for (int i = 0; i < paquets; i++) {
|
||||
for (Verdict v : m.mouvement(joueur, (i + 1) * 50L, EtatJoueur.normal(), f.apply(i))) {
|
||||
if (v.controle() == Controle.ANTI_FAIM) pts += v.points();
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.ANTI_FAIM));
|
||||
assertEquals(Controle.ANTI_FAIM, Controle.parse("anti-faim"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void courseDeclareeEnLAirVue() {
|
||||
assertTrue(total(new Moteur(cfg), 20, i -> course(false, 0)) > 0, "20 paquets de suite");
|
||||
assertEquals(0, total(new Moteur(cfg), 19, i -> course(false, 0)), 1e-9, "19 : pas encore");
|
||||
}
|
||||
|
||||
@Test
|
||||
void courseHonneteEtSautsRien() {
|
||||
assertEquals(0, total(new Moteur(cfg), 200, i -> course(true, 0)), 1e-9, "au sol déclaré");
|
||||
// Sprint-saut : en l'air avec dy non nul, puis au sol.
|
||||
double[] saut = {0.42, 0.333, 0.248, 0.165, 0.083, 0.0, -0.078, -0.155, -0.23, -0.303, -0.375, -0.13};
|
||||
assertEquals(0, total(new Moteur(cfg), 240, i -> {
|
||||
int k = i % (saut.length + 1);
|
||||
return k == saut.length ? course(true, 0) : course(false, saut[k]);
|
||||
}), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void uneInterruptionRemetLaSerieAZero() {
|
||||
assertEquals(0, total(new Moteur(cfg), 200, i -> i % 15 == 14 ? course(true, 0) : course(false, 0)), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sansSprintMarcheLenteOuMilieuSpecialRien() {
|
||||
EtatMouvement marche = new EtatMouvement(0.21, 0, 1, false, true, false, false, false, 0, 0, false, false);
|
||||
assertEquals(0, total(new Moteur(cfg), 100, i -> marche), 1e-9, "marche : vanilla ne coûte rien");
|
||||
EtatMouvement lente = new EtatMouvement(0.05, 0, 1, false, true, true, false, false, 0, 0, false, false);
|
||||
assertEquals(0, total(new Moteur(cfg), 100, i -> lente), 1e-9);
|
||||
EtatMouvement eau = new EtatMouvement(0.28, 0, 1, false, true, true, false, false, 0, 0, true, false);
|
||||
assertEquals(0, total(new Moteur(cfg), 100, i -> eau), 1e-9);
|
||||
EtatMouvement airServeur = new EtatMouvement(0.28, 0, 1, false, false, true, false, false, 0, 0, false, false);
|
||||
assertEquals(0, total(new Moteur(cfg), 100, i -> airServeur), 1e-9, "en l'air aussi pour le serveur : vol");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
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.5, P3.1 : auto-cristal (âge du cristal de l'End au moment du coup). */
|
||||
class AutoCristalP3Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** Un coup par seconde, âges donnés. */
|
||||
private double frapper(Moteur m, EtatJoueur etat, int... ages) {
|
||||
double pts = 0;
|
||||
for (int i = 0; i < ages.length; i++) {
|
||||
for (Verdict v : m.frappeCristal(joueur, 10_000L + i * 1000L, etat, ages[i])) {
|
||||
if (v.controle() == Controle.AUTO_CRISTAL) pts += v.points();
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.AUTO_CRISTAL));
|
||||
assertEquals(Controle.AUTO_CRISTAL, Controle.parse("auto-cristal"));
|
||||
assertEquals(2, Controle.AUTO_CRISTAL.fiabilite());
|
||||
}
|
||||
|
||||
@Test
|
||||
void cristauxFrappesAuTickDePoseVus() {
|
||||
assertTrue(frapper(new Moteur(cfg), EtatJoueur.normal(), 0, 0, 0, 0, 0, 0, 0, 0) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void pvpHumainRapideJamaisVu() {
|
||||
// Deux à cinq ticks entre la pose et le coup, et de temps en temps un tick (paquets groupés).
|
||||
int[] a = new int[60];
|
||||
for (int i = 0; i < a.length; i++) a[i] = i % 4 == 0 ? 1 : 2 + i % 4;
|
||||
assertEquals(0, frapper(new Moteur(cfg), EtatJoueur.normal(), a), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void ageInconnuOuAncienNonMesure() {
|
||||
assertEquals(0, frapper(new Moteur(cfg), EtatJoueur.normal(), -1, -1, -1, -1, -1, -1, -1, -1, -1, -1), 1e-9);
|
||||
assertEquals(0, frapper(new Moteur(cfg), EtatJoueur.normal(), 500, 500, 500, 500, 500, 500, 500), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptionsEtLag() {
|
||||
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
|
||||
EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().tps(12).build(),
|
||||
EtatJoueur.builder().ticksDepuisGel(3).build()}) {
|
||||
assertEquals(0, frapper(new Moteur(cfg), e, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 1e-9, e.toString());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -307,6 +307,7 @@ class AutotestContournementsTest {
|
||||
@Test
|
||||
void CORRIGE_C15_timerA109EstVuAvecLOption() {
|
||||
assertTrue(timer(40, 10) > 0, "témoin : 25 paquets/s (timer 1,25) est vu");
|
||||
cfg.timerSoldeMax = 0; // 0.5 (P1.12) : le défaut est passé à 20
|
||||
assertEquals(0, timer(46, 30), 1e-9, "option coupée : rien (comme avant)");
|
||||
cfg.timerSoldeMax = 20;
|
||||
assertTrue(timer(46, 30) > 0, "corrigé : 21,7 paquets/s (timer 1,09) pendant 30 s vu par le solde");
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
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.5, P3.7 : débit des demandes de complétion de commande. */
|
||||
class CompletionP3Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** n demandes espacées de pasMs ; renvoie [points, ignorées]. */
|
||||
private double[] demandes(Moteur m, int n, long pasMs) {
|
||||
double pts = 0;
|
||||
int ignorees = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (Verdict v : m.completion(joueur, 1_000_000L + i * pasMs, EtatJoueur.normal())) pts += v.points();
|
||||
if (m.completionAIgnorer(joueur)) ignorees++;
|
||||
}
|
||||
return new double[] {pts, ignorees};
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.COMPLETION));
|
||||
assertEquals(Controle.COMPLETION, Controle.parse("completion"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void frappeHumaineJamaisVue() {
|
||||
// 15 frappes par seconde pendant une minute.
|
||||
assertEquals(0, demandes(new Moteur(cfg), 900, 66)[0], 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void rafaleCourteToleree() {
|
||||
assertEquals(0, demandes(new Moteur(cfg), 40, 0)[0], 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void spamVuMaisRienIgnoreEnObserve() {
|
||||
double[] r = demandes(new Moteur(cfg), 2000, 1);
|
||||
assertTrue(r[0] > 0);
|
||||
assertEquals(0, r[1], 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void enforceIgnoreChaqueDemandeEnExces() {
|
||||
cfg.mode(Controle.COMPLETION, Mode.ENFORCE);
|
||||
Moteur m = new Moteur(cfg);
|
||||
double[] r = demandes(m, 1000, 0); // 1000 demandes au même instant : 40 servies, 960 ignorées
|
||||
assertEquals(960, r[1], 1e-9);
|
||||
assertFalse(new Completion().demande(0, cfg));
|
||||
}
|
||||
}
|
||||
@@ -184,6 +184,7 @@ class ControlesTest {
|
||||
|
||||
@Test
|
||||
void timerAttendTroisSecondes() {
|
||||
cfg.timerSoldeMax = 0; // 0.5 (P1.12) : on mesure ici le débit seul
|
||||
TimerPaquets t = new TimerPaquets();
|
||||
double a2000 = -1;
|
||||
double a3000 = -1;
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P1.10 : auto-criticals (micro-sauts fictifs avant le coup). */
|
||||
class CriticalsP1Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
private long t = 1000;
|
||||
|
||||
private static EtatMouvement paquet(double dy, boolean solClient) {
|
||||
return new EtatMouvement(0, dy, 1, solClient, solClient, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
private void bouger(Moteur m, EtatMouvement... suite) {
|
||||
for (EtatMouvement e : suite) {
|
||||
t += 50;
|
||||
m.mouvement(joueur, t, EtatJoueur.normal(), e);
|
||||
}
|
||||
}
|
||||
|
||||
private double critique(Moteur m) {
|
||||
return m.critique(joueur, t, EtatJoueur.normal()).stream()
|
||||
.filter(v -> v.controle() == Controle.CRITICALS).mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefautEtFiabiliteFaible() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.CRITICALS));
|
||||
assertEquals(2, Controle.CRITICALS.fiabilite());
|
||||
}
|
||||
|
||||
@Test
|
||||
void microSautsAvantChaqueCoupVusEnSerie() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double total = 0;
|
||||
int premierCompte = -1;
|
||||
for (int i = 0; i < 6; i++) {
|
||||
// Wurst « packet » : +0,0625 puis retour au niveau du sol, onGround faux, puis le coup.
|
||||
bouger(m, paquet(0, true), paquet(0.0625, false), paquet(-0.0625, false));
|
||||
double p = critique(m);
|
||||
if (p > 0 && premierCompte < 0) premierCompte = i + 1;
|
||||
total += p;
|
||||
}
|
||||
assertTrue(total > 0);
|
||||
assertEquals(3, premierCompte, "rien avant le 3e critique suspect (criticalsSerieMin)");
|
||||
}
|
||||
|
||||
@Test
|
||||
void vraisSautsJamaisSuspects() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
bouger(m, paquet(0, true), paquet(0.42, false), paquet(0.333, false), paquet(0.248, false),
|
||||
paquet(0.165, false), paquet(0.083, false), paquet(0.0, false), paquet(-0.078, false));
|
||||
total += critique(m);
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void chuteDUnRebordAuDeuxiemeTickPasSuspecte() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
bouger(m, paquet(0, true), paquet(-0.078, false), paquet(-0.155, false));
|
||||
total += critique(m);
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void longueChuteOuMilieuSpecialAbandonneLaReference() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
bouger(m, paquet(0, true));
|
||||
for (int i = 0; i < Criticals.PAQUETS_AIR_MAX + 1; i++) bouger(m, paquet(0, false)); // flottement (vol couvre)
|
||||
Criticals c = m.suivi(joueur).criticals;
|
||||
assertTrue(!c.suspect(cfg));
|
||||
bouger(m, paquet(0, true), paquet(0.0625, false));
|
||||
assertTrue(c.suspect(cfg));
|
||||
t += 50;
|
||||
m.mouvement(joueur, t, EtatJoueur.normal(),
|
||||
new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, true, false));
|
||||
assertTrue(!c.suspect(cfg), "eau / échelle");
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptionCombatEtModeOff() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
for (int i = 0; i < 5; i++) {
|
||||
bouger(m, paquet(0, true), paquet(0.0625, false), paquet(-0.0625, false));
|
||||
List<Verdict> v = m.critique(joueur, t, EtatJoueur.builder().enVehicule(true).build());
|
||||
assertTrue(v.isEmpty(), "passager : exempté");
|
||||
}
|
||||
cfg.mode(Controle.CRITICALS, Mode.OFF);
|
||||
assertTrue(m.critique(joueur, t, EtatJoueur.normal()).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void enforceAtteintLeSetbackPourAnnulerLeCritique() {
|
||||
cfg.mode(Controle.CRITICALS, Mode.ENFORCE);
|
||||
Moteur m = new Moteur(cfg);
|
||||
Sanction pire = Sanction.AUCUNE;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
bouger(m, paquet(0, true), paquet(0.0625, false), paquet(-0.0625, false));
|
||||
Sanction s = Verdict.pire(m.critique(joueur, t, EtatJoueur.normal()));
|
||||
if (s.ordinal() > pire.ordinal()) pire = s;
|
||||
}
|
||||
assertTrue(pire.ordinal() >= Sanction.SETBACK.ordinal(), "" + pire);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
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.5, P1.6 : déploiements d'élytres répétés (ElytraFly « packet »). */
|
||||
class ElytresP1Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
private double deploiements(Moteur m, EtatJoueur e, long debut, long pasMs, int n) {
|
||||
double pts = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (Verdict v : m.deploiementElytres(joueur, debut + i * pasMs, e)) pts += v.points();
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void basculeAChaqueDeuxTicksVue() {
|
||||
// START_FALL_FLYING à chaque tick : plané coupé puis relancé, un déploiement tous les 2 ticks (10 par seconde).
|
||||
assertTrue(deploiements(new Moteur(cfg), EtatJoueur.normal(), 1000, 100, 40) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void redeploiementsHumainsRien() {
|
||||
// 5 par seconde (au seuil) : rien ; un redéploiement toutes les 2 s : rien.
|
||||
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.normal(), 1000, 200, 50), 1e-9);
|
||||
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.normal(), 1000, 2000, 30), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void creatifOuVolAutoriseOuCoupeRien() {
|
||||
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.builder().creatif(true).build(), 1000, 100, 40), 1e-9);
|
||||
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.builder().peutVoler(true).build(), 1000, 100, 40), 1e-9);
|
||||
cfg.elytresDeploiementsMax = 0;
|
||||
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.normal(), 1000, 100, 40), 1e-9, "0 = coupé");
|
||||
cfg.elytresDeploiementsMax = 5;
|
||||
cfg.mode(Controle.ELYTRES, Mode.OFF);
|
||||
assertTrue(new Moteur(cfg).deploiementElytres(joueur, 1000, EtatJoueur.normal()).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void horlogeQuiReculeNeCompteRien() {
|
||||
DeploiementsElytres d = new DeploiementsElytres();
|
||||
for (int i = 0; i < 10; i++) d.deploiement(10_000 + i, cfg);
|
||||
assertEquals(0, d.deploiement(5_000, cfg), 1e-9, "instants futurs ignorés");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
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.5, P2.3 : fast-break (progression simulée comme ServerPlayerGameMode). */
|
||||
class FastBreakP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/**
|
||||
* Casse {@code n} blocs successifs (pierre à la pioche en bois : progression 1/15 par tick environ), chacun en
|
||||
* {@code ticksCasse} ticks après son START. Renvoie le total des points fast-break.
|
||||
*/
|
||||
private double casser(Moteur m, EtatJoueur etat, int n, double progression, int ticksCasse) {
|
||||
double pts = 0;
|
||||
long tick = 1000;
|
||||
for (int i = 0; i < n; i++) {
|
||||
m.debutCasse(joueur, tick, i, 10, 0);
|
||||
tick += ticksCasse;
|
||||
for (Verdict v : m.casseBloc(joueur, tick * 50L, tick, etat, i, 10, 0, progression)) {
|
||||
if (v.controle() == Controle.FAST_BREAK) pts += v.points();
|
||||
}
|
||||
tick += 2;
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.FAST_BREAK));
|
||||
assertEquals(Controle.FAST_BREAK, Controle.parse("fast-break"));
|
||||
assertEquals(2, Controle.FAST_BREAK.fiabilite());
|
||||
}
|
||||
|
||||
@Test
|
||||
void casseALaMargeVanillaEnSerieVue() {
|
||||
// 15 ticks attendus ; casse à 0,7 : progression × (j + 1) >= 0,7 => j = 10.
|
||||
double p = 1.0 / 15;
|
||||
assertTrue(casser(new Moteur(cfg), EtatJoueur.normal(), 10, p, 10) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void casseHonneteJamaisVue() {
|
||||
double p = 1.0 / 15;
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 50, p, 14), 1e-9); // rapport 1,0
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 50, p, 12), 1e-9); // 0,87 : jitter de 2 ticks
|
||||
}
|
||||
|
||||
@Test
|
||||
void casseSuspecteIsoleeNeComptePas() {
|
||||
// 3 suspectes sur 10 (seuil 4) : rien.
|
||||
Moteur m = new Moteur(cfg);
|
||||
double p = 1.0 / 15;
|
||||
double pts = casser(m, EtatJoueur.normal(), 7, p, 14);
|
||||
pts += casser(m, EtatJoueur.normal(), 3, p, 10);
|
||||
assertEquals(0, pts, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void blocsRapidesEtInstantanesNonMesures() {
|
||||
// 4 ticks attendus (< fastBreakTicksMin 6) et casse instantanée (progression >= 1) : jamais mesurés.
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 20, 0.25, 1), 1e-9);
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 20, 1.5, 0), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void casseSansStartAuMemeEndroitNonMesuree() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 20; i++) {
|
||||
m.debutCasse(joueur, 100 + i * 20, 0, 0, 0);
|
||||
for (Verdict v : m.casseBloc(joueur, (110 + i * 20) * 50L, 110 + i * 20, EtatJoueur.normal(), 5, 5, 5, 1.0 / 15)) {
|
||||
pts += v.points();
|
||||
}
|
||||
}
|
||||
assertEquals(0, pts, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptions() {
|
||||
double p = 1.0 / 15;
|
||||
for (EtatJoueur e : new EtatJoueur[] {
|
||||
EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build(),
|
||||
EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().ticksDepuisGel(10).build(),
|
||||
EtatJoueur.builder().tps(15).build()}) {
|
||||
assertEquals(0, casser(new Moteur(cfg), e, 20, p, 10), 1e-9, e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void serieFenetreCompteLesDernieres() {
|
||||
SerieFenetre s = new SerieFenetre(3, 1000);
|
||||
assertEquals(1, s.ajouter(0, true));
|
||||
assertEquals(2, s.ajouter(10, true));
|
||||
assertEquals(2, s.ajouter(20, false));
|
||||
assertEquals(1, s.ajouter(30, false)); // la première est sortie des 3 dernières
|
||||
assertEquals(1, s.ajouter(2000, true)); // les autres sont hors fenêtre
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.Random;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P2.4 : fast-place (régularité des poses au tick près). */
|
||||
class FastPlaceP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
private double poser(Moteur m, EtatJoueur etat, long[] ticks) {
|
||||
double pts = 0;
|
||||
for (long t : ticks) {
|
||||
for (Verdict v : m.poseBloc(joueur, t * 50L, t, etat)) {
|
||||
if (v.controle() == Controle.FAST_PLACE) pts += v.points();
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
private static long[] reguliers(int n, int intervalle) {
|
||||
long[] t = new long[n];
|
||||
for (int i = 0; i < n; i++) t[i] = 100 + (long) i * intervalle;
|
||||
return t;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.FAST_PLACE));
|
||||
assertEquals(Controle.FAST_PLACE, Controle.parse("fast-place"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void poseAChaqueTickVue() {
|
||||
assertTrue(poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(45, 1)) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void clicMaintenuVanillaJamaisVu() {
|
||||
// 4 ticks entre deux poses, parfaitement régulier : vanilla.
|
||||
assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(200, 4)), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void delaiUnSeulementSiConfigure() {
|
||||
assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(50, 2)), 1e-9);
|
||||
cfg.fastPlaceIntervalleMaxTicks = 2;
|
||||
assertTrue(poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(50, 2)) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void dragClickIrregulierJamaisVu() {
|
||||
// Poses de Poisson à 20/s (1 par tick) pendant 60 s, irréaliste (il faudrait 20 cibles par seconde) mais
|
||||
// pire cas : intervalles 0 (même tick), 1, 2, 3…
|
||||
Random r = new Random(42);
|
||||
long[] t = new long[1200];
|
||||
double temps = 100;
|
||||
for (int i = 0; i < t.length; i++) {
|
||||
temps += -Math.log(1 - r.nextDouble()) / 1.0;
|
||||
t[i] = (long) temps;
|
||||
}
|
||||
assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), t), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void pauseRemetAZero() {
|
||||
long[] t = new long[60];
|
||||
for (int i = 0; i < 60; i++) t[i] = 100 + i + (i >= 30 ? 100 : 0); // 30 + 30 poses séparées de 5 s
|
||||
assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), t), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptions() {
|
||||
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
|
||||
EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().ticksDepuisGel(3).build()}) {
|
||||
assertEquals(0, poser(new Moteur(cfg), e, reguliers(60, 1)), 1e-9, e.toString());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import java.util.function.Consumer;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* 0.4.0 : le contrôle vol remplace le « kicked for floating too long » vanilla (allow-flight=true). Flottement =
|
||||
* 80 ticks en l'air sans chute, compté en ticks écoulés. Une exemption par cas listé le 23/10 (rapport).
|
||||
*
|
||||
* Les paquets sont espacés de 20 ticks (rappel de position d'un joueur immobile) pour que le seul contrôle qui
|
||||
* parle soit le flottement : l'ancien contrôle de gravité demande 11 paquets anormaux (220 ticks).
|
||||
*/
|
||||
class FlottementVolTest {
|
||||
|
||||
private GardeConfig cfg;
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
private long now;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
cfg.mode(Controle.VOL, Mode.ENFORCE);
|
||||
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||
cfg.mode(Controle.NO_FALL, Mode.OFF);
|
||||
moteur = new Moteur(cfg);
|
||||
now = 100_000;
|
||||
}
|
||||
|
||||
private static EtatMouvement hover(int ticks, boolean milieu, boolean sol) {
|
||||
return new EtatMouvement(0, 0, ticks, sol, sol, false, false, false, 0, 0, milieu, false);
|
||||
}
|
||||
|
||||
/** Envoie n paquets de 20 ticks sans mouvement ; renvoie les points de vol cumulés et le rang du premier. */
|
||||
private double[] hoverPendant(int paquets, EtatJoueur etat, boolean milieu, boolean sol) {
|
||||
double total = 0;
|
||||
int premier = -1;
|
||||
for (int i = 1; i <= paquets; i++) {
|
||||
now += 1000;
|
||||
double pts = moteur.mouvement(joueur, now, etat, hover(20, milieu, sol)).stream()
|
||||
.filter(v -> v.controle() == Controle.VOL).mapToDouble(Verdict::points).sum();
|
||||
if (pts > 0 && premier < 0) premier = i;
|
||||
total += pts;
|
||||
}
|
||||
return new double[] {total, premier};
|
||||
}
|
||||
|
||||
@Test
|
||||
void hoverImmobileEnSurvieEstVuApres80Ticks() {
|
||||
double[] r = hoverPendant(8, EtatJoueur.normal(), false, false);
|
||||
assertEquals(5, (int) r[1], "4 paquets = 80 ticks tolérés, le 5e dépasse (comme vanilla)");
|
||||
assertTrue(r[0] > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void monteeLenteEstVue() {
|
||||
// +0,02 par tick en l'air, paquets de 1 tick : flottant pour vanilla (dy >= -0,03125)
|
||||
double total = 0;
|
||||
for (int i = 0; i < 100; i++) {
|
||||
now += 50;
|
||||
EtatMouvement m = new EtatMouvement(0.05, 0.02, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
total += moteur.mouvement(joueur, now, EtatJoueur.normal(), m).stream().mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void chuteReelleNeCompteJamaisEtRemetLeCompteurAZero() {
|
||||
double total = 0;
|
||||
double vy = 0;
|
||||
for (int i = 0; i < 70; i++) { // 70 ticks de chute libre normale
|
||||
vy = (vy - 0.08) * 0.98;
|
||||
now += 50;
|
||||
EtatMouvement m = new EtatMouvement(0, vy, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
total += moteur.mouvement(joueur, now, EtatJoueur.normal(), m).stream().mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
assertEquals(0, total);
|
||||
// 60 ticks de flottement après une chute : le compteur repart de zéro (60 < 80)
|
||||
double[] r = hoverPendant(3, EtatJoueur.normal(), false, false);
|
||||
assertEquals(0, r[0]);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sautOrdinaireNEstPasUnFlottement() {
|
||||
double vy = 0.42;
|
||||
double total = 0;
|
||||
for (int i = 0; i < 12; i++) { // saut complet jusqu'à l'atterrissage
|
||||
now += 50;
|
||||
EtatMouvement m = new EtatMouvement(0.2, vy, 1, false, false, true, false, false, 0, 0, false, false);
|
||||
total += moteur.mouvement(joueur, now, EtatJoueur.normal(), m).stream().mapToDouble(Verdict::points).sum();
|
||||
vy = (vy - 0.08) * 0.98;
|
||||
}
|
||||
assertEquals(0, total);
|
||||
}
|
||||
|
||||
@Test
|
||||
void auSolOuDansUnMilieuSpecialPasDeFlottement() {
|
||||
assertEquals(0, hoverPendant(20, EtatJoueur.normal(), false, true)[0], "debout au sol");
|
||||
// eau, lave, échelles, lianes, échafaudage, toile, neige poudreuse, miel, colonne à bulles, slime, tapis Create
|
||||
assertEquals(0, hoverPendant(20, EtatJoueur.normal(), true, false)[0], "milieu spécial");
|
||||
}
|
||||
|
||||
private void exempt(String nom, Consumer<EtatJoueur.Builder> regle) {
|
||||
Moteur m = new Moteur(cfg);
|
||||
EtatJoueur.Builder b = EtatJoueur.builder();
|
||||
regle.accept(b);
|
||||
EtatJoueur etat = b.build();
|
||||
double total = 0;
|
||||
UUID id = UUID.randomUUID();
|
||||
for (int i = 0; i < 30; i++) {
|
||||
now += 1000;
|
||||
for (Verdict v : m.mouvement(id, now, etat, hover(20, false, false))) total += v.points();
|
||||
}
|
||||
assertEquals(0, total, nom + " doit être exempté du flottement");
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptionsExplicites() {
|
||||
exempt("créatif", b -> b.creatif(true));
|
||||
exempt("spectateur", b -> b.spectateur(true));
|
||||
exempt("abilities.mayfly accordé par le serveur", b -> b.peutVoler(true));
|
||||
exempt("élytres (vol plané légitime)", b -> b.elytres(true));
|
||||
exempt("lévitation", b -> b.levitation(true));
|
||||
exempt("chute lente", b -> b.chuteLente(true));
|
||||
exempt("véhicule / passager", b -> b.enVehicule(true));
|
||||
exempt("riptide", b -> b.riptide(true));
|
||||
exempt("structure en mouvement Create / Sable", b -> b.pocheContraption(true));
|
||||
exempt("juste après une téléportation", b -> b.ticksDepuisTeleport(0));
|
||||
exempt("juste après un recul", b -> b.ticksDepuisRecul(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
void grandesStructuresLeverUneExemptionRemetLeCompteurAZero() {
|
||||
// 4 paquets sur une structure (exempté), puis il en descend : il faut 80 ticks de plus, pas 0
|
||||
EtatJoueur sur = EtatJoueur.builder().pocheContraption(true).build();
|
||||
hoverPendant(20, sur, false, false);
|
||||
double[] r = hoverPendant(4, EtatJoueur.normal(), false, false);
|
||||
assertEquals(0, r[0], "80 ticks tolérés après la fin de l'exemption");
|
||||
}
|
||||
|
||||
@Test
|
||||
void reglageAZeroCoupeLeFlottement() {
|
||||
cfg.volFlottementTicks = 0;
|
||||
assertEquals(0, hoverPendant(8, EtatJoueur.normal(), false, false)[0]);
|
||||
}
|
||||
|
||||
@Test
|
||||
void flottementDansLaListeDesVerdictsParMoteur() {
|
||||
double[] r = hoverPendant(6, EtatJoueur.normal(), false, false);
|
||||
List<Verdict> vs = moteur.mouvement(joueur, now + 1000, EtatJoueur.normal(), hover(20, false, false));
|
||||
assertTrue(r[0] > 0);
|
||||
assertTrue(vs.stream().anyMatch(v -> v.controle() == Controle.VOL));
|
||||
}
|
||||
|
||||
private double pts(EtatMouvement m) {
|
||||
now += 50;
|
||||
return moteur.mouvement(joueur, now, EtatJoueur.normal(), m).stream()
|
||||
.filter(v -> v.controle() == Controle.VOL).mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
|
||||
@Test
|
||||
void contournement_rafaleDePaquetsAZeroTickNeRemetPasLeCompteurAZero() {
|
||||
for (int i = 0; i < 3; i++) assertEquals(0, pts(hover(20, false, false))); // 60 ticks
|
||||
for (int i = 0; i < 5; i++) assertEquals(0, pts(hover(0, false, false)), "0 tick : neutre, rien n'est ajouté");
|
||||
assertEquals(0, pts(hover(20, false, false)), "80 ticks, pas encore au-dessus");
|
||||
assertTrue(pts(hover(20, false, false)) > 0, "100 ticks : le flottement continue de compter malgré la rafale");
|
||||
}
|
||||
|
||||
@Test
|
||||
void contournement_rafaleAZeroTickNAjouteRienNonPlus() {
|
||||
for (int i = 0; i < 5; i++) assertEquals(0, pts(hover(0, false, false)));
|
||||
assertEquals(0, pts(hover(20, false, false)), "5 paquets à 0 tick n'ont pas fait monter le compteur");
|
||||
}
|
||||
|
||||
@Test
|
||||
void contournement_trouDeTicksPlusGrandQueTicksMaxCompteLesTicksEcoules() {
|
||||
for (int i = 0; i < 3; i++) assertEquals(0, pts(hover(20, false, false))); // 60 ticks
|
||||
assertTrue(VolVertical.TICKS_MAX < 60);
|
||||
assertTrue(pts(hover(60, false, false)) > 0, "un trou de 60 ticks (> TICKS_MAX) ajoute 40 : 100 > 80");
|
||||
}
|
||||
|
||||
@Test
|
||||
void contournement_trouSeulSuffitAuSeuil() {
|
||||
assertEquals(0, pts(hover(100, false, false)), "un seul trou, non confirmé, ajoute au plus TICKS_MAX (40)");
|
||||
pts(hover(100, false, false));
|
||||
assertTrue(pts(hover(100, false, false)) > 0, "des trous répétés comptent");
|
||||
}
|
||||
|
||||
@Test
|
||||
void remiseAZeroSeulementSurPreuve() {
|
||||
for (int i = 0; i < 3; i++) pts(hover(20, false, false));
|
||||
pts(hover(20, false, true)); // sol confirmé par le serveur
|
||||
for (int i = 0; i < 4; i++) assertEquals(0, pts(hover(20, false, false)));
|
||||
assertTrue(pts(hover(20, false, false)) > 0);
|
||||
|
||||
// vraie chute après un trou : remise à zéro aussi
|
||||
Moteur m2 = new Moteur(cfg);
|
||||
UUID j = UUID.randomUUID();
|
||||
for (int i = 0; i < 3; i++) m2.mouvement(j, now += 1000, EtatJoueur.normal(), hover(20, false, false));
|
||||
m2.mouvement(j, now += 1000, EtatJoueur.normal(),
|
||||
new EtatMouvement(0, -20, 60, false, false, false, false, false, 0, 0, false, false)); // chute, trou 60 ticks
|
||||
for (int i = 0; i < 4; i++) {
|
||||
assertTrue(m2.mouvement(j, now += 1000, EtatJoueur.normal(), hover(20, false, false)).stream()
|
||||
.noneMatch(v -> v.controle() == Controle.VOL && v.points() > 0));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -260,58 +260,4 @@ class Garde1015Test {
|
||||
init();
|
||||
triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.ENFORCE);
|
||||
}
|
||||
|
||||
// --- D2 (0.3.2) : expulsion de combat seulement après 4 setbacks en 60 s (C5) ---
|
||||
|
||||
@Test
|
||||
void D2_hitboxEnforceExpulseApresQuatreSetbacksPasAuBoutDe5s() {
|
||||
GardeConfig c = new GardeConfig();
|
||||
c.mode(Controle.HITBOX, Mode.ENFORCE);
|
||||
Moteur m = new Moteur(c);
|
||||
UUID j = UUID.randomUUID();
|
||||
int setbacks = 0;
|
||||
long expulsionMs = -1;
|
||||
// Rapport T2 : regard décalé de 30° (manque 0,72 bloc), un coup toutes les 600 ms.
|
||||
for (int i = 0; i < 200 && expulsionMs < 0; i++) {
|
||||
long t = i * 600L;
|
||||
Sanction s = Verdict.pire(m.porteeHitbox(j, t, EtatJoueur.normal(), 2.5, 0.72, 3.0, 0.0));
|
||||
if (s == Sanction.SETBACK) setbacks++;
|
||||
if (s == Sanction.EXPULSION) expulsionMs = t;
|
||||
}
|
||||
assertEquals(c.setbacksAvantExpulsion, setbacks, "4 setbacks avant l'expulsion");
|
||||
assertTrue(expulsionMs > 5000, "expulsion trop tôt : " + expulsionMs + " ms");
|
||||
assertTrue(expulsionMs <= c.fenetreSetbacksMs, "expulsion dans la fenêtre C5 : " + expulsionMs + " ms");
|
||||
}
|
||||
|
||||
// --- D3 (0.3.2) : NoFall par paquet d'état ---
|
||||
|
||||
@Test
|
||||
void D3_noFallVoitLePaquetDEtatAuSolPendantUneChute() {
|
||||
GardeConfig c = new GardeConfig();
|
||||
c.mode(Controle.NO_FALL, Mode.OBSERVE);
|
||||
c.mode(Controle.VOL, Mode.OFF);
|
||||
c.mode(Controle.VITESSE, Mode.OFF);
|
||||
Moteur m = new Moteur(c);
|
||||
UUID j = UUID.randomUUID();
|
||||
int lignes = 0;
|
||||
// Rapport T5 : à chaque tick de chute, un paquet de position (en l'air) puis un paquet d'état « au sol ».
|
||||
double[] dys = {-0.08, -0.16, -0.23, -0.30, -0.38, -0.45, -0.52, -0.58};
|
||||
for (int i = 0; i < dys.length; i++) {
|
||||
long t = i * 50L;
|
||||
lignes += m.mouvement(j, t, EtatJoueur.normal(), new EtatMouvement(0, dys[i], 1, false, false,
|
||||
false, false, false, 0, 0, false, false)).size();
|
||||
lignes += m.mouvement(j, t, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, false,
|
||||
false, false, false, 0, 0, false, false)).size();
|
||||
}
|
||||
assertTrue(lignes >= 4, "paquets d'état au sol pendant la chute rapide : " + lignes);
|
||||
|
||||
// Honnête : posé au sol, puis paquets d'état « au sol » immobiles (bloc dessous) ; et saut au sommet.
|
||||
Moteur h = new Moteur(c);
|
||||
assertTrue(h.mouvement(j, 0, EtatJoueur.normal(), new EtatMouvement(0, -0.5, 1, true, true,
|
||||
false, false, false, 0, 0, false, false)).isEmpty());
|
||||
assertTrue(h.mouvement(j, 50, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, true,
|
||||
false, false, false, 0, 0, false, false)).isEmpty());
|
||||
assertTrue(h.mouvement(j, 100, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, false,
|
||||
false, false, false, 0, 0, false, false)).isEmpty(), "après le sol, la chute est oubliée");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,173 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P2.5 : interaction-bloc (AirPlace, face cachée, portée, impact forgé). */
|
||||
class InteractionBlocP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** Bloc plein en (0, 64, 0). */
|
||||
private static final double[] CUBE = {0, 64, 0, 1, 65, 1};
|
||||
/** Dalle du bas en (0, 64, 0). */
|
||||
private static final double[] DALLE = {0, 64, 0, 1, 64.5, 1};
|
||||
private static final int BAS = 0, HAUT = 1, NORD = 2, SUD = 3, OUEST = 4, EST = 5;
|
||||
|
||||
private static String a(double[] oeil, double[] boite, int face, double[] impact, boolean air, boolean plein) {
|
||||
return InteractionBloc.anomalie(oeil, boite, face, impact, air, plein, 4.5, 0.5);
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.INTERACTION_BLOC));
|
||||
assertEquals(Controle.INTERACTION_BLOC, Controle.parse("interaction-bloc"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void clicsVanillaSansAnomalie() {
|
||||
// Debout sur le bloc voisin, regard vers la face du haut ; face est vue de l'est ; dalle par-dessus.
|
||||
assertNull(a(new double[] {1.5, 66.62, 0.5}, CUBE, HAUT, new double[] {0.7, 65, 0.5}, false, true));
|
||||
assertNull(a(new double[] {3.0, 65.62, 0.5}, CUBE, EST, new double[] {1, 64.6, 0.5}, false, true));
|
||||
assertNull(a(new double[] {0.5, 64.3 + 1.62, 2.0}, DALLE, HAUT, new double[] {0.5, 64.5, 0.9}, false, false));
|
||||
// Scaffold vanilla (pont vers l'avant en reculant) : face nord du bloc sous soi, œil juste derrière le plan.
|
||||
assertNull(a(new double[] {0.5, 66.62, -0.2}, CUBE, NORD, new double[] {0.5, 64.8, 0}, false, true));
|
||||
// Début de casse sans impact, à 4 blocs.
|
||||
assertNull(a(new double[] {0.5, 66.62, 5.0}, CUBE, SUD, null, false, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
void anomalies() {
|
||||
assertEquals("bloc-vide", a(new double[] {0.5, 66.62, 2}, CUBE, HAUT, new double[] {0.5, 65, 0.5}, true, false));
|
||||
// Face du bas cliquée depuis au-dessus du bloc (à travers le bloc).
|
||||
assertEquals("face-cachee", a(new double[] {0.5, 66.62, 2}, CUBE, BAS, new double[] {0.5, 64, 0.5}, false, true));
|
||||
// Face ouest cliquée depuis l'est, à 2 blocs derrière le plan.
|
||||
assertEquals("face-cachee", a(new double[] {3.0, 65.62, 0.5}, CUBE, OUEST, new double[] {0, 64.5, 0.5}, false, true));
|
||||
// Impact au centre du bloc (vecteur forgé), face haute.
|
||||
assertEquals("impact-hors-face", a(new double[] {0.5, 66.62, 2}, CUBE, HAUT, new double[] {0.5, 64.5, 0.5}, false, true));
|
||||
// 5,2 blocs : au-delà de 4,5 + 0,5, en deçà de la limite vanilla (portée + 1).
|
||||
assertEquals("hors-portee", a(new double[] {0.5, 64.5, 6.2}, CUBE, SUD, new double[] {0.5, 64.5, 1}, false, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
void coordonneesTransformeesNonMesurees() {
|
||||
// Au-delà de portée + 1, vanilla refuse le paquet : si l'événement arrive quand même, un mod (Sable) a
|
||||
// transformé les coordonnées : rien n'est mesuré, même un bloc d'air.
|
||||
assertNull(a(new double[] {5000, 100, 5000}, CUBE, BAS, new double[] {0.5, 64, 0.5}, true, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
void margeDuDeplacement() {
|
||||
// Œil 1 bloc derrière le plan : anomalie avec la marge seule, pas après un déplacement de 0,6 bloc.
|
||||
double[] oeil = {1.0, 66.62, 0.5};
|
||||
double[] impact = {0, 64.5, 0.5};
|
||||
assertEquals(null, InteractionBloc.anomalie(oeil, CUBE, OUEST, impact, false, true, 4.5, 1.1));
|
||||
assertEquals("face-cachee", InteractionBloc.anomalie(oeil, CUBE, OUEST, impact, false, true, 4.5, 0.5));
|
||||
}
|
||||
|
||||
private double serie(Moteur m, EtatJoueur etat, int n, boolean air) {
|
||||
double pts = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (Verdict v : m.interactionBloc(joueur, i * 500L, etat, new double[] {0.5, 66.62, 2}, CUBE, HAUT,
|
||||
new double[] {0.5, 65, 0.5}, air, true, 4.5, 0)) {
|
||||
if (v.controle() == Controle.INTERACTION_BLOC) pts += v.points();
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void serieExigee() {
|
||||
assertEquals(0, serie(new Moteur(cfg), EtatJoueur.normal(), 2, true), 1e-9);
|
||||
assertTrue(serie(new Moteur(cfg), EtatJoueur.normal(), 3, true) > 0);
|
||||
assertEquals(0, serie(new Moteur(cfg), EtatJoueur.normal(), 50, false), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptions() {
|
||||
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
|
||||
EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().pocheContraption(true).build()}) {
|
||||
assertEquals(0, serie(new Moteur(cfg), e, 10, true), 1e-9, e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
// --- Revues de sécurité (main secondaire, doublons) ---
|
||||
|
||||
private static final double[] OEIL = {0.5, 66.62, 2};
|
||||
private static final double[] IMPACT = {0.5, 65, 0.5};
|
||||
|
||||
private List<Verdict> clic(Moteur m, long t, long cle, int main, int face, double[] impact, boolean air) {
|
||||
return m.interactionBloc(joueur, t, cle, main, EtatJoueur.normal(), OEIL, CUBE, face, impact, air, true, 4.5, 0);
|
||||
}
|
||||
|
||||
private static double pts(List<Verdict> v) {
|
||||
return v.stream().filter(x -> x.controle() == Controle.INTERACTION_BLOC).mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
|
||||
@Test
|
||||
void mainSecondaireSeuleMesuree() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double p = 0;
|
||||
for (int i = 0; i < 3; i++) p += pts(clic(m, i * 500L, 100L + i, 1, HAUT, IMPACT, true));
|
||||
assertTrue(p > 0, "3 clics forgés en main secondaire seule suffisent");
|
||||
}
|
||||
|
||||
@Test
|
||||
void doublonVanillaMainPuisSecondaireCompteUneFoisEtGardeLaDecision() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
for (int i = 0; i < 2; i++) {
|
||||
clic(m, i * 500L, 7L, 0, HAUT, IMPACT, true);
|
||||
clic(m, i * 500L, 7L, 1, HAUT, IMPACT, true);
|
||||
}
|
||||
assertEquals(2, m.suivi(joueur).interactionBloc.dernierCompte(), "2 clics (4 événements) = 2 anomalies");
|
||||
// 3e clic : la principale atteint la série ; la secondaire reprend exactement ses verdicts (même annulation).
|
||||
List<Verdict> principale = clic(m, 1000L, 7L, 0, HAUT, IMPACT, true);
|
||||
List<Verdict> secondaire = clic(m, 1000L, 7L, 1, HAUT, IMPACT, true);
|
||||
assertTrue(pts(principale) > 0);
|
||||
assertEquals(principale, secondaire, "un doublon ne se lit jamais comme autorisé");
|
||||
assertEquals(3, m.suivi(joueur).interactionBloc.dernierCompte(), "non recompté");
|
||||
}
|
||||
|
||||
@Test
|
||||
void deuxiemeEvenementIdentiqueDeLaMemeMainEvalue() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double p = 0;
|
||||
for (int k = 0; k < 3; k++) p += pts(clic(m, 500L, 7L, 0, HAUT, IMPACT, true)); // 3 fois la principale, même tick
|
||||
assertTrue(p > 0, "les répétitions de la même main comptent");
|
||||
// secondaire répétée : dédoublonnée une seule fois par tick
|
||||
Moteur m2 = new Moteur(cfg);
|
||||
clic(m2, 500L, 7L, 0, HAUT, IMPACT, true);
|
||||
clic(m2, 500L, 7L, 1, HAUT, IMPACT, true);
|
||||
clic(m2, 500L, 7L, 1, HAUT, IMPACT, true);
|
||||
assertEquals(2, m2.suivi(joueur).interactionBloc.dernierCompte());
|
||||
}
|
||||
|
||||
@Test
|
||||
void secondaireAvecAutreFaceOuImpactEvaluee() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
clic(m, 500L, 7L, 0, HAUT, IMPACT, false);
|
||||
// même tick, même bloc, main secondaire mais face du bas vue d'en haut : vérifiée et comptée
|
||||
clic(m, 500L, 7L, 1, BAS, new double[] {0.5, 64, 0.5}, false);
|
||||
assertEquals(1, m.suivi(joueur).interactionBloc.dernierCompte());
|
||||
clic(m, 600L, 7L, 0, HAUT, IMPACT, false);
|
||||
clic(m, 600L, 7L, 1, HAUT, new double[] {0.5, 64.5, 0.5}, false); // impact forgé au centre
|
||||
assertEquals(2, m.suivi(joueur).interactionBloc.dernierCompte());
|
||||
}
|
||||
|
||||
@Test
|
||||
void rafaleSurLeMemeBlocDetectee() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double p = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
p += pts(clic(m, 500L, 7L, 0, HAUT, IMPACT, true));
|
||||
p += pts(clic(m, 500L, 7L, 1, HAUT, IMPACT, true));
|
||||
}
|
||||
assertTrue(p > 0, "rafale de 20 événements dans un tick sur un bloc d'air");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
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 java.util.function.IntFunction;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P2.11 : jesus (au sol déclaré sur un fluide). */
|
||||
class JesusP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** Marche à 0,2 bloc/tick, au sol selon le client ou non, sol serveur faux (fluide), milieu spécial (dans l'eau). */
|
||||
private static EtatMouvement surEau(boolean solClient, double dy) {
|
||||
return new EtatMouvement(0.2, dy, 1, solClient, false, false, false, false, 0, 0, true, false);
|
||||
}
|
||||
|
||||
private double total(EtatJoueur etat, int n, IntFunction<EtatMouvement> m, FaitsMouvement f) {
|
||||
Moteur mo = new Moteur(cfg);
|
||||
double pts = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (Verdict v : mo.mouvementP2(joueur, i * 50L, etat, m.apply(i), f)) {
|
||||
if (v.controle() == Controle.JESUS) pts += v.points();
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
private static FaitsMouvement eau() {
|
||||
return new FaitsMouvement().fluide(true, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.JESUS));
|
||||
assertEquals(Controle.JESUS, Controle.parse("jesus"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void marcheSurLEauVue() {
|
||||
assertTrue(total(EtatJoueur.normal(), 10, i -> surEau(true, 0), eau()) > 0);
|
||||
assertEquals(0, total(EtatJoueur.normal(), 9, i -> surEau(true, 0), eau()), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void nageHonneteJamaisVue() {
|
||||
// Nage en surface : jamais au sol selon le client vanilla (un fluide n'a pas de collision).
|
||||
assertEquals(0, total(EtatJoueur.normal(), 200, i -> surEau(false, i % 2 == 0 ? 0.02 : -0.02), eau()), 1e-9);
|
||||
// Debout au fond (sol serveur vrai), sur un nénuphar ou de la glace : sol serveur, rien.
|
||||
assertEquals(0, total(EtatJoueur.normal(), 200,
|
||||
i -> new EtatMouvement(0.1, 0, 1, true, true, false, false, false, 0, 0, true, false), eau()), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void bateauOuVaisseauSousLesPiedsExempte() {
|
||||
assertEquals(0, total(EtatJoueur.normal(), 50, i -> surEau(true, 0), new FaitsMouvement().fluide(true, true)), 1e-9);
|
||||
assertEquals(0, total(EtatJoueur.builder().pocheContraption(true).build(), 50, i -> surEau(true, 0), eau()), 1e-9);
|
||||
assertEquals(0, total(EtatJoueur.builder().enVehicule(true).build(), 50, i -> surEau(true, 0), eau()), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sansFluideRien() {
|
||||
assertEquals(0, total(EtatJoueur.normal(), 50, i -> surEau(true, 0), new FaitsMouvement()), 1e-9);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
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 java.util.function.IntFunction;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P2.1 : no-slow (vitesse gardée pendant un usage d'objet). */
|
||||
class NoSlowP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** Paquet d'un tick au sol plat, en utilisant un objet, à la vitesse dxz. */
|
||||
private static EtatMouvement usage(double dxz, int vitesse) {
|
||||
return new EtatMouvement(dxz, 0, 1, true, true, true, false, true, vitesse, 0, false, false);
|
||||
}
|
||||
|
||||
private double total(Moteur m, EtatJoueur etat, int paquets, IntFunction<EtatMouvement> f, int graceUsage) {
|
||||
double pts = 0;
|
||||
for (int i = 0; i < paquets; i++) {
|
||||
FaitsMouvement faits = new FaitsMouvement().ticksUsage(i + graceUsage);
|
||||
for (Verdict v : m.mouvementP2(joueur, (i + 1) * 50L, etat, f.apply(i), faits)) {
|
||||
if (v.controle() == Controle.NO_SLOW) pts += v.points();
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefautEtFiabiliteFaible() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.NO_SLOW));
|
||||
assertEquals(Controle.NO_SLOW, Controle.parse("no-slow"));
|
||||
assertEquals(2, Controle.NO_SLOW.fiabilite());
|
||||
}
|
||||
|
||||
@Test
|
||||
void courseEnMangeantVue() {
|
||||
// 0,28 bloc/tick (course vanilla) en mangeant, 20 paquets : au moins une infraction.
|
||||
assertTrue(total(new Moteur(cfg), EtatJoueur.normal(), 20, i -> usage(0.28, 0), 0) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void joueurHonneteJamaisVu() {
|
||||
// Vanilla : ×0,2, sprint gardé = ~0,056 bloc/tick ; avec Vitesse II, ~0,08.
|
||||
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 200, i -> usage(0.06, 0), 0), 1e-9);
|
||||
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 200, i -> usage(0.08, 2), 0), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void elanDuDebutDUsageIgnore() {
|
||||
// Les 3 premiers ticks d'usage (élan de la course) ne comptent pas : 3 + 9 paquets rapides = pas encore 10.
|
||||
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 12, i -> usage(0.28, 0), -2), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sautGlaceMilieuEtPaquetsGroupesNeComptentPas() {
|
||||
// Saut (dy != 0), glace, eau, plusieurs ticks entre deux paquets : rien.
|
||||
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
|
||||
i -> new EtatMouvement(0.28, i % 2 == 0 ? 0.42 : 0, 1, false, i % 2 != 0, true, false, true, 0, 0, false, false), 0), 1e-9);
|
||||
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
|
||||
i -> new EtatMouvement(0.28, 0, 1, true, true, true, false, true, 0, 0, false, true), 0), 1e-9);
|
||||
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
|
||||
i -> new EtatMouvement(0.28, 0, 1, true, true, true, false, true, 0, 0, true, false), 0), 1e-9);
|
||||
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
|
||||
i -> new EtatMouvement(0.56, 0, 2, true, true, true, false, true, 0, 0, false, false), 0), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sansUsageDObjetRien() {
|
||||
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
|
||||
i -> new EtatMouvement(0.28, 0, 1, true, true, true, false, false, 0, 0, false, false), 0), 1e-9);
|
||||
// usage inconnu (-1) : pas de mesure
|
||||
Moteur m = new Moteur(cfg);
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 40; i++) {
|
||||
for (Verdict v : m.mouvementP2(joueur, i * 50L, EtatJoueur.normal(), usage(0.28, 0), new FaitsMouvement())) pts += v.points();
|
||||
}
|
||||
assertEquals(0, pts, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptions() {
|
||||
for (EtatJoueur e : new EtatJoueur[] {
|
||||
EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build(),
|
||||
EtatJoueur.builder().enVehicule(true).build(), EtatJoueur.builder().pocheContraption(true).build(),
|
||||
EtatJoueur.builder().ticksDepuisRecul(1).build(), EtatJoueur.builder().ticksDepuisGel(5).build(),
|
||||
EtatJoueur.builder().connexionRecente(true).build()}) {
|
||||
assertEquals(0, total(new Moteur(cfg), e, 40, i -> usage(0.28, 0), 0), 1e-9, e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void offNeMesureRien() {
|
||||
cfg.mode(Controle.NO_SLOW, Mode.OFF);
|
||||
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40, i -> usage(0.28, 0), 0), 1e-9);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,634 @@
|
||||
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.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.4.0 : contrôles elytres (Elytra Hack), velocite (Anti Knockback / Anti Push), auto-totem, et bateau. */
|
||||
class NouveauxControlesTest {
|
||||
|
||||
private GardeConfig cfg;
|
||||
private Moteur moteur;
|
||||
private final UUID j = UUID.randomUUID();
|
||||
private long now;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
moteur = new Moteur(cfg);
|
||||
now = 1_000_000;
|
||||
}
|
||||
|
||||
@Test
|
||||
void modesParDefautTousEnObserve() {
|
||||
for (Controle c : List.of(Controle.ELYTRES, Controle.VELOCITE, Controle.AUTO_TOTEM)) {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(c), c.id());
|
||||
assertEquals(c == Controle.AUTO_TOTEM ? 0 : 2, c.fiabilite(), c.id() + " : plafond 50 (auto-totem, 0.4.1) ou 15");
|
||||
}
|
||||
}
|
||||
|
||||
// --- Elytres ---
|
||||
|
||||
private double plane(EtatJoueur etat, double dxz, double dy, int ticks) {
|
||||
now += 50L * ticks;
|
||||
EtatMouvement m = new EtatMouvement(dxz, dy, ticks, false, false, false, false, false, 0, 0, false, false);
|
||||
return moteur.mouvement(j, now, etat, m).stream().filter(v -> v.controle() == Controle.ELYTRES)
|
||||
.mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
|
||||
private static EtatJoueur enPlane() {
|
||||
return EtatJoueur.builder().elytres(true).build();
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresMonteeSansPerteDeVitesseEstVue_VanillaFly() {
|
||||
double total = 0;
|
||||
for (int i = 0; i < 40; i++) total += plane(enPlane(), 1.0, 0.4, 1); // monte à vitesse constante
|
||||
assertTrue(total > 0);
|
||||
assertEquals(Mode.OBSERVE, moteur.config().mode(Controle.ELYTRES));
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresPlaneImmobileEstVu() {
|
||||
double total = 0;
|
||||
for (int i = 0; i < 40; i++) total += plane(enPlane(), 0.02, 0.0, 1);
|
||||
assertTrue(total > 0, "immobile en plané sans chuter : impossible en vanilla");
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresVraiPlaneEtMonteeAvecPerteDeVitesseSontNormaux() {
|
||||
double total = 0;
|
||||
double v = 2.0;
|
||||
for (int i = 0; i < 25; i++) { // piqué puis cabré : la vitesse se transforme en altitude
|
||||
total += plane(enPlane(), v, -0.5, 1);
|
||||
v *= 0.99;
|
||||
}
|
||||
for (int i = 0; i < 30; i++) {
|
||||
total += plane(enPlane(), v, 0.35, 1);
|
||||
v *= 0.93; // la montée coûte de la vitesse
|
||||
}
|
||||
for (int i = 0; i < 40; i++) total += plane(enPlane(), 1.0, -0.2, 1); // plané descendant
|
||||
assertEquals(0, total);
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresFuseeQuiAccelereVraimentSuspendLesCompteursSansLesEffacer() {
|
||||
double total = 0;
|
||||
for (int i = 0; i < 15; i++) total += plane(enPlane(), 1.0, 0.4, 1); // 15 ticks de montée suspecte
|
||||
assertEquals(0, total, "sous les 20 ticks");
|
||||
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
|
||||
double v = 1.0;
|
||||
for (int i = 0; i < 60; i++) { // la fusée accélère réellement : 1,0 -> 1,6
|
||||
v = Math.min(1.6, v + 0.05);
|
||||
total += plane(fusee, v, 0.4, 1);
|
||||
}
|
||||
assertEquals(0, total, "pendant la grâce rien ne compte");
|
||||
// grâce finie : les 15 ticks d'avant sont conservés, 6 ticks de plus suffisent (> 20)
|
||||
double apres = 0;
|
||||
for (int i = 0; i < 6; i++) apres += plane(enPlane(), 1.6, 0.4, 1);
|
||||
assertTrue(apres > 0, "compteurs conservés, pas remis à zéro par la fusée");
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresFuseeQuiNAcceleratPasEstRevoqueeApres10Ticks() {
|
||||
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
|
||||
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); // vitesse d'avant la fusée : 1,0
|
||||
double total = 0;
|
||||
for (int i = 0; i < 60; i++) total += plane(fusee, 1.0, 0.4, 1); // vitesse constante : la fusée ne pousse pas
|
||||
assertTrue(total > 0, "grâce révoquée, la montée à vitesse constante est vue malgré le drapeau");
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresFuseeDejaALaVitesseMaximaleGardeLaGrace() {
|
||||
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
|
||||
double total = 0;
|
||||
for (int i = 0; i < 40; i++) total += plane(fusee, 1.8, 0.3, 1);
|
||||
assertEquals(0, total);
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresAutreExemptionOuMilieuSpecialEcarteLeControle() {
|
||||
EtatJoueur recul = EtatJoueur.builder().elytres(true).ticksDepuisRecul(0).build();
|
||||
double total = 0;
|
||||
for (int i = 0; i < 60; i++) total += plane(recul, 1.0, 0.4, 1);
|
||||
assertEquals(0, total, "plané + recul : plusieurs raisons, contrôle écarté");
|
||||
for (int i = 0; i < 60; i++) {
|
||||
now += 50;
|
||||
EtatMouvement milieu = new EtatMouvement(1.0, 0.4, 1, false, false, false, false, false, 0, 0, true, false);
|
||||
assertTrue(moteur.mouvement(j, now, enPlane(), milieu).isEmpty(), "courant d'air / bulles / eau");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresPaquetsADeuxTicksEtRafalesNeSontPasMesures() {
|
||||
double total = 0;
|
||||
for (int i = 0; i < 40; i++) total += plane(enPlane(), 1.0, 0.4, 0); // 0 tick : neutre
|
||||
assertEquals(0, total);
|
||||
for (int i = 0; i < 40; i++) total += plane(enPlane(), 3.0, 0.8, 5); // trous : neutre aussi
|
||||
assertEquals(0, total);
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresDesactiveParLeMode() {
|
||||
cfg.mode(Controle.ELYTRES, Mode.OFF);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 60; i++) total += plane(enPlane(), 1.0, 0.4, 1);
|
||||
assertEquals(0, total);
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresNeSanctionnePasEnObserve() {
|
||||
for (int i = 0; i < 200; i++) {
|
||||
now += 50;
|
||||
EtatMouvement m = new EtatMouvement(1.0, 0.4, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
for (Verdict v : moteur.mouvement(j, now, enPlane(), m)) {
|
||||
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal(), v.toString());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- Velocite ---
|
||||
|
||||
/** Recul de force 0,4 vers +x ; le joueur se déplace de dx par tick pendant n ticks. */
|
||||
private double recul(double force, double dxParTick, int n, EtatJoueur etat, boolean milieu) {
|
||||
now += 50;
|
||||
moteur.suivi(j);
|
||||
moteur.reculApplique(j, now, 1, 0, force, true);
|
||||
double pts = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
now += 50;
|
||||
pts += moteur.mesureRecul(j, now, etat, dxParTick, 0, milieu, (x, z) -> false).stream().mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteReculVanillaNEstJamaisUneInfraction() {
|
||||
for (int k = 0; k < 10; k++) {
|
||||
// 0,4 de force : 0,4 puis 0,364... environ 1,8 bloc en 6 ticks
|
||||
assertEquals(0, recul(0.4, 0.3, 7, EtatJoueur.normal(), false));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteAntiKnockbackEstVuEnSerieSeulement() {
|
||||
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false), "1er recul absent : pas de série");
|
||||
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false), "2e : pas encore");
|
||||
assertTrue(recul(0.4, 0.0, 7, EtatJoueur.normal(), false) > 0, "3e recul absent sur 3 : infraction");
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteJoueurContreUnMurFrappeSouventNAJamaisDeVerdict() {
|
||||
// griefing : un tiers coince le joueur contre un mur puis le frappe ; l'adaptateur passe libre = false
|
||||
for (int k = 0; k < 12; k++) {
|
||||
now += 50;
|
||||
moteur.suivi(j);
|
||||
moteur.reculApplique(j, now, 1, 0, 0.4, false);
|
||||
for (int i = 0; i < 7; i++) {
|
||||
now += 50;
|
||||
assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false).isEmpty());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteJoueurDansUnTrouDUnBlocFrappeNAJamaisDeVerdict() {
|
||||
for (int k = 0; k < 12; k++) {
|
||||
now += 50;
|
||||
moteur.suivi(j);
|
||||
moteur.reculApplique(j, now, 0, 1, 0.9, false);
|
||||
for (int i = 0; i < 7; i++) {
|
||||
now += 50;
|
||||
assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false).isEmpty());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteJoueurLibreSansReculDonneUnVerdict() {
|
||||
recul(0.4, 0.0, 7, EtatJoueur.normal(), false);
|
||||
recul(0.4, 0.0, 7, EtatJoueur.normal(), false);
|
||||
assertTrue(recul(0.4, 0.0, 7, EtatJoueur.normal(), false) > 0);
|
||||
}
|
||||
|
||||
/** Trois reculs de force 0,4 vers +x, joueur immobile ; renvoie les points du dernier, avec un prédicat de blocage. */
|
||||
private double troisReculs(java.util.function.BiPredicate<Double, Double> bloque, java.util.function.IntPredicate tickBloque) {
|
||||
double derniers = 0;
|
||||
for (int k = 0; k < 3; k++) {
|
||||
now += 50;
|
||||
moteur.suivi(j);
|
||||
moteur.reculApplique(j, now, 1, 0, 0.4, true);
|
||||
derniers = 0;
|
||||
int[] tick = {0};
|
||||
for (int i = 0; i < 7; i++) {
|
||||
now += 50;
|
||||
final int t = tick[0]++;
|
||||
derniers += moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false,
|
||||
(x, z) -> bloque.test(x, z) && tickBloque.test(t)).stream().mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
}
|
||||
return derniers;
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteMurLateralPerpendiculaireAuReculGardeLaMesure() {
|
||||
// le mur est sur l'axe z ; le recul part vers +x : le prédicat directionnel ne le voit pas
|
||||
assertTrue(troisReculs((x, z) -> z != 0, t -> true) > 0, "mesure gardée, verdict à la série");
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteMurDansLaDirectionDuReculAbandonneLaMesure() {
|
||||
assertEquals(0, troisReculs((x, z) -> x > 0, t -> true));
|
||||
for (int k = 0; k < 6; k++) assertEquals(0, troisReculs((x, z) -> x > 0, t -> true));
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteUnSeulTickDeCollisionNAnnulePasLaFenetre() {
|
||||
assertTrue(troisReculs((x, z) -> true, t -> t == 3) > 0, "un tick isolé : mesure gardée");
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteGelDuServeurOuTpsBasAbandonneLaMesure() {
|
||||
EtatJoueur gel = EtatJoueur.builder().ticksDepuisGel(10).build();
|
||||
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, gel, false), "juste après un gel du serveur");
|
||||
EtatJoueur lag = EtatJoueur.builder().tps(10.0).build();
|
||||
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, lag, false), "serveur qui rame");
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresPicIsoleSuiviDUneVitessePlateRetireLaGrace() {
|
||||
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); // vitesse avant la fusée : 1,0
|
||||
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
|
||||
moteur.nouvelleFusee(j);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 60; i++) {
|
||||
double v = i == 2 ? 3.0 : 1.0; // un seul pic, puis plat
|
||||
total += plane(fusee, v, 0.4, 1);
|
||||
}
|
||||
assertTrue(total > 0, "la médiane reste à 1,0 : pas de gain réel, grâce retirée");
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresDixFuseesEnchaineesSansGainReelSontRetirees() {
|
||||
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
|
||||
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); // vitesse d'avant : 1,0
|
||||
double total = 0;
|
||||
for (int f = 0; f < 10; f++) {
|
||||
moteur.nouvelleFusee(j); // ne remet rien à zéro
|
||||
for (int i = 0; i < 6; i++) total += plane(fusee, 1.0, 0.4, 1); // le drapeau ne tombe jamais
|
||||
}
|
||||
assertTrue(total > 0, "60 ticks de grâce cumulés sans gain : le test de gain est évalué et retire la grâce");
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresGraceRefuseeNeSeReouvrePasAvantUnePause() {
|
||||
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
|
||||
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1);
|
||||
for (int i = 0; i < 12; i++) plane(fusee, 1.0, 0.1, 1); // fenêtre sans gain : refusée
|
||||
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); // le drapeau tombe 5 ticks seulement
|
||||
double total = 0;
|
||||
for (int i = 0; i < 40; i++) total += plane(fusee, 1.0, 0.4, 1); // nouvelle fusée aussitôt : pas de grâce
|
||||
assertTrue(total > 0, "nouvelle fenêtre refusée tant que la pause n'est pas écoulée");
|
||||
// après une vraie pause, une fusée qui accélère est de nouveau acceptée
|
||||
for (int i = 0; i < 50; i++) plane(enPlane(), 1.0, -0.1, 1);
|
||||
double v = 1.0, apres = 0;
|
||||
for (int i = 0; i < 12; i++) apres += plane(fusee, v += 0.06, 0.4, 1);
|
||||
assertEquals(0, apres);
|
||||
}
|
||||
|
||||
@Test
|
||||
void elytresAtterrissagePuisDecollageAvecFuseePasDeVieilleReference() {
|
||||
// vitesse élevée en plané, puis atterrissage (sol serveur) : la référence est effacée
|
||||
for (int i = 0; i < 10; i++) plane(enPlane(), 2.5, -0.1, 1);
|
||||
now += 50;
|
||||
moteur.mouvement(j, now, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, true, false, false, false, 0, 0, false, false));
|
||||
// décollage lent avec fusée : sans vieille référence de 2,5, un vrai gain (0,6 -> 1,2) garde la grâce
|
||||
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
|
||||
double total = 0;
|
||||
double v = 0.6;
|
||||
for (int i = 0; i < 40; i++) total += plane(fusee, v = Math.min(1.5, v + 0.05), 0.4, 1);
|
||||
assertEquals(0, total, "gain réel mesuré contre une référence inconnue, pas contre l'ancienne vitesse de 2,5");
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteEtAutoTotemJamaisDeSanctionEnObserve() { // 0.4.2 : en ENFORCE, voir Sanctions042Test
|
||||
cfg.mode(Controle.VELOCITE, Mode.OBSERVE);
|
||||
cfg.mode(Controle.AUTO_TOTEM, Mode.OBSERVE);
|
||||
boolean vu = false;
|
||||
for (int k = 0; k < 40; k++) {
|
||||
now += 50;
|
||||
moteur.suivi(j);
|
||||
moteur.reculApplique(j, now, 1, 0, 0.4, true);
|
||||
for (int i = 0; i < 7; i++) {
|
||||
now += 50;
|
||||
for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false)) {
|
||||
vu = true;
|
||||
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal(), v.toString());
|
||||
}
|
||||
}
|
||||
}
|
||||
assertTrue(vu);
|
||||
boolean totemVu = false;
|
||||
for (int k = 0; k < 30; k++) {
|
||||
moteur.totemEclate(j, now += 1000, false);
|
||||
for (Verdict v : moteur.totemEnMain(j, now += 50, EtatJoueur.normal(), true)) {
|
||||
totemVu = true;
|
||||
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal(), v.toString());
|
||||
}
|
||||
}
|
||||
assertTrue(totemVu);
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteUnMurOuUnContreIsoleNeSuffitPas() {
|
||||
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false)); // contre un mur
|
||||
assertEquals(0, recul(0.4, 0.3, 7, EtatJoueur.normal(), false)); // recul normal
|
||||
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false)); // contre un mur encore
|
||||
assertEquals(0, recul(0.4, 0.3, 7, EtatJoueur.normal(), false));
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteTraceReelleDElytresHonnetesSansInfractionElytres() throws Exception {
|
||||
// trace du 15/10 : plané honnête (fusées comprises, non marquées dans la trace : on ne vérifie que la montée)
|
||||
List<String> lignes = java.nio.file.Files.readAllLines(java.nio.file.Path.of(
|
||||
NouveauxControlesTest.class.getResource("/traces/elytres-2026-10-15.jsonl").toURI()));
|
||||
Rejeu.Resume r = Rejeu.rejouer(lignes, new GardeConfig());
|
||||
System.out.println("ELYTRES-HONNETE infractions=" + r.infractions() + " exemples=" + r.exemples());
|
||||
assertTrue(r.mouvements() > 500);
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteJoueurQuiContreEnMarchantEnArriereReculeEncore() {
|
||||
// marche à 0,22 bloc par tick dans le sens opposé : recul net 0,4 + ... > 15 % du recul attendu
|
||||
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.9, 0.25, 7, EtatJoueur.normal(), false));
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteExemptionsEtMilieux() {
|
||||
List<EtatJoueur> etats = List.of(
|
||||
EtatJoueur.builder().creatif(true).build(),
|
||||
EtatJoueur.builder().spectateur(true).build(),
|
||||
EtatJoueur.builder().peutVoler(true).build(),
|
||||
EtatJoueur.builder().elytres(true).build(),
|
||||
EtatJoueur.builder().enVehicule(true).build(),
|
||||
EtatJoueur.builder().riptide(true).build(),
|
||||
EtatJoueur.builder().pocheContraption(true).build(),
|
||||
EtatJoueur.builder().ticksDepuisTeleport(0).build());
|
||||
for (EtatJoueur e : etats) {
|
||||
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, e, false), e.toString());
|
||||
}
|
||||
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), true), "eau, échelle…");
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteDeuxReculsDansLaFenetreOuForceNegligeableAnnulentLaMesure() {
|
||||
for (int k = 0; k < 5; k++) {
|
||||
now += 50;
|
||||
moteur.reculApplique(j, now, 1, 0, 0.4, true);
|
||||
moteur.reculApplique(j, now + 50, 1, 0, 0.4, true); // second coup pendant la fenêtre
|
||||
for (int i = 0; i < 7; i++) {
|
||||
now += 50;
|
||||
assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false).isEmpty());
|
||||
}
|
||||
}
|
||||
for (int k = 0; k < 5; k++) assertEquals(0, recul(0.05, 0.0, 7, EtatJoueur.normal(), false), "force < 0,15");
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteAnciennesMesuresExpirent() {
|
||||
recul(0.4, 0.0, 7, EtatJoueur.normal(), false);
|
||||
recul(0.4, 0.0, 7, EtatJoueur.normal(), false);
|
||||
now += Velocite.VALIDITE_MS + 1000;
|
||||
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false), "les deux premiers ont plus de 2 minutes");
|
||||
}
|
||||
|
||||
// --- Auto-totem ---
|
||||
|
||||
private double totem(long delaiMs, int ping, boolean reserve) {
|
||||
Moteur m = new Moteur(cfg);
|
||||
UUID id = UUID.randomUUID();
|
||||
m.suivi(id);
|
||||
long t = 5_000_000;
|
||||
m.totemEclate(id, t, reserve);
|
||||
EtatJoueur e = EtatJoueur.builder().pingMs(ping).build();
|
||||
double pts = 0;
|
||||
for (long d = 50; d <= delaiMs + 200; d += 50) {
|
||||
boolean enMain = d >= delaiMs;
|
||||
pts += m.totemEnMain(id, t + d, e, enMain).stream().mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void autoTotemRemisInstantanementEstVu() {
|
||||
assertTrue(totem(50, 30, false) > 0);
|
||||
assertTrue(totem(100, 30, false) > 0, "100 ms < 150 + 30");
|
||||
}
|
||||
|
||||
@Test
|
||||
void autoTotemDelaiHumainNormal() {
|
||||
assertEquals(0, totem(300, 30, false));
|
||||
assertEquals(0, totem(250, 50, false));
|
||||
assertEquals(0, totem(2000, 30, false), "totem remis bien plus tard");
|
||||
}
|
||||
|
||||
@Test
|
||||
void autoTotemLePingNEntreQueBorne() {
|
||||
assertEquals(0, totem(250, 100, false), "250 >= 150 + 100");
|
||||
// ping annoncé de 5 s : seulement 200 ms de marge au plus (150 + 200 = 350)
|
||||
assertTrue(totem(300, 5000, false) > 0);
|
||||
assertEquals(0, totem(400, 5000, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
void autoTotemTotemDeReserveEnMainAnnuleLaMesure() {
|
||||
assertEquals(0, totem(50, 30, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
void autoTotemAucunTotemRemisOuTropTardNeCompteRien() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
UUID id = UUID.randomUUID();
|
||||
m.suivi(id);
|
||||
m.totemEclate(id, 1000, false);
|
||||
EtatJoueur e = EtatJoueur.normal();
|
||||
assertTrue(m.totemEnMain(id, 1050, e, false).isEmpty());
|
||||
assertTrue(m.totemEnMain(id, 1000 + AutoTotem.EXPIRATION_MS + 50, e, true).isEmpty(), "mesure expirée");
|
||||
// un totem ramassé bien après, sans nouvel éclatement : rien
|
||||
assertTrue(m.totemEnMain(id, 1000 + AutoTotem.EXPIRATION_MS + 100, e, true).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void autoTotemMemeTickQueLEclatementNeCompteRien() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
UUID id = UUID.randomUUID();
|
||||
m.suivi(id);
|
||||
m.totemEclate(id, 1000, false);
|
||||
assertTrue(m.totemEnMain(id, 1000, EtatJoueur.normal(), true).isEmpty(), "totem encore compté dans la main");
|
||||
}
|
||||
|
||||
@Test
|
||||
void autoTotemOffEtObserve() {
|
||||
cfg.mode(Controle.AUTO_TOTEM, Mode.OFF);
|
||||
assertEquals(0, totem(50, 30, false));
|
||||
}
|
||||
|
||||
// --- Bateau (Boat Hack : friction 0,99) ---
|
||||
|
||||
private static EtatVehicule bateau(double dxz, boolean glace) {
|
||||
return new EtatVehicule(EtatVehicule.Type.BATEAU, dxz, 0, 1, false, true, glace, 0, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
void bateauVanillaSurEauNEstJamaisVu() {
|
||||
VehiculeMouvement v = new VehiculeMouvement();
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 400; i++) pts += v.vitesse(bateau(0.40, false), 1.0, 1.5);
|
||||
assertEquals(0, pts);
|
||||
}
|
||||
|
||||
@Test
|
||||
void bateauSurGlaceBleueVanillaNEstJamaisVu() {
|
||||
VehiculeMouvement v = new VehiculeMouvement();
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 400; i++) pts += v.vitesse(bateau(3.6, true), 1.0, 1.5);
|
||||
assertEquals(0, pts);
|
||||
}
|
||||
|
||||
@Test
|
||||
void bateauFriction099EstVuEnQuelquesTicks() {
|
||||
VehiculeMouvement v = new VehiculeMouvement();
|
||||
int premier = -1;
|
||||
for (int i = 0; i < 60 && premier < 0; i++) {
|
||||
// boat hack : l'eau garde 99 % de la vitesse, l'accélération 0,04 par tick s'accumule vers 4 blocs par tick
|
||||
double dxz = Math.min(4.0, 0.4 + 0.04 * i / 0.01 * 0.1);
|
||||
if (v.vitesse(bateau(dxz, false), 1.0, 1.5) > 0) premier = i;
|
||||
}
|
||||
assertTrue(premier >= 0 && premier < 40, "premier point au tick " + premier);
|
||||
}
|
||||
|
||||
@Test
|
||||
void bateauLegerementTropRapideSeVoitAuBoutDeQuelquesSecondes() {
|
||||
// 0,479 bloc/tick (valeur du journal du 23/10) : 0,03 au-dessus de la borne de 0,45, il faut du temps
|
||||
VehiculeMouvement v = new VehiculeMouvement();
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 20; i++) pts += v.vitesse(bateau(0.479, false), 1.0, 1.5);
|
||||
assertEquals(0, pts, "20 ticks à 0,479 : 0,6 bloc d'excès cumulé, sous le seuil de 1,5");
|
||||
for (int i = 0; i < 100; i++) pts += v.vitesse(bateau(0.479, false), 1.0, 1.5);
|
||||
assertTrue(pts > 0, "soutenu 6 s, cela compte");
|
||||
}
|
||||
|
||||
@Test
|
||||
void controlesNouveauxPrisEnCompteParLeScoreDeSuspicion() {
|
||||
// auto-totem seul ne rend jamais suspect (plafond 15) ; les trois ensemble restent sous 50
|
||||
Suspicion s = new Suspicion(cfg);
|
||||
s.noter(Controle.AUTO_TOTEM, 99, false, 0);
|
||||
s.noter(Controle.VELOCITE, 99, false, 0);
|
||||
s.noter(Controle.ELYTRES, 99, false, 0);
|
||||
assertEquals(80, s.score(0), 1e-9); // 0.4.1 : auto-totem fiable (plafond 50) : 50 + 15 + 15
|
||||
|
||||
}
|
||||
|
||||
// --- 0.4.1 ---
|
||||
|
||||
@Test
|
||||
void v041_autoTotemContinueApresPassageEnEnforceSansSanctionReelle() {
|
||||
for (int k = 0; k < 5; k++) {
|
||||
now += 5000;
|
||||
moteur.totemEclate(j, now, false);
|
||||
now += 50;
|
||||
moteur.totemEnMain(j, now, EtatJoueur.normal(), true);
|
||||
}
|
||||
cfg.mode(Controle.AUTO_TOTEM, Mode.ENFORCE); // ce que fait /garde mode ou /garde reload sur la meme config
|
||||
int vus = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
now += 5000;
|
||||
moteur.totemEclate(j, now, false);
|
||||
now += 50;
|
||||
for (Verdict v : moteur.totemEnMain(j, now, EtatJoueur.normal(), true)) {
|
||||
if (v.controle() != Controle.AUTO_TOTEM) continue; // 0.5 (P2.7) : auto-totem-regulier à part
|
||||
vus++;
|
||||
assertEquals(Mode.ENFORCE, v.mode());
|
||||
assertTrue(v.applicable() != Sanction.SETBACK, "0.4.2 : auto-totem n'a pas de setback (expulsion possible)");
|
||||
}
|
||||
}
|
||||
assertEquals(10, vus, "les detections continuent en ENFORCE");
|
||||
assertFalse(moteur.estExpulse(j));
|
||||
}
|
||||
|
||||
@Test
|
||||
void v041_velociteSixReculsAbsentsEspacesDe3sDepassentLeSetback() {
|
||||
assertEquals(4.0, cfg.velocitePoints, 1e-9, "defaut 0.4.1");
|
||||
double vlMax = 0;
|
||||
for (int k = 0; k < 6; k++) {
|
||||
now += 3000 - 50L * 8; // ~3 s entre deux coups
|
||||
now += 50;
|
||||
moteur.reculApplique(j, now, 1, 0, 0.4, true);
|
||||
for (int i = 0; i < 7; i++) {
|
||||
now += 50;
|
||||
for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false)) {
|
||||
vlMax = Math.max(vlMax, v.vl());
|
||||
}
|
||||
}
|
||||
}
|
||||
assertTrue(vlMax > cfg.seuilSetback, "vl max " + vlMax + " doit depasser " + cfg.seuilSetback);
|
||||
}
|
||||
|
||||
@Test
|
||||
void v041_velocitePointsConfigurables() {
|
||||
cfg.velocitePoints = 2.0; // comportement 0.4.0 : plafonne sous le setback
|
||||
double vlMax = 0;
|
||||
for (int k = 0; k < 6; k++) {
|
||||
now += 2600;
|
||||
moteur.reculApplique(j, now, 1, 0, 0.4, true);
|
||||
for (int i = 0; i < 7; i++) {
|
||||
now += 50;
|
||||
for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false)) {
|
||||
vlMax = Math.max(vlMax, v.vl());
|
||||
}
|
||||
}
|
||||
}
|
||||
assertTrue(vlMax < cfg.seuilSetback, "2 points : " + vlMax);
|
||||
}
|
||||
|
||||
@Test
|
||||
void v041_elytresMonteeAvecFuseeJournalTotoche10SansInfraction() {
|
||||
// journal reel : plane rapide (reference hors grace ~1,5), puis fusee en montee : dxz 1,30-1,52, dy 0,66-1,04
|
||||
for (int i = 0; i < 10; i++) plane(enPlane(), 1.55, -0.2, 1);
|
||||
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
|
||||
double[][] journal = {{1.300, 1.039}, {1.520, 0.658}, {1.456, 0.807}};
|
||||
double total = 0;
|
||||
for (int i = 0; i < 45; i++) {
|
||||
double[] p = journal[i % 3];
|
||||
total += plane(fusee, p[0], p[1], 1);
|
||||
}
|
||||
assertEquals(0, total, 1e-9, "fusee reelle en montee : aucune infraction");
|
||||
}
|
||||
|
||||
@Test
|
||||
void v041_elytresVlNeMontePlusDe1Point5ParPaquet() {
|
||||
double vlMax = 0;
|
||||
for (int i = 0; i < 20; i++) plane(enPlane(), 1.0, 0.4, 1); // periode de montee suspecte
|
||||
for (int i = 0; i < 20; i++) {
|
||||
now += 50;
|
||||
EtatMouvement m = new EtatMouvement(1.0, 0.4, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
for (Verdict v : moteur.mouvement(j, now, enPlane(), m)) vlMax = Math.max(vlMax, v.vl());
|
||||
}
|
||||
assertTrue(vlMax > 0, "VanillaFly toujours vu");
|
||||
assertTrue(vlMax <= 3.0, "au plus 1,5 point par periode de " + cfg.elytresMonteeTicks + " ticks : " + vlMax);
|
||||
}
|
||||
|
||||
@Test
|
||||
void v041_elytresFuseeSansPousseeToujoursRevoquee() {
|
||||
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
|
||||
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 60; i++) total += plane(fusee, 1.0, 0.4, 1); // 3D 1,08 < 1,44 : pas une vraie fusee
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
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.5, P3.3 : nuker (blocs cassés dans un même tick serveur). */
|
||||
class NukerP3Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** casses[i] blocs au tick 100 + i * pas. */
|
||||
private double casser(Moteur m, EtatJoueur etat, int pas, int... casses) {
|
||||
double pts = 0;
|
||||
for (int i = 0; i < casses.length; i++) {
|
||||
long t = 100 + (long) i * pas;
|
||||
for (int k = 0; k < casses[i]; k++) {
|
||||
for (Verdict v : m.casseNuker(joueur, t * 50L, t, etat)) {
|
||||
if (v.controle() == Controle.NUKER) pts += v.points();
|
||||
}
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.NUKER));
|
||||
assertEquals(Controle.NUKER, Controle.parse("nuker"));
|
||||
assertEquals(2, Controle.NUKER.fiabilite());
|
||||
}
|
||||
|
||||
@Test
|
||||
void nukerDeVingtBlocsParTickVu() {
|
||||
assertTrue(casser(new Moteur(cfg), EtatJoueur.normal(), 5, 20, 20, 20, 20) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void uneCasseParTickJamaisVue() {
|
||||
int[] c = new int[400];
|
||||
java.util.Arrays.fill(c, 1);
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 1, c), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void paquetsGroupesParLaGigueTolere() {
|
||||
// Herbe fauchée au clic maintenu, ticks client groupés par deux ou trois : jamais au-delà du plafond.
|
||||
int[] c = new int[300];
|
||||
for (int i = 0; i < c.length; i++) c[i] = 1 + i % 3;
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 2, c), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void unSeulTickSuspectNeSuffitPas() {
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 5, 1, 1, 8, 1, 1, 1, 1), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptions() {
|
||||
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
|
||||
EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().pocheContraption(true).build(),
|
||||
EtatJoueur.builder().ticksDepuisGel(3).build(), EtatJoueur.builder().tps(12).build()}) {
|
||||
assertEquals(0, casser(new Moteur(cfg), e, 5, 20, 20, 20, 20, 20), 1e-9, e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
/** Rafale de n casses au tick t : [points comptés, casses annulées]. */
|
||||
private double[] rafale(Moteur m, long t, int n) {
|
||||
double pts = 0;
|
||||
int annulees = 0;
|
||||
for (int k = 0; k < n; k++) {
|
||||
for (Verdict v : m.casseNuker(joueur, t * 50L, t, EtatJoueur.normal())) pts += v.points();
|
||||
if (m.nukerAnnulerCasse(joueur, t * 50L, t)) annulees++;
|
||||
}
|
||||
return new double[] {pts, annulees};
|
||||
}
|
||||
|
||||
@Test
|
||||
void enforceAnnuleToutesLesCassesExcedentairesDuTick() {
|
||||
cfg.mode(Controle.NUKER, Mode.ENFORCE);
|
||||
Moteur m = new Moteur(cfg);
|
||||
double[] r = null;
|
||||
// Rafales de 30 casses par tick jusqu'au palier SETBACK (10 de VL, 2 points par tick suspect en série).
|
||||
for (int i = 0; i < 12; i++) r = rafale(m, 100 + i * 5L, 30);
|
||||
assertEquals(2.0, r[0], 1e-9, "une seule infraction comptée par tick");
|
||||
assertEquals(30 - cfg.nukerBlocsParTickMax, r[1], 1e-9, "toutes les casses excédentaires annulées");
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeNAnnuleRien() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double annulees = 0;
|
||||
for (int i = 0; i < 12; i++) annulees += rafale(m, 100 + i * 5L, 30)[1];
|
||||
assertEquals(0, annulees, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void desactive() {
|
||||
cfg.mode(Controle.NUKER, Mode.OFF);
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 5, 20, 20, 20, 20), 1e-9);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
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 java.util.function.IntFunction;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P2.14 : omnisprint (sprint en reculant ou de côté). */
|
||||
class OmnisprintP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
private static final EtatMouvement COURSE = new EtatMouvement(0.28, 0, 1, true, true, true, false, false, 0, 0, false, false);
|
||||
|
||||
private double total(EtatJoueur etat, int n, EtatMouvement m, IntFunction<FaitsMouvement> f) {
|
||||
Moteur mo = new Moteur(cfg);
|
||||
double pts = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (Verdict v : mo.mouvementP2(joueur, i * 50L, etat, m, f.apply(i))) {
|
||||
if (v.controle() == Controle.OMNISPRINT) pts += v.points();
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
/** Regard vers +z (yaw 0) ; déplacement de 0,28 dans la direction d'angle donnée (degrés depuis +z vers −x). */
|
||||
private static FaitsMouvement dep(double angleDeg) {
|
||||
double r = Math.toRadians(angleDeg);
|
||||
return new FaitsMouvement().direction(-Math.sin(r) * 0.28, Math.cos(r) * 0.28, 0f);
|
||||
}
|
||||
|
||||
@Test
|
||||
void angleCalcule() {
|
||||
assertEquals(0, Omnisprint.angle(0, 1, 0f), 1e-6); // yaw 0 = regard vers +z
|
||||
assertEquals(180, Omnisprint.angle(0, -1, 0f), 1e-6);
|
||||
assertEquals(90, Omnisprint.angle(-1, 0, 0f), 1e-6);
|
||||
assertEquals(0, Omnisprint.angle(-1, 0, 90f), 1e-6); // yaw 90 = regard vers −x
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.OMNISPRINT));
|
||||
}
|
||||
|
||||
@Test
|
||||
void sprintEnReculantVu() {
|
||||
assertTrue(total(EtatJoueur.normal(), 10, COURSE, i -> dep(180)) > 0);
|
||||
assertTrue(total(EtatJoueur.normal(), 10, COURSE, i -> dep(120)) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sprintVanillaJamaisVu() {
|
||||
assertEquals(0, total(EtatJoueur.normal(), 200, COURSE, i -> dep(0)), 1e-9);
|
||||
assertEquals(0, total(EtatJoueur.normal(), 200, COURSE, i -> dep(45)), 1e-9); // avant + côté
|
||||
// demi-tour de la souris : élan arrière 3 ticks seulement
|
||||
assertEquals(0, total(EtatJoueur.normal(), 200, COURSE, i -> dep(i % 20 < 3 ? 180 : 0)), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void reculGlaceEtAirExemptes() {
|
||||
assertEquals(0, total(EtatJoueur.builder().ticksDepuisRecul(2).build(), 30, COURSE, i -> dep(180)), 1e-9);
|
||||
assertEquals(0, total(EtatJoueur.normal(), 30,
|
||||
new EtatMouvement(0.28, 0, 1, true, true, true, false, false, 0, 0, false, true), i -> dep(180)), 1e-9);
|
||||
assertEquals(0, total(EtatJoueur.normal(), 30,
|
||||
new EtatMouvement(0.28, -0.1, 1, false, false, true, false, false, 0, 0, false, false), i -> dep(180)), 1e-9);
|
||||
assertEquals(0, total(EtatJoueur.normal(), 30, COURSE, i -> new FaitsMouvement()), 1e-9, "direction inconnue");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.4.2 : vraies sanctions pour auto-totem et velocite, seuils propres a ces controles. */
|
||||
class Sanctions042Test {
|
||||
|
||||
private GardeConfig cfg;
|
||||
private Moteur moteur;
|
||||
private final UUID j = UUID.randomUUID();
|
||||
private long now;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
moteur = new Moteur(cfg);
|
||||
now = 1_000_000;
|
||||
}
|
||||
|
||||
@Test
|
||||
void seuilsParDefaut() {
|
||||
assertEquals(9, cfg.autoTotemSeuilExpulsion, 1e-9);
|
||||
assertEquals(8, cfg.velociteSeuilSetback, 1e-9);
|
||||
assertEquals(16, cfg.velociteSeuilExpulsion, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void paliersVelocite() {
|
||||
assertEquals(Sanction.ALERTE, Paliers.palier(7.9, cfg, Controle.VELOCITE));
|
||||
assertEquals(Sanction.SETBACK, Paliers.palier(8, cfg, Controle.VELOCITE));
|
||||
assertEquals(Sanction.SETBACK, Paliers.palier(15.9, cfg, Controle.VELOCITE));
|
||||
assertEquals(Sanction.EXPULSION, Paliers.palier(16, cfg, Controle.VELOCITE));
|
||||
}
|
||||
|
||||
@Test
|
||||
void paliersAutoTotem() {
|
||||
assertEquals(Sanction.EXPULSION, Paliers.palier(9, cfg, Controle.AUTO_TOTEM));
|
||||
assertTrue(Paliers.palier(8.9, cfg, Controle.AUTO_TOTEM).ordinal() < Sanction.EXPULSION.ordinal());
|
||||
}
|
||||
|
||||
@Test
|
||||
void seuilsAZeroRetombentSurLesSeuilsGlobaux() {
|
||||
cfg.velociteSeuilSetback = 0;
|
||||
cfg.velociteSeuilExpulsion = 0;
|
||||
cfg.autoTotemSeuilExpulsion = 0;
|
||||
for (double vl : new double[] {3, 9, 12, 15, 25}) {
|
||||
assertEquals(Paliers.palier(vl, cfg), Paliers.palier(vl, cfg, Controle.VELOCITE));
|
||||
assertEquals(Paliers.palier(vl, cfg), Paliers.palier(vl, cfg, Controle.AUTO_TOTEM));
|
||||
}
|
||||
cfg.velociteSeuilSetback = 8;
|
||||
assertEquals(Paliers.palier(9, cfg), Paliers.palier(9, cfg, Controle.VITESSE), "autres controles inchanges");
|
||||
}
|
||||
|
||||
@Test
|
||||
void sanctionMaxResteRespecte() {
|
||||
cfg.sanctionMax = Sanction.SETBACK;
|
||||
assertEquals(Sanction.SETBACK, Paliers.palier(50, cfg, Controle.VELOCITE));
|
||||
}
|
||||
|
||||
private List<Verdict> totem() {
|
||||
moteur.totemEclate(j, now, false);
|
||||
now += 50;
|
||||
return moteur.totemEnMain(j, now, EtatJoueur.normal(), true);
|
||||
}
|
||||
|
||||
@Test
|
||||
void autoTotemEnforceExpulseSansJamaisDeSetback() {
|
||||
cfg.mode(Controle.AUTO_TOTEM, Mode.ENFORCE);
|
||||
Sanction pire = Sanction.AUCUNE;
|
||||
int detections = 0;
|
||||
for (int k = 0; k < 6 && pire != Sanction.EXPULSION; k++) {
|
||||
for (Verdict v : totem()) {
|
||||
detections++;
|
||||
assertTrue(v.applicable() != Sanction.SETBACK, "palier SETBACK ramene a ALERTE");
|
||||
if (v.applicable().ordinal() > pire.ordinal()) pire = v.applicable();
|
||||
}
|
||||
now += 300; // detections rapprochees
|
||||
}
|
||||
assertEquals(Sanction.EXPULSION, pire);
|
||||
assertTrue(detections <= 4, "expulsion a la 3e ou 4e detection rapprochee : " + detections);
|
||||
}
|
||||
|
||||
@Test
|
||||
void autoTotemEnObserveJamaisDeSanction() {
|
||||
for (int k = 0; k < 10; k++) {
|
||||
for (Verdict v : totem()) assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal());
|
||||
now += 300;
|
||||
}
|
||||
}
|
||||
|
||||
private Sanction recul() {
|
||||
now += 2000;
|
||||
moteur.reculApplique(j, now, 1, 0, 0.4, true);
|
||||
Sanction pire = Sanction.AUCUNE;
|
||||
for (int i = 0; i < 7; i++) {
|
||||
now += 50;
|
||||
for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false)) {
|
||||
if (v.applicable().ordinal() > pire.ordinal()) pire = v.applicable();
|
||||
}
|
||||
}
|
||||
return pire;
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteEnforceSetbackPuisExpulsion() {
|
||||
cfg.mode(Controle.VELOCITE, Mode.ENFORCE);
|
||||
cfg.setbacksAvantExpulsion = 0; // isole les seuils de velocite (C5 teste ailleurs)
|
||||
boolean setback = false;
|
||||
Sanction s = Sanction.AUCUNE;
|
||||
for (int k = 0; k < 20 && s != Sanction.EXPULSION; k++) {
|
||||
s = recul();
|
||||
if (s == Sanction.SETBACK) setback = true;
|
||||
}
|
||||
assertTrue(setback, "retour en arriere avant l'expulsion");
|
||||
assertEquals(Sanction.EXPULSION, s);
|
||||
}
|
||||
|
||||
@Test
|
||||
void velociteEnObserveJamaisDeSanction() {
|
||||
for (int k = 0; k < 20; k++) assertTrue(recul().ordinal() <= Sanction.ALERTE.ordinal());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
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.5, P2.12 : Spider / WallClimb. Pas de nouveau contrôle : la montée le long d'un mur hors échelle, lianes ou
|
||||
* échafaudage (milieu spécial) viole la gravité, que le contrôle vol (en ENFORCE en production) mesure déjà. Ces tests
|
||||
* le vérifient pour les vitesses de montée des modules courants (0,2 et 0,12 bloc/tick) et la variante qui alterne.
|
||||
*/
|
||||
class SpiderP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
|
||||
private double vol(java.util.function.IntFunction<EtatMouvement> f, int n) {
|
||||
Moteur m = new Moteur(cfg);
|
||||
UUID j = UUID.randomUUID();
|
||||
double pts = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (Verdict v : m.mouvement(j, i * 50L, EtatJoueur.normal(), f.apply(i))) {
|
||||
if (v.controle() == Controle.VOL) pts += v.points();
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
private static EtatMouvement montee(double dy, boolean milieu) {
|
||||
return new EtatMouvement(0.0, dy, 1, false, false, false, false, false, 0, 0, milieu, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
void monteeContreUnMurVueParVol() {
|
||||
assertTrue(vol(i -> montee(0.2, false), 30) > 0);
|
||||
assertTrue(vol(i -> montee(0.12, false), 30) > 0);
|
||||
assertTrue(vol(i -> montee(i % 2 == 0 ? 0.3 : 0.0, false), 40) > 0, "montée par à-coups");
|
||||
}
|
||||
|
||||
@Test
|
||||
void echelleNonComptee() {
|
||||
assertEquals(0, vol(i -> montee(0.1176, true), 60), 1e-9); // vitesse vanilla à l'échelle, milieu spécial
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P1.9 : step (marche trop haute en un tick, au sol avant et après). */
|
||||
class StepP1Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
/** Joueur vanilla : max(step_height 0,6, saut 0,42). */
|
||||
private static final double VANILLA = 0.6;
|
||||
|
||||
private static EtatMouvement sol(double dy, boolean solServeur) {
|
||||
return new EtatMouvement(0.2, dy, 1, solServeur, solServeur, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
private double step(Moteur m, double hauteur, EtatMouvement... suite) {
|
||||
double total = 0;
|
||||
long t = 0;
|
||||
for (EtatMouvement e : suite) {
|
||||
t += 50;
|
||||
for (Verdict v : m.mouvement(joueur, t, EtatJoueur.normal(), e, hauteur)) {
|
||||
if (v.controle() == Controle.STEP) total += v.points();
|
||||
}
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.STEP));
|
||||
assertEquals(2, Controle.STEP.fiabilite(), "plafond faible du score");
|
||||
assertEquals(Controle.STEP, Controle.parse("step"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void unBlocEnUnTickAuSolEstVu() {
|
||||
assertTrue(step(new Moteur(cfg), VANILLA, sol(0, true), sol(1.0, true)) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void dallesEscaliersEtLitsNeComptentPas() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
assertEquals(0, step(m, VANILLA, sol(0, true), sol(0.5, true), sol(0.5, true), sol(0.5625, true), sol(0.6, true)), 1e-9);
|
||||
assertEquals(0, step(m, VANILLA, sol(0, true), sol(0.69, true)), 1e-9, "dans la marge");
|
||||
}
|
||||
|
||||
@Test
|
||||
void attributStepOuSautAmelioreReleveLeSeuil() {
|
||||
assertEquals(0, step(new Moteur(cfg), 1.0, sol(0, true), sol(1.0, true)), 1e-9, "attribut step_height 1,0");
|
||||
// Saut amélioré V : 0,42 + 0,5 = 0,92 en un tick ; atterrir sur un bloc de 0,9 n'est pas un step.
|
||||
assertEquals(0, step(new Moteur(cfg), 0.92, sol(0, true), sol(0.9, true)), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sautOrdinaireEtAirPasMesures() {
|
||||
// Saut : en l'air après le premier tick (sol serveur faux), puis retombée sur un bloc.
|
||||
Moteur m = new Moteur(cfg);
|
||||
assertEquals(0, step(m, VANILLA, sol(0, true), sol(0.42, false), sol(0.33, false), sol(0.25, true)), 1e-9);
|
||||
// Pas de sol au paquet précédent : rien
|
||||
assertEquals(0, step(new Moteur(cfg), VANILLA, sol(0, false), sol(1.0, true)), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void plusieursTicksMilieuSpecialOuHauteurInconnuePasMesures() {
|
||||
EtatMouvement deuxTicks = new EtatMouvement(0.4, 1.0, 2, true, true, false, false, false, 0, 0, false, false);
|
||||
assertEquals(0, step(new Moteur(cfg), VANILLA, sol(0, true), deuxTicks), 1e-9);
|
||||
EtatMouvement echelle = new EtatMouvement(0, 1.0, 1, true, true, false, false, false, 0, 0, true, false);
|
||||
assertEquals(0, step(new Moteur(cfg), VANILLA, sol(0, true), echelle), 1e-9);
|
||||
assertEquals(0, step(new Moteur(cfg), Double.NaN, sol(0, true), sol(1.0, true)), 1e-9, "piston proche");
|
||||
// L'ancienne signature (traces, rejeu) ne mesure jamais step.
|
||||
Moteur m = new Moteur(cfg);
|
||||
m.mouvement(joueur, 50, EtatJoueur.normal(), sol(0, true));
|
||||
List<Verdict> v = m.mouvement(joueur, 100, EtatJoueur.normal(), sol(1.0, true));
|
||||
assertTrue(v.stream().noneMatch(x -> x.controle() == Controle.STEP));
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptionCoupeEtRemetLaReferenceAZero() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
m.mouvement(joueur, 50, EtatJoueur.normal(), sol(0, true), VANILLA);
|
||||
EtatJoueur teleport = EtatJoueur.builder().ticksDepuisTeleport(1).build();
|
||||
assertTrue(m.mouvement(joueur, 100, teleport, sol(1.0, true), VANILLA).isEmpty());
|
||||
// Juste après l'exemption : pas de référence, le gain n'est pas compté.
|
||||
List<Verdict> v = m.mouvement(joueur, 150, EtatJoueur.normal(), sol(1.0, true), VANILLA);
|
||||
assertTrue(v.stream().noneMatch(x -> x.controle() == Controle.STEP));
|
||||
}
|
||||
|
||||
@Test
|
||||
void enObserveJamaisDeSanction() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
Sanction pire = Sanction.AUCUNE;
|
||||
long t = 0;
|
||||
for (int i = 0; i < 40; i++) {
|
||||
t += 50;
|
||||
m.mouvement(joueur, t, EtatJoueur.normal(), sol(0, true), VANILLA);
|
||||
t += 50;
|
||||
Sanction s = Verdict.pire(m.mouvement(joueur, t, EtatJoueur.normal(), sol(1.2, true), VANILLA));
|
||||
if (s.ordinal() > pire.ordinal()) pire = s;
|
||||
}
|
||||
assertTrue(pire.ordinal() <= Sanction.ALERTE.ordinal(), "OBSERVE : au plus une alerte, " + pire);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,294 @@
|
||||
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.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.io.TempDir;
|
||||
|
||||
/** Score de suspicion 0-100 (0.4.0) : contributions, plafonds, décroissance, diversité, paliers, historique. */
|
||||
class SuspicionTest {
|
||||
|
||||
private static final long MIN = 60_000L;
|
||||
|
||||
private GardeConfig cfg;
|
||||
private Suspicion s;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
s = new Suspicion(cfg);
|
||||
}
|
||||
|
||||
@Test
|
||||
void valeursParDefautDeLaConception() {
|
||||
assertEquals(25, cfg.suspicionSeuilSurveiller);
|
||||
assertEquals(50, cfg.suspicionSeuilSuspect);
|
||||
assertEquals(75, cfg.suspicionSeuilFort);
|
||||
assertEquals(10, cfg.suspicionDemiVieMinutes);
|
||||
assertEquals(50, cfg.suspicionPlafondFiable);
|
||||
assertEquals(30, cfg.suspicionPlafondMoyen);
|
||||
assertEquals(15, cfg.suspicionPlafondFaible);
|
||||
assertEquals(3, cfg.suspicionDiversiteControles);
|
||||
assertEquals(10, cfg.suspicionDiversiteFenetreMinutes);
|
||||
assertEquals(7, cfg.suspicionHistoriqueJours);
|
||||
assertTrue(cfg.suspicionActive);
|
||||
}
|
||||
|
||||
@Test
|
||||
void fiabiliteDeChaqueControle() {
|
||||
List<Controle> fiables = List.of(Controle.VOL, Controle.VITESSE, Controle.NO_FALL, Controle.PORTEE,
|
||||
Controle.HITBOX, Controle.REGULARITE, Controle.AUTO_TOTEM);
|
||||
List<Controle> moyens = List.of(Controle.COUPS_HORS_BOITE, Controle.KILLAURA_ANGLE, Controle.KILLAURA_CIBLES,
|
||||
Controle.CADENCE);
|
||||
for (Controle c : Controle.values()) {
|
||||
double attendu = fiables.contains(c) ? 50 : moyens.contains(c) ? 30 : 15;
|
||||
assertEquals(attendu, Suspicion.plafond(c, cfg), c.id());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void contributionNormaliseeParLeSeuilDExpulsionEtPlafonnee() {
|
||||
s.noter(Controle.VOL, 10, false, 0); // moitié du seuil d'expulsion (20)
|
||||
assertEquals(25, s.score(0), 1e-9);
|
||||
s.noter(Controle.VOL, 20, false, 0);
|
||||
assertEquals(50, s.score(0), 1e-9);
|
||||
s.noter(Controle.VOL, 5000, false, 0); // au-delà : plafonné
|
||||
assertEquals(50, s.score(0), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void plafondsParFiabilite() {
|
||||
s.noter(Controle.CADENCE, 999, false, 0);
|
||||
assertEquals(30, s.score(0), 1e-9);
|
||||
Suspicion t = new Suspicion(cfg);
|
||||
t.noter(Controle.TIMER, 1331, false, 0); // le timer a atteint 1331 en jeu
|
||||
assertEquals(15, t.score(0), 1e-9);
|
||||
assertEquals(Suspicion.Niveau.NORMAL, t.niveau(0), "un contrôle à faux positifs ne rend jamais suspect seul");
|
||||
for (Controle c : List.of(Controle.ROTATION, Controle.ATTAQUE_IMPOSSIBLE, Controle.VEHICULE_VITESSE,
|
||||
Controle.VEHICULE_VOL, Controle.TIMER)) {
|
||||
t.noter(c, 999, false, 0);
|
||||
}
|
||||
// 5 contrôles faibles saturés = 75 : possible, mais seulement par accumulation (et par diversité, voir plus bas)
|
||||
assertEquals(75, t.score(0), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sommePlafonneeACent() {
|
||||
for (Controle c : List.of(Controle.VOL, Controle.VITESSE, Controle.NO_FALL, Controle.PORTEE)) {
|
||||
s.noter(c, 20, false, 0);
|
||||
}
|
||||
assertEquals(100, s.score(0), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void demiVieDeDixMinutes() {
|
||||
s.noter(Controle.VITESSE, 20, false, 0);
|
||||
assertEquals(50, s.score(0), 1e-9);
|
||||
assertEquals(25, s.score(10 * MIN), 1e-6);
|
||||
assertEquals(12.5, s.score(20 * MIN), 1e-6);
|
||||
assertEquals(Suspicion.Niveau.A_SURVEILLER, s.niveau(10 * MIN));
|
||||
assertEquals(Suspicion.Niveau.NORMAL, s.niveau(11 * MIN));
|
||||
}
|
||||
|
||||
@Test
|
||||
void ledecompteNeCompteQueLePicEtNonLeVlQuiRetombe() {
|
||||
// Le VL retombe à 0 (setback ou 0,5/s) mais le pic reste dans le score jusqu'à décroissance.
|
||||
s.noter(Controle.VOL, 20, true, 0);
|
||||
s.noter(Controle.VOL, 1, false, 30_000); // VL reparti de zéro : le pic de 20 ne baisse pas
|
||||
double apres = s.score(30_000);
|
||||
assertTrue(apres > 45 && apres <= 50, "pic gardé, un peu décru : " + apres);
|
||||
}
|
||||
|
||||
@Test
|
||||
void diversiteTroisControlesAuPalierSetbackDonneSuspectFort() {
|
||||
// Trois contrôles faibles, chacun à moitié : 3 x 7,5 = 22,5 (normal) sans la règle de diversité.
|
||||
s.noter(Controle.TIMER, 10, true, 0);
|
||||
s.noter(Controle.ROTATION, 10, true, 1 * MIN);
|
||||
assertTrue(s.score(1 * MIN) < 25);
|
||||
assertEquals(Suspicion.Niveau.NORMAL, s.niveau(1 * MIN));
|
||||
s.noter(Controle.VEHICULE_VITESSE, 10, true, 2 * MIN);
|
||||
assertTrue(s.score(2 * MIN) >= 75, "diversité : au moins suspect fort, score " + s.score(2 * MIN));
|
||||
assertEquals(Suspicion.Niveau.SUSPECT_FORT, s.niveau(2 * MIN));
|
||||
assertEquals(3, s.controlesDivers(2 * MIN));
|
||||
}
|
||||
|
||||
@Test
|
||||
void diversiteDeuxControlesNeSuffitPasEtLaFenetreExpire() {
|
||||
s.noter(Controle.TIMER, 10, true, 0);
|
||||
s.noter(Controle.ROTATION, 10, true, 1 * MIN);
|
||||
assertFalse(s.score(1 * MIN) >= 75);
|
||||
// Le troisième arrive après 10 minutes : le premier est sorti de la fenêtre.
|
||||
s.noter(Controle.VEHICULE_VITESSE, 10, true, 10 * MIN + 1);
|
||||
assertEquals(2, s.controlesDivers(10 * MIN + 1));
|
||||
assertTrue(s.score(10 * MIN + 1) < 75);
|
||||
}
|
||||
|
||||
@Test
|
||||
void diversiteExigeLePalierSetback() {
|
||||
s.noter(Controle.TIMER, 10, true, 0);
|
||||
s.noter(Controle.ROTATION, 10, true, 0);
|
||||
s.noter(Controle.VEHICULE_VITESSE, 4, false, 0); // seulement journal / alerte
|
||||
assertEquals(2, s.controlesDivers(0));
|
||||
assertTrue(s.score(0) < 75);
|
||||
}
|
||||
|
||||
@Test
|
||||
void diversiteCoupeeParLaConfiguration() {
|
||||
cfg.suspicionDiversiteControles = 0;
|
||||
s.noter(Controle.TIMER, 10, true, 0);
|
||||
s.noter(Controle.ROTATION, 10, true, 0);
|
||||
s.noter(Controle.VEHICULE_VITESSE, 10, true, 0);
|
||||
assertTrue(s.score(0) < 75);
|
||||
}
|
||||
|
||||
@Test
|
||||
void transitionsUneSeuleFoisParPalierEtReArmement() {
|
||||
s.noter(Controle.VOL, 10, false, 0); // 25
|
||||
assertEquals(Suspicion.Niveau.A_SURVEILLER, s.prendreTransition());
|
||||
assertNull(s.prendreTransition(), "consommée");
|
||||
s.noter(Controle.VOL, 10.5, false, 1); // encore 26 : même palier
|
||||
assertNull(s.prendreTransition());
|
||||
s.noter(Controle.VITESSE, 10, false, 2); // 50
|
||||
assertEquals(Suspicion.Niveau.SUSPECT, s.prendreTransition());
|
||||
s.noter(Controle.NO_FALL, 10, false, 3); // 75
|
||||
assertEquals(Suspicion.Niveau.SUSPECT_FORT, s.prendreTransition());
|
||||
s.noter(Controle.NO_FALL, 20, false, 4);
|
||||
assertNull(s.prendreTransition(), "déjà notifié");
|
||||
|
||||
// Longtemps après, le score est retombé sous 25 : le palier peut de nouveau être franchi.
|
||||
s.noter(Controle.TIMER, 1, false, 60 * MIN);
|
||||
s.prendreTransition();
|
||||
s.noter(Controle.VOL, 20, false, 60 * MIN + 1);
|
||||
assertEquals(Suspicion.Niveau.SUSPECT, s.prendreTransition());
|
||||
}
|
||||
|
||||
@Test
|
||||
void passageDirectAuFortParDiversiteNEmetQueLeFort() {
|
||||
s.noter(Controle.TIMER, 10, true, 0);
|
||||
s.noter(Controle.ROTATION, 10, true, 0);
|
||||
s.noter(Controle.VEHICULE_VITESSE, 10, true, 0);
|
||||
assertEquals(Suspicion.Niveau.SUSPECT_FORT, s.prendreTransition());
|
||||
assertNull(s.prendreTransition());
|
||||
}
|
||||
|
||||
@Test
|
||||
void desactiveParLaConfiguration() {
|
||||
cfg.suspicionActive = false;
|
||||
s.noter(Controle.VOL, 20, true, 0);
|
||||
assertEquals(0, s.score(0));
|
||||
assertNull(s.prendreTransition());
|
||||
}
|
||||
|
||||
@Test
|
||||
void horlogeQuiRecule_PasDeScoreNegatifNiDeRemontee() {
|
||||
s.noter(Controle.VOL, 20, false, 10 * MIN);
|
||||
double avant = s.score(10 * MIN);
|
||||
s.noter(Controle.VITESSE, 0, false, 5 * MIN); // horloge en arrière : ignorée
|
||||
assertEquals(avant, s.score(10 * MIN), 1e-9);
|
||||
}
|
||||
|
||||
// --- Dans le moteur : contrôles en OBSERVE inclus, aucune sanction, historique ---
|
||||
|
||||
private static void tapesRegulieres(Moteur m, UUID id, int n, long[] t, java.util.List<Verdict> sortie) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
t[0] += 50;
|
||||
sortie.addAll(m.attaque(id, t[0], EtatJoueur.normal(), -1, 1, true));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void controlesEnObserveComptentMaisNeSanctionnentPas() {
|
||||
GardeConfig c = new GardeConfig();
|
||||
c.mode(Controle.REGULARITE, Mode.OBSERVE);
|
||||
Moteur m = new Moteur(c);
|
||||
long[] horloge = {0};
|
||||
m.horloge(() -> horloge[0]);
|
||||
UUID id = UUID.randomUUID();
|
||||
java.util.List<Verdict> vs = new java.util.ArrayList<>();
|
||||
tapesRegulieres(m, id, 60, horloge, vs);
|
||||
assertTrue(vs.stream().allMatch(v -> v.applicable().ordinal() <= Sanction.ALERTE.ordinal()),
|
||||
"OBSERVE ne dépasse jamais l'alerte");
|
||||
assertEquals(50, m.scoreSuspicion(id), 1e-6, "la régularité en OBSERVE a atteint son plafond de 50");
|
||||
Moteur.AlerteSuspicion a = m.alerteSuspicion(id, 1_000_000L);
|
||||
assertNotNull(a);
|
||||
assertEquals(Suspicion.Niveau.SUSPECT, a.niveau());
|
||||
}
|
||||
|
||||
@Test
|
||||
void alerteEnregistreLIncidentDansLHistoriqueSeulementDesSuspect() {
|
||||
GardeConfig c = new GardeConfig();
|
||||
Moteur m = new Moteur(c);
|
||||
long[] horloge = {0};
|
||||
m.horloge(() -> horloge[0]);
|
||||
UUID id = UUID.randomUUID();
|
||||
// Cadence (moyen, 30 max) : reste « à surveiller » ; pas d'incident dans l'historique.
|
||||
m.suivi(id).suspicion.noter(Controle.CADENCE, 20, false, 0);
|
||||
Moteur.AlerteSuspicion a = m.alerteSuspicion(id, 5_000L);
|
||||
assertEquals(Suspicion.Niveau.A_SURVEILLER, a.niveau());
|
||||
assertEquals(0, a.incidents());
|
||||
m.suivi(id).suspicion.noter(Controle.REGULARITE, 8, false, 0);
|
||||
a = m.alerteSuspicion(id, 6_000L);
|
||||
assertEquals(Suspicion.Niveau.SUSPECT, a.niveau());
|
||||
assertEquals(1, a.incidents());
|
||||
assertTrue(a.controles().contains("regularite:20"), a.controles());
|
||||
assertNull(m.alerteSuspicion(id, 7_000L));
|
||||
}
|
||||
|
||||
@Test
|
||||
void scoreRepartDeZeroApresReconnexion() {
|
||||
Moteur m = new Moteur(new GardeConfig());
|
||||
m.horloge(() -> 0L);
|
||||
UUID id = UUID.randomUUID();
|
||||
m.suivi(id).suspicion.noter(Controle.VOL, 20, false, 0);
|
||||
assertTrue(m.scoreSuspicion(id) > 0);
|
||||
m.retirer(id);
|
||||
assertEquals(0, m.scoreSuspicion(id));
|
||||
}
|
||||
|
||||
// --- Historique persistant ---
|
||||
|
||||
@Test
|
||||
void historiquePersisteEtOublieLesVieuxIncidents(@TempDir Path dir) throws IOException {
|
||||
Path f = dir.resolve("sous-dossier").resolve("incidents.csv");
|
||||
long jour = 86_400_000L;
|
||||
long maintenant = 100 * jour;
|
||||
UUID a = UUID.randomUUID();
|
||||
UUID b = UUID.randomUUID();
|
||||
HistoriqueSuspicion h = new HistoriqueSuspicion();
|
||||
h.ouvrir(f, maintenant, 7);
|
||||
h.enregistrer(a, maintenant - 8 * jour, Suspicion.Niveau.SUSPECT, 55, "vol:50");
|
||||
h.enregistrer(a, maintenant - 3 * jour, Suspicion.Niveau.SUSPECT_FORT, 80, "vol:50;vitesse:30"); // ';' neutralisé
|
||||
h.enregistrer(b, maintenant - 1 * jour, Suspicion.Niveau.SUSPECT, 50, "regularite:50");
|
||||
assertEquals(1, h.incidents(a, maintenant, 7), "celui de 8 jours est hors fenêtre même en mémoire");
|
||||
|
||||
// Redémarrage : relecture du fichier, le vieil incident est écarté et le fichier réécrit compact.
|
||||
Files.writeString(f, "ligne illisible\n", StandardCharsets.UTF_8, java.nio.file.StandardOpenOption.APPEND);
|
||||
HistoriqueSuspicion h2 = new HistoriqueSuspicion();
|
||||
h2.ouvrir(f, maintenant, 7);
|
||||
assertEquals(1, h2.incidents(a, maintenant, 7));
|
||||
assertEquals(1, h2.incidents(b, maintenant, 7));
|
||||
assertEquals(0, h2.incidents(UUID.randomUUID(), maintenant, 7));
|
||||
assertEquals(2, Files.readAllLines(f).size(), "fichier compact : plus de vieille ligne ni de ligne illisible");
|
||||
// Plus tard, l'incident de a sort aussi de la fenêtre.
|
||||
assertEquals(0, h2.incidents(a, maintenant + 5 * jour, 7));
|
||||
}
|
||||
|
||||
@Test
|
||||
void historiqueSansFichierResteEnMemoire() {
|
||||
HistoriqueSuspicion h = new HistoriqueSuspicion();
|
||||
UUID a = UUID.randomUUID();
|
||||
h.enregistrer(a, 1000, Suspicion.Niveau.SUSPECT, 50, "x");
|
||||
assertEquals(1, h.incidents(a, 2000, 7));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P1.12 : timer, solde actif par défaut (20), dette réglable, connexion ignorée. */
|
||||
class TimerP1Test {
|
||||
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
private static double points(List<Verdict> vs) {
|
||||
return vs.stream().filter(v -> v.controle() == Controle.TIMER).mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
|
||||
private static double regulier(GardeConfig cfg, UUID j, long intervalleMs, int secondes, EtatJoueur e) {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double total = 0;
|
||||
for (long t = 0; t < secondes * 1000L; t += intervalleMs) total += points(m.paquetMouvement(j, 10_000 + t, e));
|
||||
return total;
|
||||
}
|
||||
|
||||
/** 1 s sans paquet puis 20 paquets d'un coup, puis 2 s normales, répété. */
|
||||
private static double lags(GardeConfig cfg, UUID j) {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double total = 0;
|
||||
long t = 10_000;
|
||||
for (int r = 0; r < 20; r++) {
|
||||
t += 1000;
|
||||
for (int i = 0; i < 20; i++) total += points(m.paquetMouvement(j, t, EtatJoueur.normal()));
|
||||
for (int i = 0; i < 40; i++) {
|
||||
t += 50;
|
||||
total += points(m.paquetMouvement(j, t, EtatJoueur.normal()));
|
||||
}
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void soldeActifParDefaut() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
assertEquals(20, cfg.timerSoldeMax);
|
||||
assertEquals(40, cfg.timerDetteMax);
|
||||
assertTrue(regulier(cfg, joueur, 46, 30, EtatJoueur.normal()) > 0, "timer 1,09 vu sans réglage");
|
||||
assertEquals(0, regulier(cfg, joueur, 50, 60, EtatJoueur.normal()), 1e-9, "20 paquets/s : rien");
|
||||
assertEquals(0, lags(cfg, joueur), 1e-9, "rattrapage après lag : rien");
|
||||
}
|
||||
|
||||
/** 2 s sans paquet puis les 40 paquets en retard d'un coup (rattrapage exact), puis 2 s normales, répété. */
|
||||
private static double rattrapages(GardeConfig cfg, UUID j) {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double total = 0;
|
||||
long t = 10_000;
|
||||
for (int i = 0; i < 40; i++, t += 50) total += points(m.paquetMouvement(j, t, EtatJoueur.normal())); // amorce
|
||||
for (int r = 0; r < 10; r++) {
|
||||
t += 2000;
|
||||
for (int i = 0; i < 40; i++) total += points(m.paquetMouvement(j, t, EtatJoueur.normal()));
|
||||
for (int i = 0; i < 40; i++) {
|
||||
t += 50;
|
||||
total += points(m.paquetMouvement(j, t, EtatJoueur.normal()));
|
||||
}
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void detteReglableLeRattrapageExactNeCompteQuAvecUnCredit() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
assertEquals(0, rattrapages(cfg, joueur), 1e-9, "dette 40 : rattrapage exact de 2 s, rien");
|
||||
cfg.timerDetteMax = 0; // aucun crédit : la rafale qui suit le trou fait monter le solde
|
||||
assertTrue(rattrapages(cfg, joueur) > 0, "la dette est bien le réglage utilisé");
|
||||
}
|
||||
|
||||
@Test
|
||||
void connexionRecenteIgnoree() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
EtatJoueur connexion = EtatJoueur.builder().connexionRecente(true).build();
|
||||
assertEquals(0, regulier(cfg, joueur, 20, 10, connexion), 1e-9, "50 paquets/s pendant le chargement : rien");
|
||||
assertTrue(regulier(cfg, joueur, 20, 10, EtatJoueur.normal()) > 0, "témoin hors grâce");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
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.5, P2.7 : auto-totem-regulier (distribution des délais de remise). */
|
||||
class TotemRegulierP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** Une série d'éclatements, chaque totem remis après le délai donné (ms, multiple de 50). */
|
||||
private double points(Moteur m, Controle c, long... delais) {
|
||||
double pts = 0;
|
||||
long t = 1_000_000;
|
||||
m.suivi(joueur);
|
||||
for (long d : delais) {
|
||||
m.totemEclate(joueur, t, false);
|
||||
for (long x = 50; x <= d; x += 50) {
|
||||
for (Verdict v : m.totemEnMain(joueur, t + x, EtatJoueur.normal(), x >= d)) {
|
||||
if (v.controle() == c) pts += v.points();
|
||||
}
|
||||
}
|
||||
t += 60_000;
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.AUTO_TOTEM_REGULIER));
|
||||
assertEquals(Controle.AUTO_TOTEM_REGULIER, Controle.parse("auto-totem-regulier"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void delaiFixeAuDessusDuSeuilVu() {
|
||||
// 250 ms à chaque fois : passe auto-totem (150 + ping 30) mais pas la distribution.
|
||||
Moteur m = new Moteur(cfg);
|
||||
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM, 250, 250, 250, 250, 250), 1e-9);
|
||||
assertTrue(points(m, Controle.AUTO_TOTEM_REGULIER, 250, 250, 250, 250, 250) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void humainVarieJamaisVu() {
|
||||
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM_REGULIER, 250, 400, 300, 650, 350, 900, 450), 1e-9);
|
||||
// rapide mais variable : écart type > 30 ms
|
||||
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM_REGULIER, 200, 250, 150, 250, 200), 1e-9);
|
||||
// régulier mais lent (≥ 300 ms) : pas compté
|
||||
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM_REGULIER, 350, 350, 350, 350, 350), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void moinsDeCinqEchantillonsRien() {
|
||||
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM_REGULIER, 250, 250, 250, 250), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void marcheMemeSiAutoTotemEstCoupe() {
|
||||
cfg.mode(Controle.AUTO_TOTEM, Mode.OFF);
|
||||
Moteur m = new Moteur(cfg);
|
||||
assertTrue(points(m, Controle.AUTO_TOTEM_REGULIER, 250, 250, 250, 250, 250) > 0);
|
||||
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM, 50, 50, 50), 1e-9, "auto-totem coupé : aucun verdict");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
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.5, P3.2 : tower (pilier monté plus vite que le saut vanilla). */
|
||||
class TowerP3Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** n poses en pilier (x = 10, z = 20), une toutes les {@code pas} ticks ; renvoie le nombre de verdicts. */
|
||||
private int pilier(Moteur m, EtatJoueur etat, int n, int pas) {
|
||||
int verdicts = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
long t = 100 + (long) i * pas;
|
||||
int by = 64 + i;
|
||||
for (Verdict v : m.poseTower(joueur, t * 50L, t, etat, 10, by, 20, 10.5, by + 1.1, 20.5, 0.2)) {
|
||||
if (v.controle() == Controle.TOWER) verdicts++;
|
||||
}
|
||||
}
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.TOWER));
|
||||
assertEquals(Controle.TOWER, Controle.parse("tower"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void towerToutesLesTroisTicksVuEtChaquePoseCompte() {
|
||||
// 5 intervalles courts pour armer, puis chaque pose rapide donne un verdict (annulable en ENFORCE).
|
||||
assertEquals(20 - 1 - cfg.towerSerie + 1, pilier(new Moteur(cfg), EtatJoueur.normal(), 20, 3));
|
||||
}
|
||||
|
||||
@Test
|
||||
void pilierVanillaJamaisVu() {
|
||||
assertEquals(0, pilier(new Moteur(cfg), EtatJoueur.normal(), 100, 9));
|
||||
assertEquals(0, pilier(new Moteur(cfg), EtatJoueur.normal(), 100, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
void poseHorsColonneOuSansMonteeNonMesuree() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
int n = 0;
|
||||
for (int i = 0; i < 30; i++) {
|
||||
long t = 100 + i * 2L;
|
||||
// pont horizontal : bloc devant, joueur qui ne monte pas
|
||||
n += m.poseTower(joueur, t * 50L, t, EtatJoueur.normal(), 10 + i, 63, 20, 10.5 + i, 64, 20.5, 0).size();
|
||||
}
|
||||
assertEquals(0, n);
|
||||
}
|
||||
|
||||
@Test
|
||||
void levitationEtCreatifExemptes() {
|
||||
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
|
||||
EtatJoueur.builder().levitation(true).build(), EtatJoueur.builder().peutVoler(true).build()}) {
|
||||
assertEquals(0, pilier(new Moteur(cfg), e, 30, 2), e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void enforceChaquePoseRapideAtteintLePalier() {
|
||||
cfg.mode(Controle.TOWER, Mode.ENFORCE);
|
||||
Moteur m = new Moteur(cfg);
|
||||
boolean setback = false;
|
||||
for (int i = 0; i < 40; i++) {
|
||||
long t = 100 + i * 2L;
|
||||
int by = 64 + i;
|
||||
for (Verdict v : m.poseTower(joueur, t * 50L, t, EtatJoueur.normal(), 10, by, 20, 10.5, by + 1.1, 20.5, 0.2)) {
|
||||
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) setback = true;
|
||||
}
|
||||
}
|
||||
assertTrue(setback);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
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.5, P2.10 : x-ray statistique (alerte seulement). */
|
||||
class XrayP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** n blocs cassés à y = -50 ; tous les k blocs un rare, exposé ou non. */
|
||||
private double miner(Moteur m, EtatJoueur e, int n, int k, boolean expose) {
|
||||
double pts = 0;
|
||||
for (int i = 1; i <= n; i++) {
|
||||
boolean rare = i % k == 0;
|
||||
for (Verdict v : m.casseXray(joueur, i * 1000L, e, -50, rare, expose)) {
|
||||
pts += v.points();
|
||||
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal());
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.XRAY));
|
||||
}
|
||||
|
||||
@Test
|
||||
void mineraisCachesEnSerieAlerte() {
|
||||
// 1 rare caché tous les 10 blocs (10 %) : alerte au 12e.
|
||||
assertTrue(miner(new Moteur(cfg), EtatJoueur.normal(), 200, 10, false) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void minageHonneteJamaisAlerte() {
|
||||
// Minerais trouvés dans les parois (exposés), même à 10 %.
|
||||
assertEquals(0, miner(new Moteur(cfg), EtatJoueur.normal(), 2000, 10, true), 1e-9);
|
||||
// Minerais cachés mais rares (1 %, minage en branche).
|
||||
assertEquals(0, miner(new Moteur(cfg), EtatJoueur.normal(), 2000, 100, false), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void unFilonChanceuxNeSuffitPas() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 8; i++) pts += m.casseXray(joueur, i, EtatJoueur.normal(), -50, true, false).stream().mapToDouble(Verdict::points).sum();
|
||||
assertEquals(0, pts, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void enSurfaceEtCreatifRien() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 100; i++) pts += m.casseXray(joueur, i, EtatJoueur.normal(), 60, true, false).size();
|
||||
assertEquals(0, pts, 1e-9);
|
||||
assertEquals(0, miner(new Moteur(cfg), EtatJoueur.builder().creatif(true).build(), 200, 10, false), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void jamaisDeSanctionMemeEnEnforce() {
|
||||
cfg.mode(Controle.XRAY, Mode.ENFORCE);
|
||||
cfg.seuilAlerte = 0.5;
|
||||
cfg.seuilSetback = 1;
|
||||
cfg.seuilExpulsion = 1.5;
|
||||
assertTrue(miner(new Moteur(cfg), EtatJoueur.normal(), 400, 10, false) > 0); // l'assertion ≤ ALERTE est dans miner
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur