Comparer les révisions
30
Révisions
Aucun fichier ne correspond à votre recherche
@@ -7,3 +7,4 @@ run/
|
|||||||
|
|
||||||
# sauvegardes avant modification
|
# sauvegardes avant modification
|
||||||
*.avant-*
|
*.avant-*
|
||||||
|
livrable/
|
||||||
@@ -0,0 +1,56 @@
|
|||||||
|
# Journal des versions
|
||||||
|
|
||||||
|
## 0.4.0 (non publiée, branche feat/suspicion-score, dérivée de release/0.3.1 = jar déployé)
|
||||||
|
|
||||||
|
Testé hors jeu seulement (JUnit) ; rien n'a été essayé sur un serveur Minecraft. Aucun mode existant n'est modifié.
|
||||||
|
- 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)
|
||||||
|
|
||||||
|
Version de correctifs. Les modes OBSERVE / ENFORCE de chaque contrôle sont inchangés (aucun défaut de mode modifié).
|
||||||
|
Toutes les options nouvelles sont désactivées par défaut : sans changement de config, seuls les correctifs « actifs
|
||||||
|
sans option » ci-dessous changent le comportement. Tout est testé hors jeu seulement ; rien n'a été essayé en jeu.
|
||||||
|
|
||||||
|
### Vol et élytres (incident VOL du 15/10, branche fix/vol-elytres)
|
||||||
|
- C1 : grâce de fin de plané en élytres bornée (`graceFinElytresTicks` = 50 ticks, finit à l'atterrissage).
|
||||||
|
- C2 : après un setback, vol, vitesse et points VOL / VITESSE remis à zéro.
|
||||||
|
- C3 : position de retour du setback = dernière position au sol (ou milieu spécial : eau, échelle).
|
||||||
|
- C4 : expulsion à usage unique (une ligne EXPULSE), contrôles de nouveau actifs après reconnexion. Jamais de bannissement.
|
||||||
|
- C5 : escalade : expulsion seulement après 4 setbacks en 60 s.
|
||||||
|
|
||||||
|
### Coups-hors-boite, portée, C10, C13, C15 (branche fix/hitbox-c10-c13-c15)
|
||||||
|
- Le ping élevé (> 500 ms) n'exempte plus le coup ; fenêtre bornée à `seriePingMaxMs`.
|
||||||
|
- Œil / regard suivants bornés (un tick, 90°) ; éviction de la cible non joueur la plus ancienne quand la table est pleine.
|
||||||
|
- Fenêtre de ping fondée sur le plancher des 2 dernières minutes (`PingPlancher`, `seriePingMargeMs` = 50 ms).
|
||||||
|
- Options (désactivées par défaut) : `volFenetreGlissante` (C10, sauts en l'air espacés), `vitesseMoyenne` (C15, bhop / sol),
|
||||||
|
`timerSoldeMax` (C15, timer ; 0 = désactivé, essai conseillé 20).
|
||||||
|
- Seuils de `portee` / `hitbox` non resserrés.
|
||||||
|
|
||||||
|
### Rafales réseau (branche fix/rafales-reseau)
|
||||||
|
- Faux positif VOL sur chute reçue en rafales (3, 0, 0) corrigé : ticks dus bornés (`AVANCE_MAX` = 4). Actif sans option ;
|
||||||
|
la chute ralentie par triche reste détectée.
|
||||||
|
|
||||||
|
### Constats hauts (branche fix/constats-hauts)
|
||||||
|
- Options (désactivées par défaut) : `elytresExemptionStricte` (C7), `combatMesureEnVehicule` (C8),
|
||||||
|
`empilementSeulementEnMouvement` (C18, minecarts à contenu immobiles non cassés).
|
||||||
|
- C27 (modes vol / portée / hitbox en production) : décision de config, non traitée par le code.
|
||||||
|
|
||||||
|
### Tests du câblage Minecraft (branche test/cablage-minecraft)
|
||||||
|
- Refactoring sans changement de comportement : classe `Cablage` (entrées d'événements, sanctions, C7).
|
||||||
|
- `CablageTest` et `CablageMinecraftTest` ajoutés.
|
||||||
|
- Défaut connu non corrigé : `Garde.apresVehicule` ne consulte pas la marque d'expulsion (test `FAILLE_C4_...`).
|
||||||
|
|
||||||
|
### Version
|
||||||
|
- `gradle.properties` et `neoforge.mods.toml` en 0.3.1 ; jar `gastinelgarde-neoforge-1.21.1-0.3.1.jar`.
|
||||||
|
|
||||||
|
## 0.3.0
|
||||||
|
Corrections de l'audit du 14/10/2026 (voir `audit/CORRECTIONS.md`).
|
||||||
+2
-2
@@ -1,7 +1,7 @@
|
|||||||
# GastinelGarde
|
# GastinelGarde
|
||||||
|
|
||||||
Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur uniquement). Plan et décisions :
|
Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur uniquement). Plan et décisions :
|
||||||
`../PLAN-GASTINELGARDE.md`. Version **0.3.0** : phases 0, 1 et 2 du plan, plus les corrections de l'audit du
|
`../PLAN-GASTINELGARDE.md`. Version **0.3.1** (voir `CHANGELOG.md`) : phases 0, 1 et 2 du plan, plus les corrections de l'audit du
|
||||||
2026-10-14 (`audit/`).
|
2026-10-14 (`audit/`).
|
||||||
|
|
||||||
**État** : compilé, 180 tests JUnit verts (au 16/10) (cœur pur, commandes, configuration, application réelle des mixins,
|
**État** : compilé, 180 tests JUnit verts (au 16/10) (cœur pur, commandes, configuration, application réelle des mixins,
|
||||||
@@ -251,7 +251,7 @@ journaliser et alerter (le coup a déjà eu lieu quand l'aller-retour est vu).
|
|||||||
Les traces JSONL se rejouent dans le moteur, sans serveur :
|
Les traces JSONL se rejouent dans le moteur, sans serveur :
|
||||||
|
|
||||||
```
|
```
|
||||||
java -cp build/libs/gastinelgarde-neoforge-1.21.1-0.3.0.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl
|
java -cp build/libs/gastinelgarde-neoforge-1.21.1-0.3.1.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl
|
||||||
```
|
```
|
||||||
|
|
||||||
Sortie : nombre de mouvements et d'attaques, infractions et points maximaux par contrôle, vingt exemples. Méthode :
|
Sortie : nombre de mouvements et d'attaques, infractions et points maximaux par contrôle, vingt exemples. Méthode :
|
||||||
|
|||||||
@@ -0,0 +1,41 @@
|
|||||||
|
#!/bin/sh
|
||||||
|
# Autotests GastinelGarde (16/10/2026) : compile et lance les tests dans un conteneur JDK 21 jetable.
|
||||||
|
# Usage (sur cornafserver) : sh ~/staging/garde-cas-limites-1016/autotests.sh
|
||||||
|
# Entrée : ~/staging/garde-cas-limites-1016/garde.tgz (copie du worktree test/cas-limites, sans .git ni build).
|
||||||
|
# Ne touche ni à ~/server-infra ni au conteneur minecraft-neoforge.
|
||||||
|
set -e
|
||||||
|
D="$HOME/staging/garde-cas-limites-1016"
|
||||||
|
cd "$D"
|
||||||
|
rm -rf src-build
|
||||||
|
mkdir src-build
|
||||||
|
tar xzf garde.tgz -C src-build
|
||||||
|
cd src-build
|
||||||
|
sed -i 's/\r$//' gradlew
|
||||||
|
mkdir -p "$HOME/.cache/gastinelclaims-gradle"
|
||||||
|
set +e
|
||||||
|
nice -n 10 docker run --rm --memory 4g --cpus 4 \
|
||||||
|
-u "$(id -u):$(id -g)" \
|
||||||
|
-e GRADLE_USER_HOME=/gradle-home \
|
||||||
|
-v "$HOME/.cache/gastinelclaims-gradle:/gradle-home" \
|
||||||
|
-v "$(pwd):/src" -w /src \
|
||||||
|
eclipse-temurin:21-jdk \
|
||||||
|
sh ./gradlew --no-daemon clean test > "$D/build.log" 2>&1
|
||||||
|
CODE=$?
|
||||||
|
set -e
|
||||||
|
echo "code de sortie gradle : $CODE"
|
||||||
|
grep -E "FAILED|BUILD|error:|tests completed" "$D/build.log" | head -40
|
||||||
|
echo "--- totaux (XML JUnit) ---"
|
||||||
|
T=0; F=0; E=0; S=0
|
||||||
|
for x in build/test-results/test/*.xml; do
|
||||||
|
[ -f "$x" ] || continue
|
||||||
|
l=$(grep -o '<testsuite [^>]*>' "$x" | head -1)
|
||||||
|
t=$(echo "$l" | sed -n 's/.* tests="\([0-9]*\)".*/\1/p'); f=$(echo "$l" | sed -n 's/.* failures="\([0-9]*\)".*/\1/p')
|
||||||
|
e=$(echo "$l" | sed -n 's/.* errors="\([0-9]*\)".*/\1/p'); s=$(echo "$l" | sed -n 's/.* skipped="\([0-9]*\)".*/\1/p')
|
||||||
|
T=$((T+t)); F=$((F+f)); E=$((E+e)); S=$((S+s))
|
||||||
|
case "$x" in *Autotest*) echo "$(basename "$x") tests=$t echecs=$f erreurs=$e ignores=$s";; esac
|
||||||
|
done
|
||||||
|
echo "TOTAL tests=$T echecs=$F erreurs=$E ignores=$S"
|
||||||
|
echo "--- mesures ---"
|
||||||
|
cat build/minecraft-junit/build/autotests-mesures.txt build/autotests-mesures.txt 2>/dev/null || true
|
||||||
|
echo "--- echecs detailles ---"
|
||||||
|
for x in build/test-results/test/*.xml; do grep -A6 '<failure' "$x" 2>/dev/null | head -30; done | head -120
|
||||||
@@ -159,6 +159,8 @@
|
|||||||
#Minecarts superposés au plus : au-delà, poussée mutuelle coupée et excédentaires (sans passager) cassés. 0 = pas de limite.
|
#Minecarts superposés au plus : au-delà, poussée mutuelle coupée et excédentaires (sans passager) cassés. 0 = pas de limite.
|
||||||
# Range: 0 ~ 64
|
# Range: 0 ~ 64
|
||||||
minecartsSuperposesMax = 4
|
minecartsSuperposesMax = 4
|
||||||
|
#C18 : ne casser que les minecarts empilés en mouvement ou sans contenu (défaut false, décision de Théo)
|
||||||
|
empilementSeulementEnMouvement = false
|
||||||
alertesOps = true
|
alertesOps = true
|
||||||
|
|
||||||
#Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.
|
#Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.
|
||||||
|
|||||||
@@ -1,7 +1,7 @@
|
|||||||
org.gradle.jvmargs=-Xmx2G
|
org.gradle.jvmargs=-Xmx2G
|
||||||
org.gradle.parallel=true
|
org.gradle.parallel=true
|
||||||
|
|
||||||
mod_version=0.3.0
|
mod_version=0.4.0
|
||||||
mod_group_id=com.gastinelgarde
|
mod_group_id=com.gastinelgarde
|
||||||
mod_id=gastinelgarde
|
mod_id=gastinelgarde
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,193 @@
|
|||||||
|
package com.gastinelgarde;
|
||||||
|
|
||||||
|
import com.gastinelgarde.core.DetectionContraption;
|
||||||
|
import com.gastinelgarde.core.GraceTeleport;
|
||||||
|
import com.gastinelgarde.core.Moteur;
|
||||||
|
import com.gastinelgarde.core.Sanction;
|
||||||
|
import com.gastinelgarde.core.Suivi;
|
||||||
|
import com.gastinelgarde.core.Verdict;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.UUID;
|
||||||
|
import java.util.function.BooleanSupplier;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Décisions du câblage Minecraft (Garde, GardeEvents) sorties sans changement de comportement (16/10, constat C4 ⚠️),
|
||||||
|
* pour être testées sans serveur. Aucun type Minecraft ici : Garde et GardeEvents lisent le serveur, appellent ces
|
||||||
|
* méthodes et appliquent le résultat.
|
||||||
|
*/
|
||||||
|
final class Cablage {
|
||||||
|
|
||||||
|
private Cablage() { }
|
||||||
|
|
||||||
|
// --- Entrées des événements ---
|
||||||
|
|
||||||
|
/** Ce que fait onAttaque avant toute mesure. */
|
||||||
|
enum EntreeAttaque {
|
||||||
|
/** C4 : expulsion en cours, le coup est annulé et rien n'est évalué. */
|
||||||
|
ANNULER,
|
||||||
|
/** Exemption manuelle (/garde exempter) : le coup passe sans mesure. */
|
||||||
|
IGNORER,
|
||||||
|
EVALUER
|
||||||
|
}
|
||||||
|
|
||||||
|
static EntreeAttaque entreeAttaque(boolean expulse, boolean exempteManuellement) {
|
||||||
|
if (expulse) return EntreeAttaque.ANNULER;
|
||||||
|
if (exempteManuellement) return EntreeAttaque.IGNORER;
|
||||||
|
return EntreeAttaque.EVALUER;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Fin de onAttaque : le coup est-il annulé ? (portée / hitbox ENFORCE, ou sanction ≥ SETBACK). */
|
||||||
|
static boolean annulerCoup(boolean coupsBloques, Sanction s) {
|
||||||
|
return coupsBloques || s.ordinal() >= Sanction.SETBACK.ordinal();
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Fin de onAttaque : seule une EXPULSION est appliquée au joueur (un SETBACK de combat annule seulement le coup). */
|
||||||
|
static boolean appliquerApresCoup(Sanction s) {
|
||||||
|
return s == Sanction.EXPULSION;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** avantMouvement : évaluer ce paquet ? (F01 thread serveur, C4 expulsion, exemption manuelle). */
|
||||||
|
static boolean evaluerAvantMouvement(boolean surThreadServeur, BooleanSupplier expulse,
|
||||||
|
BooleanSupplier exempteManuellement) {
|
||||||
|
// Paresseux : hors du thread serveur, l'état du mod n'est pas lu du tout (F01).
|
||||||
|
return surThreadServeur && !expulse.getAsBoolean() && !exempteManuellement.getAsBoolean();
|
||||||
|
}
|
||||||
|
|
||||||
|
/** apresMouvement : traiter ce paquet (état, position, traces) ? L'exemption manuelle est vue plus loin. */
|
||||||
|
static boolean traiterApresMouvement(boolean surThreadServeur, BooleanSupplier expulse) {
|
||||||
|
return surThreadServeur && !expulse.getAsBoolean();
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Sanction de mouvement à appliquer (≥ SETBACK). */
|
||||||
|
static boolean sanctionDeMouvement(Sanction s) {
|
||||||
|
return s.ordinal() >= Sanction.SETBACK.ordinal();
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Exemptions contraption de la cible (portée / hitbox) ---
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Portée et hitbox mesurées ? Non si la cible, ou son véhicule racine, est une contraption ou sur un vaisseau
|
||||||
|
* Sable. Évaluation paresseuse dans le même ordre que l'ancien code.
|
||||||
|
*/
|
||||||
|
static boolean mesurerPorteeHitbox(BooleanSupplier cibleContraption, BooleanSupplier cibleSable,
|
||||||
|
boolean racineEstCible, BooleanSupplier racineContraption,
|
||||||
|
BooleanSupplier racineSable) {
|
||||||
|
return !cibleContraption.getAsBoolean() && !cibleSable.getAsBoolean()
|
||||||
|
&& (racineEstCible || (!racineContraption.getAsBoolean() && !racineSable.getAsBoolean()));
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- C7 : déploiement des élytres ---
|
||||||
|
|
||||||
|
/** Suivi du plané en cours : est-il commencé moins de elytresAirMinTicks après le dernier sol serveur ? */
|
||||||
|
static final class Elytres {
|
||||||
|
boolean vues;
|
||||||
|
boolean suspectes;
|
||||||
|
|
||||||
|
/** À chaque construction de l'état : transition isFallFlying. */
|
||||||
|
void observer(boolean plane, int solServeurTick, int tick, int airMinTicks) {
|
||||||
|
if (plane) {
|
||||||
|
if (!vues) {
|
||||||
|
vues = true;
|
||||||
|
suspectes = solServeurTick != Integer.MIN_VALUE && tick - solServeurTick < airMinTicks;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
vues = false;
|
||||||
|
suspectes = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Détection en cache (contraption, courant d'air) ---
|
||||||
|
|
||||||
|
/** Détection refaite au plus toutes les 10 ticks, puis grâce après la dernière détection positive. */
|
||||||
|
static final class CacheDetection {
|
||||||
|
int tick = Integer.MIN_VALUE;
|
||||||
|
int vuTick = Integer.MIN_VALUE;
|
||||||
|
boolean proche;
|
||||||
|
|
||||||
|
boolean lire(int maintenant, BooleanSupplier detecter, int graceTicks) {
|
||||||
|
if (tick == Integer.MIN_VALUE || maintenant - tick >= 10 || maintenant < tick) {
|
||||||
|
proche = detecter.getAsBoolean();
|
||||||
|
tick = maintenant;
|
||||||
|
if (proche) vuTick = maintenant;
|
||||||
|
}
|
||||||
|
return proche || DetectionContraption.dansLaGrace(maintenant, vuTick, graceTicks);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- 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 = 5;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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, 200) + MARGE_FUSEE_TICKS;
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Position de retour (C3) ---
|
||||||
|
|
||||||
|
/** apresMouvement : la position de ce paquet devient-elle la position de retour ? */
|
||||||
|
static boolean memoriserRetour(Moteur moteur, int dernierVerdictTick, int tick, BooleanSupplier vehiculeControle,
|
||||||
|
boolean solServeur, boolean milieuSpecial) {
|
||||||
|
return dernierVerdictTick != tick && !vehiculeControle.getAsBoolean()
|
||||||
|
&& moteur.positionDeRetourAdmise(solServeur, milieuSpecial);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Sanctions (C2, C4) ---
|
||||||
|
|
||||||
|
/** Ce que la sanction fait au joueur réel (adaptateur ServerPlayer dans Garde, doublure dans les tests). */
|
||||||
|
interface Joueur {
|
||||||
|
UUID id();
|
||||||
|
String nom();
|
||||||
|
String dimension();
|
||||||
|
int tick();
|
||||||
|
void annoncerTeleport(GraceTeleport.Origine origine);
|
||||||
|
void teleporter(double x, double y, double z, float yaw, float pitch);
|
||||||
|
void deconnecter(String message);
|
||||||
|
void journal(String ligne);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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;
|
||||||
|
for (Verdict v : verdicts) {
|
||||||
|
if (v.applicable() == s) return v.controle().id();
|
||||||
|
if (retenu == null || v.applicable().ordinal() > retenu.applicable().ordinal()) retenu = v;
|
||||||
|
}
|
||||||
|
return retenu == null ? "anti-triche" : retenu.controle().id();
|
||||||
|
}
|
||||||
|
|
||||||
|
/** 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 = raison(verdicts, s);
|
||||||
|
if (s == Sanction.EXPULSION) {
|
||||||
|
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
|
||||||
|
if (!moteur.expulser(p.id(), p.tick() * 50L)) return;
|
||||||
|
p.journal(p.nom() + " EXPULSE (" + raison + ")");
|
||||||
|
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
|
||||||
|
} else if (s == Sanction.SETBACK) {
|
||||||
|
Suivi sv = moteur.suivi(p.id());
|
||||||
|
if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) {
|
||||||
|
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
|
||||||
|
p.teleporter(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
|
||||||
|
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
|
||||||
|
moteur.apresSetback(p.id(), p.tick() * 50L);
|
||||||
|
p.journal(p.nom() + " SETBACK (" + raison + ")");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -8,6 +8,8 @@ import com.gastinelgarde.core.EtatVehicule;
|
|||||||
import com.gastinelgarde.core.GardeConfig;
|
import com.gastinelgarde.core.GardeConfig;
|
||||||
import com.gastinelgarde.core.GraceRecul;
|
import com.gastinelgarde.core.GraceRecul;
|
||||||
import com.gastinelgarde.core.GraceTeleport;
|
import com.gastinelgarde.core.GraceTeleport;
|
||||||
|
import com.gastinelgarde.core.HistoriqueBoites;
|
||||||
|
import com.gastinelgarde.core.PorteeHitbox;
|
||||||
import com.gastinelgarde.core.Mode;
|
import com.gastinelgarde.core.Mode;
|
||||||
import com.gastinelgarde.core.Moteur;
|
import com.gastinelgarde.core.Moteur;
|
||||||
import com.gastinelgarde.core.RiptideSuivi;
|
import com.gastinelgarde.core.RiptideSuivi;
|
||||||
@@ -58,6 +60,8 @@ public final class Garde {
|
|||||||
/** Marques propres à un joueur, côté adaptateur (ticks du serveur). */
|
/** Marques propres à un joueur, côté adaptateur (ticks du serveur). */
|
||||||
private static final class Marques {
|
private static final class Marques {
|
||||||
int teleportTick = Integer.MIN_VALUE;
|
int teleportTick = 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 reculTick = Integer.MIN_VALUE;
|
||||||
int dernierVerdictTick = Integer.MIN_VALUE;
|
int dernierVerdictTick = Integer.MIN_VALUE;
|
||||||
int dernierTraceTick = Integer.MIN_VALUE;
|
int dernierTraceTick = Integer.MIN_VALUE;
|
||||||
@@ -75,15 +79,37 @@ public final class Garde {
|
|||||||
int vehiculeTick = Integer.MIN_VALUE;
|
int vehiculeTick = Integer.MIN_VALUE;
|
||||||
double vehiculeX, vehiculeY, vehiculeZ;
|
double vehiculeX, vehiculeY, vehiculeZ;
|
||||||
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
|
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
|
||||||
int contraptionTick = Integer.MIN_VALUE;
|
final Cablage.CacheDetection contraption = new Cablage.CacheDetection();
|
||||||
int contraptionVuTick = Integer.MIN_VALUE;
|
// C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
|
||||||
boolean contraptionProche;
|
int solServeurTick = Integer.MIN_VALUE;
|
||||||
|
final Cablage.Elytres elytres = new Cablage.Elytres();
|
||||||
// Cache de la détection d'un courant d'air (ventilateur Create), même principe
|
// Cache de la détection d'un courant d'air (ventilateur Create), même principe
|
||||||
int courantTick = Integer.MIN_VALUE;
|
final Cablage.CacheDetection courant = new Cablage.CacheDetection();
|
||||||
int courantVuTick = Integer.MIN_VALUE;
|
// #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux)
|
||||||
boolean courantProche;
|
double[] oeilDernier;
|
||||||
|
double[] oeilAvant;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** #92 : historique des boîtes d'une entité suivie (joueurs, et entités frappées récemment). */
|
||||||
|
private static final class Suivie {
|
||||||
|
final Entity entite;
|
||||||
|
final HistoriqueBoites historique = new HistoriqueBoites();
|
||||||
|
net.minecraft.world.level.Level niveau;
|
||||||
|
int jusquaTick;
|
||||||
|
|
||||||
|
Suivie(Entity e) {
|
||||||
|
this.entite = e;
|
||||||
|
this.niveau = e.level();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Entités dont on garde les boîtes, par identifiant (unique sur le serveur). */
|
||||||
|
private static final Map<Integer, Suivie> SUIVIES = new HashMap<>();
|
||||||
|
/** Une entité non joueur frappée est suivie pendant 10 s après le dernier coup. */
|
||||||
|
private static final int SUIVI_ENTITE_TICKS = 200;
|
||||||
|
/** Garde-fou mémoire : au plus ce nombre d'entités non joueur suivies. */
|
||||||
|
private static final int SUIVIES_MAX = 256;
|
||||||
|
|
||||||
private static final GardeConfig CONFIG = new GardeConfig();
|
private static final GardeConfig CONFIG = new GardeConfig();
|
||||||
private static final Moteur MOTEUR = new Moteur(CONFIG);
|
private static final Moteur MOTEUR = new Moteur(CONFIG);
|
||||||
private static final Map<UUID, Marques> MARQUES = new HashMap<>();
|
private static final Map<UUID, Marques> MARQUES = new HashMap<>();
|
||||||
@@ -119,6 +145,13 @@ public final class Garde {
|
|||||||
Files.createDirectories(journal.getParent());
|
Files.createDirectories(journal.getParent());
|
||||||
traces = new TraceFichier(jeu.resolve("gastinelgarde-traces"), GardeSpec.tracesJours(), GardeSpec.tracesTailleOctets());
|
traces = new TraceFichier(jeu.resolve("gastinelgarde-traces"), GardeSpec.tracesJours(), GardeSpec.tracesTailleOctets());
|
||||||
tracesEnCours = GardeSpec.tracesActives();
|
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) {
|
} catch (IOException e) {
|
||||||
GastinelGarde.LOGGER.error("[GastinelGarde] Impossible d'ouvrir le dossier de traces", e);
|
GastinelGarde.LOGGER.error("[GastinelGarde] Impossible d'ouvrir le dossier de traces", e);
|
||||||
traces = null;
|
traces = null;
|
||||||
@@ -136,6 +169,7 @@ public final class Garde {
|
|||||||
traces = null;
|
traces = null;
|
||||||
}
|
}
|
||||||
MARQUES.clear();
|
MARQUES.clear();
|
||||||
|
SUIVIES.clear();
|
||||||
}
|
}
|
||||||
|
|
||||||
public static synchronized void flushTraces() {
|
public static synchronized void flushTraces() {
|
||||||
@@ -170,6 +204,8 @@ public final class Garde {
|
|||||||
m.teleportTick = p.server.getTickCount();
|
m.teleportTick = p.server.getTickCount();
|
||||||
m.mouvementTick = Integer.MIN_VALUE;
|
m.mouvementTick = Integer.MIN_VALUE;
|
||||||
m.vehiculeId = -1;
|
m.vehiculeId = -1;
|
||||||
|
m.oeilAvant = null;
|
||||||
|
m.oeilDernier = null;
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
|
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
|
||||||
@@ -188,6 +224,116 @@ public final class Garde {
|
|||||||
if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount();
|
if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount();
|
||||||
m.mouvementTick = Integer.MIN_VALUE;
|
m.mouvementTick = Integer.MIN_VALUE;
|
||||||
m.vehiculeId = -1;
|
m.vehiculeId = -1;
|
||||||
|
m.oeilAvant = null;
|
||||||
|
m.oeilDernier = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Historique des cibles (#92, contrôle coups-hors-boite) ---
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Début de tick (après les paquets reçus entre deux ticks, avant l'envoi des positions aux clients) : boîte de
|
||||||
|
* chaque joueur et de chaque entité frappée récemment. C'est ce que les clients vont recevoir pendant ce tick.
|
||||||
|
* Coût : quelques joueurs et quelques mobs, 6 doubles chacun.
|
||||||
|
*/
|
||||||
|
public static void enregistrerHistoriques(MinecraftServer server) {
|
||||||
|
if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) {
|
||||||
|
if (!SUIVIES.isEmpty()) SUIVIES.clear();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
int tick = server.getTickCount();
|
||||||
|
for (ServerPlayer p : server.getPlayerList().getPlayers()) {
|
||||||
|
Suivie s = SUIVIES.get(p.getId());
|
||||||
|
if (s == null || s.entite != p) {
|
||||||
|
s = new Suivie(p); // connexion, ou réapparition (nouvel objet joueur, même identifiant)
|
||||||
|
SUIVIES.put(p.getId(), s);
|
||||||
|
}
|
||||||
|
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
|
||||||
|
// Revue 4 (16/10) : ping noté chaque seconde, hors combat aussi, pour le plancher de ping.
|
||||||
|
if (tick % 20 == 0) MOTEUR.pingFenetre(p.getUUID(), tick * 50L, p.connection.latency());
|
||||||
|
}
|
||||||
|
java.util.Iterator<Map.Entry<Integer, Suivie>> it = SUIVIES.entrySet().iterator();
|
||||||
|
while (it.hasNext()) {
|
||||||
|
Suivie s = it.next().getValue();
|
||||||
|
Entity e = s.entite;
|
||||||
|
if (e.isRemoved() || tick > s.jusquaTick) {
|
||||||
|
it.remove();
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (e.level() != s.niveau) { // changement de dimension : les anciennes boîtes ne veulent plus rien dire
|
||||||
|
s.historique.vider();
|
||||||
|
s.niveau = e.level();
|
||||||
|
}
|
||||||
|
net.minecraft.world.phys.AABB b = boiteVisee(e);
|
||||||
|
s.historique.ajouter(tick, b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Boîte que le client vise (vanilla : boîte gonflée du rayon de visée de l'entité, 0 pour presque toutes). */
|
||||||
|
static net.minecraft.world.phys.AABB boiteVisee(Entity e) {
|
||||||
|
float r = e.getPickRadius();
|
||||||
|
return r > 0 ? e.getBoundingBox().inflate(r) : e.getBoundingBox();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Boîtes de la cible sur la fenêtre où l'attaquant a pu la voir (selon son ping), ou null si l'historique ne
|
||||||
|
* couvre pas toute la fenêtre (entité jamais frappée jusque-là, connexion récente) : on ne mesure pas.
|
||||||
|
* Une entité non joueur frappée commence ici à être suivie.
|
||||||
|
*/
|
||||||
|
public static double[][] boitesVues(Entity cible, ServerPlayer attaquant, int tick) {
|
||||||
|
if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return null;
|
||||||
|
Suivie s = SUIVIES.get(cible.getId());
|
||||||
|
if (s == null || s.entite != cible) {
|
||||||
|
if (!(cible instanceof Player)) {
|
||||||
|
// Revue 3 (16/10) : table pleine, on évince la cible non joueur frappée il y a le plus longtemps
|
||||||
|
// (avant : la nouvelle cible n'était jamais suivie, faire frapper beaucoup d'entités aveuglait le
|
||||||
|
// contrôle). La cible qu'on frappe sans arrêt est la plus récente : jamais évincée.
|
||||||
|
if (s == null && SUIVIES.size() >= SUIVIES_MAX) evincerPlusAncienne();
|
||||||
|
s = new Suivie(cible);
|
||||||
|
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
|
||||||
|
SUIVIES.put(cible.getId(), s);
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
|
||||||
|
if (s.niveau != cible.level()) return null;
|
||||||
|
// Revue 4 (16/10) : ping plancher des 2 dernières minutes + marge, pas le ping déclaré du moment.
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(
|
||||||
|
MOTEUR.pingFenetre(attaquant.getUUID(), tick * 50L, attaquant.connection.latency()), CONFIG);
|
||||||
|
return s.historique.depuis(tick - fenetre);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Revue 3 : retire de la table l'entrée non joueur dont le dernier coup est le plus ancien. */
|
||||||
|
private static void evincerPlusAncienne() {
|
||||||
|
Integer cle = null;
|
||||||
|
int plusTot = Integer.MAX_VALUE;
|
||||||
|
for (Map.Entry<Integer, Suivie> e : SUIVIES.entrySet()) {
|
||||||
|
Suivie v = e.getValue();
|
||||||
|
if (v != null && v.entite instanceof Player) continue;
|
||||||
|
int t = v == null ? Integer.MIN_VALUE : v.jusquaTick;
|
||||||
|
if (cle == null || t < plusTot) {
|
||||||
|
cle = e.getKey();
|
||||||
|
plusTot = t;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (cle != null) SUIVIES.remove(cle);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Œil de l'attaquant au paquet de mouvement d'avant le dernier (null si inconnu). */
|
||||||
|
public static double[] oeilAvant(ServerPlayer p) {
|
||||||
|
Marques m = MARQUES.get(p.getUUID());
|
||||||
|
return m == null ? null : m.oeilAvant;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* La cible est-elle sur ou près d'une contraption Create / d'un vaisseau Sable ? Sa position affichée chez les
|
||||||
|
* autres clients peut alors suivre la contraption autrement que ses positions serveur : on ne mesure pas.
|
||||||
|
*/
|
||||||
|
public static boolean cibleProcheContraption(Entity cible, int tick) {
|
||||||
|
if (cible instanceof ServerPlayer j) return pocheContraptionEnCache(j, marques(j.getUUID()), tick);
|
||||||
|
if (SableAcces.surSousNiveau(cible)) return true;
|
||||||
|
int dist = GardeSpec.distanceContraption();
|
||||||
|
if (dist <= 0) return false;
|
||||||
|
return !cible.level().getEntities(cible, cible.getBoundingBox().inflate(dist), Garde::estContraption).isEmpty();
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Recul réel (F06). Auto-infligé (charge de vent à ses pieds) : grâce limitée, voir GraceRecul. */
|
/** Recul réel (F06). Auto-infligé (charge de vent à ses pieds) : grâce limitée, voir GraceRecul. */
|
||||||
@@ -198,6 +344,40 @@ public final class Garde {
|
|||||||
if (m.graceRecul.recul(tick, autoInflige)) m.reculTick = tick;
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
public static void noterTickServeur(MinecraftServer server, long dureeNs) {
|
public static void noterTickServeur(MinecraftServer server, long dureeNs) {
|
||||||
double ms = dureeNs / 1_000_000.0;
|
double ms = dureeNs / 1_000_000.0;
|
||||||
if (ms > 250.0) gelTick = server.getTickCount();
|
if (ms > 250.0) gelTick = server.getTickCount();
|
||||||
@@ -248,12 +428,16 @@ public final class Garde {
|
|||||||
mange = anim == UseAnim.EAT || anim == UseAnim.DRINK;
|
mange = anim == UseAnim.EAT || anim == UseAnim.DRINK;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// C7 : au début du plané, combien de ticks en l'air (sol serveur) ? Moins que elytresAirMinTicks : suspect.
|
||||||
|
m.elytres.observer(p.isFallFlying(), m.solServeurTick, tick, config().elytresAirMinTicks);
|
||||||
|
|
||||||
return EtatJoueur.builder()
|
return EtatJoueur.builder()
|
||||||
.creatif(p.isCreative())
|
.creatif(p.isCreative())
|
||||||
.spectateur(p.isSpectator())
|
.spectateur(p.isSpectator())
|
||||||
.peutVoler(p.getAbilities().mayfly)
|
.peutVoler(p.getAbilities().mayfly)
|
||||||
.riptide(riptideRecent)
|
.riptide(riptideRecent)
|
||||||
.elytres(p.isFallFlying())
|
.elytres(p.isFallFlying())
|
||||||
|
.elytresDeploiementSuspect(m.elytres.suspectes)
|
||||||
.levitation(p.hasEffect(MobEffects.LEVITATION))
|
.levitation(p.hasEffect(MobEffects.LEVITATION))
|
||||||
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
|
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
|
||||||
.enVehicule(p.isPassenger())
|
.enVehicule(p.isPassenger())
|
||||||
@@ -264,6 +448,7 @@ public final class Garde {
|
|||||||
.ticksDepuisGel(depuis(tick, gelTick))
|
.ticksDepuisGel(depuis(tick, gelTick))
|
||||||
.tps(tpsEstime)
|
.tps(tpsEstime)
|
||||||
.pingMs(p.connection.latency())
|
.pingMs(p.connection.latency())
|
||||||
|
.propulsionRecente(tick <= m.propulsionJusquaTick)
|
||||||
.build();
|
.build();
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -332,12 +517,7 @@ public final class Garde {
|
|||||||
|
|
||||||
/** La détection est refaite au plus toutes les 10 ticks par joueur ; grâce de 2 s après la dernière détection. */
|
/** La détection est refaite au plus toutes les 10 ticks par joueur ; grâce de 2 s après la dernière détection. */
|
||||||
private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) {
|
private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) {
|
||||||
if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) {
|
return m.contraption.lire(tick, () -> pocheContraption(p), GRACE_CONTRAPTION_TICKS);
|
||||||
m.contraptionProche = pocheContraption(p);
|
|
||||||
m.contraptionTick = tick;
|
|
||||||
if (m.contraptionProche) m.contraptionVuTick = tick;
|
|
||||||
}
|
|
||||||
return m.contraptionProche || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -388,9 +568,31 @@ public final class Garde {
|
|||||||
}
|
}
|
||||||
if (v.notifier()) alerterOps(p, v);
|
if (v.notifier()) alerterOps(p, v);
|
||||||
}
|
}
|
||||||
|
reagirSuspicion(p);
|
||||||
return Verdict.pire(verdicts);
|
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) {
|
private static void alerterOps(ServerPlayer cible, Verdict v) {
|
||||||
Component msg = Component.literal(String.format("[Garde] %s : %s VL=%.1f (%s, %s)",
|
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()))
|
cible.getGameProfile().getName(), v.controle().id(), v.vl(), v.mode(), v.applicable()))
|
||||||
@@ -432,20 +634,23 @@ public final class Garde {
|
|||||||
|
|
||||||
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */
|
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */
|
||||||
public static void avantMouvement(ServerPlayer p) {
|
public static void avantMouvement(ServerPlayer p) {
|
||||||
if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà)
|
// F01 : jamais depuis le thread réseau (le mixin l'évite déjà) ; C4 : expulsion en cours, plus rien à évaluer
|
||||||
if (estExempteManuellement(p.getUUID())) return;
|
if (!Cablage.evaluerAvantMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()),
|
||||||
|
() -> estExempteManuellement(p.getUUID()))) return;
|
||||||
EtatJoueur etat = etat(p, false);
|
EtatJoueur etat = etat(p, false);
|
||||||
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
|
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
|
||||||
Sanction s = traiter(p, v);
|
Sanction s = traiter(p, v);
|
||||||
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v);
|
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */
|
/** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */
|
||||||
public static void apresMouvement(ServerPlayer p) {
|
public static void apresMouvement(ServerPlayer p) {
|
||||||
if (!surThreadServeur(p)) return;
|
// C4 / C6 : ni évaluation ni état recréé après l'expulsion
|
||||||
|
if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;
|
||||||
int tick = p.server.getTickCount();
|
int tick = p.server.getTickCount();
|
||||||
Marques m = marques(p.getUUID());
|
Marques m = marques(p.getUUID());
|
||||||
boolean solServeur = auSolServeur(p, m);
|
boolean solServeur = auSolServeur(p, m);
|
||||||
|
if (solServeur) m.solServeurTick = tick; // C7
|
||||||
|
|
||||||
// Phase 2 : no-fall (divergence), vitesse horizontale, vol.
|
// Phase 2 : no-fall (divergence), vitesse horizontale, vol.
|
||||||
boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID());
|
boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID());
|
||||||
@@ -463,7 +668,7 @@ public final class Garde {
|
|||||||
if (controler && em != null) {
|
if (controler && em != null) {
|
||||||
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
|
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
|
||||||
Sanction s = traiter(p, v);
|
Sanction s = traiter(p, v);
|
||||||
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v);
|
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
|
||||||
}
|
}
|
||||||
// F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup.
|
// F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup.
|
||||||
if (!estExempteManuellement(p.getUUID())) {
|
if (!estExempteManuellement(p.getUUID())) {
|
||||||
@@ -476,6 +681,25 @@ public final class Garde {
|
|||||||
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z});
|
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z});
|
||||||
Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques)
|
Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques)
|
||||||
if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh);
|
if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh);
|
||||||
|
// #92 : œil des deux derniers paquets, pour le prochain coup.
|
||||||
|
m.oeilAvant = m.oeilDernier;
|
||||||
|
m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z};
|
||||||
|
}
|
||||||
|
// 0.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)) {
|
||||||
|
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)));
|
||||||
|
traiter(p, v); // information seulement : jamais de setback ni d'expulsion pour la vélocité
|
||||||
|
}
|
||||||
|
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);
|
||||||
|
traiter(p, vt); // information seulement : jamais de setback pour un totem
|
||||||
}
|
}
|
||||||
m.mouvementTick = tick;
|
m.mouvementTick = tick;
|
||||||
m.mouvementX = p.getX();
|
m.mouvementX = p.getX();
|
||||||
@@ -484,7 +708,9 @@ public final class Garde {
|
|||||||
|
|
||||||
// En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée
|
// En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée
|
||||||
// qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait.
|
// qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait.
|
||||||
if (m.dernierVerdictTick != tick && !vehiculeControle(p)) {
|
// C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air.
|
||||||
|
if (Cablage.memoriserRetour(MOTEUR, m.dernierVerdictTick, tick, () -> vehiculeControle(p), solServeur,
|
||||||
|
em != null && em.milieuSpecial())) {
|
||||||
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
|
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
|
||||||
p.level().dimension().location().toString());
|
p.level().dimension().location().toString());
|
||||||
}
|
}
|
||||||
@@ -704,12 +930,7 @@ public final class Garde {
|
|||||||
|
|
||||||
/** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */
|
/** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */
|
||||||
private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) {
|
private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) {
|
||||||
if (m.courantTick == Integer.MIN_VALUE || tick - m.courantTick >= 10 || tick < m.courantTick) {
|
return m.courant.lire(tick, () -> courantAir(p), GRACE_COURANT_TICKS);
|
||||||
m.courantProche = courantAir(p);
|
|
||||||
m.courantTick = tick;
|
|
||||||
if (m.courantProche) m.courantVuTick = tick;
|
|
||||||
}
|
|
||||||
return m.courantProche || DetectionContraption.dansLaGrace(tick, m.courantVuTick, GRACE_COURANT_TICKS);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -751,18 +972,22 @@ public final class Garde {
|
|||||||
}
|
}
|
||||||
|
|
||||||
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
|
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
|
||||||
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
|
Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts);
|
||||||
if (s == Sanction.EXPULSION) {
|
}
|
||||||
ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")");
|
|
||||||
p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ")."));
|
/** Adaptateur ServerPlayer de Cablage.appliquerSanction. */
|
||||||
} else if (s == Sanction.SETBACK) {
|
private static Cablage.Joueur joueur(ServerPlayer p) {
|
||||||
Suivi sv = MOTEUR.suivi(p.getUUID());
|
return new Cablage.Joueur() {
|
||||||
String dim = p.level().dimension().location().toString();
|
@Override public UUID id() { return p.getUUID(); }
|
||||||
if (sv.aPositionValide() && sv.dimension().equals(dim)) {
|
@Override public String nom() { return p.getGameProfile().getName(); }
|
||||||
annoncerTeleport(p, GraceTeleport.Origine.SETBACK);
|
@Override public String dimension() { return p.level().dimension().location().toString(); }
|
||||||
p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
|
@Override public int tick() { return p.server.getTickCount(); }
|
||||||
ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")");
|
@Override public void annoncerTeleport(GraceTeleport.Origine origine) { Garde.annoncerTeleport(p, origine); }
|
||||||
|
@Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
|
||||||
|
p.connection.teleport(x, y, z, yaw, pitch);
|
||||||
}
|
}
|
||||||
}
|
@Override public void deconnecter(String message) { p.connection.disconnect(Component.literal(message)); }
|
||||||
|
@Override public void journal(String ligne) { ecrireJournal(ligne); }
|
||||||
|
};
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -137,6 +137,17 @@ public final class GardeAntiCrash {
|
|||||||
if (!AntiCrashEntites.empilementExcessif(n, r)) return false;
|
if (!AntiCrashEntites.empilementExcessif(n, r)) return false;
|
||||||
if (cart.isVehicle() || Garde.estContraption(cart) || SableAcces.surSousNiveau(cart)) return false;
|
if (cart.isVehicle() || Garde.estContraption(cart) || SableAcces.surSousNiveau(cart)) return false;
|
||||||
Vec3 v = cart.getDeltaMovement();
|
Vec3 v = cart.getDeltaMovement();
|
||||||
|
// C18 : avec l'option, un minecart contenant immobile (stockage) n'est pas cassé.
|
||||||
|
boolean contenant = cart instanceof net.minecraft.world.Container;
|
||||||
|
if (!AntiCrashEntites.empilementACasser(n, r, v.length(), contenant)) {
|
||||||
|
if (plafonnementASignaler(cart.getUUID())) {
|
||||||
|
Garde.journaliser(String.format(java.util.Locale.ROOT,
|
||||||
|
"anti-crash EMPILEMENT %s immobile garde (%d minecarts superposés > %d), dim=%s pos=(%.1f, %.1f, %.1f)",
|
||||||
|
BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()), n, r.empilementMax,
|
||||||
|
cart.level().dimension().location(), cart.getX(), cart.getY(), cart.getZ()));
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
cart.destroy(cart.getPickResult().getItem());
|
cart.destroy(cart.getPickResult().getItem());
|
||||||
String type = BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()).toString();
|
String type = BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()).toString();
|
||||||
String ligne = String.format(java.util.Locale.ROOT,
|
String ligne = String.format(java.util.Locale.ROOT,
|
||||||
|
|||||||
@@ -91,6 +91,8 @@ public final class GardeCommands {
|
|||||||
sb.append("\n ").append(k.id()).append(" VL=")
|
sb.append("\n ").append(k.id()).append(" VL=")
|
||||||
.append(String.format(java.util.Locale.ROOT, "%.1f", suivi.vl.valeur(k, now)));
|
.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)");
|
if (Garde.estExempteManuellement(p.getUUID())) sb.append("\n (exempté manuellement)");
|
||||||
ok(ctx, sb.toString());
|
ok(ctx, sb.toString());
|
||||||
return 1;
|
return 1;
|
||||||
|
|||||||
@@ -44,6 +44,7 @@ public final class GardeEvents {
|
|||||||
@SubscribeEvent
|
@SubscribeEvent
|
||||||
public static void onTickPre(ServerTickEvent.Pre event) {
|
public static void onTickPre(ServerTickEvent.Pre event) {
|
||||||
debutTickNs = System.nanoTime();
|
debutTickNs = System.nanoTime();
|
||||||
|
Garde.enregistrerHistoriques(event.getServer()); // #92 : boîtes des cibles possibles
|
||||||
}
|
}
|
||||||
|
|
||||||
@SubscribeEvent
|
@SubscribeEvent
|
||||||
@@ -56,7 +57,16 @@ public final class GardeEvents {
|
|||||||
@SubscribeEvent
|
@SubscribeEvent
|
||||||
public static void onAttaque(AttackEntityEvent event) {
|
public static void onAttaque(AttackEntityEvent event) {
|
||||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||||
if (Garde.estExempteManuellement(p.getUUID())) return;
|
switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) {
|
||||||
|
case ANNULER -> { // C4 : expulsion en cours
|
||||||
|
event.setCanceled(true);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
case IGNORER -> {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
case EVALUER -> { }
|
||||||
|
}
|
||||||
|
|
||||||
Entity cible = event.getTarget();
|
Entity cible = event.getTarget();
|
||||||
int tick = p.server.getTickCount();
|
int tick = p.server.getTickCount();
|
||||||
@@ -78,14 +88,19 @@ public final class GardeEvents {
|
|||||||
// (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere).
|
// (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere).
|
||||||
// L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
|
// L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
|
||||||
Entity racine = cible.getRootVehicle();
|
Entity racine = cible.getRootVehicle();
|
||||||
boolean mesurerPH = !Garde.estContraption(cible) && !SableAcces.surSousNiveau(cible)
|
boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> Garde.estContraption(cible),
|
||||||
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
|
() -> SableAcces.surSousNiveau(cible), racine == cible, () -> Garde.estContraption(racine),
|
||||||
|
() -> SableAcces.surSousNiveau(racine));
|
||||||
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
|
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
|
||||||
+ Math.pow(cible.getZ() - cible.zo, 2));
|
+ Math.pow(cible.getZ() - cible.zo, 2));
|
||||||
|
// #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge
|
||||||
|
// « vitesse × ticks » dans toutes les directions. Null (pas de mesure) si l'historique est incomplet ou si
|
||||||
|
// la cible est sur ou près d'une contraption / d'un vaisseau.
|
||||||
|
double[][] vues = mesurerPH && !Garde.cibleProcheContraption(cible, tick) ? Garde.boitesVues(cible, p, tick) : null;
|
||||||
verdicts.addAll(Garde.moteur().coupDiffere(p.getUUID(), tick * 50L, etat,
|
verdicts.addAll(Garde.moteur().coupDiffere(p.getUUID(), tick * 50L, etat,
|
||||||
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z},
|
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z},
|
||||||
new double[] {bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ}, p.entityInteractionRange(),
|
new double[] {bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ}, p.entityInteractionRange(),
|
||||||
vitesseCible, mesurerPH, true));
|
vitesseCible, mesurerPH, true, Garde.oeilAvant(p), vues));
|
||||||
|
|
||||||
if (Garde.tracesEnCours()) {
|
if (Garde.tracesEnCours()) {
|
||||||
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
|
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
|
||||||
@@ -94,11 +109,9 @@ public final class GardeEvents {
|
|||||||
}
|
}
|
||||||
|
|
||||||
Sanction s = Garde.traiter(p, verdicts);
|
Sanction s = Garde.traiter(p, verdicts);
|
||||||
if (Garde.moteur().coupsBloques(p.getUUID(), tick * 50L)) event.setCanceled(true); // portée / hitbox ENFORCE
|
// portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé
|
||||||
if (s.ordinal() >= Sanction.SETBACK.ordinal()) {
|
if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true);
|
||||||
event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé
|
if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
|
||||||
if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
|
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
|
||||||
@@ -116,7 +129,11 @@ public final class GardeEvents {
|
|||||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||||
public static void onRecul(LivingKnockBackEvent event) {
|
public static void onRecul(LivingKnockBackEvent event) {
|
||||||
if (event.isCanceled() || event.getStrength() <= 0.0F) return;
|
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). */
|
/** Explosion, charge de vent (Wind Charge) : poussée vers le joueur. Celle qu'il s'inflige est limitée (GraceRecul). */
|
||||||
@@ -126,11 +143,36 @@ public final class GardeEvents {
|
|||||||
if (!(event.getAffectedEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
if (!(event.getAffectedEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||||
boolean auto = event.getExplosion().getIndirectSourceEntity() == p || event.getExplosion().getDirectSourceEntity() == p;
|
boolean auto = event.getExplosion().getIndirectSourceEntity() == p || event.getExplosion().getDirectSourceEntity() == p;
|
||||||
Garde.noterRecul(p, auto);
|
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);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** 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
|
@SubscribeEvent
|
||||||
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
|
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
|
||||||
if (event.getEntity() instanceof ServerPlayer p) Garde.noterTeleport(p);
|
if (event.getEntity() instanceof ServerPlayer p) {
|
||||||
|
Garde.moteur().oublierExpulsion(p.getUUID()); // C4 : la marque d'expulsion vaut jusqu'à la reconnexion
|
||||||
|
Garde.noterTeleport(p);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@SubscribeEvent
|
@SubscribeEvent
|
||||||
|
|||||||
@@ -47,6 +47,29 @@ public final class GardeSpec {
|
|||||||
private static final ModConfigSpec.IntValue PING_LATENCE_MAX;
|
private static final ModConfigSpec.IntValue PING_LATENCE_MAX;
|
||||||
private static final ModConfigSpec.DoubleValue VITESSE_CIBLE_MAX;
|
private static final ModConfigSpec.DoubleValue VITESSE_CIBLE_MAX;
|
||||||
|
|
||||||
|
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 ELY_MONTEE, ELY_STATIONNAIRE, VEL_FENETRE, VEL_SERIE, TOTEM_DELAI, TOTEM_PING;
|
||||||
|
private static final ModConfigSpec.DoubleValue VEL_RAPPORT, VEL_FORCE;
|
||||||
|
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;
|
||||||
|
private static final ModConfigSpec.IntValue ELYTRES_AIR_MIN;
|
||||||
|
private static final ModConfigSpec.BooleanValue COMBAT_VEHICULE;
|
||||||
|
private static final ModConfigSpec.BooleanValue AC_EMPILEMENT_MOUVEMENT;
|
||||||
|
private static final ModConfigSpec.DoubleValue SERIE_MANQUE;
|
||||||
|
private static final ModConfigSpec.DoubleValue SERIE_PORTEE;
|
||||||
|
private static final ModConfigSpec.IntValue SERIE_COUPS;
|
||||||
|
private static final ModConfigSpec.IntValue SERIE_HORS_MIN;
|
||||||
|
private static final ModConfigSpec.IntValue SERIE_FENETRE_MS;
|
||||||
|
private static final ModConfigSpec.DoubleValue SERIE_POINTS;
|
||||||
|
|
||||||
private static final ModConfigSpec.ConfigValue<String> PREFIXES_CONTRAPTION;
|
private static final ModConfigSpec.ConfigValue<String> PREFIXES_CONTRAPTION;
|
||||||
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
|
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
|
||||||
private static final ModConfigSpec.ConfigValue<String> BLOCS_COURANT_AIR;
|
private static final ModConfigSpec.ConfigValue<String> BLOCS_COURANT_AIR;
|
||||||
@@ -110,15 +133,97 @@ public final class GardeSpec {
|
|||||||
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
|
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
|
||||||
b.pop();
|
b.pop();
|
||||||
|
|
||||||
|
b.comment("Contrôle coups-hors-boite (#92) : le regard est testé contre toutes les positions où le client a pu",
|
||||||
|
"voir la cible (historique des boîtes), au lieu d'une marge « vitesse × ticks » dans toutes les directions.",
|
||||||
|
"Un coup isolé ne compte pas : seulement une série (serieHorsMin coups hors boîte sur les serieCoups derniers).",
|
||||||
|
"Valeurs de départ prudentes, à régler avec les journaux en OBSERVE avant tout ENFORCE.").push("coupsHorsBoite");
|
||||||
|
TICKS_AFFICHAGE = b.comment("Retard d'affichage de base de la cible chez le client (ticks) ; le ping s'ajoute (ping / 50).")
|
||||||
|
.defineInRange("ticksAffichageCible", 7, 2, 12);
|
||||||
|
SERIE_PING_MAX = b.comment("Ping (ms) pris en compte au plus dans la fenêtre (au-delà, le coup est mesuré avec cette fenêtre).")
|
||||||
|
.defineInRange("seriePingMaxMs", 500, 100, 500);
|
||||||
|
SERIE_PING_MARGE = b.comment("Fenêtre selon le ping le plus bas des 2 dernières minutes + cette marge (ms), pas le ping du moment.")
|
||||||
|
.defineInRange("seriePingMargeMs", 50, 0, 500);
|
||||||
|
SERIE_MANQUE = b.comment("Coup hors boîte si le regard manque toutes les boîtes vues de plus de cette marge (blocs).")
|
||||||
|
.defineInRange("serieManqueBlocs", 0.15, 0.05, 2.0);
|
||||||
|
SERIE_PORTEE = b.comment("... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs).")
|
||||||
|
.defineInRange("seriePorteeMargeBlocs", 0.15, 0.05, 2.0);
|
||||||
|
SERIE_COUPS = b.defineInRange("serieCoups", 10, 3, 32);
|
||||||
|
SERIE_HORS_MIN = b.defineInRange("serieHorsMin", 4, 2, 32);
|
||||||
|
SERIE_FENETRE_MS = b.defineInRange("serieFenetreMs", 30000, 1000, 600000);
|
||||||
|
SERIE_POINTS = b.defineInRange("seriePoints", 2.0, 0.1, 20.0);
|
||||||
|
b.pop();
|
||||||
|
|
||||||
b.push("timer");
|
b.push("timer");
|
||||||
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
|
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
|
||||||
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
|
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);
|
||||||
|
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);
|
||||||
|
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);
|
||||||
|
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.pop();
|
||||||
|
|
||||||
b.push("mouvement");
|
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.",
|
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.")
|
"Valeurs de départ généreuses, à resserrer avec les traces réelles.")
|
||||||
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
|
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
|
||||||
|
VOL_FENETRE_GLISSANTE = b.comment("C10 : vol, ticks anormaux sur une fenêtre glissante et sauts en l'air répétés.",
|
||||||
|
"Désactivé par défaut : à essayer en OBSERVE (vol est en ENFORCE en production).")
|
||||||
|
.define("volFenetreGlissante", false);
|
||||||
|
VITESSE_MOYENNE = b.comment("C15 : vitesse moyenne sur 40 paquets comparée à la moyenne vanilla (course, sprint-saut).",
|
||||||
|
"Désactivé par défaut : à essayer en OBSERVE (fausse alerte possible sous un plafond bas, C16).")
|
||||||
|
.define("vitesseMoyenne", false);
|
||||||
|
ELYTRES_STRICTE = b.comment("C7 : plané déclenché sans ticks en l'air (sol serveur) = pas d'exemption de mouvement ;",
|
||||||
|
"portée et hitbox mesurées pendant le plané. Désactivé par défaut : à essayer en OBSERVE.")
|
||||||
|
.define("elytresExemptionStricte", false);
|
||||||
|
ELYTRES_AIR_MIN = b.comment("C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres.")
|
||||||
|
.defineInRange("elytresAirMinTicks", 2, 1, 20);
|
||||||
|
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);
|
||||||
b.pop();
|
b.pop();
|
||||||
|
|
||||||
b.push("exemptions");
|
b.push("exemptions");
|
||||||
@@ -168,6 +273,9 @@ public final class GardeSpec {
|
|||||||
AC_EMPILEMENT_MAX = b.comment("Minecarts au plus qui se chevauchent : au-delà, leur poussée mutuelle est coupée et les",
|
AC_EMPILEMENT_MAX = b.comment("Minecarts au plus qui se chevauchent : au-delà, leur poussée mutuelle est coupée et les",
|
||||||
"excédentaires (sans passager) sont cassés et lâchent leur objet. 0 = pas de limite.")
|
"excédentaires (sans passager) sont cassés et lâchent leur objet. 0 = pas de limite.")
|
||||||
.defineInRange("minecartsSuperposesMax", 4, 0, 64);
|
.defineInRange("minecartsSuperposesMax", 4, 0, 64);
|
||||||
|
AC_EMPILEMENT_MOUVEMENT = b.comment("C18 : ne casser que les minecarts empilés en mouvement ou sans contenu ; un stockage",
|
||||||
|
"immobile de minecarts à coffre / à trémie n'est plus cassé (poussée coupée, journal seulement). Défaut false.")
|
||||||
|
.define("empilementSeulementEnMouvement", false);
|
||||||
AC_ALERTES_OPS = b.comment("Message aux ops (5 au plus par 10 s ; tout est dans logs/gastinelgarde.log).")
|
AC_ALERTES_OPS = b.comment("Message aux ops (5 au plus par 10 s ; tout est dans logs/gastinelgarde.log).")
|
||||||
.define("alertesOps", true);
|
.define("alertesOps", true);
|
||||||
b.pop();
|
b.pop();
|
||||||
@@ -219,6 +327,41 @@ public final class GardeSpec {
|
|||||||
c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
|
c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
|
||||||
c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
|
c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
|
||||||
c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
|
c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
|
||||||
|
c.ticksAffichageCible = TICKS_AFFICHAGE.get();
|
||||||
|
c.seriePingMaxMs = SERIE_PING_MAX.get();
|
||||||
|
c.seriePingMargeMs = SERIE_PING_MARGE.get();
|
||||||
|
c.timerSoldeMax = TIMER_SOLDE_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.velociteFenetreTicks = VEL_FENETRE.get();
|
||||||
|
c.velociteRapportMin = VEL_RAPPORT.get();
|
||||||
|
c.velociteSerieMin = VEL_SERIE.get();
|
||||||
|
c.velociteForceMin = VEL_FORCE.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();
|
||||||
|
c.elytresAirMinTicks = ELYTRES_AIR_MIN.get();
|
||||||
|
c.combatMesureEnVehicule = COMBAT_VEHICULE.get();
|
||||||
|
c.serieManqueBlocs = SERIE_MANQUE.get();
|
||||||
|
c.seriePorteeMargeBlocs = SERIE_PORTEE.get();
|
||||||
|
c.serieCoups = SERIE_COUPS.get();
|
||||||
|
c.serieHorsMin = Math.min(SERIE_HORS_MIN.get(), c.serieCoups);
|
||||||
|
c.serieFenetreMs = SERIE_FENETRE_MS.get();
|
||||||
|
c.seriePoints = SERIE_POINTS.get();
|
||||||
c.graceTeleportTicks = GRACE_TELEPORT.get();
|
c.graceTeleportTicks = GRACE_TELEPORT.get();
|
||||||
c.graceReculTicks = GRACE_RECUL.get();
|
c.graceReculTicks = GRACE_RECUL.get();
|
||||||
c.graceGelTicks = GRACE_GEL.get();
|
c.graceGelTicks = GRACE_GEL.get();
|
||||||
@@ -287,6 +430,7 @@ public final class GardeSpec {
|
|||||||
r.margeBordure = l ? AC_MARGE_BORDURE.get() : AC_MARGE_BORDURE.getDefault();
|
r.margeBordure = l ? AC_MARGE_BORDURE.get() : AC_MARGE_BORDURE.getDefault();
|
||||||
r.vitesseMaxMinecart = l ? AC_VITESSE_MINECART.get() : AC_VITESSE_MINECART.getDefault();
|
r.vitesseMaxMinecart = l ? AC_VITESSE_MINECART.get() : AC_VITESSE_MINECART.getDefault();
|
||||||
r.empilementMax = l ? AC_EMPILEMENT_MAX.get() : AC_EMPILEMENT_MAX.getDefault();
|
r.empilementMax = l ? AC_EMPILEMENT_MAX.get() : AC_EMPILEMENT_MAX.getDefault();
|
||||||
|
r.empilementSeulementEnMouvement = l ? AC_EMPILEMENT_MOUVEMENT.get() : AC_EMPILEMENT_MOUVEMENT.getDefault();
|
||||||
return r;
|
return r;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -48,6 +48,14 @@ public final class AntiCrashEntites {
|
|||||||
public double vitesseMaxMinecart = 3.0;
|
public double vitesseMaxMinecart = 3.0;
|
||||||
/** Minecarts au plus qui se chevauchent ; au-delà, la poussée mutuelle est coupée et les excédentaires cassés. */
|
/** Minecarts au plus qui se chevauchent ; au-delà, la poussée mutuelle est coupée et les excédentaires cassés. */
|
||||||
public int empilementMax = 4;
|
public int empilementMax = 4;
|
||||||
|
/**
|
||||||
|
* C18 (16/10) : ne casser que les minecarts en mouvement ou sans contenu (minecart simple). Les minecarts à
|
||||||
|
* coffre / à trémie immobiles d'un stockage honnête ne sont plus cassés (poussée coupée, journal seulement).
|
||||||
|
* Désactivé par défaut : décision de Théo.
|
||||||
|
*/
|
||||||
|
public boolean empilementSeulementEnMouvement = false;
|
||||||
|
/** C18 : vitesse (blocs/tick) au-delà de laquelle un minecart empilé est « en mouvement ». */
|
||||||
|
public double empilementVitesseMin = 0.05;
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Bordure du monde (rectangle horizontal). */
|
/** Bordure du monde (rectangle horizontal). */
|
||||||
@@ -136,6 +144,17 @@ public final class AntiCrashEntites {
|
|||||||
return r != null && r.actif && r.empilementMax > 0 && minecartsQuiSeChevauchent > r.empilementMax;
|
return r != null && r.actif && r.empilementMax > 0 && minecartsQuiSeChevauchent > r.empilementMax;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* C18 : ce minecart empilé doit-il être cassé ?
|
||||||
|
* @param vitesse norme de sa vitesse (blocs/tick)
|
||||||
|
* @param contenant minecart à coffre, à trémie… (casser répand le contenu)
|
||||||
|
*/
|
||||||
|
public static boolean empilementACasser(int minecartsQuiSeChevauchent, Reglages r, double vitesse, boolean contenant) {
|
||||||
|
if (!empilementExcessif(minecartsQuiSeChevauchent, r)) return false;
|
||||||
|
if (!r.empilementSeulementEnMouvement) return true;
|
||||||
|
return !contenant || !(vitesse <= r.empilementVitesseMin);
|
||||||
|
}
|
||||||
|
|
||||||
/** Position dans la bordure + marge, et dans les limites absolues du jeu. */
|
/** Position dans la bordure + marge, et dans les limites absolues du jeu. */
|
||||||
public static boolean dansLimites(Bordure b, double marge, double x, double y, double z) {
|
public static boolean dansLimites(Bordure b, double marge, double x, double y, double z) {
|
||||||
if (Math.abs(x) > LIMITE_HORIZONTALE || Math.abs(z) > LIMITE_HORIZONTALE || Math.abs(y) > LIMITE_VERTICALE) {
|
if (Math.abs(x) > LIMITE_HORIZONTALE || Math.abs(z) > LIMITE_HORIZONTALE || Math.abs(y) > LIMITE_VERTICALE) {
|
||||||
|
|||||||
@@ -0,0 +1,46 @@
|
|||||||
|
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;
|
||||||
|
|
||||||
|
/** @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;
|
||||||
|
long minimum = cfg.totemDelaiMinMs + Math.min(Math.max(0, pingMs), cfg.totemPingMaxMs);
|
||||||
|
return delai < minimum ? 3.0 : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void vider() {
|
||||||
|
actif = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -10,12 +10,20 @@ public enum Controle {
|
|||||||
ROTATION("rotation"),
|
ROTATION("rotation"),
|
||||||
PORTEE("portee"),
|
PORTEE("portee"),
|
||||||
HITBOX("hitbox"),
|
HITBOX("hitbox"),
|
||||||
|
/** #92 : série de coups qui manquent toutes les positions où la cible a pu être vue (hitbox, reach). */
|
||||||
|
COUPS_HORS_BOITE("coups-hors-boite"),
|
||||||
TIMER("timer"),
|
TIMER("timer"),
|
||||||
NO_FALL("no-fall"),
|
NO_FALL("no-fall"),
|
||||||
VITESSE("vitesse"),
|
VITESSE("vitesse"),
|
||||||
VOL("vol"),
|
VOL("vol"),
|
||||||
VEHICULE_VITESSE("vehicule-vitesse"),
|
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");
|
||||||
|
|
||||||
private final String id;
|
private final String id;
|
||||||
|
|
||||||
@@ -33,7 +41,17 @@ public enum Controle {
|
|||||||
* correction de l'interdiction du 15/10, qui empêchait aussi la correction no-fall de d0c001d).
|
* correction de l'interdiction du 15/10, qui empêchait aussi la correction no-fall de d0c001d).
|
||||||
*/
|
*/
|
||||||
public boolean observeParDefaut() {
|
public boolean observeParDefaut() {
|
||||||
return this == NO_FALL || this == VITESSE || this == VOL || this == PORTEE || this == HITBOX;
|
return this == NO_FALL || this == VITESSE || this == VOL || this == PORTEE || this == HITBOX
|
||||||
|
|| 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 -> 0;
|
||||||
|
case COUPS_HORS_BOITE, KILLAURA_ANGLE, KILLAURA_CIBLES, CADENCE -> 1;
|
||||||
|
case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, AUTO_TOTEM -> 2;
|
||||||
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
public static Controle parse(String texte) {
|
public static Controle parse(String texte) {
|
||||||
|
|||||||
@@ -15,6 +15,24 @@ final class CoupDiffere {
|
|||||||
/** Le paquet de mouvement du même tick arrive normalement juste après ; 2 ticks de marge pour la gigue. */
|
/** Le paquet de mouvement du même tick arrive normalement juste après ; 2 ticks de marge pour la gigue. */
|
||||||
static final int TICKS_MAX = 2;
|
static final int TICKS_MAX = 2;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Revue 2 / C13 (16/10) : au-delà de cet angle entre le regard du coup et celui du paquet suivant (rotation
|
||||||
|
* silencieuse : regard ailleurs au coup, ramené sur la cible juste après), le regard suivant n'est plus pris par
|
||||||
|
* coups-hors-boite, et le coup est compté comme « sauvé par le regard suivant » pour l'angle killaura (série, voir
|
||||||
|
* {@link Suivi#regardsSauves}). Un coup isolé garde le bénéfice du doute (demi-tour honnête possible).
|
||||||
|
* [À VÉRIFIER] en jeu : 90° couvre un « flick » honnête.
|
||||||
|
*/
|
||||||
|
static final double REGARD_SUIVANT_MAX_DEGRES = 90.0;
|
||||||
|
/**
|
||||||
|
* Revue 2 / C13 : l'œil du paquet suivant est ramené à au plus un tick de déplacement de l'œil du coup :
|
||||||
|
* déplacement horizontal du tick précédent + cette marge (accélération, élan d'un saut en courant)...
|
||||||
|
*/
|
||||||
|
static final double OEIL_SUIVANT_MARGE_H = 0.4;
|
||||||
|
/** ... déplacement vertical du tick précédent + cette marge (saut : 0,42)... */
|
||||||
|
static final double OEIL_SUIVANT_MARGE_V = 0.5;
|
||||||
|
/** ... ou, sans œil précédent connu, ce déplacement (horizontal et vertical). */
|
||||||
|
static final double OEIL_SUIVANT_DEFAUT = 0.6;
|
||||||
|
|
||||||
final long nowMs;
|
final long nowMs;
|
||||||
final EtatJoueur etat;
|
final EtatJoueur etat;
|
||||||
final double[] boite;
|
final double[] boite;
|
||||||
@@ -27,6 +45,18 @@ final class CoupDiffere {
|
|||||||
/** Excédent d'angle killaura (degrés), -1 si non mesuré. */
|
/** Excédent d'angle killaura (degrés), -1 si non mesuré. */
|
||||||
double excedent;
|
double excedent;
|
||||||
|
|
||||||
|
// #92 : mesure compensée par l'historique de la cible (contrôle coups-hors-boite). Null : pas d'historique.
|
||||||
|
double[][] boitesVues;
|
||||||
|
/** Œil au paquet d'avant, au coup, au paquet suivant (null si inconnu). */
|
||||||
|
double[] oeilPrecedent, oeilCoup, oeilSuivant;
|
||||||
|
/** Regard au coup et au paquet suivant (null si inconnu). */
|
||||||
|
double[] regardCoup, regardSuivant;
|
||||||
|
|
||||||
|
/** Le regard du paquet suivant a été refusé (trop loin du regard du coup). */
|
||||||
|
boolean regardSuivantRefuse;
|
||||||
|
/** Excédent d'angle killaura avec le regard du coup seul (avant affinage), -1 si non mesuré. */
|
||||||
|
double excedentCoup = -1;
|
||||||
|
|
||||||
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
|
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
|
||||||
double distance, double manque, double excedent, boolean porteeHitbox) {
|
double distance, double manque, double excedent, boolean porteeHitbox) {
|
||||||
this.nowMs = nowMs;
|
this.nowMs = nowMs;
|
||||||
@@ -45,8 +75,18 @@ final class CoupDiffere {
|
|||||||
return d >= 0 && d <= TICKS_MAX;
|
return d >= 0 && d <= TICKS_MAX;
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. */
|
/**
|
||||||
void affiner(double[] oeil, double[] regard) {
|
* Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. Revue 2 / C13 (16/10) : l'œil
|
||||||
|
* suivant est borné à un tick de déplacement depuis l'œil du coup, et le regard suivant n'est pris que s'il reste
|
||||||
|
* à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup.
|
||||||
|
*/
|
||||||
|
void affiner(double[] oeilRecu, double[] regardRecu) {
|
||||||
|
double[] oeil = oeilCoup == null ? oeilRecu.clone() : bornerOeil(oeilCoup, oeilPrecedent, oeilRecu);
|
||||||
|
double[] regard = regardRecu.clone();
|
||||||
|
regardSuivantRefuse = regardCoup != null && !regardAdmis(regardCoup, regardRecu);
|
||||||
|
excedentCoup = excedent;
|
||||||
|
oeilSuivant = oeil;
|
||||||
|
regardSuivant = regardSuivantRefuse ? null : regard;
|
||||||
double[] b = boite;
|
double[] b = boite;
|
||||||
double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]);
|
double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]);
|
||||||
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
||||||
@@ -59,4 +99,33 @@ final class CoupDiffere {
|
|||||||
if (a >= 0) excedent = Math.min(excedent, a);
|
if (a >= 0) excedent = Math.min(excedent, a);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** Le regard suivant est-il à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup ? */
|
||||||
|
static boolean regardAdmis(double[] coup, double[] suivant) {
|
||||||
|
double n1 = Math.sqrt(coup[0] * coup[0] + coup[1] * coup[1] + coup[2] * coup[2]);
|
||||||
|
double n2 = Math.sqrt(suivant[0] * suivant[0] + suivant[1] * suivant[1] + suivant[2] * suivant[2]);
|
||||||
|
if (n1 < 1e-9 || n2 < 1e-9) return true;
|
||||||
|
double c = (coup[0] * suivant[0] + coup[1] * suivant[1] + coup[2] * suivant[2]) / (n1 * n2);
|
||||||
|
return c >= Math.cos(Math.toRadians(REGARD_SUIVANT_MAX_DEGRES)) - 1e-9;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Œil suivant ramené à un tick de déplacement de l'œil du coup (horizontal et vertical à part). */
|
||||||
|
static double[] bornerOeil(double[] coup, double[] precedent, double[] suivant) {
|
||||||
|
double bornH, bornV;
|
||||||
|
if (precedent == null) {
|
||||||
|
bornH = OEIL_SUIVANT_DEFAUT;
|
||||||
|
bornV = OEIL_SUIVANT_DEFAUT;
|
||||||
|
} else {
|
||||||
|
bornH = Math.hypot(coup[0] - precedent[0], coup[2] - precedent[2]) + OEIL_SUIVANT_MARGE_H;
|
||||||
|
bornV = Math.abs(coup[1] - precedent[1]) + OEIL_SUIVANT_MARGE_V;
|
||||||
|
}
|
||||||
|
double dx = suivant[0] - coup[0], dz = suivant[2] - coup[2], dy = suivant[1] - coup[1];
|
||||||
|
double h = Math.hypot(dx, dz);
|
||||||
|
if (h > bornH) {
|
||||||
|
dx *= bornH / h;
|
||||||
|
dz *= bornH / h;
|
||||||
|
}
|
||||||
|
if (Math.abs(dy) > bornV) dy = Math.copySign(bornV, dy);
|
||||||
|
return new double[] {coup[0] + dx, coup[1] + dy, coup[2] + dz};
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -15,11 +15,13 @@ public record EtatJoueur(
|
|||||||
boolean enVehicule,
|
boolean enVehicule,
|
||||||
boolean pocheContraption,
|
boolean pocheContraption,
|
||||||
boolean utiliseObjet,
|
boolean utiliseObjet,
|
||||||
|
boolean elytresDeploiementSuspect,
|
||||||
int ticksDepuisTeleport,
|
int ticksDepuisTeleport,
|
||||||
int ticksDepuisRecul,
|
int ticksDepuisRecul,
|
||||||
int ticksDepuisGel,
|
int ticksDepuisGel,
|
||||||
double tps,
|
double tps,
|
||||||
int pingMs) {
|
int pingMs,
|
||||||
|
boolean propulsionRecente) {
|
||||||
|
|
||||||
public static final int JAMAIS = Integer.MAX_VALUE;
|
public static final int JAMAIS = Integer.MAX_VALUE;
|
||||||
|
|
||||||
@@ -34,10 +36,11 @@ public record EtatJoueur(
|
|||||||
|
|
||||||
public static final class Builder {
|
public static final class Builder {
|
||||||
private boolean creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente;
|
private boolean creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente;
|
||||||
private boolean enVehicule, pocheContraption, utiliseObjet;
|
private boolean enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect;
|
||||||
private int ticksDepuisTeleport = JAMAIS, ticksDepuisRecul = JAMAIS, ticksDepuisGel = JAMAIS;
|
private int ticksDepuisTeleport = JAMAIS, ticksDepuisRecul = JAMAIS, ticksDepuisGel = JAMAIS;
|
||||||
private double tps = 20.0;
|
private double tps = 20.0;
|
||||||
private int pingMs = 30;
|
private int pingMs = 30;
|
||||||
|
private boolean propulsionRecente;
|
||||||
|
|
||||||
public Builder creatif(boolean v) { creatif = v; return this; }
|
public Builder creatif(boolean v) { creatif = v; return this; }
|
||||||
public Builder spectateur(boolean v) { spectateur = v; return this; }
|
public Builder spectateur(boolean v) { spectateur = v; return this; }
|
||||||
@@ -49,16 +52,20 @@ public record EtatJoueur(
|
|||||||
public Builder enVehicule(boolean v) { enVehicule = v; return this; }
|
public Builder enVehicule(boolean v) { enVehicule = v; return this; }
|
||||||
public Builder pocheContraption(boolean v) { pocheContraption = v; return this; }
|
public Builder pocheContraption(boolean v) { pocheContraption = v; return this; }
|
||||||
public Builder utiliseObjet(boolean v) { utiliseObjet = v; return this; }
|
public Builder utiliseObjet(boolean v) { utiliseObjet = v; return this; }
|
||||||
|
/** C7 : plané déclenché sans assez de ticks en l'air côté serveur (onGround probablement falsifié). */
|
||||||
|
public Builder elytresDeploiementSuspect(boolean v) { elytresDeploiementSuspect = v; return this; }
|
||||||
public Builder ticksDepuisTeleport(int v) { ticksDepuisTeleport = v; return this; }
|
public Builder ticksDepuisTeleport(int v) { ticksDepuisTeleport = v; return this; }
|
||||||
public Builder ticksDepuisRecul(int v) { ticksDepuisRecul = v; return this; }
|
public Builder ticksDepuisRecul(int v) { ticksDepuisRecul = v; return this; }
|
||||||
public Builder ticksDepuisGel(int v) { ticksDepuisGel = v; return this; }
|
public Builder ticksDepuisGel(int v) { ticksDepuisGel = v; return this; }
|
||||||
public Builder tps(double v) { tps = v; return this; }
|
public Builder tps(double v) { tps = v; return this; }
|
||||||
public Builder pingMs(int v) { pingMs = 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; }
|
||||||
|
|
||||||
public EtatJoueur build() {
|
public EtatJoueur build() {
|
||||||
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
|
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
|
||||||
enVehicule, pocheContraption, utiliseObjet, ticksDepuisTeleport, ticksDepuisRecul,
|
enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect, ticksDepuisTeleport, ticksDepuisRecul,
|
||||||
ticksDepuisGel, tps, pingMs);
|
ticksDepuisGel, tps, pingMs, propulsionRecente);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -28,13 +28,16 @@ public final class Exemptions {
|
|||||||
|
|
||||||
switch (famille) {
|
switch (famille) {
|
||||||
case COMBAT -> {
|
case COMBAT -> {
|
||||||
if (e.enVehicule()) raisons.add("vehicule");
|
// C8 (16/10) : option combatMesureEnVehicule (défaut false) : le passager est mesuré comme à pied.
|
||||||
|
if (e.enVehicule() && !cfg.combatMesureEnVehicule) raisons.add("vehicule");
|
||||||
if (e.pocheContraption()) raisons.add("contraption");
|
if (e.pocheContraption()) raisons.add("contraption");
|
||||||
}
|
}
|
||||||
case MOUVEMENT -> {
|
case MOUVEMENT -> {
|
||||||
if (e.peutVoler()) raisons.add("peut-voler");
|
if (e.peutVoler()) raisons.add("peut-voler");
|
||||||
if (e.riptide()) raisons.add("riptide");
|
if (e.riptide()) raisons.add("riptide");
|
||||||
if (e.elytres()) raisons.add("elytres");
|
// C7 (16/10) : option elytresExemptionStricte (défaut false) : un plané déclenché sans ticks en l'air
|
||||||
|
// côté serveur (onGround falsifié) n'exempte plus le mouvement.
|
||||||
|
if (e.elytres() && !(cfg.elytresExemptionStricte && e.elytresDeploiementSuspect())) raisons.add("elytres");
|
||||||
if (e.levitation()) raisons.add("levitation");
|
if (e.levitation()) raisons.add("levitation");
|
||||||
if (e.chuteLente()) raisons.add("chute-lente");
|
if (e.chuteLente()) raisons.add("chute-lente");
|
||||||
if (e.enVehicule()) raisons.add("vehicule");
|
if (e.enVehicule()) raisons.add("vehicule");
|
||||||
|
|||||||
@@ -17,6 +17,52 @@ public final class GardeConfig {
|
|||||||
public double seuilExpulsion = 20.0;
|
public double seuilExpulsion = 20.0;
|
||||||
/** Sanction la plus forte autorisée (T4 : setback puis expulsion, jamais de bannissement). */
|
/** Sanction la plus forte autorisée (T4 : setback puis expulsion, jamais de bannissement). */
|
||||||
public Sanction sanctionMax = Sanction.EXPULSION;
|
public Sanction sanctionMax = Sanction.EXPULSION;
|
||||||
|
/**
|
||||||
|
* C5 (16/10) : un retour en arrière remet le VL du contrôle à zéro ; l'expulsion pour un contrôle de mouvement
|
||||||
|
* vient quand ce nombre de setbacks a déjà eu lieu dans {@link #fenetreSetbacksMs}.
|
||||||
|
*/
|
||||||
|
public int setbacksAvantExpulsion = 4;
|
||||||
|
public long fenetreSetbacksMs = 60_000;
|
||||||
|
/** 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;
|
||||||
|
|
||||||
|
// --- 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;
|
||||||
|
/** 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;
|
||||||
|
/** 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 ---
|
// --- Killaura ---
|
||||||
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
|
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
|
||||||
@@ -58,6 +104,51 @@ public final class GardeConfig {
|
|||||||
/** Cible plus rapide que ça (blocs/tick : élytres, riptide, téléportation, recul fort) : pas de mesure. */
|
/** Cible plus rapide que ça (blocs/tick : élytres, riptide, téléportation, recul fort) : pas de mesure. */
|
||||||
public double vitesseCibleMaxMesure = 1.0;
|
public double vitesseCibleMaxMesure = 1.0;
|
||||||
|
|
||||||
|
// --- Coups hors boîte (#92, 16/10 : le cas de Rednixxu passait sous portee et hitbox) ---
|
||||||
|
/**
|
||||||
|
* Retard d'affichage de base de la cible chez le client (ticks) : envoi de sa position toutes les 2 (joueur) à
|
||||||
|
* 3 ticks (mob), interpolation sur 3 ticks, plus 1 tick de gigue. Le ping s'ajoute (voir seriePingMaxMs).
|
||||||
|
*/
|
||||||
|
public int ticksAffichageCible = 7;
|
||||||
|
/** Ping (ms) pris en compte au plus dans la fenêtre (revue 1, 16/10 : au-delà, mesuré quand même, fenêtre bornée). */
|
||||||
|
public int seriePingMaxMs = 500;
|
||||||
|
/** Un coup est « hors boîte » si le regard manque toutes les boîtes vues de plus de cette marge (blocs). */
|
||||||
|
public double serieManqueBlocs = 0.15;
|
||||||
|
/** ... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs). */
|
||||||
|
public double seriePorteeMargeBlocs = 0.15;
|
||||||
|
/** Nombre de derniers coups mesurés examinés. */
|
||||||
|
public int serieCoups = 10;
|
||||||
|
/** Coups hors boîte, parmi les serieCoups derniers, à partir desquels un coup hors boîte compte. */
|
||||||
|
public int serieHorsMin = 4;
|
||||||
|
/** Âge maximal (ms) d'un coup encore compté dans la série. */
|
||||||
|
public long serieFenetreMs = 30000;
|
||||||
|
/** Points par coup hors boîte dans une série suspecte. */
|
||||||
|
public double seriePoints = 2.0;
|
||||||
|
/**
|
||||||
|
* Revue 4 (16/10) : la fenêtre d'historique suit le ping le plus bas vu ces 2 dernières minutes, plus cette marge
|
||||||
|
* (ms), et non le ping déclaré : gonfler son ping pendant un combat n'élargit plus la fenêtre.
|
||||||
|
*/
|
||||||
|
public int seriePingMargeMs = 50;
|
||||||
|
|
||||||
|
// --- C10 / C15 (16/10) : détections supplémentaires, DÉSACTIVÉES par défaut (à valider en OBSERVE) ---
|
||||||
|
/** C10 : vol, ticks anormaux comptés sur une fenêtre glissante et sauts en l'air sans appui. */
|
||||||
|
public boolean volFenetreGlissante = false;
|
||||||
|
/** C15 : vitesse moyenne sur 2 s comparée à la moyenne vanilla (course, sprint-saut). */
|
||||||
|
public boolean vitesseMoyenne = false;
|
||||||
|
|
||||||
|
// --- C7 / C8 (16/10, constats hauts) : DÉSACTIVÉS par défaut (à valider en OBSERVE) ---
|
||||||
|
/**
|
||||||
|
* C7 : élytres. Pas d'exemption de mouvement si le plané a été déclenché sans au moins
|
||||||
|
* {@link #elytresAirMinTicks} ticks en l'air (sol serveur), et portée / hitbox mesurées pendant le plané.
|
||||||
|
*/
|
||||||
|
public boolean elytresExemptionStricte = false;
|
||||||
|
/** C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres. */
|
||||||
|
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;
|
||||||
|
|
||||||
// --- Exemptions ---
|
// --- Exemptions ---
|
||||||
public int graceTeleportTicks = 40;
|
public int graceTeleportTicks = 40;
|
||||||
public int graceReculTicks = 20;
|
public int graceReculTicks = 20;
|
||||||
|
|||||||
@@ -0,0 +1,94 @@
|
|||||||
|
package com.gastinelgarde.core;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Boîtes successives d'une entité, une par tick serveur (#92, 16/10/2026). Tampon circulaire de taille fixe (D4) :
|
||||||
|
* aucune allocation à l'enregistrement.
|
||||||
|
*
|
||||||
|
* Sert à savoir où un client a pu VOIR la cible au moment de son coup : le client affiche les autres entités avec
|
||||||
|
* du retard (envoi de position toutes les 2 ticks pour un joueur, 3 pour la plupart des mobs, interpolation sur
|
||||||
|
* 3 ticks, plus le ping). Au lieu d'élargir la boîte réelle dans toutes les directions de « vitesse × ticks »
|
||||||
|
* (ancien calcul, qui donnait jusqu'à 1 bloc de marge partout dès que la cible bouge), on teste le regard contre
|
||||||
|
* les boîtes réellement occupées pendant cette fenêtre.
|
||||||
|
*/
|
||||||
|
public final class HistoriqueBoites {
|
||||||
|
|
||||||
|
/** 32 ticks (1,6 s) : couvre la fenêtre la plus large (7 ticks + 500 ms de ping = 17 ticks) avec de la marge. */
|
||||||
|
public static final int CAPACITE = 32;
|
||||||
|
|
||||||
|
private final int[] ticks = new int[CAPACITE];
|
||||||
|
private final double[] boites = new double[CAPACITE * 6];
|
||||||
|
/** Nombre d'entrées valides. */
|
||||||
|
private int taille;
|
||||||
|
/** Indice de la prochaine écriture. */
|
||||||
|
private int tete;
|
||||||
|
|
||||||
|
/** Enregistre la boîte du tick ; un second enregistrement au même tick remplace le premier. */
|
||||||
|
public void ajouter(int tick, double minX, double minY, double minZ, double maxX, double maxY, double maxZ) {
|
||||||
|
int i;
|
||||||
|
if (taille > 0 && ticks[indice(taille - 1)] == tick) {
|
||||||
|
i = indice(taille - 1);
|
||||||
|
} else {
|
||||||
|
if (taille > 0 && tick < ticks[indice(taille - 1)]) vider(); // horloge revenue en arrière : on repart
|
||||||
|
i = tete;
|
||||||
|
tete = (tete + 1) % CAPACITE;
|
||||||
|
if (taille < CAPACITE) taille++;
|
||||||
|
}
|
||||||
|
ticks[i] = tick;
|
||||||
|
int o = i * 6;
|
||||||
|
boites[o] = minX;
|
||||||
|
boites[o + 1] = minY;
|
||||||
|
boites[o + 2] = minZ;
|
||||||
|
boites[o + 3] = maxX;
|
||||||
|
boites[o + 4] = maxY;
|
||||||
|
boites[o + 5] = maxZ;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void ajouter(int tick, double[] b) {
|
||||||
|
ajouter(tick, b[0], b[1], b[2], b[3], b[4], b[5]);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void vider() {
|
||||||
|
taille = 0;
|
||||||
|
tete = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int taille() {
|
||||||
|
return taille;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Tick de l'entrée la plus récente, ou {@link Integer#MIN_VALUE} si vide. */
|
||||||
|
public int dernierTick() {
|
||||||
|
return taille == 0 ? Integer.MIN_VALUE : ticks[indice(taille - 1)];
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Tick de l'entrée la plus ancienne, ou {@link Integer#MAX_VALUE} si vide. */
|
||||||
|
public int premierTick() {
|
||||||
|
return taille == 0 ? Integer.MAX_VALUE : ticks[indice(0)];
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Boîtes de la fenêtre [tickMin, ...], dans l'ordre chronologique, plus la dernière entrée antérieure à tickMin
|
||||||
|
* (la cible affichée peut être en cours d'interpolation depuis cette position).
|
||||||
|
*
|
||||||
|
* @return null si l'historique ne remonte pas jusqu'à tickMin (fenêtre incomplète : on ne sait pas où le client
|
||||||
|
* a pu voir la cible, donc on ne mesure pas)
|
||||||
|
*/
|
||||||
|
public double[][] depuis(int tickMin) {
|
||||||
|
if (taille == 0 || premierTick() > tickMin) return null;
|
||||||
|
int debut = 0;
|
||||||
|
for (int k = taille - 1; k >= 0; k--) {
|
||||||
|
if (ticks[indice(k)] <= tickMin) { debut = k; break; }
|
||||||
|
}
|
||||||
|
double[][] sortie = new double[taille - debut][];
|
||||||
|
for (int k = debut; k < taille; k++) {
|
||||||
|
int o = indice(k) * 6;
|
||||||
|
sortie[k - debut] = new double[] {boites[o], boites[o + 1], boites[o + 2], boites[o + 3], boites[o + 4], boites[o + 5]};
|
||||||
|
}
|
||||||
|
return sortie;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Indice dans le tampon de la k-ième entrée valide (0 = la plus ancienne). */
|
||||||
|
private int indice(int k) {
|
||||||
|
return ((tete - taille + k) % CAPACITE + CAPACITE) % CAPACITE;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -21,6 +21,47 @@ public final class Moteur {
|
|||||||
|
|
||||||
private final GardeConfig cfg;
|
private final GardeConfig cfg;
|
||||||
private final Map<UUID, Suivi> suivis = new HashMap<>();
|
private final Map<UUID, Suivi> suivis = new HashMap<>();
|
||||||
|
/** 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) {
|
public Moteur(GardeConfig cfg) {
|
||||||
this.cfg = cfg;
|
this.cfg = cfg;
|
||||||
@@ -31,7 +72,7 @@ public final class Moteur {
|
|||||||
}
|
}
|
||||||
|
|
||||||
public Suivi suivi(UUID joueur) {
|
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) {
|
public void retirer(UUID joueur) {
|
||||||
@@ -54,6 +95,7 @@ public final class Moteur {
|
|||||||
*/
|
*/
|
||||||
public List<Verdict> attaque(UUID joueur, long nowMs, EtatJoueur etat, double excedentDegres,
|
public List<Verdict> attaque(UUID joueur, long nowMs, EtatJoueur etat, double excedentDegres,
|
||||||
int idCible, boolean cibleVisible) {
|
int idCible, boolean cibleVisible) {
|
||||||
|
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
|
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
|
||||||
if (ex.exempt()) return List.of();
|
if (ex.exempt()) return List.of();
|
||||||
|
|
||||||
@@ -97,6 +139,7 @@ public final class Moteur {
|
|||||||
*/
|
*/
|
||||||
public List<Verdict> porteeHitbox(UUID joueur, long nowMs, EtatJoueur etat, double distance, double manque,
|
public List<Verdict> porteeHitbox(UUID joueur, long nowMs, EtatJoueur etat, double distance, double manque,
|
||||||
double porteeJoueur, double vitesseCible) {
|
double porteeJoueur, double vitesseCible) {
|
||||||
|
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||||
boolean portee = cfg.mode(Controle.PORTEE) != Mode.OFF;
|
boolean portee = cfg.mode(Controle.PORTEE) != Mode.OFF;
|
||||||
boolean hitbox = cfg.mode(Controle.HITBOX) != Mode.OFF;
|
boolean hitbox = cfg.mode(Controle.HITBOX) != Mode.OFF;
|
||||||
if (!portee && !hitbox) return List.of();
|
if (!portee && !hitbox) return List.of();
|
||||||
@@ -149,11 +192,30 @@ public final class Moteur {
|
|||||||
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
|
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
|
||||||
double[] boite, double porteeJoueur, double vitesseCible,
|
double[] boite, double porteeJoueur, double vitesseCible,
|
||||||
boolean porteeHitbox, boolean angle) {
|
boolean porteeHitbox, boolean angle) {
|
||||||
|
return coupDiffere(joueur, nowMs, etat, oeil, regard, boite, porteeJoueur, vitesseCible, porteeHitbox, angle,
|
||||||
|
null, null);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Idem, avec ce qu'il faut pour la mesure compensée du contrôle coups-hors-boite (#92).
|
||||||
|
*
|
||||||
|
* @param oeilPrecedent œil au paquet de mouvement d'avant le dernier (null si inconnu)
|
||||||
|
* @param boitesVues boîtes de la cible sur la fenêtre où le client a pu la voir, dans l'ordre chronologique
|
||||||
|
* (voir {@link HistoriqueBoites#depuis} et {@link PorteeHitbox#ticksFenetre}) ; null si
|
||||||
|
* l'historique est incomplet : le contrôle ne mesure pas ce coup
|
||||||
|
*/
|
||||||
|
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
|
||||||
|
double[] boite, double porteeJoueur, double vitesseCible,
|
||||||
|
boolean porteeHitbox, boolean angle, double[] oeilPrecedent,
|
||||||
|
double[][] boitesVues) {
|
||||||
|
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||||
List<Verdict> verdicts = terminerCoup(joueur);
|
List<Verdict> verdicts = terminerCoup(joueur);
|
||||||
|
boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0
|
||||||
|
&& cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF;
|
||||||
boolean ph = porteeHitbox
|
boolean ph = porteeHitbox
|
||||||
&& (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
|
&& (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
|
||||||
boolean an = angle && cfg.mode(Controle.KILLAURA_ANGLE) != Mode.OFF;
|
boolean an = angle && cfg.mode(Controle.KILLAURA_ANGLE) != Mode.OFF;
|
||||||
if (!ph && !an) return verdicts;
|
if (!ph && !an && !serie) return verdicts;
|
||||||
double ex = an ? KillauraAngle.excedentDegres(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
double ex = an ? KillauraAngle.excedentDegres(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
||||||
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]) : -1;
|
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]) : -1;
|
||||||
if (an && ex < 0) ex = -1;
|
if (an && ex < 0) ex = -1;
|
||||||
@@ -161,12 +223,63 @@ public final class Moteur {
|
|||||||
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
|
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
|
||||||
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
||||||
porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
|
porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
|
||||||
suivi(joueur).coupDiffere = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
|
CoupDiffere c = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
|
||||||
|
// Revue 2 / C13 : œil et regard du coup gardés dans tous les cas, pour borner ceux du paquet suivant.
|
||||||
|
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
|
||||||
|
c.oeilCoup = oeil.clone();
|
||||||
|
c.regardCoup = regard.clone();
|
||||||
|
if (serie) c.boitesVues = boitesVues;
|
||||||
|
suivi(joueur).coupDiffere = c;
|
||||||
return verdicts;
|
return verdicts;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Contrôle coups-hors-boite (#92) : mesure compensée du coup (toutes les positions où la cible a pu être vue,
|
||||||
|
* tous les yeux et regards plausibles de l'attaquant), puis série sur les derniers coups.
|
||||||
|
*/
|
||||||
|
private List<Verdict> coupsHorsBoite(Suivi s, CoupDiffere c) {
|
||||||
|
if (c.boitesVues == null || cfg.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return List.of();
|
||||||
|
Exemptions.Resultat ex = Exemptions.evaluer(c.etat, cfg, Exemptions.Famille.COMBAT);
|
||||||
|
if (ex.exempt()) return List.of();
|
||||||
|
if (PorteeHitbox.raisonNonMesureSerie(c.etat, cfg) != null) return List.of();
|
||||||
|
|
||||||
|
double[][] boites = new double[c.boitesVues.length + 1][];
|
||||||
|
System.arraycopy(c.boitesVues, 0, boites, 0, c.boitesVues.length);
|
||||||
|
boites[c.boitesVues.length] = c.boite; // boîte au moment du coup
|
||||||
|
PorteeHitbox.Mesure m = PorteeHitbox.mesureCompensee(
|
||||||
|
new double[][] {c.oeilPrecedent, c.oeilCoup, c.oeilSuivant},
|
||||||
|
new double[][] {c.regardCoup, c.regardSuivant},
|
||||||
|
boites, c.porteeJoueur + 1.0, cfg.vitesseCibleMaxMesure);
|
||||||
|
// Cible qui a sauté (téléportation) ou file trop vite dans la fenêtre : on ne sait pas ce que le client a vu.
|
||||||
|
if (m.deplacementMax() > cfg.vitesseCibleMaxMesure) return List.of();
|
||||||
|
|
||||||
|
double f = ex.facteur();
|
||||||
|
double seuilManque = cfg.serieManqueBlocs * f;
|
||||||
|
double seuilPortee = c.porteeJoueur + cfg.seriePorteeMargeBlocs * f;
|
||||||
|
boolean hors = m.manque() > seuilManque || m.distance() > seuilPortee;
|
||||||
|
double pts = s.serie.enregistrer(c.nowMs, hors, cfg);
|
||||||
|
List<Verdict> verdicts = new ArrayList<>(1);
|
||||||
|
ajouter(verdicts, s, Controle.COUPS_HORS_BOITE, pts, c.nowMs, ex, String.format(Locale.ROOT,
|
||||||
|
"manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d%s",
|
||||||
|
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal(),
|
||||||
|
c.regardSuivantRefuse ? ", regard suivant refuse" : ""));
|
||||||
|
return verdicts;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Revue 4 (16/10) : ping à utiliser pour la fenêtre d'historique de coups-hors-boite (voir
|
||||||
|
* {@link PorteeHitbox#ticksFenetre}). Note aussi le ping déclaré.
|
||||||
|
*/
|
||||||
|
public int pingFenetre(UUID joueur, long nowMs, int pingDeclare) {
|
||||||
|
Suivi s = suivi(joueur);
|
||||||
|
int plancher = s.pingPlancher.noter(nowMs, pingDeclare);
|
||||||
|
long avecMarge = (long) plancher + Math.max(0, cfg.seriePingMargeMs);
|
||||||
|
return (int) Math.max(0, Math.min(pingDeclare, avecMarge));
|
||||||
|
}
|
||||||
|
|
||||||
/** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */
|
/** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */
|
||||||
public List<Verdict> regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) {
|
public List<Verdict> regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) {
|
||||||
|
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||||
Suivi s = suivis.get(joueur);
|
Suivi s = suivis.get(joueur);
|
||||||
if (s == null || s.coupDiffere == null) return List.of();
|
if (s == null || s.coupDiffere == null) return List.of();
|
||||||
if (s.coupDiffere.encoreValable(nowMs)) s.coupDiffere.affiner(oeil, regard);
|
if (s.coupDiffere.encoreValable(nowMs)) s.coupDiffere.affiner(oeil, regard);
|
||||||
@@ -187,11 +300,18 @@ public final class Moteur {
|
|||||||
double seuil = cfg.angleMaxDegres * ex.facteur();
|
double seuil = cfg.angleMaxDegres * ex.facteur();
|
||||||
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, KillauraAngle.points(c.excedent, seuil), c.nowMs, ex,
|
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, KillauraAngle.points(c.excedent, seuil), c.nowMs, ex,
|
||||||
String.format(Locale.ROOT, "excedent=%.1f deg (seuil %.0f, mesure differee)", c.excedent, seuil));
|
String.format(Locale.ROOT, "excedent=%.1f deg (seuil %.0f, mesure differee)", c.excedent, seuil));
|
||||||
|
// C13 : coup « sauvé » seulement par un regard suivant à plus de 90° du regard du coup.
|
||||||
|
boolean sauve = c.regardSuivantRefuse && c.excedentCoup > seuil && !(c.excedent > seuil);
|
||||||
|
double ptsSauves = s.regardsSauves.enregistrer(c.nowMs, sauve, cfg);
|
||||||
|
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, ptsSauves, c.nowMs, ex, String.format(Locale.ROOT,
|
||||||
|
"regard ramene sur la cible au paquet suivant (excedent au coup %.1f deg), %d coups sur %d",
|
||||||
|
c.excedentCoup, s.regardsSauves.dernierCompte(), s.regardsSauves.dernierTotal()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (c.porteeHitbox) {
|
if (c.porteeHitbox) {
|
||||||
verdicts.addAll(porteeHitbox(joueur, c.nowMs, c.etat, c.distance, c.manque, c.porteeJoueur, c.vitesseCible));
|
verdicts.addAll(porteeHitbox(joueur, c.nowMs, c.etat, c.distance, c.manque, c.porteeJoueur, c.vitesseCible));
|
||||||
}
|
}
|
||||||
|
verdicts.addAll(coupsHorsBoite(s, c));
|
||||||
for (Verdict v : verdicts) { // le coup est déjà passé : en ENFORCE, on annule les suivants
|
for (Verdict v : verdicts) { // le coup est déjà passé : en ENFORCE, on annule les suivants
|
||||||
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
|
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
|
||||||
s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS);
|
s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS);
|
||||||
@@ -212,6 +332,7 @@ public final class Moteur {
|
|||||||
*/
|
*/
|
||||||
public List<Verdict> regard(UUID joueur, long nowMs, java.util.function.Supplier<EtatJoueur> etat,
|
public List<Verdict> regard(UUID joueur, long nowMs, java.util.function.Supplier<EtatJoueur> etat,
|
||||||
float yaw, float pitch) {
|
float yaw, float pitch) {
|
||||||
|
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||||
if (cfg.mode(Controle.ROTATION) == Mode.OFF) return List.of();
|
if (cfg.mode(Controle.ROTATION) == Mode.OFF) return List.of();
|
||||||
Suivi s = suivi(joueur);
|
Suivi s = suivi(joueur);
|
||||||
double pts = s.rotation.regard(nowMs / 50, yaw, pitch);
|
double pts = s.rotation.regard(nowMs / 50, yaw, pitch);
|
||||||
@@ -227,6 +348,7 @@ public final class Moteur {
|
|||||||
|
|
||||||
/** Un paquet de mouvement vient d'arriver (temps réel en ms, pour mesurer le débit). */
|
/** Un paquet de mouvement vient d'arriver (temps réel en ms, pour mesurer le débit). */
|
||||||
public List<Verdict> paquetMouvement(UUID joueur, long nowMs, EtatJoueur etat) {
|
public List<Verdict> paquetMouvement(UUID joueur, long nowMs, EtatJoueur etat) {
|
||||||
|
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||||
if (cfg.mode(Controle.TIMER) == Mode.OFF) return List.of();
|
if (cfg.mode(Controle.TIMER) == Mode.OFF) return List.of();
|
||||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER);
|
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER);
|
||||||
if (ex.exempt()) {
|
if (ex.exempt()) {
|
||||||
@@ -246,6 +368,7 @@ public final class Moteur {
|
|||||||
* Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout.
|
* 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) {
|
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m) {
|
||||||
|
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||||
boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF;
|
boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF;
|
||||||
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
|
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
|
||||||
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
|
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
|
||||||
@@ -257,20 +380,45 @@ public final class Moteur {
|
|||||||
// 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…).
|
// 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…).
|
||||||
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
|
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
|
||||||
s.vol.vider();
|
s.vol.vider();
|
||||||
return List.of();
|
// 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 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);
|
List<Verdict> verdicts = new ArrayList<>(3);
|
||||||
if (noFall) {
|
if (noFall) {
|
||||||
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m), nowMs, ex,
|
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m), nowMs, ex,
|
||||||
"au sol declare sans bloc dessous pendant une chute");
|
"au sol declare sans bloc dessous pendant une chute");
|
||||||
}
|
}
|
||||||
if (vitesse) {
|
if (vitesse) {
|
||||||
|
s.vitesse.moyenne = cfg.vitesseMoyenne; // C15, désactivé par défaut
|
||||||
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
|
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
|
||||||
ajouter(verdicts, s, Controle.VITESSE, pts, nowMs, ex,
|
ajouter(verdicts, s, Controle.VITESSE, pts, nowMs, ex,
|
||||||
String.format(Locale.ROOT, "dxz=%.3f max=%.3f ticks=%d base=%.3f", m.dxz(),
|
String.format(Locale.ROOT, "dxz=%.3f max=%.3f ticks=%d base=%.3f", m.dxz(),
|
||||||
s.vitesse.dernierPermis() * Math.max(1, m.ticks()), m.ticks(), VitesseHorizontale.vitesseMax(m)));
|
s.vitesse.dernierPermis() * Math.max(1, m.ticks()), m.ticks(), VitesseHorizontale.vitesseMax(m)));
|
||||||
}
|
}
|
||||||
if (vol) {
|
boolean graceElytres = false;
|
||||||
|
if (m.auSolServeur()) {
|
||||||
|
s.graceElytresJusquaMs = Long.MIN_VALUE; // atterrissage : fin de la grâce de fin d'élytres
|
||||||
|
} else if (nowMs <= s.graceElytresJusquaMs) {
|
||||||
|
graceElytres = true;
|
||||||
|
}
|
||||||
|
if (vol && graceElytres) {
|
||||||
|
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);
|
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()));
|
ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy()));
|
||||||
}
|
}
|
||||||
@@ -292,6 +440,7 @@ public final class Moteur {
|
|||||||
* Un mouvement de véhicule piloté par le joueur, accepté par le serveur (F20) : vitesse et vol du véhicule.
|
* Un mouvement de véhicule piloté par le joueur, accepté par le serveur (F20) : vitesse et vol du véhicule.
|
||||||
*/
|
*/
|
||||||
public List<Verdict> vehicule(UUID joueur, long nowMs, EtatJoueur etat, EtatVehicule m) {
|
public List<Verdict> vehicule(UUID joueur, long nowMs, EtatJoueur etat, EtatVehicule m) {
|
||||||
|
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||||
boolean vitesse = cfg.mode(Controle.VEHICULE_VITESSE) != Mode.OFF;
|
boolean vitesse = cfg.mode(Controle.VEHICULE_VITESSE) != Mode.OFF;
|
||||||
boolean vol = cfg.mode(Controle.VEHICULE_VOL) != Mode.OFF;
|
boolean vol = cfg.mode(Controle.VEHICULE_VOL) != Mode.OFF;
|
||||||
if (!vitesse && !vol) return List.of();
|
if (!vitesse && !vol) return List.of();
|
||||||
@@ -337,6 +486,108 @@ public final class Moteur {
|
|||||||
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** 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 (cfg.mode(Controle.AUTO_TOTEM) == Mode.OFF || 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 (cfg.mode(Controle.AUTO_TOTEM) == Mode.OFF || expulses.contains(joueur)) return List.of();
|
||||||
|
Suivi s = suivis.get(joueur);
|
||||||
|
if (s == null) return List.of();
|
||||||
|
List<Verdict> v = new ArrayList<>(1);
|
||||||
|
ajouter(v, s, Controle.AUTO_TOTEM, s.totem.mains(nowMs, totemEnMain, etat.pingMs(), cfg), nowMs,
|
||||||
|
Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT), "totem remis en main trop vite apres l'eclatement");
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Setback, expulsion, position de retour (16/10, incident VOL) ----------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* C2 (16/10) : un retour en arrière vient d'être appliqué. Le contrôle vol et la vitesse repartent de zéro (le
|
||||||
|
* paquet suivant sert de référence) et leurs VL sont remis à zéro ; le setback est compté pour l'escalade (C5).
|
||||||
|
*/
|
||||||
|
public void apresSetback(UUID joueur, long nowMs) {
|
||||||
|
Suivi s = suivi(joueur);
|
||||||
|
s.vol.vider();
|
||||||
|
s.vitesse.vider();
|
||||||
|
s.graceElytresJusquaMs = Long.MIN_VALUE;
|
||||||
|
s.vl.remettreAZero(Controle.VOL);
|
||||||
|
s.vl.remettreAZero(Controle.VITESSE);
|
||||||
|
s.noterSetback(nowMs);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* C4 (16/10) : expulsion à usage unique. Vrai la première fois seulement ; ensuite le joueur n'est plus évalué
|
||||||
|
* jusqu'à sa reconnexion ({@link #oublierExpulsion}). La marque survit à {@link #retirer} (C6).
|
||||||
|
*/
|
||||||
|
public boolean expulser(UUID joueur, long nowMs) {
|
||||||
|
return expulses.add(joueur);
|
||||||
|
}
|
||||||
|
|
||||||
|
public boolean estExpulse(UUID joueur) {
|
||||||
|
return expulses.contains(joueur);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Reconnexion du joueur : il repart d'un état neuf. */
|
||||||
|
public void oublierExpulsion(UUID joueur) {
|
||||||
|
expulses.remove(joueur);
|
||||||
|
suivis.remove(joueur);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* C3 (16/10) : la position d'un paquet sans verdict ne sert de retour en arrière que si le joueur est au sol vu
|
||||||
|
* par le serveur (ou dans un milieu où la gravité vanilla ne s'applique pas : eau, échelle…). Avant, toute
|
||||||
|
* position était gardée, y compris pendant les 10 ticks anormaux tolérés : retour en l'air.
|
||||||
|
*/
|
||||||
|
public boolean positionDeRetourAdmise(boolean auSolServeur, boolean milieuSpecial) {
|
||||||
|
return auSolServeur || milieuSpecial;
|
||||||
|
}
|
||||||
|
|
||||||
// --- Interne ----------------------------------------------------------------------------------------
|
// --- Interne ----------------------------------------------------------------------------------------
|
||||||
|
|
||||||
private void ajouter(List<Verdict> sortie, Suivi s, Controle c, double points, long nowMs,
|
private void ajouter(List<Verdict> sortie, Suivi s, Controle c, double points, long nowMs,
|
||||||
@@ -345,7 +596,16 @@ public final class Moteur {
|
|||||||
Mode mode = cfg.mode(c);
|
Mode mode = cfg.mode(c);
|
||||||
double vl = s.vl.ajouter(c, points, nowMs);
|
double vl = s.vl.ajouter(c, points, nowMs);
|
||||||
Sanction palier = Paliers.palier(vl, cfg);
|
Sanction palier = Paliers.palier(vl, cfg);
|
||||||
|
// 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);
|
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.
|
||||||
|
if (c == Controle.VELOCITE || c == Controle.AUTO_TOTEM) 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()
|
boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal()
|
||||||
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
|
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
|
||||||
sortie.add(new Verdict(c, mode, points, vl, palier, applicable, notifier, details, ex.raisons()));
|
sortie.add(new Verdict(c, mode, points, vl, palier, applicable, notifier, details, ex.raisons()));
|
||||||
|
|||||||
@@ -0,0 +1,43 @@
|
|||||||
|
package com.gastinelgarde.core;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Revue 4 (16/10/2026) : ping le plus bas vu sur les 2 dernières minutes, par tranches de 10 s.
|
||||||
|
*
|
||||||
|
* La fenêtre d'historique de coups-hors-boite suivait le ping déclaré : un client qui gonfle son ping pendant un
|
||||||
|
* combat (réponses keep-alive retardées) élargissait la fenêtre et cachait un « hitbox » ou un « reach ». Elle suit
|
||||||
|
* maintenant ce plancher (plus une marge, voir {@link GardeConfig#seriePingMargeMs}) : le ping qui monte d'un coup
|
||||||
|
* n'élargit plus rien, un ping durablement élevé (plus de 2 minutes) est de nouveau pris en compte.
|
||||||
|
*
|
||||||
|
* Coût constant : 12 tranches.
|
||||||
|
*/
|
||||||
|
final class PingPlancher {
|
||||||
|
|
||||||
|
static final long TRANCHE_MS = 10_000;
|
||||||
|
static final int TRANCHES = 12;
|
||||||
|
|
||||||
|
private final long[] tranche = new long[TRANCHES];
|
||||||
|
private final int[] min = new int[TRANCHES];
|
||||||
|
|
||||||
|
PingPlancher() {
|
||||||
|
java.util.Arrays.fill(tranche, Long.MIN_VALUE);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Note le ping déclaré et renvoie le plancher (ce ping s'il n'y a rien d'autre). */
|
||||||
|
int noter(long nowMs, int ping) {
|
||||||
|
long t = Math.floorDiv(nowMs, TRANCHE_MS);
|
||||||
|
int i = (int) Math.floorMod(t, (long) TRANCHES);
|
||||||
|
if (tranche[i] != t) {
|
||||||
|
tranche[i] = t;
|
||||||
|
min[i] = ping;
|
||||||
|
} else {
|
||||||
|
min[i] = Math.min(min[i], ping);
|
||||||
|
}
|
||||||
|
int plancher = ping;
|
||||||
|
for (int k = 0; k < TRANCHES; k++) {
|
||||||
|
if (tranche[k] != Long.MIN_VALUE && t - tranche[k] < TRANCHES && tranche[k] <= t) {
|
||||||
|
plancher = Math.min(plancher, min[k]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return plancher;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,163 @@
|
|||||||
|
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];
|
||||||
|
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;
|
||||||
|
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];
|
||||||
|
return mediane >= vitesseGrace + GAIN_MIN || min >= 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;
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
} 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;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -98,7 +98,7 @@ public final class PorteeHitbox {
|
|||||||
*/
|
*/
|
||||||
public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) {
|
public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) {
|
||||||
if (e.riptide()) return "riptide";
|
if (e.riptide()) return "riptide";
|
||||||
if (e.elytres()) return "elytres";
|
if (e.elytres() && !cfg.elytresExemptionStricte) return "elytres"; // C7 : mesuré avec l'option
|
||||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) return "teleportation";
|
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) return "teleportation";
|
||||||
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul";
|
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul";
|
||||||
if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide";
|
if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide";
|
||||||
@@ -126,4 +126,94 @@ public final class PorteeHitbox {
|
|||||||
if (!(manque > seuil)) return 0;
|
if (!(manque > seuil)) return 0;
|
||||||
return 1.0 + Math.min(2.0, (manque - seuil) / 0.3);
|
return 1.0 + Math.min(2.0, (manque - seuil) / 0.3);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// --- Mesure compensée par l'historique de la cible (#92, contrôle coups-hors-boite) ----------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Écart maximal (en entrées d'historique) entre deux boîtes réunies : la cible affichée est interpolée en
|
||||||
|
* ligne droite entre deux positions reçues, espacées de 2 ticks (joueur) à 3 ticks (mob) ; la boîte englobante
|
||||||
|
* de deux boîtes contient tout le segment qui les relie.
|
||||||
|
*/
|
||||||
|
public static final int ECART_REUNION_MAX = 3;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Mesure compensée.
|
||||||
|
*
|
||||||
|
* @param distance distance minimale œil – boîte, sur tous les yeux et toutes les boîtes candidates
|
||||||
|
* @param manque gonflement minimal pour que l'un des regards touche l'une des boîtes candidates
|
||||||
|
* @param deplacementMax plus grand déplacement de la cible d'une entrée d'historique à la suivante (blocs)
|
||||||
|
*/
|
||||||
|
public record Mesure(double distance, double manque, double deplacementMax) { }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Fenêtre d'historique (ticks) où le client a pu voir la cible : retard d'affichage de base, plus le ping
|
||||||
|
* (aller-retour : la position part vers l'attaquant, le coup revient), borné.
|
||||||
|
*/
|
||||||
|
public static int ticksFenetre(int pingMs, GardeConfig cfg) {
|
||||||
|
int ping = Math.min(Math.max(0, pingMs), Math.max(0, cfg.seriePingMaxMs));
|
||||||
|
return Math.max(0, cfg.ticksAffichageCible) + (int) Math.ceil(ping / 50.0);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Distance et manque minimaux sur toutes les combinaisons (œil, regard, boîte candidate). Boîtes candidates :
|
||||||
|
* chaque boîte de l'historique, et la boîte englobante de deux boîtes distantes d'au plus
|
||||||
|
* {@link #ECART_REUNION_MAX} entrées (position interpolée entre les deux), sauf si la cible a « sauté » plus
|
||||||
|
* de {@code sautMax} blocs par entrée entre elles (téléportation : pas d'interpolation).
|
||||||
|
*
|
||||||
|
* Toutes les sources d'écart honnêtes sont prises du côté favorable au joueur : œil précédent, actuel et
|
||||||
|
* suivant (le client vise depuis une position interpolée entre deux paquets), regard actuel et suivant.
|
||||||
|
*/
|
||||||
|
public static Mesure mesureCompensee(double[][] yeux, double[][] regards, double[][] boites, double longueur,
|
||||||
|
double sautMax) {
|
||||||
|
double distance = Double.MAX_VALUE;
|
||||||
|
double manque = MANQUE_MAX;
|
||||||
|
double deplacementMax = 0;
|
||||||
|
for (int i = 1; i < boites.length; i++) deplacementMax = Math.max(deplacementMax, ecartCentres(boites[i - 1], boites[i]));
|
||||||
|
for (int i = 0; i < boites.length; i++) {
|
||||||
|
for (int k = 0; k <= ECART_REUNION_MAX && i + k < boites.length; k++) {
|
||||||
|
double[] b;
|
||||||
|
if (k == 0) {
|
||||||
|
b = boites[i];
|
||||||
|
} else {
|
||||||
|
if (ecartCentres(boites[i], boites[i + k]) > sautMax * k) continue;
|
||||||
|
b = reunion(boites[i], boites[i + k]);
|
||||||
|
}
|
||||||
|
for (double[] oeil : yeux) {
|
||||||
|
if (oeil == null) continue;
|
||||||
|
distance = Math.min(distance, distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]));
|
||||||
|
for (double[] r : regards) {
|
||||||
|
if (r == null || manque == 0) continue;
|
||||||
|
manque = Math.min(manque, manqueRegard(oeil[0], oeil[1], oeil[2], r[0], r[1], r[2], longueur,
|
||||||
|
b[0], b[1], b[2], b[3], b[4], b[5]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (distance == Double.MAX_VALUE) distance = 0;
|
||||||
|
return new Mesure(distance, manque, deplacementMax);
|
||||||
|
}
|
||||||
|
|
||||||
|
static double ecartCentres(double[] a, double[] b) {
|
||||||
|
double dx = (a[0] + a[3] - b[0] - b[3]) / 2, dy = (a[1] + a[4] - b[1] - b[4]) / 2, dz = (a[2] + a[5] - b[2] - b[5]) / 2;
|
||||||
|
return Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||||
|
}
|
||||||
|
|
||||||
|
static double[] reunion(double[] a, double[] b) {
|
||||||
|
return new double[] {Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.min(a[2], b[2]),
|
||||||
|
Math.max(a[3], b[3]), Math.max(a[4], b[4]), Math.max(a[5], b[5])};
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Situations où la mesure compensée n'est pas fiable (en plus de {@link #raisonNonMesure}, sans la vitesse
|
||||||
|
* instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées).
|
||||||
|
*
|
||||||
|
* Revue 1 (16/10) : un ping au-delà de {@link GardeConfig#seriePingMaxMs} n'exempte plus le coup (le ping est
|
||||||
|
* falsifiable) ; la fenêtre reste bornée à ce ping par {@link #ticksFenetre}.
|
||||||
|
*/
|
||||||
|
public static String raisonNonMesureSerie(EtatJoueur e, GardeConfig cfg) {
|
||||||
|
String r = raisonNonMesure(e, 0, cfg);
|
||||||
|
if (r != null) return r;
|
||||||
|
if (e.ticksDepuisGel() <= cfg.graceGelTicks) return "gel-serveur";
|
||||||
|
return null;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -0,0 +1,62 @@
|
|||||||
|
package com.gastinelgarde.core;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Contrôle « coups-hors-boite » (#92, 16/10/2026) : sur les derniers coups mesurés, combien ont touché une cible
|
||||||
|
* que le regard ne touchait nulle part, même en tenant compte de toutes les positions où le client a pu la voir.
|
||||||
|
*
|
||||||
|
* Un joueur honnête vise ce qu'il voit : sa mesure compensée vaut 0 (aux erreurs de modèle près, rares et isolées).
|
||||||
|
* Un client « hitbox » (boîtes grossies) ou « reach » touche régulièrement à côté ou trop loin. Un coup isolé ne
|
||||||
|
* prouve rien ; une proportion soutenue, si. Tampon de taille fixe, aucune allocation.
|
||||||
|
*/
|
||||||
|
public final class SerieCoups {
|
||||||
|
|
||||||
|
public static final int TAILLE_MAX = 32;
|
||||||
|
|
||||||
|
private final long[] instants = new long[TAILLE_MAX];
|
||||||
|
private final boolean[] hors = new boolean[TAILLE_MAX];
|
||||||
|
private int taille;
|
||||||
|
private int tete;
|
||||||
|
private int dernierCompte;
|
||||||
|
private int dernierTotal;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Enregistre un coup mesuré.
|
||||||
|
*
|
||||||
|
* @return points : {@link GardeConfig#seriePoints} si ce coup est hors boîte ET qu'au moins
|
||||||
|
* {@link GardeConfig#serieHorsMin} des {@link GardeConfig#serieCoups} derniers coups (dans
|
||||||
|
* {@link GardeConfig#serieFenetreMs}) le sont aussi ; 0 sinon.
|
||||||
|
*/
|
||||||
|
public double enregistrer(long nowMs, boolean horsBoite, GardeConfig cfg) {
|
||||||
|
int n = Math.max(1, Math.min(TAILLE_MAX, cfg.serieCoups));
|
||||||
|
instants[tete] = nowMs;
|
||||||
|
hors[tete] = horsBoite;
|
||||||
|
tete = (tete + 1) % TAILLE_MAX;
|
||||||
|
if (taille < TAILLE_MAX) taille++;
|
||||||
|
|
||||||
|
int compte = 0, total = 0;
|
||||||
|
for (int k = 0; k < Math.min(n, taille); k++) {
|
||||||
|
int i = ((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX;
|
||||||
|
if (nowMs - instants[i] > cfg.serieFenetreMs || instants[i] > nowMs) break;
|
||||||
|
total++;
|
||||||
|
if (hors[i]) compte++;
|
||||||
|
}
|
||||||
|
dernierCompte = compte;
|
||||||
|
dernierTotal = total;
|
||||||
|
return horsBoite && compte >= cfg.serieHorsMin ? cfg.seriePoints : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Coups hors boîte parmi les derniers comptés (pour le journal). */
|
||||||
|
public int dernierCompte() {
|
||||||
|
return dernierCompte;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Coups comptés au dernier enregistrement (pour le journal). */
|
||||||
|
public int dernierTotal() {
|
||||||
|
return dernierTotal;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void vider() {
|
||||||
|
taille = 0;
|
||||||
|
tete = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -14,11 +14,36 @@ public final class Suivi {
|
|||||||
public final VitesseHorizontale vitesse = new VitesseHorizontale();
|
public final VitesseHorizontale vitesse = new VitesseHorizontale();
|
||||||
public final VolVertical vol = new VolVertical();
|
public final VolVertical vol = new VolVertical();
|
||||||
public final VehiculeMouvement vehicule = new VehiculeMouvement();
|
public final VehiculeMouvement vehicule = new VehiculeMouvement();
|
||||||
|
/** #92 : derniers coups mesurés avec l'historique de la cible (contrôle coups-hors-boite). */
|
||||||
|
public final SerieCoups serie = new SerieCoups();
|
||||||
|
/** Revue 4 (16/10) : ping le plus bas des 2 dernières minutes (fenêtre de coups-hors-boite). */
|
||||||
|
final PingPlancher pingPlancher = new PingPlancher();
|
||||||
|
/**
|
||||||
|
* C13 (16/10) : derniers coups dont l'angle killaura n'était bon que grâce à un regard suivant à plus de 90° du
|
||||||
|
* regard du coup (rotation silencieuse). Mêmes réglages de série que coups-hors-boite.
|
||||||
|
*/
|
||||||
|
public final SerieCoups regardsSauves = new SerieCoups();
|
||||||
|
|
||||||
/** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
|
/** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
|
||||||
CoupDiffere coupDiffere;
|
CoupDiffere coupDiffere;
|
||||||
/** Jusqu'à quand (ms) les coups sont annulés après une sanction portée / hitbox en ENFORCE. */
|
/** Jusqu'à quand (ms) les coups sont annulés après une sanction portée / hitbox en ENFORCE. */
|
||||||
long coupsBloquesJusqua = Long.MIN_VALUE;
|
long coupsBloquesJusqua = Long.MIN_VALUE;
|
||||||
|
/** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */
|
||||||
|
long graceElytresJusquaMs = Long.MIN_VALUE;
|
||||||
|
/** 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<>();
|
||||||
|
|
||||||
|
void noterSetback(long nowMs) {
|
||||||
|
setbacks.addLast(nowMs);
|
||||||
|
while (setbacks.size() > 32) setbacks.removeFirst();
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Nombre de setbacks dans la fenêtre {@code fenetreMs} qui précède {@code nowMs}. */
|
||||||
|
int setbacksRecents(long nowMs, long fenetreMs) {
|
||||||
|
int n = 0;
|
||||||
|
for (long t : setbacks) if (nowMs - t <= fenetreMs) n++;
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
// Dernière position jugée valide (retour en arrière).
|
// Dernière position jugée valide (retour en arrière).
|
||||||
private boolean positionValide;
|
private boolean positionValide;
|
||||||
@@ -28,8 +53,20 @@ public final class Suivi {
|
|||||||
|
|
||||||
private final Map<Controle, Long> derniereAlerte = new EnumMap<>(Controle.class);
|
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();
|
||||||
|
|
||||||
public Suivi(double decroissanceParSeconde) {
|
public Suivi(double decroissanceParSeconde) {
|
||||||
|
this(decroissanceParSeconde, new GardeConfig());
|
||||||
|
}
|
||||||
|
|
||||||
|
public Suivi(double decroissanceParSeconde, GardeConfig cfg) {
|
||||||
this.vl = new VlCompteur(decroissanceParSeconde);
|
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) {
|
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();
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -16,7 +16,36 @@ public final class TimerPaquets {
|
|||||||
|
|
||||||
private final CompteurTranches compteur = new CompteurTranches(TRANCHE_MS, SECONDES_MAX * TRANCHES_PAR_SECONDE + 1);
|
private final CompteurTranches compteur = new CompteurTranches(TRANCHE_MS, SECONDES_MAX * TRANCHES_PAR_SECONDE + 1);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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}.
|
||||||
|
*/
|
||||||
|
static final double CREDIT_MAX = 40;
|
||||||
|
private double solde;
|
||||||
|
private long dernierMs = Long.MIN_VALUE;
|
||||||
|
|
||||||
|
private double solde(long nowMs, GardeConfig cfg, double facteur) {
|
||||||
|
if (cfg.timerSoldeMax <= 0) return 0;
|
||||||
|
if (dernierMs == Long.MIN_VALUE) {
|
||||||
|
dernierMs = nowMs;
|
||||||
|
solde = 0;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
solde += 1.0 - Math.max(0, nowMs - dernierMs) / (double) TRANCHE_MS;
|
||||||
|
solde = Math.max(-CREDIT_MAX, solde);
|
||||||
|
dernierMs = Math.max(dernierMs, nowMs);
|
||||||
|
double max = cfg.timerSoldeMax * facteur;
|
||||||
|
if (solde <= max) return 0;
|
||||||
|
return 1.0 + Math.min(3.0, (solde - max) / 20.0);
|
||||||
|
}
|
||||||
|
|
||||||
public double enregistrer(long nowMs, GardeConfig cfg, double facteur) {
|
public double enregistrer(long nowMs, GardeConfig cfg, double facteur) {
|
||||||
|
double ptsSolde = solde(nowMs, cfg, facteur);
|
||||||
|
return Math.max(ptsSolde, enregistrerDebit(nowMs, cfg, facteur));
|
||||||
|
}
|
||||||
|
|
||||||
|
private double enregistrerDebit(long nowMs, GardeConfig cfg, double facteur) {
|
||||||
compteur.ajouter(nowMs);
|
compteur.ajouter(nowMs);
|
||||||
int max = (int) Math.floor(cfg.paquetsParSecondeMax * facteur);
|
int max = (int) Math.floor(cfg.paquetsParSecondeMax * facteur);
|
||||||
int secondes = Math.min(SECONDES_MAX, Math.max(1, cfg.timerSecondesSoutenues));
|
int secondes = Math.min(SECONDES_MAX, Math.max(1, cfg.timerSecondesSoutenues));
|
||||||
@@ -31,5 +60,7 @@ public final class TimerPaquets {
|
|||||||
|
|
||||||
public void vider() {
|
public void vider() {
|
||||||
compteur.vider();
|
compteur.vider();
|
||||||
|
solde = 0;
|
||||||
|
dernierMs = Long.MIN_VALUE;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -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 ? 2.0 : 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();
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -56,6 +56,24 @@ public final class VitesseHorizontale {
|
|||||||
private int ticksDepuisSortie = Integer.MAX_VALUE;
|
private int ticksDepuisSortie = Integer.MAX_VALUE;
|
||||||
private double dernierPermis;
|
private double dernierPermis;
|
||||||
|
|
||||||
|
// --- C15 (16/10) : vitesse moyenne, option {@link GardeConfig#vitesseMoyenne} désactivée par défaut ---
|
||||||
|
/** Fenêtre (paquets) sur laquelle la vitesse moyenne est comparée à la moyenne vanilla. */
|
||||||
|
public static final int MOYENNE_PAQUETS = 40;
|
||||||
|
/** Moyenne vanilla en course au sol (0,2806 bloc/tick en régime établi) et en sprint-saut (~0,356, 7,13 m/s). */
|
||||||
|
public static final double MOYENNE_COURSE_SOL = 0.29;
|
||||||
|
public static final double MOYENNE_COURSE_AIR = 0.36;
|
||||||
|
/** Marche : au sol 0,216 ; en l'air (saut en marchant) la base actuelle suffit. */
|
||||||
|
public static final double MOYENNE_MARCHE_SOL = 0.22;
|
||||||
|
/** Marge sur la moyenne attendue (arrondis, petites accélérations). [À VÉRIFIER] avec des traces réelles. */
|
||||||
|
public static final double MOYENNE_MARGE = 0.08;
|
||||||
|
|
||||||
|
/** Activé par le moteur selon la configuration. */
|
||||||
|
boolean moyenne;
|
||||||
|
private final double[] moyDxz = new double[MOYENNE_PAQUETS];
|
||||||
|
private final double[] moyAttendu = new double[MOYENNE_PAQUETS];
|
||||||
|
private int moyIndex;
|
||||||
|
private int moyRemplis;
|
||||||
|
|
||||||
/** Vitesse maximale attendue (blocs par tick) pour cet état, avant la tolérance du lag. */
|
/** Vitesse maximale attendue (blocs par tick) pour cet état, avant la tolérance du lag. */
|
||||||
public static double vitesseMax(EtatMouvement e) {
|
public static double vitesseMax(EtatMouvement e) {
|
||||||
double v;
|
double v;
|
||||||
@@ -84,6 +102,7 @@ public final class VitesseHorizontale {
|
|||||||
double base = vitesseMax(e) * facteur;
|
double base = vitesseMax(e) * facteur;
|
||||||
if (e.milieuSpecial() || e.frictionAnormale()) {
|
if (e.milieuSpecial() || e.frictionAnormale()) {
|
||||||
// Glace, eau, échelle… : non contrôlé, mais l'élan qui en sort est légitime.
|
// Glace, eau, échelle… : non contrôlé, mais l'élan qui en sort est légitime.
|
||||||
|
viderMoyenne();
|
||||||
pousser(0);
|
pousser(0);
|
||||||
memoriser(e.dxz(), base, TRAINEE_AIR);
|
memoriser(e.dxz(), base, TRAINEE_AIR);
|
||||||
avancerSortie(ticks);
|
avancerSortie(ticks);
|
||||||
@@ -105,13 +124,49 @@ public final class VitesseHorizontale {
|
|||||||
// Un paquet = un tick du client, même arrivé après 2 ticks serveur : l'élan est son déplacement, borné par le
|
// Un paquet = un tick du client, même arrivé après 2 ticks serveur : l'élan est son déplacement, borné par le
|
||||||
// permis d'UN tick (sinon un client qui n'envoie qu'un paquet sur deux se construirait un élan).
|
// permis d'UN tick (sinon un client qui n'envoie qu'un paquet sur deux se construirait un élan).
|
||||||
memoriser(Math.min(e.dxz(), permisParTick), base, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
|
memoriser(Math.min(e.dxz(), permisParTick), base, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
|
||||||
|
boolean sortieRecente = ticksDepuisSortie < MOYENNE_PAQUETS;
|
||||||
avancerSortie(ticks);
|
avancerSortie(ticks);
|
||||||
|
double ptsMoyenne = moyenne ? moyenne(e, ticks, facteur, sortieRecente) : 0;
|
||||||
|
|
||||||
if (depasse <= 0) return 0;
|
if (depasse <= 0) return ptsMoyenne;
|
||||||
double total = 0;
|
double total = 0;
|
||||||
for (double v : exces) total += v;
|
for (double v : exces) total += v;
|
||||||
if (total <= seuilBlocs) return 0;
|
if (total <= seuilBlocs) return ptsMoyenne;
|
||||||
return 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0);
|
return Math.max(ptsMoyenne, 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0));
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* C15 (16/10) : la base en l'air (0,42 dès que le joueur court) et le tampon de 1,5 bloc sur 20 ticks laissaient
|
||||||
|
* passer un Speed à 0,37-0,40 bloc/tick sans fin. Ici, la moyenne des {@link #MOYENNE_PAQUETS} derniers paquets est
|
||||||
|
* comparée à la moyenne vanilla du même état (course au sol, sprint-saut). Pas de mesure juste après un état
|
||||||
|
* exempté (élan hérité) ni dans un milieu non contrôlé (fenêtre vidée).
|
||||||
|
*/
|
||||||
|
private double moyenne(EtatMouvement e, int ticks, double facteur, boolean sortieRecente) {
|
||||||
|
if (sortieRecente) {
|
||||||
|
viderMoyenne();
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
double base = vitesseMax(e);
|
||||||
|
double brut;
|
||||||
|
if (e.furtif() || e.ralentiParObjet()) brut = base; // pas de moyenne connue : la borne actuelle
|
||||||
|
else if (e.sprint()) brut = base * (e.auSolServeur() ? MOYENNE_COURSE_SOL / COURSE : MOYENNE_COURSE_AIR / COURSE_SAUT);
|
||||||
|
else brut = e.auSolServeur() ? base * MOYENNE_MARCHE_SOL / MARCHE : base;
|
||||||
|
moyDxz[moyIndex] = e.dxz();
|
||||||
|
moyAttendu[moyIndex] = brut * facteur * ticks;
|
||||||
|
moyIndex = (moyIndex + 1) % MOYENNE_PAQUETS;
|
||||||
|
if (moyRemplis < MOYENNE_PAQUETS) moyRemplis++;
|
||||||
|
if (moyRemplis < MOYENNE_PAQUETS) return 0;
|
||||||
|
double d = 0, a = 0;
|
||||||
|
for (int i = 0; i < MOYENNE_PAQUETS; i++) {
|
||||||
|
d += moyDxz[i];
|
||||||
|
a += moyAttendu[i];
|
||||||
|
}
|
||||||
|
return d > a * (1.0 + MOYENNE_MARGE) ? 0.5 : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void viderMoyenne() {
|
||||||
|
moyIndex = 0;
|
||||||
|
moyRemplis = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -125,6 +180,7 @@ public final class VitesseHorizontale {
|
|||||||
public void exempter(EtatMouvement e, double facteur, boolean sortieDEtat) {
|
public void exempter(EtatMouvement e, double facteur, boolean sortieDEtat) {
|
||||||
java.util.Arrays.fill(exces, 0);
|
java.util.Arrays.fill(exces, 0);
|
||||||
index = 0;
|
index = 0;
|
||||||
|
viderMoyenne();
|
||||||
int ticks = Math.max(1, e.ticks());
|
int ticks = Math.max(1, e.ticks());
|
||||||
memoriser(e.dxz(), vitesseMax(e) * facteur, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
|
memoriser(e.dxz(), vitesseMax(e) * facteur, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
|
||||||
if (sortieDEtat) ticksDepuisSortie = 0;
|
if (sortieDEtat) ticksDepuisSortie = 0;
|
||||||
@@ -161,5 +217,6 @@ public final class VitesseHorizontale {
|
|||||||
aElan = false;
|
aElan = false;
|
||||||
elan = 0;
|
elan = 0;
|
||||||
ticksDepuisSortie = Integer.MAX_VALUE;
|
ticksDepuisSortie = Integer.MAX_VALUE;
|
||||||
|
viderMoyenne();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -42,6 +42,11 @@ public final class VlCompteur {
|
|||||||
etats.clear();
|
etats.clear();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** C2 (16/10) : remet à zéro un seul contrôle (après un setback). */
|
||||||
|
public void remettreAZero(Controle c) {
|
||||||
|
etats.remove(c);
|
||||||
|
}
|
||||||
|
|
||||||
private double decayed(Etat e, long nowMs) {
|
private double decayed(Etat e, long nowMs) {
|
||||||
if (nowMs <= e.dernierMs) return e.valeur;
|
if (nowMs <= e.dernierMs) return e.valeur;
|
||||||
double perdu = (nowMs - e.dernierMs) / 1000.0 * decroissanceParSeconde;
|
double perdu = (nowMs - e.dernierMs) / 1000.0 * decroissanceParSeconde;
|
||||||
|
|||||||
@@ -19,6 +19,33 @@ public final class VolVertical {
|
|||||||
private boolean etaitEnAir;
|
private boolean etaitEnAir;
|
||||||
private int anormauxConsecutifs;
|
private int anormauxConsecutifs;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Rafales réseau (16/10) : ticks serveur écoulés moins ticks client couverts par les paquets déjà vus. Un paquet
|
||||||
|
* d'un tick client reçu après 3 ticks serveur laisse 2 ticks « dus », couverts ensuite par les paquets à 0 tick de
|
||||||
|
* la même rafale. Borné à {@link #AVANCE_MAX} : au-delà, on revient à la règle stricte (n-1 ou n ticks), donc
|
||||||
|
* un client qui ralentit durablement sa chute (un tick de gravité toutes les 3 ticks) reste vu.
|
||||||
|
*/
|
||||||
|
public static final int AVANCE_MAX = 4;
|
||||||
|
private int avance;
|
||||||
|
|
||||||
|
// --- C10 (16/10) : option {@link GardeConfig#volFenetreGlissante}, désactivée par défaut ---
|
||||||
|
/** Fenêtre glissante (ticks en l'air évalués) où l'on compte les ticks anormaux. */
|
||||||
|
public static final int FENETRE_TICKS = 20;
|
||||||
|
/** Plus de ticks anormaux que ça dans la fenêtre : infraction (alterner 1 anormal / 1 normal en donne 10). */
|
||||||
|
public static final int FENETRE_ANORMAUX_MAX = 8;
|
||||||
|
/** Un « saut en l'air » : montée d'au moins ça (blocs) au-dessus de la prévision de gravité, sans appui. */
|
||||||
|
public static final double SAUT_EN_L_AIR_MIN = 0.2;
|
||||||
|
/** Deux sauts en l'air à moins de ce nombre de ticks en l'air l'un de l'autre : infraction. */
|
||||||
|
public static final int SAUTS_FENETRE_TICKS = 60;
|
||||||
|
|
||||||
|
/** Activé par le moteur selon la configuration. */
|
||||||
|
boolean fenetreGlissante;
|
||||||
|
private final boolean[] fenetre = new boolean[FENETRE_TICKS];
|
||||||
|
private int fenetreIndex;
|
||||||
|
private int fenetreAnormaux;
|
||||||
|
private int ticksEnAir;
|
||||||
|
private int dernierSautEnAir = Integer.MIN_VALUE;
|
||||||
|
|
||||||
/** Au-delà, l'écart entre deux paquets est trop grand pour prédire (lag) : on oublie la vitesse. */
|
/** Au-delà, l'écart entre deux paquets est trop grand pour prédire (lag) : on oublie la vitesse. */
|
||||||
public static final int TICKS_MAX = 40;
|
public static final int TICKS_MAX = 40;
|
||||||
|
|
||||||
@@ -33,9 +60,12 @@ public final class VolVertical {
|
|||||||
*/
|
*/
|
||||||
public double enregistrer(EtatMouvement e, boolean exempt) {
|
public double enregistrer(EtatMouvement e, boolean exempt) {
|
||||||
int n = e.ticks();
|
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) {
|
if (n > TICKS_MAX || n < 0) {
|
||||||
aVitesse = false;
|
aVitesse = false;
|
||||||
return 0;
|
avance = 0;
|
||||||
|
return ptsFlottement;
|
||||||
}
|
}
|
||||||
boolean enAir = !e.auSolServeur();
|
boolean enAir = !e.auSolServeur();
|
||||||
double dy = e.dy();
|
double dy = e.dy();
|
||||||
@@ -44,39 +74,125 @@ public final class VolVertical {
|
|||||||
|
|
||||||
if (exempt || e.milieuSpecial() || !enAir) {
|
if (exempt || e.milieuSpecial() || !enAir) {
|
||||||
anormauxConsecutifs = 0;
|
anormauxConsecutifs = 0;
|
||||||
|
avance = 0;
|
||||||
|
viderFenetre();
|
||||||
} else if (etaitEnAir && aVitesse) {
|
} else if (etaitEnAir && aVitesse) {
|
||||||
// Ticks candidats couverts par ce paquet : n exactement à l'heure ; n-1 ou n en retard ; 1 si 0.
|
// Ticks candidats couverts par ce paquet : n exactement à l'heure ; n-1 ou n en retard ; 1 si 0.
|
||||||
int kMin = n <= 1 ? 1 : n - 1;
|
// Rafales : jusqu'à AVANCE_MAX ticks dus peuvent rester en attente ; la règle d'avant reste toujours admise.
|
||||||
|
int kMin = Math.max(1, Math.min(n <= 1 ? 1 : n - 1, n + avance - AVANCE_MAX));
|
||||||
int kMax = Math.max(1, n);
|
int kMax = Math.max(1, n);
|
||||||
|
int kRetenu = kMax;
|
||||||
boolean ecart = true;
|
boolean ecart = true;
|
||||||
double v = derniereVitesse;
|
double v = derniereVitesse;
|
||||||
double somme = 0;
|
double somme = 0;
|
||||||
|
double sommeMax = -Double.MAX_VALUE; // la prévision la plus haute parmi les ticks candidats
|
||||||
for (int k = 1; k <= kMax; k++) {
|
for (int k = 1; k <= kMax; k++) {
|
||||||
v = (v - GRAVITE) * TRAINEE;
|
v = (v - GRAVITE) * TRAINEE;
|
||||||
somme += v;
|
somme += v;
|
||||||
|
if (k >= kMin) sommeMax = Math.max(sommeMax, somme);
|
||||||
if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) {
|
if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) {
|
||||||
ecart = false;
|
ecart = false;
|
||||||
vitesseFin = n <= 1 ? dy : v;
|
vitesseFin = n <= 1 ? dy : v;
|
||||||
|
kRetenu = k;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
avance = Math.max(0, Math.min(AVANCE_MAX, avance + n - kRetenu));
|
||||||
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08 par tick.
|
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08 par tick.
|
||||||
if (ecart) anormauxConsecutifs++;
|
if (ecart) anormauxConsecutifs++;
|
||||||
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
|
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
|
||||||
if (anormauxConsecutifs > TICKS_ANORMAUX) {
|
if (anormauxConsecutifs > TICKS_ANORMAUX) {
|
||||||
points = 1.0 + Math.min(3.0, (anormauxConsecutifs - TICKS_ANORMAUX) / 10.0);
|
points = 1.0 + Math.min(3.0, (anormauxConsecutifs - TICKS_ANORMAUX) / 10.0);
|
||||||
}
|
}
|
||||||
|
if (fenetreGlissante) {
|
||||||
|
points = Math.max(points, fenetreGlissante(ecart, dy, sommeMax, Math.max(1, n)));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
points = Math.max(points, ptsFlottement);
|
||||||
|
|
||||||
derniereVitesse = vitesseFin;
|
derniereVitesse = vitesseFin;
|
||||||
aVitesse = true;
|
aVitesse = true;
|
||||||
etaitEnAir = enAir;
|
etaitEnAir = enAir;
|
||||||
return points;
|
return points;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* C10 (16/10) : le compteur de ticks anormaux consécutifs redescend d'un cran à chaque tick normal ; un saut en
|
||||||
|
* l'air tous les 10 ticks, ou l'alternance d'un tick plané et d'un tick de gravité, ne l'atteignaient jamais.
|
||||||
|
* En plus : ticks anormaux comptés sur une fenêtre glissante, et tout gain d'altitude franc en l'air (sans sol,
|
||||||
|
* hors exemptions : recul, téléportation, milieux spéciaux) compté comme un saut en l'air ; le deuxième à moins
|
||||||
|
* de {@link #SAUTS_FENETRE_TICKS} ticks en l'air du précédent est une infraction.
|
||||||
|
*/
|
||||||
|
private double fenetreGlissante(boolean ecart, double dy, double prevision, int ticks) {
|
||||||
|
ticksEnAir += ticks;
|
||||||
|
if (fenetre[fenetreIndex]) fenetreAnormaux--;
|
||||||
|
fenetre[fenetreIndex] = ecart;
|
||||||
|
if (ecart) fenetreAnormaux++;
|
||||||
|
fenetreIndex = (fenetreIndex + 1) % FENETRE_TICKS;
|
||||||
|
double points = 0;
|
||||||
|
if (fenetreAnormaux > FENETRE_ANORMAUX_MAX) {
|
||||||
|
points = 1.0 + Math.min(3.0, (fenetreAnormaux - FENETRE_ANORMAUX_MAX) / 4.0);
|
||||||
|
}
|
||||||
|
if (ecart && dy > 0 && dy - prevision >= SAUT_EN_L_AIR_MIN) {
|
||||||
|
if (dernierSautEnAir != Integer.MIN_VALUE && ticksEnAir - dernierSautEnAir <= SAUTS_FENETRE_TICKS) {
|
||||||
|
points = Math.max(points, 2.0);
|
||||||
|
}
|
||||||
|
dernierSautEnAir = ticksEnAir;
|
||||||
|
}
|
||||||
|
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;
|
||||||
|
fenetreAnormaux = 0;
|
||||||
|
ticksEnAir = 0;
|
||||||
|
dernierSautEnAir = Integer.MIN_VALUE;
|
||||||
|
}
|
||||||
|
|
||||||
public void vider() {
|
public void vider() {
|
||||||
derniereVitesse = 0;
|
derniereVitesse = 0;
|
||||||
aVitesse = false;
|
aVitesse = false;
|
||||||
etaitEnAir = false;
|
etaitEnAir = false;
|
||||||
anormauxConsecutifs = 0;
|
anormauxConsecutifs = 0;
|
||||||
|
avance = 0;
|
||||||
|
flottementTicks = 0;
|
||||||
|
viderFenetre();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -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]]
|
[[mods]]
|
||||||
modId="gastinelgarde"
|
modId="gastinelgarde"
|
||||||
version="0.3.0"
|
version="0.3.1"
|
||||||
displayName="GastinelGarde"
|
displayName="GastinelGarde"
|
||||||
authors="Théo Gastinel"
|
authors="Théo Gastinel"
|
||||||
description='''Anti-triche maison : combat, cadence, rotation, timer (phase 1), no-fall, vitesse, vol et véhicules (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
|
description='''Anti-triche maison : combat, cadence, rotation, timer (phase 1), no-fall, vitesse, vol et véhicules (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
|
||||||
|
|||||||
@@ -0,0 +1,62 @@
|
|||||||
|
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.assertNull;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||||
|
|
||||||
|
import java.lang.reflect.Field;
|
||||||
|
import java.util.Map;
|
||||||
|
import net.minecraft.world.entity.Entity;
|
||||||
|
import net.minecraft.world.entity.EntityType;
|
||||||
|
import net.minecraft.world.entity.Marker;
|
||||||
|
import org.junit.jupiter.api.Assumptions;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Autotests du 16/10/2026, nuit : contournement n°3 de la revue de sécurité (table SUIVIES pleine).
|
||||||
|
*
|
||||||
|
* Corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) : quand la table est pleine, la cible non joueur suivie dont le
|
||||||
|
* dernier coup est le plus ancien est évincée au profit de la nouvelle (avant : la nouvelle n'était jamais suivie). La table est commune à
|
||||||
|
* tout le serveur, les joueurs connectés y comptent aussi (sans plafond), une entrée vit 10 s après le dernier coup.
|
||||||
|
*
|
||||||
|
* Le test remplit la table par réflexion avec des identifiants négatifs (jamais attribués) et frappe une entité
|
||||||
|
* « marker » construite sans monde. Si l'environnement de test ne permet pas de construire l'entité, le test est
|
||||||
|
* ignoré (assumption) au lieu d'échouer.
|
||||||
|
*/
|
||||||
|
class AutotestSuiviesTest {
|
||||||
|
|
||||||
|
@SuppressWarnings("unchecked")
|
||||||
|
@Test
|
||||||
|
void CORRIGE_revue3_tablePleineLaNouvelleCibleEvinceLaPlusAncienne() throws Exception {
|
||||||
|
Field fTable = Garde.class.getDeclaredField("SUIVIES");
|
||||||
|
fTable.setAccessible(true);
|
||||||
|
Map<Integer, Object> table = (Map<Integer, Object>) fTable.get(null);
|
||||||
|
Field fMax = Garde.class.getDeclaredField("SUIVIES_MAX");
|
||||||
|
fMax.setAccessible(true);
|
||||||
|
int max = fMax.getInt(null);
|
||||||
|
assertEquals(256, max);
|
||||||
|
|
||||||
|
Entity cible;
|
||||||
|
try {
|
||||||
|
cible = new Marker(EntityType.MARKER, null);
|
||||||
|
} catch (Throwable t) {
|
||||||
|
Assumptions.abort("entité impossible à construire hors jeu : " + t);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
table.clear();
|
||||||
|
try {
|
||||||
|
// Témoin : table vide, la cible frappée entre dans la table (mesurée au coup suivant).
|
||||||
|
assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet");
|
||||||
|
assertTrue(table.containsKey(cible.getId()), "témoin : la cible est suivie");
|
||||||
|
|
||||||
|
table.clear();
|
||||||
|
for (int i = 0; i < max; i++) table.put(-1 - i, null);
|
||||||
|
assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet");
|
||||||
|
assertTrue(table.containsKey(cible.getId()), "corrigé : table pleine, la cible est quand même suivie");
|
||||||
|
assertEquals(max, table.size(), "une entrée évincée, la table ne grandit pas");
|
||||||
|
} finally {
|
||||||
|
table.clear();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,336 @@
|
|||||||
|
package com.gastinelgarde;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||||
|
|
||||||
|
import com.gastinelgarde.core.GardeConfig;
|
||||||
|
import java.io.InputStream;
|
||||||
|
import java.lang.reflect.Field;
|
||||||
|
import java.lang.reflect.Method;
|
||||||
|
import java.lang.reflect.Proxy;
|
||||||
|
import java.nio.charset.StandardCharsets;
|
||||||
|
import java.nio.file.Files;
|
||||||
|
import java.nio.file.Path;
|
||||||
|
import java.util.HashSet;
|
||||||
|
import java.util.Set;
|
||||||
|
import net.neoforged.neoforge.common.ModConfigSpec;
|
||||||
|
import org.junit.jupiter.api.Assumptions;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
import org.objectweb.asm.ClassReader;
|
||||||
|
import org.objectweb.asm.tree.AbstractInsnNode;
|
||||||
|
import org.objectweb.asm.tree.ClassNode;
|
||||||
|
import org.objectweb.asm.tree.InvokeDynamicInsnNode;
|
||||||
|
import org.objectweb.asm.tree.MethodInsnNode;
|
||||||
|
import org.objectweb.asm.tree.MethodNode;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Câblage Minecraft (constat C4 ⚠️), partie qui demande les classes du jeu mais pas de serveur : événements
|
||||||
|
* NeoForge abonnés, gardes d'expulsion lues dans le bytecode, types d'entités (C18, F20), options (C7, C8, C10, C15,
|
||||||
|
* C18) du fichier toml jusqu'à la configuration du moteur.
|
||||||
|
*/
|
||||||
|
class CablageMinecraftTest {
|
||||||
|
|
||||||
|
// --- Bytecode ---
|
||||||
|
|
||||||
|
private static ClassNode lire(Class<?> c) throws Exception {
|
||||||
|
try (InputStream in = c.getResourceAsStream("/" + c.getName().replace('.', '/') + ".class")) {
|
||||||
|
assertNotNull(in, c.getName());
|
||||||
|
ClassNode n = new ClassNode();
|
||||||
|
new ClassReader(in).accept(n, 0);
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Méthodes appelées par une méthode et par ses lambdas (récursivement, dans la même classe). */
|
||||||
|
private static Set<String> appels(ClassNode classe, String methode) {
|
||||||
|
Set<String> sortie = new HashSet<>();
|
||||||
|
Set<String> vues = new HashSet<>();
|
||||||
|
parcourir(classe, methode, sortie, vues);
|
||||||
|
return sortie;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void parcourir(ClassNode classe, String methode, Set<String> sortie, Set<String> vues) {
|
||||||
|
if (!vues.add(methode)) return;
|
||||||
|
boolean trouvee = false;
|
||||||
|
for (MethodNode m : classe.methods) {
|
||||||
|
if (!m.name.equals(methode)) continue;
|
||||||
|
trouvee = true;
|
||||||
|
for (AbstractInsnNode i : m.instructions) {
|
||||||
|
if (i instanceof MethodInsnNode mi) {
|
||||||
|
sortie.add(mi.owner.substring(mi.owner.lastIndexOf('/') + 1) + "." + mi.name);
|
||||||
|
} else if (i instanceof InvokeDynamicInsnNode d) {
|
||||||
|
for (Object a : d.bsmArgs) {
|
||||||
|
if (a instanceof org.objectweb.asm.Handle h && h.getOwner().equals(classe.name)) {
|
||||||
|
parcourir(classe, h.getName(), sortie, vues);
|
||||||
|
} else if (a instanceof org.objectweb.asm.Handle h) {
|
||||||
|
sortie.add(h.getOwner().substring(h.getOwner().lastIndexOf('/') + 1) + "." + h.getName());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertTrue(trouvee, methode);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C4_lesPointsDEntreeConsultentLaMarqueDExpulsion() throws Exception {
|
||||||
|
ClassNode garde = lire(Garde.class);
|
||||||
|
ClassNode events = lire(GardeEvents.class);
|
||||||
|
assertTrue(appels(garde, "avantMouvement").contains("Moteur.estExpulse"));
|
||||||
|
assertTrue(appels(garde, "avantMouvement").contains("Cablage.evaluerAvantMouvement"));
|
||||||
|
assertTrue(appels(garde, "apresMouvement").contains("Moteur.estExpulse"));
|
||||||
|
assertTrue(appels(garde, "apresMouvement").contains("Cablage.traiterApresMouvement"));
|
||||||
|
assertTrue(appels(events, "onAttaque").contains("Moteur.estExpulse"));
|
||||||
|
assertTrue(appels(events, "onAttaque").contains("Cablage.entreeAttaque"));
|
||||||
|
assertTrue(appels(events, "onConnexion").contains("Moteur.oublierExpulsion"), "reconnexion : marque effacée");
|
||||||
|
assertFalse(appels(events, "onDeconnexion").contains("Moteur.oublierExpulsion"),
|
||||||
|
"la marque survit à la déconnexion (C6)");
|
||||||
|
assertTrue(appels(garde, "appliquerSanctionMouvement").contains("Cablage.appliquerSanction"));
|
||||||
|
Set<String> sanction = appels(lire(Cablage.class), "appliquerSanction");
|
||||||
|
assertTrue(sanction.contains("Moteur.expulser"));
|
||||||
|
assertTrue(sanction.contains("Moteur.apresSetback"));
|
||||||
|
assertFalse(appels(garde, "appliquerSanctionMouvement").stream().anyMatch(a -> a.toLowerCase().contains("ban")),
|
||||||
|
"jamais de bannissement");
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* FAILLE (16/10, trouvée en écrivant ces tests) : apresVehicule ne regarde pas la marque d'expulsion, à la
|
||||||
|
* différence de avantMouvement / apresMouvement / onAttaque. Un paquet de véhicule traité après l'expulsion
|
||||||
|
* (même lot de paquets, avant la fermeture de la connexion) est encore évalué : journal, alerte aux ops,
|
||||||
|
* stopRiding + setback, et l'état du moteur (Suivi) est recréé. L'expulsion elle-même reste unique
|
||||||
|
* (Moteur.expulser). Ce test est vert tant que le défaut existe. Proposition : en tête d'apresVehicule,
|
||||||
|
* {@code if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;}
|
||||||
|
* (même garde, et idem pour auSolPourChute, qui peut encore appeler le moteur). Non corrigé : décision de Théo.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
void FAILLE_C4_apresVehiculeNeConsultePasLaMarqueDExpulsion() throws Exception {
|
||||||
|
ClassNode garde = lire(Garde.class);
|
||||||
|
Set<String> a = appels(garde, "apresVehicule");
|
||||||
|
assertTrue(a.contains("Moteur.vehicule"), "le paquet de véhicule est bien évalué par le moteur");
|
||||||
|
assertFalse(a.contains("Moteur.estExpulse"), "défaut corrigé : inverser en CORRIGE_");
|
||||||
|
assertFalse(appels(garde, "auSolPourChute").contains("Moteur.estExpulse"));
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Événements NeoForge abonnés ---
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void evenementsAbonnes() {
|
||||||
|
Set<Class<?>> ev = new HashSet<>();
|
||||||
|
for (Method m : GardeEvents.class.getDeclaredMethods()) {
|
||||||
|
if (m.isAnnotationPresent(net.neoforged.bus.api.SubscribeEvent.class)) {
|
||||||
|
assertEquals(1, m.getParameterCount(), m.getName());
|
||||||
|
assertTrue(java.lang.reflect.Modifier.isStatic(m.getModifiers()), m.getName());
|
||||||
|
ev.add(m.getParameterTypes()[0]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for (Class<?> c : new Class<?>[] {
|
||||||
|
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class,
|
||||||
|
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent.class,
|
||||||
|
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedOutEvent.class,
|
||||||
|
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerChangedDimensionEvent.class,
|
||||||
|
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerRespawnEvent.class,
|
||||||
|
net.neoforged.neoforge.event.tick.ServerTickEvent.Pre.class,
|
||||||
|
net.neoforged.neoforge.event.tick.ServerTickEvent.Post.class,
|
||||||
|
net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent.Stop.class,
|
||||||
|
net.neoforged.neoforge.event.server.ServerStartingEvent.class,
|
||||||
|
net.neoforged.neoforge.event.server.ServerStoppedEvent.class}) {
|
||||||
|
assertTrue(ev.contains(c), c.getName());
|
||||||
|
}
|
||||||
|
assertTrue(net.neoforged.bus.api.ICancellableEvent.class.isAssignableFrom(
|
||||||
|
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class), "un coup peut être annulé");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void lesFauxJoueursNeSontJamaisControles() {
|
||||||
|
// GardeEvents filtre « p instanceof FakePlayer » : un FakePlayer est un ServerPlayer.
|
||||||
|
assertTrue(net.minecraft.server.level.ServerPlayer.class.isAssignableFrom(
|
||||||
|
net.neoforged.neoforge.common.util.FakePlayer.class));
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Types d'entités (C18 GardeAntiCrash, F20 vehiculeControle / etatVehicule) ---
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C18_seulsLesMinecartsContenantsSontGardesImmobiles() {
|
||||||
|
Class<?> container = net.minecraft.world.Container.class;
|
||||||
|
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartChest.class));
|
||||||
|
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartHopper.class));
|
||||||
|
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.Minecart.class));
|
||||||
|
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartTNT.class));
|
||||||
|
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartFurnace.class));
|
||||||
|
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartSpawner.class));
|
||||||
|
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartCommandBlock.class));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void F20_vehiculesControles() {
|
||||||
|
Class<?> bateau = net.minecraft.world.entity.vehicle.Boat.class;
|
||||||
|
Class<?> monture = net.minecraft.world.entity.LivingEntity.class;
|
||||||
|
assertTrue(bateau.isAssignableFrom(net.minecraft.world.entity.vehicle.ChestBoat.class), "bateau à coffre, radeau");
|
||||||
|
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.horse.Horse.class));
|
||||||
|
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.Pig.class));
|
||||||
|
Class<?> minecart = net.minecraft.world.entity.vehicle.AbstractMinecart.class;
|
||||||
|
assertFalse(bateau.isAssignableFrom(minecart) || monture.isAssignableFrom(minecart),
|
||||||
|
"minecart : non contrôlé (type AUTRE), la position de retour suit le joueur");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Options : du fichier toml au moteur ---
|
||||||
|
|
||||||
|
private static Object valeur(String champ) throws Exception {
|
||||||
|
Field f = GardeSpec.class.getDeclaredField(champ);
|
||||||
|
f.setAccessible(true);
|
||||||
|
return f.get(null);
|
||||||
|
}
|
||||||
|
|
||||||
|
@SuppressWarnings("unchecked")
|
||||||
|
private static <T> T defaut(String champ) throws Exception {
|
||||||
|
return ((ModConfigSpec.ConfigValue<T>) valeur(champ)).getDefault();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void optionsDesactiveesParDefautDansLeFichierEtLeMoteur() throws Exception {
|
||||||
|
GardeConfig c = new GardeConfig();
|
||||||
|
assertEquals(false, defaut("ELYTRES_STRICTE"));
|
||||||
|
assertEquals(c.elytresExemptionStricte, defaut("ELYTRES_STRICTE"));
|
||||||
|
assertEquals(2, (int) defaut("ELYTRES_AIR_MIN"));
|
||||||
|
assertEquals(c.elytresAirMinTicks, (int) defaut("ELYTRES_AIR_MIN"));
|
||||||
|
assertEquals(false, defaut("COMBAT_VEHICULE"));
|
||||||
|
assertEquals(c.combatMesureEnVehicule, defaut("COMBAT_VEHICULE"));
|
||||||
|
assertEquals(false, defaut("VOL_FENETRE_GLISSANTE"));
|
||||||
|
assertEquals(c.volFenetreGlissante, defaut("VOL_FENETRE_GLISSANTE"));
|
||||||
|
assertEquals(false, defaut("VITESSE_MOYENNE"));
|
||||||
|
assertEquals(c.vitesseMoyenne, defaut("VITESSE_MOYENNE"));
|
||||||
|
assertEquals(0, (int) defaut("TIMER_SOLDE_MAX"));
|
||||||
|
assertEquals(c.timerSoldeMax, (int) defaut("TIMER_SOLDE_MAX"));
|
||||||
|
assertEquals(c.seriePingMargeMs, (int) defaut("SERIE_PING_MARGE"));
|
||||||
|
assertEquals(false, defaut("AC_EMPILEMENT_MOUVEMENT"));
|
||||||
|
assertFalse(new com.gastinelgarde.core.AntiCrashEntites.Reglages().empilementSeulementEnMouvement);
|
||||||
|
assertFalse(GardeSpec.antiCrash().empilementSeulementEnMouvement, "fichier non chargé : défaut");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void laConfigProposeeNActivePasLesNouvellesOptions() throws Exception {
|
||||||
|
// Les tests tournent dans build/minecraft-junit : on remonte jusqu'à la racine du projet.
|
||||||
|
Path toml = null;
|
||||||
|
for (Path d = Path.of("").toAbsolutePath(); d != null && toml == null; d = d.getParent()) {
|
||||||
|
Path f = d.resolve("config-proposee").resolve("gastinelgarde-server.toml");
|
||||||
|
if (Files.exists(f)) toml = f;
|
||||||
|
}
|
||||||
|
Assumptions.assumeTrue(toml != null, "config-proposee introuvable depuis " + Path.of("").toAbsolutePath());
|
||||||
|
String t = Files.readString(toml, StandardCharsets.UTF_8);
|
||||||
|
for (String cle : new String[] {"elytresExemptionStricte", "combatMesureEnVehicule", "volFenetreGlissante",
|
||||||
|
"vitesseMoyenne", "empilementSeulementEnMouvement"}) {
|
||||||
|
assertFalse(t.matches("(?s).*\\b" + cle + "\\s*=\\s*true.*"), cle);
|
||||||
|
}
|
||||||
|
assertFalse(t.matches("(?s).*\\btimerSoldeMax\\s*=\\s*[1-9].*"), "timerSoldeMax");
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* GardeSpec.appliquer recopie bien chaque option dans GardeConfig. On charge le fichier en mémoire
|
||||||
|
* (ModConfigSpec.acceptConfig, par réflexion : signature propre à NeoForge 21.1), puis on le décharge.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
void appliquerRecopieLesOptionsDuFichier() throws Exception {
|
||||||
|
Object charge = chargerEnMemoire();
|
||||||
|
Assumptions.assumeTrue(charge != null, "[À VÉRIFIER] chargement en mémoire du ModConfigSpec impossible ici");
|
||||||
|
try {
|
||||||
|
assertTrue(GardeSpec.SPEC.isLoaded());
|
||||||
|
GardeConfig vide = new GardeConfig();
|
||||||
|
GardeSpec.appliquer(vide);
|
||||||
|
assertFalse(vide.elytresExemptionStricte);
|
||||||
|
assertFalse(vide.combatMesureEnVehicule);
|
||||||
|
assertFalse(vide.volFenetreGlissante);
|
||||||
|
assertFalse(vide.vitesseMoyenne);
|
||||||
|
assertEquals(0, vide.timerSoldeMax);
|
||||||
|
for (com.gastinelgarde.core.Controle k : com.gastinelgarde.core.Controle.values()) {
|
||||||
|
assertEquals(new GardeConfig().mode(k), vide.mode(k), "mode par défaut inchangé : " + k);
|
||||||
|
}
|
||||||
|
|
||||||
|
((ModConfigSpec.BooleanValue) valeur("ELYTRES_STRICTE")).set(true);
|
||||||
|
((ModConfigSpec.IntValue) valeur("ELYTRES_AIR_MIN")).set(5);
|
||||||
|
((ModConfigSpec.BooleanValue) valeur("COMBAT_VEHICULE")).set(true);
|
||||||
|
((ModConfigSpec.BooleanValue) valeur("VOL_FENETRE_GLISSANTE")).set(true);
|
||||||
|
((ModConfigSpec.BooleanValue) valeur("VITESSE_MOYENNE")).set(true);
|
||||||
|
((ModConfigSpec.IntValue) valeur("TIMER_SOLDE_MAX")).set(20);
|
||||||
|
GardeConfig c = new GardeConfig();
|
||||||
|
GardeSpec.appliquer(c);
|
||||||
|
assertTrue(c.elytresExemptionStricte, "C7");
|
||||||
|
assertEquals(5, c.elytresAirMinTicks, "C7");
|
||||||
|
assertTrue(c.combatMesureEnVehicule, "C8");
|
||||||
|
assertTrue(c.volFenetreGlissante, "C10");
|
||||||
|
assertTrue(c.vitesseMoyenne, "C15");
|
||||||
|
assertEquals(20, c.timerSoldeMax, "C15");
|
||||||
|
} finally {
|
||||||
|
dechargerEnMemoire();
|
||||||
|
}
|
||||||
|
assertFalse(GardeSpec.SPEC.isLoaded(), "les autres tests attendent un fichier non chargé");
|
||||||
|
}
|
||||||
|
|
||||||
|
/** null si l'API n'est pas celle attendue (le test est alors ignoré, pas faux). */
|
||||||
|
private static Object chargerEnMemoire() {
|
||||||
|
try {
|
||||||
|
Method accept = null;
|
||||||
|
for (Method m : ModConfigSpec.class.getMethods()) {
|
||||||
|
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) accept = m;
|
||||||
|
}
|
||||||
|
if (accept == null) return null;
|
||||||
|
Class<?> type = accept.getParameterTypes()[0];
|
||||||
|
com.electronwill.nightconfig.core.CommentedConfig cc =
|
||||||
|
com.electronwill.nightconfig.core.CommentedConfig.inMemory();
|
||||||
|
// Fichier déjà corrigé (valeurs par défaut) : acceptConfig n'a rien à sauvegarder.
|
||||||
|
for (Method m : ModConfigSpec.class.getMethods()) {
|
||||||
|
if (m.getName().equals("correct") && m.getParameterCount() == 1
|
||||||
|
&& m.getParameterTypes()[0].isInstance(cc)) {
|
||||||
|
m.invoke(GardeSpec.SPEC, cc);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Object config = null;
|
||||||
|
if (type.isInstance(cc)) {
|
||||||
|
config = cc;
|
||||||
|
} else if (type.isSealed()) {
|
||||||
|
// NeoForge 21.1 : IConfigSpec.ILoadedConfig est scellée, seule implémentation LoadedConfig.
|
||||||
|
for (Class<?> impl : type.getPermittedSubclasses()) {
|
||||||
|
for (java.lang.reflect.Constructor<?> k : impl.getDeclaredConstructors()) {
|
||||||
|
Class<?>[] p = k.getParameterTypes();
|
||||||
|
if (p.length == 0 || !p[0].isInstance(cc)) continue;
|
||||||
|
Object[] args = new Object[p.length];
|
||||||
|
args[0] = cc;
|
||||||
|
k.setAccessible(true);
|
||||||
|
config = k.newInstance(args);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (config != null) break;
|
||||||
|
}
|
||||||
|
} else if (type.isInterface()) {
|
||||||
|
config = Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[] {type}, (o, m, a) -> switch (m.getName()) {
|
||||||
|
case "config" -> cc;
|
||||||
|
case "hashCode" -> System.identityHashCode(o);
|
||||||
|
case "equals" -> o == a[0];
|
||||||
|
case "toString" -> "config-en-memoire";
|
||||||
|
default -> null;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
if (config == null) return null;
|
||||||
|
accept.invoke(GardeSpec.SPEC, config);
|
||||||
|
return GardeSpec.SPEC.isLoaded() ? config : null;
|
||||||
|
} catch (ReflectiveOperationException | RuntimeException | LinkageError e) {
|
||||||
|
System.out.println("[CablageMinecraftTest] chargement en mémoire impossible : " + e);
|
||||||
|
dechargerEnMemoire();
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void dechargerEnMemoire() {
|
||||||
|
try {
|
||||||
|
for (Method m : ModConfigSpec.class.getMethods()) {
|
||||||
|
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) {
|
||||||
|
m.invoke(GardeSpec.SPEC, new Object[] {null});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} catch (ReflectiveOperationException | RuntimeException e) {
|
||||||
|
System.out.println("[CablageMinecraftTest] déchargement : " + e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,123 @@
|
|||||||
|
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");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- (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");
|
||||||
|
assertEquals(0, p.compte("journal"));
|
||||||
|
// Le VL de vol n'est donc pas remis à zéro (apresSetback non appelé) et continue vers l'expulsion.
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,300 @@
|
|||||||
|
package com.gastinelgarde;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||||
|
|
||||||
|
import com.gastinelgarde.core.Controle;
|
||||||
|
import com.gastinelgarde.core.EtatJoueur;
|
||||||
|
import com.gastinelgarde.core.Exemptions;
|
||||||
|
import com.gastinelgarde.core.GardeConfig;
|
||||||
|
import com.gastinelgarde.core.GraceTeleport;
|
||||||
|
import com.gastinelgarde.core.Mode;
|
||||||
|
import com.gastinelgarde.core.Moteur;
|
||||||
|
import com.gastinelgarde.core.Sanction;
|
||||||
|
import com.gastinelgarde.core.Verdict;
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.UUID;
|
||||||
|
import java.util.concurrent.atomic.AtomicInteger;
|
||||||
|
import java.util.function.BooleanSupplier;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Câblage Minecraft (constat C4 ⚠️) : décisions de Garde / GardeEvents sorties dans {@link Cablage}, testées sans
|
||||||
|
* serveur avec une doublure du joueur et un vrai {@link Moteur}.
|
||||||
|
*/
|
||||||
|
class CablageTest {
|
||||||
|
|
||||||
|
private static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
|
||||||
|
private static final String MONDE = "minecraft:overworld";
|
||||||
|
|
||||||
|
/** Doublure de ServerPlayer : enregistre ce que la sanction lui fait, dans l'ordre. */
|
||||||
|
static final class FauxJoueur implements Cablage.Joueur {
|
||||||
|
final List<String> actions = new ArrayList<>();
|
||||||
|
String dimension = MONDE;
|
||||||
|
int tick = 1000;
|
||||||
|
|
||||||
|
@Override public UUID id() { return ID; }
|
||||||
|
@Override public String nom() { return "Tricheur"; }
|
||||||
|
@Override public String dimension() { return dimension; }
|
||||||
|
@Override public int tick() { return tick; }
|
||||||
|
@Override public void annoncerTeleport(GraceTeleport.Origine o) { actions.add("annonce " + o); }
|
||||||
|
@Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
|
||||||
|
actions.add(String.format(java.util.Locale.ROOT, "teleport %.1f %.1f %.1f %.0f %.0f", x, y, z, yaw, pitch));
|
||||||
|
}
|
||||||
|
@Override public void deconnecter(String message) { actions.add("deconnexion " + message); }
|
||||||
|
@Override public void journal(String ligne) { actions.add("journal " + ligne); }
|
||||||
|
|
||||||
|
long compte(String prefixe) {
|
||||||
|
return actions.stream().filter(a -> a.startsWith(prefixe)).count();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static Verdict verdict(Controle c, Sanction s) {
|
||||||
|
return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of());
|
||||||
|
}
|
||||||
|
|
||||||
|
private static BooleanSupplier compteur(AtomicInteger n, boolean valeur) {
|
||||||
|
return () -> {
|
||||||
|
n.incrementAndGet();
|
||||||
|
return valeur;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Expulsion unique (C4) ---
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C4_expulsionUneSeuleFoisPuisDeNouveauApresReconnexion() {
|
||||||
|
Moteur moteur = new Moteur(new GardeConfig());
|
||||||
|
FauxJoueur p = new FauxJoueur();
|
||||||
|
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.EXPULSION));
|
||||||
|
for (int i = 0; i < 344; i++) { // incident du 15/10 : 344 disconnect en 18 s
|
||||||
|
p.tick++;
|
||||||
|
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
|
||||||
|
}
|
||||||
|
assertEquals(1, p.compte("deconnexion"), p.actions.toString());
|
||||||
|
assertEquals(1, p.compte("journal"));
|
||||||
|
assertEquals("journal Tricheur EXPULSE (vol)", p.actions.get(0)); // journal avant la déconnexion
|
||||||
|
assertEquals("deconnexion Expulsé par l'anti-triche (vol).", p.actions.get(1));
|
||||||
|
assertTrue(moteur.estExpulse(ID));
|
||||||
|
|
||||||
|
// GardeEvents.onConnexion : oublierExpulsion, la prochaine expulsion est de nouveau possible.
|
||||||
|
moteur.oublierExpulsion(ID);
|
||||||
|
assertFalse(moteur.estExpulse(ID));
|
||||||
|
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
|
||||||
|
assertEquals(2, p.compte("deconnexion"));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C4_apresLExpulsionPlusAucuneEvaluationNiCoup() {
|
||||||
|
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, false));
|
||||||
|
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, true)); // l'expulsion passe avant
|
||||||
|
assertEquals(Cablage.EntreeAttaque.IGNORER, Cablage.entreeAttaque(false, true));
|
||||||
|
assertEquals(Cablage.EntreeAttaque.EVALUER, Cablage.entreeAttaque(false, false));
|
||||||
|
|
||||||
|
AtomicInteger lus = new AtomicInteger();
|
||||||
|
assertFalse(Cablage.evaluerAvantMouvement(true, () -> true, compteur(lus, false)));
|
||||||
|
assertEquals(0, lus.get(), "expulsé : l'exemption n'est même pas lue");
|
||||||
|
assertFalse(Cablage.evaluerAvantMouvement(true, () -> false, () -> true)); // exemption manuelle
|
||||||
|
assertTrue(Cablage.evaluerAvantMouvement(true, () -> false, () -> false));
|
||||||
|
assertFalse(Cablage.traiterApresMouvement(true, () -> true));
|
||||||
|
assertTrue(Cablage.traiterApresMouvement(true, () -> false));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void F01_horsDuThreadServeurLEtatDuModNEstPasLu() {
|
||||||
|
AtomicInteger lus = new AtomicInteger();
|
||||||
|
assertFalse(Cablage.evaluerAvantMouvement(false, compteur(lus, false), compteur(lus, false)));
|
||||||
|
assertFalse(Cablage.traiterApresMouvement(false, compteur(lus, false)));
|
||||||
|
assertEquals(0, lus.get());
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void expulsionSansVerdictRaisonParDefaut() {
|
||||||
|
Moteur moteur = new Moteur(new GardeConfig());
|
||||||
|
FauxJoueur p = new FauxJoueur();
|
||||||
|
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, List.of());
|
||||||
|
assertEquals("journal Tricheur EXPULSE (anti-triche)", p.actions.get(0));
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Setback (C2, C3) ---
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C2_setbackVersLaPositionAuSolPuisRemiseAZeroDuVol() {
|
||||||
|
Moteur moteur = new Moteur(new GardeConfig());
|
||||||
|
FauxJoueur p = new FauxJoueur();
|
||||||
|
long ms = p.tick * 50L;
|
||||||
|
moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE);
|
||||||
|
moteur.suivi(ID).vl.ajouter(Controle.VOL, 30, ms);
|
||||||
|
moteur.suivi(ID).vl.ajouter(Controle.VITESSE, 20, ms);
|
||||||
|
moteur.suivi(ID).vl.ajouter(Controle.KILLAURA_CIBLES, 7, ms);
|
||||||
|
|
||||||
|
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||||
|
|
||||||
|
assertEquals(List.of("annonce SETBACK", "teleport 10.5 64.0 -3.5 90 10", "journal Tricheur SETBACK (vol)"),
|
||||||
|
p.actions, "la grâce est annoncée avant le teleport (F05)");
|
||||||
|
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VOL, ms), 1e-9);
|
||||||
|
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VITESSE, ms), 1e-9);
|
||||||
|
assertTrue(moteur.suivi(ID).vl.valeur(Controle.KILLAURA_CIBLES, ms) > 6.9, "les autres VL ne sont pas touchées");
|
||||||
|
assertFalse(moteur.estExpulse(ID));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void setbackSansPositionOuAutreDimensionNeFaitRien() {
|
||||||
|
Moteur moteur = new Moteur(new GardeConfig());
|
||||||
|
FauxJoueur p = new FauxJoueur();
|
||||||
|
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.SETBACK));
|
||||||
|
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
|
||||||
|
assertTrue(p.actions.isEmpty(), "aucune position de retour : rien");
|
||||||
|
|
||||||
|
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
|
||||||
|
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
|
||||||
|
assertTrue(p.actions.isEmpty(), "position dans une autre dimension : jamais de teleport inter-dimension");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void sanctionsInferieuresAuSetbackNeTouchentPasLeJoueur() {
|
||||||
|
Moteur moteur = new Moteur(new GardeConfig());
|
||||||
|
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, MONDE);
|
||||||
|
FauxJoueur p = new FauxJoueur();
|
||||||
|
for (Sanction s : new Sanction[] {Sanction.AUCUNE, Sanction.JOURNAL, Sanction.ALERTE}) {
|
||||||
|
Cablage.appliquerSanction(moteur, p, s, List.of(verdict(Controle.VOL, s)));
|
||||||
|
assertFalse(Cablage.sanctionDeMouvement(s), s.name());
|
||||||
|
}
|
||||||
|
assertTrue(p.actions.isEmpty());
|
||||||
|
assertTrue(Cablage.sanctionDeMouvement(Sanction.SETBACK));
|
||||||
|
assertTrue(Cablage.sanctionDeMouvement(Sanction.EXPULSION));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C3_positionDeRetourSeulementAuSolEtSansVerdictNiVehicule() {
|
||||||
|
Moteur moteur = new Moteur(new GardeConfig());
|
||||||
|
int tick = 500;
|
||||||
|
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, true, false));
|
||||||
|
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, true), "eau, échelle…");
|
||||||
|
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, false), "en l'air");
|
||||||
|
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> true, true, false), "véhicule contrôlé");
|
||||||
|
AtomicInteger lus = new AtomicInteger();
|
||||||
|
assertFalse(Cablage.memoriserRetour(moteur, tick, tick, compteur(lus, false), true, false), "verdict ce tick");
|
||||||
|
assertEquals(0, lus.get(), "le véhicule n'est pas lu si un verdict est tombé à ce tick");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Coups (GardeEvents.onAttaque) ---
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void coupAnnuleEnEnforceOuSurSanctionEtExpulsionSeuleAppliquee() {
|
||||||
|
for (Sanction s : Sanction.values()) {
|
||||||
|
boolean grave = s.ordinal() >= Sanction.SETBACK.ordinal();
|
||||||
|
assertEquals(grave, Cablage.annulerCoup(false, s), s.name());
|
||||||
|
assertTrue(Cablage.annulerCoup(true, s), "portée / hitbox ENFORCE : " + s);
|
||||||
|
assertEquals(s == Sanction.EXPULSION, Cablage.appliquerApresCoup(s), "pas de setback sur un coup : " + s);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void cibleSurContraptionOuVaisseauPasDeMesurePorteeHitbox() {
|
||||||
|
BooleanSupplier oui = () -> true;
|
||||||
|
BooleanSupplier non = () -> false;
|
||||||
|
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, non, non));
|
||||||
|
assertFalse(Cablage.mesurerPorteeHitbox(oui, non, true, non, non), "cible contraption");
|
||||||
|
assertFalse(Cablage.mesurerPorteeHitbox(non, oui, true, non, non), "cible sur vaisseau Sable");
|
||||||
|
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, oui, non), "assise sur un siège Create");
|
||||||
|
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, non, oui), "véhicule sur un vaisseau");
|
||||||
|
assertTrue(Cablage.mesurerPorteeHitbox(non, non, false, non, non), "cheval, bateau : mesuré");
|
||||||
|
AtomicInteger lus = new AtomicInteger();
|
||||||
|
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, compteur(lus, true), compteur(lus, true)));
|
||||||
|
assertEquals(0, lus.get(), "sans véhicule, la racine n'est pas interrogée");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- C7 : élytres ---
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C7_deploiementTropTotApresLeSolEstSuspectPourTouteLaDureeDuPlane() {
|
||||||
|
Cablage.Elytres e = new Cablage.Elytres();
|
||||||
|
int sol = 100;
|
||||||
|
e.observer(false, sol, 100, 2);
|
||||||
|
e.observer(true, sol, 101, 2); // 1 tick après le sol (onGround falsifié)
|
||||||
|
assertTrue(e.suspectes);
|
||||||
|
for (int t = 102; t < 300; t++) e.observer(true, sol, t, 2);
|
||||||
|
assertTrue(e.suspectes, "reste suspect jusqu'à la fin du plané");
|
||||||
|
e.observer(false, sol, 300, 2);
|
||||||
|
assertFalse(e.suspectes);
|
||||||
|
assertFalse(e.vues);
|
||||||
|
|
||||||
|
Cablage.Elytres h = new Cablage.Elytres();
|
||||||
|
h.observer(true, sol, 102, 2); // 2 ticks en l'air : honnête
|
||||||
|
assertFalse(h.suspectes);
|
||||||
|
Cablage.Elytres jamais = new Cablage.Elytres();
|
||||||
|
jamais.observer(true, Integer.MIN_VALUE, 5, 2); // jamais vu au sol (connexion en plein vol)
|
||||||
|
assertFalse(jamais.suspectes);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C7_unSolServeurVuPendantLePlaneNeRendPasSuspectApresCoup() {
|
||||||
|
Cablage.Elytres e = new Cablage.Elytres();
|
||||||
|
e.observer(true, 100, 120, 2);
|
||||||
|
assertFalse(e.suspectes);
|
||||||
|
e.observer(true, 125, 125, 2); // frôle un bloc en plané
|
||||||
|
assertFalse(e.suspectes, "seul le début du plané compte");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C7_cableJusquAuxExemptions_avecEtSansOption() {
|
||||||
|
Cablage.Elytres e = new Cablage.Elytres();
|
||||||
|
e.observer(true, 100, 101, 2);
|
||||||
|
EtatJoueur etat = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(e.suspectes).build();
|
||||||
|
GardeConfig defaut = new GardeConfig();
|
||||||
|
assertFalse(defaut.elytresExemptionStricte, "option désactivée par défaut");
|
||||||
|
assertTrue(Exemptions.evaluer(etat, defaut, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
|
||||||
|
GardeConfig stricte = new GardeConfig();
|
||||||
|
stricte.elytresExemptionStricte = true;
|
||||||
|
assertFalse(Exemptions.evaluer(etat, stricte, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- C8 : combat en véhicule ---
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void C8_passagerMesureSeulementAvecLOptionEtContraptionToujoursExemptee() {
|
||||||
|
EtatJoueur cheval = EtatJoueur.builder().enVehicule(true).build();
|
||||||
|
EtatJoueur siege = EtatJoueur.builder().enVehicule(true).pocheContraption(true).build();
|
||||||
|
GardeConfig defaut = new GardeConfig();
|
||||||
|
assertFalse(defaut.combatMesureEnVehicule);
|
||||||
|
assertTrue(Exemptions.evaluer(cheval, defaut, Exemptions.Famille.COMBAT).exempt());
|
||||||
|
GardeConfig option = new GardeConfig();
|
||||||
|
option.combatMesureEnVehicule = true;
|
||||||
|
assertFalse(Exemptions.evaluer(cheval, option, Exemptions.Famille.COMBAT).exempt());
|
||||||
|
assertTrue(Exemptions.evaluer(siege, option, Exemptions.Famille.COMBAT).raisons().contains("contraption"));
|
||||||
|
assertTrue(Exemptions.evaluer(cheval, option, Exemptions.Famille.MOUVEMENT).raisons().contains("vehicule"),
|
||||||
|
"l'option ne touche que le combat");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Cache des détections (contraption, courant d'air) ---
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void cacheDeDetectionToutesLesDixTicksPuisGrace() {
|
||||||
|
Cablage.CacheDetection c = new Cablage.CacheDetection();
|
||||||
|
AtomicInteger appels = new AtomicInteger();
|
||||||
|
boolean[] present = {true};
|
||||||
|
BooleanSupplier detecter = () -> {
|
||||||
|
appels.incrementAndGet();
|
||||||
|
return present[0];
|
||||||
|
};
|
||||||
|
assertTrue(c.lire(100, detecter, 40));
|
||||||
|
assertEquals(1, appels.get());
|
||||||
|
present[0] = false; // la contraption s'éloigne
|
||||||
|
assertTrue(c.lire(109, detecter, 40), "valeur en cache");
|
||||||
|
assertEquals(1, appels.get());
|
||||||
|
assertTrue(c.lire(110, detecter, 40), "redétecté (absent) mais dans la grâce");
|
||||||
|
assertEquals(2, appels.get());
|
||||||
|
assertTrue(c.lire(140, detecter, 40));
|
||||||
|
assertFalse(c.lire(150, detecter, 40), "grâce terminée");
|
||||||
|
assertTrue(c.lire(5, () -> true, 40), "tick qui recule (redémarrage) : redétecté");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void cacheJamaisVuPasDeGrace() {
|
||||||
|
Cablage.CacheDetection c = new Cablage.CacheDetection();
|
||||||
|
assertFalse(c.lire(100, () -> false, 40));
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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) <= 205, "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 < 40, "chaque grâce vaut la vie de la fusée (~30 ticks) + 5, pas 120 ticks fixes");
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,365 @@
|
|||||||
|
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;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Autotests du 16/10/2026, nuit : cas limites d'un joueur HONNÊTE (fins d'élytres, bords de blocs, échelles, eau,
|
||||||
|
* slime, miel, montures, téléportations, Create / Aeronautics, riptide, lag).
|
||||||
|
*
|
||||||
|
* Un test {@code honnete_…} vérifie qu'aucun point n'est donné. Un test {@code FAUX_POSITIF_…} montre un cas honnête
|
||||||
|
* (ou plausible, à confirmer en jeu) qui est puni aujourd'hui : il passe tant que le défaut existe.
|
||||||
|
*
|
||||||
|
* Les drapeaux « milieu spécial », « au sol serveur », exemptions… sont calculés par l'adaptateur (Garde.java) à partir
|
||||||
|
* du monde : ici on suppose qu'il les calcule bien. Ce qui dépend de la détection elle-même (bloc de miel trouvé,
|
||||||
|
* contraption vue) n'est pas testable hors jeu.
|
||||||
|
*/
|
||||||
|
class AutotestCasLimitesTest {
|
||||||
|
|
||||||
|
private GardeConfig cfg;
|
||||||
|
private Moteur moteur;
|
||||||
|
private final UUID joueur = UUID.randomUUID();
|
||||||
|
private long tick;
|
||||||
|
|
||||||
|
@BeforeEach
|
||||||
|
void init() {
|
||||||
|
cfg = new GardeConfig();
|
||||||
|
cfg.mode(Controle.VOL, Mode.ENFORCE);
|
||||||
|
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||||
|
cfg.mode(Controle.NO_FALL, Mode.OBSERVE);
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
tick = 5000;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static EtatMouvement m(double dxz, double dy, int ticks, boolean sol, boolean milieu) {
|
||||||
|
return new EtatMouvement(dxz, dy, ticks, sol, sol, false, false, false, 0, 0, milieu, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static EtatMouvement air(double dy) {
|
||||||
|
return m(0.1, dy, 1, false, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static EtatMouvement sol() {
|
||||||
|
return m(0.1, 0, 1, true, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double points(List<Verdict> vs, Controle c) {
|
||||||
|
double p = 0;
|
||||||
|
for (Verdict v : vs) if (v.controle() == c) p += v.points();
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
private double paquet(EtatJoueur e, EtatMouvement mv) {
|
||||||
|
tick += Math.max(1, mv.ticks());
|
||||||
|
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, e, mv);
|
||||||
|
return points(vs, Controle.VOL) + points(vs, Controle.NO_FALL) + points(vs, Controle.VITESSE);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Chute vanilla depuis la vitesse v, n ticks. */
|
||||||
|
private double chute(EtatJoueur e, double v, int n) {
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < n; i++) {
|
||||||
|
total += paquet(e, air(v));
|
||||||
|
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
}
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void auSol(int n) {
|
||||||
|
for (int i = 0; i < n; i++) paquet(EtatJoueur.normal(), sol());
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Élytres -----------------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_atterrissageEnElytresPuisMarche() {
|
||||||
|
auSol(3);
|
||||||
|
EtatJoueur el = EtatJoueur.builder().elytres(true).build();
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 100; i++) total += paquet(el, m(1.2, -0.4, 1, false, false));
|
||||||
|
total += paquet(el, m(0.8, -0.3, 1, true, false)); // touche le sol, drapeau encore là
|
||||||
|
for (int i = 0; i < 20; i++) total += paquet(EtatJoueur.normal(), sol());
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_finDElytresVitesseHorizontaleQuiDecroit() {
|
||||||
|
cfg.mode(Controle.VITESSE, Mode.OBSERVE);
|
||||||
|
auSol(3);
|
||||||
|
EtatJoueur el = EtatJoueur.builder().elytres(true).build();
|
||||||
|
for (int i = 0; i < 40; i++) paquet(el, m(1.5, -0.3, 1, false, false));
|
||||||
|
double total = 0, dxz = 1.5, v = -0.3;
|
||||||
|
for (int i = 0; i < 40; i++) { // drapeau tombé, le joueur tombe vraiment : traînée 0,91 et gravité
|
||||||
|
dxz *= VitesseHorizontale.TRAINEE_AIR;
|
||||||
|
total += paquet(EtatJoueur.normal(), m(dxz, v, 1, false, false));
|
||||||
|
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void FAUX_POSITIF_finDElytresPlaneQuiContinueCoteClientPuniAussiParVitesse() {
|
||||||
|
cfg.mode(Controle.VOL, Mode.OFF);
|
||||||
|
cfg.mode(Controle.VITESSE, Mode.OBSERVE);
|
||||||
|
auSol(3);
|
||||||
|
EtatJoueur el = EtatJoueur.builder().elytres(true).build();
|
||||||
|
for (int i = 0; i < 40; i++) paquet(el, m(1.0, -0.1, 1, false, false));
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 20; i++) total += paquet(EtatJoueur.normal(), m(1.0, -0.1, 1, false, false));
|
||||||
|
// Même famille que C1 et que l'alerte vitesse de totoche10 du 15/10 : l'élan hérité ne couvre que 3 ticks.
|
||||||
|
assertTrue(total > 0, "plané continu après la chute du drapeau : puni par vitesse");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Bords de blocs ----------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_glissadeAuBordDUnBlocLaTrancheBalayeeTrouveLeBloc() {
|
||||||
|
// Bloc plein x dans [9 ; 10]. Avant : boîte [9,5 ; 10,1] (sur le bloc). Après un pas de 0,6 : [10,1 ; 10,7].
|
||||||
|
double[] t = NoFall.trancheBalayee(10.1, 64.0, 0.2, 10.7, 0.8, 0.6, 0);
|
||||||
|
assertTrue(t[0] < 10.0 && t[3] > 9.0, "la tranche couvre encore le bloc");
|
||||||
|
assertEquals(63.95, t[1], 1e-9);
|
||||||
|
// Avec le bloc trouvé, « au sol serveur » est vrai : aucun point no-fall.
|
||||||
|
assertEquals(0, NoFall.points(m(0.6, -0.5, 1, true, true)), 1e-9);
|
||||||
|
// Sans la tranche (ancien calcul), le même paquet donnait 0,5 point.
|
||||||
|
assertEquals(0.5, NoFall.points(new EtatMouvement(0.6, -0.5, 1, true, false, false, false, false, 0, 0,
|
||||||
|
false, false)), 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_tomberDUnBordEtSautSousUnPlafond() {
|
||||||
|
auSol(3);
|
||||||
|
double total = chute(EtatJoueur.normal(), -0.0784, 30); // marche au-delà du bord
|
||||||
|
auSol(3);
|
||||||
|
// Saut sous un plafond à 1,25 bloc : +0,42, puis tête cognée (vitesse remise à 0), puis gravité.
|
||||||
|
total += paquet(EtatJoueur.normal(), air(0.42));
|
||||||
|
total += paquet(EtatJoueur.normal(), air(0.05));
|
||||||
|
total += chute(EtatJoueur.normal(), (0 - VolVertical.GRAVITE) * VolVertical.TRAINEE, 6);
|
||||||
|
auSol(3);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Échelles, eau, slime, miel ------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_echelleMonteeArretAccroupiEtSortieEnHaut() {
|
||||||
|
auSol(3);
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 40; i++) total += paquet(EtatJoueur.normal(), m(0, 0.2, 1, false, true));
|
||||||
|
for (int i = 0; i < 40; i++) total += paquet(EtatJoueur.normal(), m(0, 0, 1, false, true)); // accroupi
|
||||||
|
total += chute(EtatJoueur.normal(), (0.2 - VolVertical.GRAVITE) * VolVertical.TRAINEE, 15); // lâche en haut
|
||||||
|
auSol(3);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_nageEtSortieDeLEauAvecImpulsion() {
|
||||||
|
auSol(3);
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 40; i++) total += paquet(EtatJoueur.normal(), m(0.1, 0.1, 1, false, true));
|
||||||
|
// Sortie : impulsion de 0,3 (jumpOutOfFluid) au tick où l'eau n'est plus vue [À VÉRIFIER en jeu].
|
||||||
|
total += chute(EtatJoueur.normal(), 0.3, 20);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_rebondsSurSlime() {
|
||||||
|
auSol(3);
|
||||||
|
double total = chute(EtatJoueur.normal(), -0.0784, 25); // chute de ~10 blocs
|
||||||
|
double v = 1.0;
|
||||||
|
for (int r = 0; r < 4; r++) {
|
||||||
|
total += paquet(EtatJoueur.normal(), m(0.1, 0, 1, true, true)); // contact slime
|
||||||
|
total += chute(EtatJoueur.normal(), v, 30);
|
||||||
|
v *= 0.8;
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_glissadeLeLongDUnBlocDeMielPuisChute() {
|
||||||
|
auSol(3);
|
||||||
|
double total = chute(EtatJoueur.normal(), 0.42, 3);
|
||||||
|
for (int i = 0; i < 80; i++) total += paquet(EtatJoueur.normal(), m(0, -0.05, 1, false, true));
|
||||||
|
total += chute(EtatJoueur.normal(), (-0.05 - VolVertical.GRAVITE) * VolVertical.TRAINEE, 10);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void FAUX_POSITIF_mielNonDetecteLaGlissadeEstPriseCommeUnPlane() {
|
||||||
|
// Si l'adaptateur ne voit pas le miel (bloc à plus de 0,1 bloc de la boîte, bloc de mod collant…), la descente
|
||||||
|
// à -0,05 bloc/tick est un plané : la détection elle-même n'est pas testable hors jeu.
|
||||||
|
auSol(3);
|
||||||
|
double total = chute(EtatJoueur.normal(), 0.42, 3);
|
||||||
|
for (int i = 0; i < 30; i++) total += paquet(EtatJoueur.normal(), air(-0.05));
|
||||||
|
assertTrue(total > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Montures et véhicules -------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_descendreDeChevalEnPleinSaut() {
|
||||||
|
auSol(3);
|
||||||
|
EtatJoueur monte = EtatJoueur.builder().enVehicule(true).build();
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 10; i++) total += paquet(monte, air(0.3));
|
||||||
|
total += chute(EtatJoueur.normal(), 0.1, 25);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_sautDeChevalEtBateauQuiTombeDUneFalaise() {
|
||||||
|
UUID j = UUID.randomUUID();
|
||||||
|
double total = 0;
|
||||||
|
double v = 0.9;
|
||||||
|
for (int i = 0; i < 30; i++) { // saut de cheval (force 0,9) : ~25 ticks en l'air
|
||||||
|
EtatVehicule e = new EtatVehicule(EtatVehicule.Type.MONTURE, 0.5, v, 1, false, false, false, 0.3, false);
|
||||||
|
total += points(moteur.vehicule(j, (100 + i) * 50L, EtatJoueur.normal(), e), Controle.VEHICULE_VOL);
|
||||||
|
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
}
|
||||||
|
moteur.nouveauVehicule(j);
|
||||||
|
v = 0;
|
||||||
|
for (int i = 0; i < 80; i++) { // bateau : -0,04 par tick, sans traînée verticale
|
||||||
|
v -= 0.04;
|
||||||
|
EtatVehicule e = new EtatVehicule(EtatVehicule.Type.BATEAU, 0.3, v, 1, false, false, false, 0, false);
|
||||||
|
total += points(moteur.vehicule(j, (200 + i) * 50L, EtatJoueur.normal(), e), Controle.VEHICULE_VOL);
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Téléportations ----------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_teleportationEnLAirPuisChute() {
|
||||||
|
auSol(3);
|
||||||
|
double total = 0;
|
||||||
|
for (int t = 0; t <= cfg.graceTeleportTicks; t++) {
|
||||||
|
total += paquet(EtatJoueur.builder().ticksDepuisTeleport(t).build(), air(-0.0784 * Math.min(t, 5)));
|
||||||
|
}
|
||||||
|
total += chute(EtatJoueur.normal(), -0.5, 40);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void FAUX_POSITIF_teleportationLenteLeJoueurResteFigeApresLaGrace() {
|
||||||
|
// /rtp, /tpa vers des tronçons non chargés : si le client reste figé (dy = 0) plus de 2 s après la
|
||||||
|
// téléportation, la grâce (40 ticks) est finie et l'immobilité en l'air est un plané [À VÉRIFIER en jeu].
|
||||||
|
auSol(3);
|
||||||
|
double total = 0;
|
||||||
|
for (int t = 0; t <= cfg.graceTeleportTicks; t++) {
|
||||||
|
total += paquet(EtatJoueur.builder().ticksDepuisTeleport(t).build(), air(0));
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9, "pendant la grâce : rien");
|
||||||
|
for (int i = 0; i < 20; i++) total += paquet(EtatJoueur.normal(), air(0));
|
||||||
|
assertTrue(total > 0, "figé 1 s de plus après la grâce : puni");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void FAUX_POSITIF_C2_reapparitionPendantUnSetbackNonOuverte() {
|
||||||
|
// Rappel : GraceTeleport n'ouvre pas de grâce pour SETBACK ni pour un renvoi de SETBACK.
|
||||||
|
GraceTeleport g = new GraceTeleport();
|
||||||
|
g.annoncer(GraceTeleport.Origine.SETBACK);
|
||||||
|
assertFalse(g.teleport());
|
||||||
|
g.annoncer(GraceTeleport.Origine.RENVOI);
|
||||||
|
assertFalse(g.teleport(), "renvoi d'un setback non confirmé : pas de grâce non plus");
|
||||||
|
assertTrue(g.teleport(), "une téléportation externe ouvre la grâce");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Create / Aeronautics -------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_surUnVaisseauQuiMontePuisSautEnBas() {
|
||||||
|
auSol(3);
|
||||||
|
EtatJoueur poche = EtatJoueur.builder().pocheContraption(true).build();
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 200; i++) total += paquet(poche, air(0.1)); // le pont monte, le serveur n'y voit pas de sol
|
||||||
|
total += chute(EtatJoueur.normal(), 0.1, 40);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
assertTrue(DetectionContraption.dansLaGrace(140, 100, 40));
|
||||||
|
assertFalse(DetectionContraption.dansLaGrace(141, 100, 40));
|
||||||
|
assertFalse(DetectionContraption.dansLaGrace(90, 100, 40), "horloge revenue en arrière : pas de grâce");
|
||||||
|
// Véhicule de mod (dirigeable, train Create) : jamais contrôlé en vol.
|
||||||
|
EtatVehicule dirigeable = new EtatVehicule(EtatVehicule.Type.AUTRE, 0.5, 0.0, 1, false, false, false, 0, false);
|
||||||
|
for (int i = 0; i < 100; i++) {
|
||||||
|
assertEquals(0, points(moteur.vehicule(joueur, (9000 + i) * 50L, EtatJoueur.normal(), dirigeable),
|
||||||
|
Controle.VEHICULE_VOL), 1e-9);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void FAUX_POSITIF_vaisseauNonDetecteLeJoueurSurLePontEstPrisPourUnVoleur() {
|
||||||
|
// Dépendance totale à la détection (DetectionContraption / SableAcces), non testable hors jeu : si le pont
|
||||||
|
// d'un grand vaisseau n'est pas vu (distanceContraption trop courte, classe de mod inconnue), punition.
|
||||||
|
auSol(3);
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 30; i++) total += paquet(EtatJoueur.normal(), air(0.1));
|
||||||
|
assertTrue(total > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Riptide -------------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_vrilleRiptidePuisArcBalistique() {
|
||||||
|
auSol(3);
|
||||||
|
EtatJoueur vrille = EtatJoueur.builder().riptide(true).build();
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 20; i++) total += paquet(vrille, m(2.5, 1.5, 1, false, false));
|
||||||
|
total += chute(EtatJoueur.normal(), 1.2, 60);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Lag ---------------------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Longue chute (80 paquets, un tick client chacun) reçue avec une gigue réseau régulière : {@code motif} donne
|
||||||
|
* les ticks serveur écoulés avant chaque paquet (ex. 3, 0, 0 : trois paquets arrivés ensemble toutes les 3 ticks).
|
||||||
|
*/
|
||||||
|
private double chuteAvecGigue(int[] motif) {
|
||||||
|
auSol(3);
|
||||||
|
double total = 0, v = 0;
|
||||||
|
for (int p = 0; p < 80; p++) {
|
||||||
|
total += paquet(EtatJoueur.normal(), m(0.1, v, motif[p % motif.length], false, false));
|
||||||
|
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
}
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_lagRafalesDeDeuxEtDeCinqPaquets() {
|
||||||
|
assertEquals(0, chuteAvecGigue(new int[] {2, 0}), 1e-9);
|
||||||
|
assertEquals(0, chuteAvecGigue(new int[] {5, 0, 0, 0, 0}), 1e-9);
|
||||||
|
assertEquals(0, chuteAvecGigue(new int[] {4, 0, 0, 0}), 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
|
||||||
|
// Inversé le 16/10 (fix/rafales-reseau) : était FAUX_POSITIF_ (88,9 points).
|
||||||
|
// Ancien commentaire :
|
||||||
|
// Un paquet d'UN tick client arrivé après 3 ticks serveur n'est comparé qu'à 2 ou 3 ticks de gravité, et la
|
||||||
|
// vitesse retenue est alors dy / 3 : le paquet suivant est faux aussi. Motif 3, 0, 0 : +1 anomalie par rafale,
|
||||||
|
// premier point après ~31 paquets (1,5 s de chute, ~12 blocs). Simulé, à confirmer avec une trace réelle.
|
||||||
|
double total = chuteAvecGigue(new int[] {3, 0, 0});
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
Mesures.noter("Lag 3,0,0 : " + total + " points de vol sur une chute de 80 paquets");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_gelDuServeurDeTroisSecondesEnPleineChute() {
|
||||||
|
auSol(3);
|
||||||
|
double total = chute(EtatJoueur.normal(), 0.42, 8);
|
||||||
|
total += paquet(EtatJoueur.normal(), m(0.1, -12.0, 60, false, false)); // 60 ticks : vitesse oubliée
|
||||||
|
total += chute(EtatJoueur.normal(), -2.5, 20);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_tpsBasLeVolNUtilisePasLeFacteurDeLagMaisLaChuteResteJuste() {
|
||||||
|
EtatJoueur lent = EtatJoueur.builder().tps(12).build();
|
||||||
|
auSol(3);
|
||||||
|
assertEquals(0, chute(lent, 0.42, 60), 1e-9);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,91 @@
|
|||||||
|
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.assertNull;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||||
|
|
||||||
|
import com.gastinelgarde.core.Exemptions.Famille;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Constats de gravité haute restants de l'autocritique du 16/10 (C7, C8, C18).
|
||||||
|
* Tests inversés (CORRIGE_) : options désactivées par défaut, vérifiées activées ; défaut inchangé vérifié aussi.
|
||||||
|
*/
|
||||||
|
class AutotestConstatsHautsTest {
|
||||||
|
|
||||||
|
private final GardeConfig cfg = new GardeConfig();
|
||||||
|
|
||||||
|
private GardeConfig strict() {
|
||||||
|
GardeConfig c = new GardeConfig();
|
||||||
|
c.elytresExemptionStricte = true;
|
||||||
|
c.combatMesureEnVehicule = true;
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
// C7 : élytres déployées depuis le sol (onGround falsifié) : plus d'exemption de mouvement avec l'option.
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C7_elytresDeployeesAuSolNExemptentPlus() {
|
||||||
|
EtatJoueur suspect = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(true).build();
|
||||||
|
assertFalse(Exemptions.evaluer(suspect, strict(), Famille.MOUVEMENT).raisons().contains("elytres"));
|
||||||
|
// Le mouvement est alors contrôlé : un vol plat soutenu donne des points.
|
||||||
|
Moteur m = new Moteur(strict());
|
||||||
|
java.util.UUID j = java.util.UUID.randomUUID();
|
||||||
|
double pts = 0;
|
||||||
|
for (int i = 0; i < 60; i++) {
|
||||||
|
for (Verdict v : m.mouvement(j, i * 50L, suspect,
|
||||||
|
new EtatMouvement(0.3, 0.0, 1, false, false, true, false, false, 0, 0, false, false))) pts += v.points();
|
||||||
|
}
|
||||||
|
assertTrue(pts > 0, "vol plat en élytres suspectes : " + pts);
|
||||||
|
}
|
||||||
|
|
||||||
|
// C7 témoin : plané honnête (déployé en l'air) toujours exempté, avec ou sans l'option ; défaut inchangé.
|
||||||
|
@Test
|
||||||
|
void temoin_C7_planeHonneteToujoursExempte() {
|
||||||
|
EtatJoueur honnete = EtatJoueur.builder().elytres(true).build();
|
||||||
|
assertTrue(Exemptions.evaluer(honnete, strict(), Famille.MOUVEMENT).raisons().contains("elytres"));
|
||||||
|
EtatJoueur suspect = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(true).build();
|
||||||
|
assertTrue(Exemptions.evaluer(suspect, cfg, Famille.MOUVEMENT).raisons().contains("elytres"), "défaut inchangé");
|
||||||
|
}
|
||||||
|
|
||||||
|
// C7 : portée / hitbox mesurées pendant le plané avec l'option.
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C7_porteeMesureeEnElytres() {
|
||||||
|
EtatJoueur e = EtatJoueur.builder().elytres(true).build();
|
||||||
|
assertNull(PorteeHitbox.raisonNonMesure(e, 0.0, strict()));
|
||||||
|
assertEquals("elytres", PorteeHitbox.raisonNonMesure(e, 0.0, cfg), "défaut inchangé");
|
||||||
|
}
|
||||||
|
|
||||||
|
// C8 : passager d'un véhicule : combat mesuré avec l'option.
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C8_combatMesureEnVehicule() {
|
||||||
|
EtatJoueur e = EtatJoueur.builder().enVehicule(true).build();
|
||||||
|
assertFalse(Exemptions.evaluer(e, strict(), Famille.COMBAT).exempt());
|
||||||
|
Moteur m = new Moteur(strict());
|
||||||
|
java.util.UUID j = java.util.UUID.randomUUID();
|
||||||
|
int verdicts = 0;
|
||||||
|
for (int i = 0; i < 40; i++) verdicts += m.attaque(j, i * 50L, e, 170.0, 1, true).size();
|
||||||
|
assertTrue(verdicts > 0);
|
||||||
|
assertTrue(Exemptions.evaluer(e, cfg, Famille.COMBAT).exempt(), "défaut inchangé");
|
||||||
|
// La contraption reste une exemption (constat : la garder pour le combat sur contraption).
|
||||||
|
assertTrue(Exemptions.evaluer(EtatJoueur.builder().pocheContraption(true).build(), strict(), Famille.COMBAT).exempt());
|
||||||
|
}
|
||||||
|
|
||||||
|
// C18 : stockage immobile de minecarts à coffre non cassé avec l'option ; empilement en mouvement ou simple cassé.
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C18_stockageImmobileNonCasse() {
|
||||||
|
AntiCrashEntites.Reglages r = new AntiCrashEntites.Reglages();
|
||||||
|
r.empilementSeulementEnMouvement = true;
|
||||||
|
assertFalse(AntiCrashEntites.empilementACasser(6, r, 0.0, true));
|
||||||
|
assertTrue(AntiCrashEntites.empilementACasser(6, r, 0.5, true));
|
||||||
|
assertTrue(AntiCrashEntites.empilementACasser(6, r, 0.0, false));
|
||||||
|
assertFalse(AntiCrashEntites.empilementACasser(3, r, 0.5, false));
|
||||||
|
AntiCrashEntites.Reglages d = new AntiCrashEntites.Reglages();
|
||||||
|
assertTrue(AntiCrashEntites.empilementACasser(6, d, 0.0, true), "défaut inchangé");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void temoin_portee_mesureeAPiedSansElytres() {
|
||||||
|
assertNull(PorteeHitbox.raisonNonMesure(EtatJoueur.normal(), 0.0, cfg));
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,328 @@
|
|||||||
|
package com.gastinelgarde.core;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.UUID;
|
||||||
|
import org.junit.jupiter.api.BeforeEach;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Autotests du 16/10/2026, nuit : contournements signalés par la revue de sécurité automatique des commits 7a5a1c9 /
|
||||||
|
* 937d43d (contrôle coups-hors-boite) et constats C13, C15 de l'autocritique.
|
||||||
|
*
|
||||||
|
* Corrigés le 16/10 (branche fix/hitbox-c10-c13-c15) : les anciens tests {@code FAILLE_…} ont été inversés et
|
||||||
|
* renommés {@code CORRIGE_…}. Chaque faille garde son test « témoin » ; les détections C15 sont des options
|
||||||
|
* désactivées par défaut, activées ici, avec un témoin honnête qui ne doit rien donner.
|
||||||
|
* Le contournement n°3 (table SUIVIES pleine) dépend de Minecraft : voir {@code com.gastinelgarde.AutotestSuiviesTest}.
|
||||||
|
*/
|
||||||
|
class AutotestContournementsTest {
|
||||||
|
|
||||||
|
private static final double V = 0.28; // cible qui sprinte, blocs/tick
|
||||||
|
private GardeConfig cfg;
|
||||||
|
private Moteur moteur;
|
||||||
|
private final UUID joueur = UUID.randomUUID();
|
||||||
|
|
||||||
|
@BeforeEach
|
||||||
|
void init() {
|
||||||
|
cfg = new GardeConfig();
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double[] boite(double x) {
|
||||||
|
return new double[] {x - 0.3, 0, -0.3, x + 0.3, 1.8, 0.3};
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Boîtes vues : cible qui avance de V par tick en x, arrivée en xNow (comme Garde92Test). */
|
||||||
|
private static double[][] vues(double xNow, int fenetre) {
|
||||||
|
double[][] b = new double[fenetre + 2][];
|
||||||
|
for (int i = 0; i < b.length; i++) b[i] = boite(xNow - V * (b.length - 1 - i));
|
||||||
|
return b;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double[] vers(double[] de, double x, double y, double z) {
|
||||||
|
return new double[] {x - de[0], y - de[1], z - de[2]};
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double points(List<Verdict> vs, Controle c) {
|
||||||
|
double p = 0;
|
||||||
|
for (Verdict v : vs) if (v.controle() == c) p += v.points();
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Coup mesuré par coups-hors-boite, puis paquet de mouvement suivant (œil et regard « suivants »). */
|
||||||
|
private List<Verdict> coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double[] oeilSuivant,
|
||||||
|
double[] regardSuivant, double xCible, double[][] vues) {
|
||||||
|
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, etat, oeil, regard, boite(xCible), 3.0,
|
||||||
|
V, true, false, oeil, vues));
|
||||||
|
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeilSuivant, regardSuivant));
|
||||||
|
return vs;
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Revue n°1 : ping gonflé au-delà de seriePingMaxMs = coup exempté -----------------------------------------
|
||||||
|
|
||||||
|
private double serieHitboxAvecPing(int ping) {
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg);
|
||||||
|
double total = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.0};
|
||||||
|
double[] regard = vers(oeil, x + 0.75, 1.2, 0); // client « hitbox » : 0,45 bloc devant la cible
|
||||||
|
total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_revue1_pingDeclareAuDessusDe500msNExemptePlusLesCoups() {
|
||||||
|
assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs) > 0, "témoin : à 500 ms, la série est vue");
|
||||||
|
assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs + 1) > 0, "corrigé : à 501 ms, la série est encore vue");
|
||||||
|
assertTrue(serieHitboxAvecPing(5000) > 0, "corrigé : à 5 s déclarées aussi (fenêtre bornée)");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Revue n°2 / C13 : regard et œil du paquet SUIVANT acceptés sans borne --------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_revue2_regardSuivantRameneSurLaCibleNEffacePlusLeCoupHorsBoite() {
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||||
|
double temoin = 0, triche = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.0};
|
||||||
|
double[] hors = {0, 0, -1}; // regard tourné à 180° de la cible au moment du coup
|
||||||
|
double[] surCible = vers(oeil, x, 1.2, 0);
|
||||||
|
triche += points(coup(k * 600L, EtatJoueur.normal(), oeil, hors, oeil, surCible, x, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.0};
|
||||||
|
double[] hors = {0, 0, -1};
|
||||||
|
temoin += points(coup(k * 600L, EtatJoueur.normal(), oeil, hors, oeil, hors, x, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertTrue(temoin > 0, "témoin : le même regard gardé au paquet suivant est vu");
|
||||||
|
assertTrue(triche > 0, "corrigé : un demi-tour du regard au paquet suivant n'est plus accepté");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_revue2_oeilSuivantAvanceDe09BlocNEffacePlusLaPorteeAllongee() {
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||||
|
double temoin = 0, triche = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] loin = {x, 1.62, -3.9}; // 3,6 blocs de la boîte : reach
|
||||||
|
double[] proche = {x, 1.62, -3.0}; // 0,9 bloc plus près au paquet suivant (sprint : 0,28 bloc/tick)
|
||||||
|
double[] regard = vers(loin, x, 1.2, 0);
|
||||||
|
triche += points(coup(k * 600L, EtatJoueur.normal(), loin, regard, proche, vers(proche, x, 1.2, 0), x,
|
||||||
|
vues(x, fenetre)), Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] loin = {x, 1.62, -3.9};
|
||||||
|
double[] regard = vers(loin, x, 1.2, 0);
|
||||||
|
temoin += points(coup(k * 600L, EtatJoueur.normal(), loin, regard, loin, regard, x, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertTrue(temoin > 0);
|
||||||
|
assertTrue(triche > 0, "corrigé : l'œil suivant est borné à un déplacement d'un tick");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C13_porteeEtAngleNeGardentPlusLeMinimumSansBorne() {
|
||||||
|
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
|
||||||
|
double[] b = boite(0);
|
||||||
|
double[] loin = {0, 1.62, -4.3}; // 4,0 blocs de la boîte : refus vanilla à la limite
|
||||||
|
double[] proche = {0, 1.62, -3.5}; // 3,2 blocs au paquet suivant
|
||||||
|
double[] regard = vers(loin, 0, 1.0, 0);
|
||||||
|
// Témoin : paquet suivant identique.
|
||||||
|
List<Verdict> t = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0,
|
||||||
|
true, false));
|
||||||
|
t.addAll(moteur.regardPorteeHitbox(joueur, 50, loin, regard));
|
||||||
|
assertTrue(points(t, Controle.PORTEE) > 0, "témoin : 4,0 blocs sur cible immobile est vu");
|
||||||
|
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
List<Verdict> v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0,
|
||||||
|
true, false));
|
||||||
|
v.addAll(moteur.regardPorteeHitbox(joueur, 50, proche, vers(proche, 0, 1.0, 0)));
|
||||||
|
assertTrue(points(v, Controle.PORTEE) > 0, "corrigé : s'avancer de 0,8 bloc au paquet suivant n'efface plus la portée");
|
||||||
|
|
||||||
|
// Angle killaura : regard à 180° au coup, sur la cible au paquet suivant. Un coup isolé n'est pas compté (un
|
||||||
|
// demi-tour honnête existe : Garde1016Test.angleKillauraRegardEnRetardPasDeFauxPositif) ; une série, si.
|
||||||
|
// [À VÉRIFIER] Théo : le témoin d'origine portait sur un seul coup.
|
||||||
|
cfg.mode(Controle.PORTEE, Mode.OFF);
|
||||||
|
cfg.mode(Controle.HITBOX, Mode.OFF);
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
double[] oeil = {0, 1.62, -2.5};
|
||||||
|
double serie = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
List<Verdict> a = new ArrayList<>(moteur.coupDiffere(joueur, k * 600L, EtatJoueur.normal(), oeil,
|
||||||
|
new double[] {0, 0, -1}, b, 3.0, 0, false, true));
|
||||||
|
a.addAll(moteur.regardPorteeHitbox(joueur, k * 600L + 50, oeil, vers(oeil, 0, 1.0, 0)));
|
||||||
|
if (k == 0) assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "un demi-tour isolé : rien");
|
||||||
|
serie += points(a, Controle.KILLAURA_ANGLE);
|
||||||
|
}
|
||||||
|
assertTrue(serie > 0, "corrigé : rotations silencieuses de 180° répétées vues");
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* C13, seuils de {@code portee} (3,3 sur cible immobile, 4,3 sur cible qui sprinte) : {@code portee} et
|
||||||
|
* {@code hitbox} ne sont pas resserrés (ils peuvent être en ENFORCE en production ; tolérance « vitesse × ticks »
|
||||||
|
* gardée). C'est {@code coups-hors-boite} (mesure sur l'historique de la cible, marge 0,15) qui doit voir ces
|
||||||
|
* reach en série. Ancien test : {@code FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee},
|
||||||
|
* qui mesurait {@code portee} seul. [À VÉRIFIER] Théo : accepter que la correction passe par coups-hors-boite.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteVusParCoupsHorsBoite() {
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||||
|
double immobile = 0, sprint = 0, honnete = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[][] fixes = new double[fenetre + 2][];
|
||||||
|
for (int i = 0; i < fixes.length; i++) fixes[i] = boite(x);
|
||||||
|
double[] oeil33 = {x, 1.62, -3.59}; // 3,29 blocs, cible immobile
|
||||||
|
immobile += points(coupV(k * 600L, oeil33, vers(oeil33, x, 1.0, 0), x, 0, fixes), Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil40 = {x, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte
|
||||||
|
sprint += points(coupV(k * 600L, oeil40, vers(oeil40, x, 1.0, 0), x, V, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.2}; // 2,9 blocs : honnête
|
||||||
|
honnete += points(coupV(k * 600L, oeil, vers(oeil, x, 1.0, 0), x, V, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertTrue(immobile > 0, "3,29 blocs sur cible immobile : vu en série");
|
||||||
|
assertTrue(sprint > 0, "3,99 blocs sur cible qui sprinte : vu en série");
|
||||||
|
assertEquals(0, honnete, 1e-9, "témoin : 2,9 blocs, rien");
|
||||||
|
}
|
||||||
|
|
||||||
|
private List<Verdict> coupV(long t, double[] oeil, double[] regard, double xCible, double vCible, double[][] vues) {
|
||||||
|
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, EtatJoueur.normal(), oeil, regard,
|
||||||
|
boite(xCible), 3.0, vCible, true, false, oeil, vues));
|
||||||
|
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeil, regard));
|
||||||
|
return vs;
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Revue n°4 : la fenêtre d'historique grandit avec le ping déclaré ------------------------------------------
|
||||||
|
|
||||||
|
/** Le joueur a eu {@code pingAvant} pendant une minute, puis déclare {@code ping} pendant le combat. */
|
||||||
|
private double serieDerriereLaCible(int pingAvant, int ping) {
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
for (long t = 0; t < 60_000; t += 1000) moteur.pingFenetre(joueur, t, pingAvant);
|
||||||
|
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
|
||||||
|
// ce que Garde.boitesVues calcule depuis latency()
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 60_000, ping), cfg);
|
||||||
|
double total = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 10 * k;
|
||||||
|
double[] oeil = {x - 1.5, 1.62, -2.5};
|
||||||
|
// Client « hitbox » : touche loin DERRIÈRE le centre de la cible (là où elle était il y a ~15 ticks).
|
||||||
|
// 16/10 (correctif) : 4,2 au lieu de 3,6. Avec la marge de 50 ms sur le plancher (30 + 50 ms : 9 ticks
|
||||||
|
// au lieu de 8), le point à 3,6 tombait au bord de la fenêtre (manque 0,135 < 0,15) ; à 4,2 il reste
|
||||||
|
// caché par une fenêtre de 16 ticks (450 ms) et vu avec 8 ou 9. [À VÉRIFIER] Théo : témoin modifié.
|
||||||
|
double[] regard = vers(oeil, x - 4.2, 1.2, 0);
|
||||||
|
total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_revue4_pingGonflePendantLeCombatNElargitPlusLaFenetre() {
|
||||||
|
assertEquals(8, PorteeHitbox.ticksFenetre(30, cfg));
|
||||||
|
assertEquals(16, PorteeHitbox.ticksFenetre(450, cfg));
|
||||||
|
assertEquals(17, PorteeHitbox.ticksFenetre(500, cfg));
|
||||||
|
assertTrue(serieDerriereLaCible(450, 450) == 0, "témoin : fenêtre de 16 ticks (450 ms durables), cachée");
|
||||||
|
assertTrue(serieDerriereLaCible(30, 30) > 0, "témoin : à 30 ms, la série est vue");
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
for (long t = 0; t < 60_000; t += 1000) moteur.pingFenetre(joueur, t, 30);
|
||||||
|
assertEquals(9, PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 60_000, 450), cfg),
|
||||||
|
"corrigé : 30 ms puis 450 annoncés : fenêtre de 9 ticks (plancher 30 + marge 50), pas 16");
|
||||||
|
assertTrue(serieDerriereLaCible(30, 450) > 0,
|
||||||
|
"corrigé : 30 ms pendant une minute puis 450 ms annoncés en combat : toujours vu");
|
||||||
|
// Joueur honnête qui a 450 ms depuis le début : fenêtre complète.
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
assertEquals(16, PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 0, 450), cfg));
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- C15 : vitesse 0,40 en l'air et Timer 1,09 non vus ---------------------------------------------------------
|
||||||
|
|
||||||
|
private static EtatMouvement pas(double dxz, boolean sol) {
|
||||||
|
return new EtatMouvement(dxz, 0, 1, sol, sol, true, false, false, 0, 0, false, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
private double vitesse(double dxzAir, double dxzSol, int cycle, int ticks) {
|
||||||
|
cfg.mode(Controle.VOL, Mode.OFF);
|
||||||
|
cfg.mode(Controle.NO_FALL, Mode.OFF);
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < ticks; i++) {
|
||||||
|
boolean sol = cycle > 0 && i % cycle == 0;
|
||||||
|
total += points(moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), pas(sol ? dxzSol : dxzAir, sol)),
|
||||||
|
Controle.VITESSE);
|
||||||
|
}
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C15_bhopA040BlocParTickEstVuAvecLOption() {
|
||||||
|
// Option désactivée par défaut : comportement inchangé.
|
||||||
|
assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9, "option coupée : rien (comme avant)");
|
||||||
|
cfg.vitesseMoyenne = true;
|
||||||
|
// 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (sprint-saut vanilla : ~0,356 en moyenne, 7,13 m/s).
|
||||||
|
assertTrue(vitesse(0.40, 0.40, 12, 400) > 0, "corrigé : bhop à 0,40 vu");
|
||||||
|
assertEquals(0, vitesse(0.356, 0.356, 12, 400), 1e-9, "témoin : sprint-saut vanilla moyen, rien");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C15_speedAuSolA037BlocParTickEstVuAvecLOption() {
|
||||||
|
assertTrue(vitesse(0.45, 0.45, 1, 200) > 0, "témoin : 0,45 au sol (+50 %) est vu");
|
||||||
|
cfg.vitesseMoyenne = true;
|
||||||
|
assertTrue(vitesse(0.37, 0.37, 1, 400) > 0, "corrigé : 0,37 au sol vu");
|
||||||
|
assertEquals(0, vitesse(0.28, 0.28, 1, 400), 1e-9, "témoin : sprint vanilla (0,28), rien");
|
||||||
|
}
|
||||||
|
|
||||||
|
private double timer(long intervalleMs, int secondes) {
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
double total = 0;
|
||||||
|
for (long t = 0; t < secondes * 1000L; t += intervalleMs) {
|
||||||
|
total += points(moteur.paquetMouvement(joueur, 10_000 + t, EtatJoueur.normal()), Controle.TIMER);
|
||||||
|
}
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C15_timerA109EstVuAvecLOption() {
|
||||||
|
assertTrue(timer(40, 10) > 0, "témoin : 25 paquets/s (timer 1,25) est vu");
|
||||||
|
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");
|
||||||
|
assertEquals(0, timer(50, 60), 1e-9, "témoin : 20 paquets/s, rien");
|
||||||
|
// Témoin lag : 1 s sans paquet, puis rafale de 20 paquets d'un coup, à répéter.
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
double lag = 0;
|
||||||
|
long t = 10_000;
|
||||||
|
for (int r = 0; r < 20; r++) {
|
||||||
|
t += 1000;
|
||||||
|
for (int i = 0; i < 20; i++) lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
|
||||||
|
for (int i = 0; i < 40; i++) {
|
||||||
|
t += 50;
|
||||||
|
lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertEquals(0, lag, 1e-9, "témoin : rafales de rattrapage après un lag, rien");
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,107 @@
|
|||||||
|
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;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Autotests du 16/10/2026 : rafales réseau (paquets de mouvement groupés après un lag). Chaque paquet couvre UN tick
|
||||||
|
* client, mais le serveur voit {@code motif[i]} ticks écoulés avant lui (3, 0, 0 : trois paquets arrivés ensemble).
|
||||||
|
*
|
||||||
|
* {@code CORRIGE_…} : anciens FAUX_POSITIF_ (joueur honnête puni), inversés : aucun point attendu.
|
||||||
|
* {@code temoin_…} : la triche équivalente (chute ralentie) doit rester vue, avant comme après le correctif.
|
||||||
|
*/
|
||||||
|
class AutotestRafalesTest {
|
||||||
|
|
||||||
|
private Moteur moteur;
|
||||||
|
private final UUID joueur = UUID.randomUUID();
|
||||||
|
private long tick;
|
||||||
|
private boolean sanctionLourde;
|
||||||
|
|
||||||
|
@BeforeEach
|
||||||
|
void init() {
|
||||||
|
GardeConfig cfg = new GardeConfig();
|
||||||
|
cfg.mode(Controle.VOL, Mode.ENFORCE);
|
||||||
|
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||||
|
cfg.mode(Controle.NO_FALL, Mode.OBSERVE);
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
tick = 5000;
|
||||||
|
sanctionLourde = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static EtatMouvement m(double dy, int ticks, boolean sol) {
|
||||||
|
return new EtatMouvement(0.1, dy, ticks, sol, sol, false, false, false, 0, 0, false, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
private double paquet(EtatMouvement mv) {
|
||||||
|
tick += mv.ticks();
|
||||||
|
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, EtatJoueur.normal(), mv);
|
||||||
|
double p = 0;
|
||||||
|
for (Verdict v : vs) {
|
||||||
|
if (v.controle() == Controle.VOL) p += v.points();
|
||||||
|
if (v.palier() == Sanction.SETBACK || v.palier() == Sanction.EXPULSION) sanctionLourde = true;
|
||||||
|
}
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Chute honnête de {@code paquets} ticks client depuis la vitesse v0, avec la gigue donnée. */
|
||||||
|
private double chute(double v0, int paquets, int[] motif) {
|
||||||
|
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
|
||||||
|
double total = 0, v = v0;
|
||||||
|
for (int p = 0; p < paquets; p++) {
|
||||||
|
total += paquet(m(v, motif[p % motif.length], false));
|
||||||
|
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
}
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_rafalesDeTroisLongueChuteSansPointNiSanction() {
|
||||||
|
double total = chute(0, 80, new int[] {3, 0, 0});
|
||||||
|
Mesures.noter("Rafales 3,0,0 chute 80 : " + total + " points, sanction lourde=" + sanctionLourde);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
assertTrue(!sanctionLourde, "aucun setback ni expulsion pour un joueur honnête");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_sautPuisChuteEnRafalesDeTrois() {
|
||||||
|
double total = chute(0.42, 80, new int[] {3, 0, 0});
|
||||||
|
Mesures.noter("Rafales 3,0,0 saut + chute 80 : " + total + " points");
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_gigueIrreguliereApresUnLag() {
|
||||||
|
// Gigue irrégulière (rafales de 3 et 4 mêlées) : mesurée à 0 point avant le correctif, doit le rester.
|
||||||
|
double total = chute(0, 90, new int[] {3, 0, 0, 4, 0, 0, 0, 1, 2, 0, 3, 0, 0});
|
||||||
|
Mesures.noter("Gigue irreguliere chute 90 : " + total + " points");
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void temoin_chuteRalentieUnPaquetDUnTickToutesLesTroisTicksResteVue() {
|
||||||
|
// Triche « slow fall / timer lent » : un paquet d'un tick de gravité toutes les 3 ticks serveur, sans rattrapage.
|
||||||
|
double total = chute(0, 80, new int[] {3});
|
||||||
|
Mesures.noter("Temoin chute ralentie 1/3 : " + total + " points");
|
||||||
|
assertTrue(total > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void temoin_planeEnRafalesResteVu() {
|
||||||
|
// Plané (dy = 0) livré en rafales : doit être vu, quelle que soit la gigue.
|
||||||
|
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
|
||||||
|
double total = 0;
|
||||||
|
int[] motif = {3, 0, 0};
|
||||||
|
for (int p = 0; p < 60; p++) total += paquet(m(-0.01, motif[p % 3], false));
|
||||||
|
assertTrue(total > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_chuteSansGigueReference() {
|
||||||
|
assertEquals(0, chute(0, 80, new int[] {1}), 1e-9);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,304 @@
|
|||||||
|
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.assertNotEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.UUID;
|
||||||
|
import org.junit.jupiter.api.BeforeEach;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Autotests du 16/10/2026, nuit : incident VOL de Rednixxu (15/10, 17:31) et constats C1 à C5, C10 de l'autocritique.
|
||||||
|
*
|
||||||
|
* C1 à C5 corrigés le 16/10 (branche fix/vol-elytres) : les anciens tests {@code FAUX_POSITIF_…} / {@code FAILLE_…}
|
||||||
|
* ont été inversés et renommés {@code CORRIGE_…}. C10 corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) par une option
|
||||||
|
* désactivée par défaut ({@code volFenetreGlissante}) : ses tests l'activent et gardent un témoin honnête.
|
||||||
|
*
|
||||||
|
* Ce qui se passe dans l'adaptateur (Garde.java, qui dépend de Minecraft) est rejoué ici par un petit modèle écrit
|
||||||
|
* d'après le code : position mémorisée après un paquet sans verdict (Garde.apresMouvement), paquet suivant un
|
||||||
|
* teleport() non mesuré (Garde.teleportVanilla remet mouvementTick à zéro).
|
||||||
|
*/
|
||||||
|
class AutotestVolIncidentTest {
|
||||||
|
|
||||||
|
private static final double Y_SOL = 110.875;
|
||||||
|
|
||||||
|
private GardeConfig cfg;
|
||||||
|
private Moteur moteur;
|
||||||
|
private final UUID joueur = UUID.randomUUID();
|
||||||
|
private int tick;
|
||||||
|
private double y;
|
||||||
|
/** Modèle de Garde.apresMouvement : dernière position mémorisée (y) et si elle était au sol serveur. */
|
||||||
|
private double yRetour;
|
||||||
|
private boolean retourAuSol;
|
||||||
|
|
||||||
|
@BeforeEach
|
||||||
|
void init() {
|
||||||
|
cfg = new GardeConfig();
|
||||||
|
cfg.mode(Controle.VOL, Mode.ENFORCE); // mode en production le 15/10 (rapport des journaux)
|
||||||
|
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||||
|
cfg.mode(Controle.NO_FALL, Mode.OFF);
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
tick = 37_000;
|
||||||
|
y = Y_SOL;
|
||||||
|
yRetour = Y_SOL;
|
||||||
|
retourAuSol = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static EtatMouvement air(double dy) {
|
||||||
|
return new EtatMouvement(0.1, dy, 1, false, false, false, false, false, 0, 0, false, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
static EtatMouvement sol() {
|
||||||
|
return new EtatMouvement(0.1, 0, 1, true, true, false, false, false, 0, 0, false, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
static double points(List<Verdict> vs, Controle c) {
|
||||||
|
double p = 0;
|
||||||
|
for (Verdict v : vs) if (v.controle() == c) p += v.points();
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Un paquet accepté, avec le modèle de mémorisation de la position de retour. */
|
||||||
|
private List<Verdict> paquet(EtatJoueur e, EtatMouvement m) {
|
||||||
|
tick++;
|
||||||
|
y += m.dy();
|
||||||
|
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, e, m);
|
||||||
|
// Garde.apresMouvement : m.dernierVerdictTick != tick, et (16/10, C3) position admise (au sol serveur)
|
||||||
|
if (vs.isEmpty() && moteur.positionDeRetourAdmise(m.auSolServeur(), m.milieuSpecial())) {
|
||||||
|
yRetour = y;
|
||||||
|
retourAuSol = m.auSolServeur();
|
||||||
|
}
|
||||||
|
return vs;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Trace de Rednixxu (rapport des journaux, ticks 37 589 à 37 614) : au sol à y = 110,875, saut, drapeau élytres
|
||||||
|
* pendant 7 ticks, drapeau retombé alors que le client plane encore (accélération ~0,02 bloc/tick² au lieu de 0,08).
|
||||||
|
*
|
||||||
|
* @return verdicts de chaque paquet de plané sans drapeau
|
||||||
|
*/
|
||||||
|
private List<List<Verdict>> sautPuisPlaneSansDrapeau(int ticksPlane) {
|
||||||
|
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||||
|
double v = 0.42;
|
||||||
|
for (int i = 0; i < 5; i++) { // saut normal
|
||||||
|
paquet(EtatJoueur.normal(), air(v));
|
||||||
|
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
}
|
||||||
|
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||||
|
for (int i = 0; i < 7; i++) paquet(elytres, air(-0.05)); // drapeau 16 : exempté
|
||||||
|
List<List<Verdict>> sortie = new ArrayList<>();
|
||||||
|
for (int k = 1; k <= ticksPlane; k++) sortie.add(paquet(EtatJoueur.normal(), air(-0.02 * k)));
|
||||||
|
return sortie;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Plané anormal depuis le sol, sans élytres (triche de type « glide ») : de quoi déclencher des setbacks. */
|
||||||
|
private EtatMouvement plane() {
|
||||||
|
return air(-0.02);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- C1 : grâce de sortie d'élytres pour le vol (corrigé le 16/10) ----------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C1_planeDElytresDontLeDrapeauTombeNEstPlusPrisPourDuVol() {
|
||||||
|
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
|
||||||
|
double total = 0;
|
||||||
|
for (List<Verdict> v : vs) total += points(v, Controle.VOL);
|
||||||
|
// Avant : premier point au 12e tick, 11,6 points en 19 ticks (incident de Rednixxu).
|
||||||
|
assertEquals(0, total, 1e-9, "grâce de fin d'élytres : la trace de Rednixxu ne donne plus rien");
|
||||||
|
Mesures.noter("C1 corrige : 19 ticks de plane sans drapeau = " + total + " point");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C1_laGraceDeFinDElytresEstBorneeDansLeTemps() {
|
||||||
|
// Témoin : un plané sans drapeau qui dure bien au-delà de la grâce finit par être vu.
|
||||||
|
// 16/10 : témoin corrigé. L'ancien (accélération 0,02 bloc/tick² prolongée) entre dans la tolérance de
|
||||||
|
// VolVertical (0,05) dès ~22 ticks et n'était donc jamais puni après 50 ticks de grâce, même sans grâce.
|
||||||
|
// Plané constant à -0,05 bloc/tick : écart ~0,077 à chaque tick, nettement anormal.
|
||||||
|
sautPuisPlaneSansDrapeau(1);
|
||||||
|
double total = 0;
|
||||||
|
for (int k = 0; k < cfg.graceFinElytresTicks + 30; k++) {
|
||||||
|
total += points(paquet(EtatJoueur.normal(), air(-0.05)), Controle.VOL);
|
||||||
|
}
|
||||||
|
assertTrue(total > 0, "après la grâce, un plané anormal est de nouveau puni");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C1_laGraceSeTermineALAtterrissage() {
|
||||||
|
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||||
|
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||||
|
for (int i = 0; i < 20; i++) paquet(elytres, air(-0.3));
|
||||||
|
for (int i = 0; i < 3; i++) paquet(EtatJoueur.normal(), sol()); // atterrissage : fin de la grâce
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 20; i++) total += points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL);
|
||||||
|
assertTrue(total > 0, "voler juste après un atterrissage d'élytres reste vu");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void honnete_finDElytresSuivieDUneVraieChuteNeDonneRien() {
|
||||||
|
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||||
|
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||||
|
for (int i = 0; i < 40; i++) paquet(elytres, air(-0.5));
|
||||||
|
double v = -0.5, total = 0;
|
||||||
|
for (int i = 0; i < 60; i++) {
|
||||||
|
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
|
||||||
|
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9, "réfuté : une fin d'élytres suivie d'une chute vanilla ne donne rien");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- C3 : point de retour au sol (corrigé le 16/10) --------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C3_pointDeRetourResteAuSolPendantUnPlane() {
|
||||||
|
sautPuisPlaneSansDrapeau(12);
|
||||||
|
assertTrue(retourAuSol, "la position de retour vient d'un paquet au sol serveur");
|
||||||
|
assertEquals(Y_SOL, yRetour, 1e-9, "et c'est la plateforme d'où il a sauté");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C3_unVolDeDixTicksNeGardePasLAltitudeGagnee() {
|
||||||
|
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||||
|
int premier = -1;
|
||||||
|
for (int k = 1; k <= 15 && premier < 0; k++) {
|
||||||
|
if (points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL) > 0) premier = k;
|
||||||
|
}
|
||||||
|
assertTrue(premier > 10, "le vol n'est vu qu'après 10 ticks anormaux");
|
||||||
|
assertTrue(retourAuSol);
|
||||||
|
assertEquals(Y_SOL, yRetour, 1e-9, "le setback ramène au sol de départ, pas à l'altitude gagnée");
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- C2, C5, C4 : setback remis à zéro, escalade, expulsion unique (corrigés le 16/10) ---------------------------
|
||||||
|
|
||||||
|
/** Modèle de Garde.appliquerSanctionMouvement (SETBACK) : téléportation au point de retour puis remise à zéro. */
|
||||||
|
private void setback() {
|
||||||
|
moteur.apresSetback(joueur, tick * 50L);
|
||||||
|
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
|
||||||
|
y = yRetour;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C2_apresUnSetbackLeVolEtLesVlRepartentDeZero() {
|
||||||
|
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||||
|
int n = 0;
|
||||||
|
while (Verdict.pire(paquet(EtatJoueur.normal(), plane())) != Sanction.SETBACK) assertTrue(++n < 100);
|
||||||
|
assertTrue(retourAuSol, "point de retour au sol");
|
||||||
|
setback();
|
||||||
|
assertEquals(0, moteur.suivi(joueur).vl.valeur(Controle.VOL, tick * 50L), 1e-9, "VL de vol remis à zéro");
|
||||||
|
// Le client, ramené au sol, reste immobile quelques paquets (téléportation pas encore confirmée) : rien.
|
||||||
|
for (int i = 0; i < 5; i++) {
|
||||||
|
List<Verdict> v = paquet(EtatJoueur.normal(), sol());
|
||||||
|
assertEquals(0, points(v, Controle.VOL), 1e-9, "paquet " + i + " après le setback");
|
||||||
|
}
|
||||||
|
// Et même gelé en l'air une demi-seconde (ancien scénario), le compteur repart de zéro : pas de point.
|
||||||
|
double total = 0;
|
||||||
|
for (int i = 0; i < 10; i++) total += points(paquet(EtatJoueur.normal(), air(0)), Controle.VOL);
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C5_C4_escaladeEnPlusDUneSecondeEtExpulsionUnique() {
|
||||||
|
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||||
|
int premierPointTick = -1, setbacks = 0, expulsionTick = -1;
|
||||||
|
for (int n = 0; n < 2000 && expulsionTick < 0; n++) {
|
||||||
|
List<Verdict> vs = paquet(EtatJoueur.normal(), plane());
|
||||||
|
if (points(vs, Controle.VOL) > 0 && premierPointTick < 0) premierPointTick = tick;
|
||||||
|
Sanction s = Verdict.pire(vs);
|
||||||
|
if (s == Sanction.SETBACK) {
|
||||||
|
setbacks++;
|
||||||
|
setback();
|
||||||
|
paquet(EtatJoueur.normal(), sol()); // de retour au sol, le tricheur recommence
|
||||||
|
} else if (s == Sanction.EXPULSION) {
|
||||||
|
expulsionTick = tick;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertTrue(expulsionTick > 0, "un tricheur obstiné finit expulsé");
|
||||||
|
int duree = expulsionTick - premierPointTick;
|
||||||
|
Mesures.noter("C5 corrige : premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), "
|
||||||
|
+ setbacks + " setbacks");
|
||||||
|
assertTrue(duree >= 40, "au moins 2 s entre le premier point et l'expulsion : " + duree + " ticks");
|
||||||
|
assertEquals(cfg.setbacksAvantExpulsion, setbacks, "l'expulsion vient après plusieurs setbacks distincts");
|
||||||
|
|
||||||
|
// C4 : l'expulsion est à usage unique ; le moteur ne rend plus rien pour ce joueur.
|
||||||
|
assertTrue(moteur.expulser(joueur, tick * 50L), "première expulsion acceptée");
|
||||||
|
assertFalse(moteur.expulser(joueur, tick * 50L), "deuxième demande refusée");
|
||||||
|
int verdictsSuivants = 0;
|
||||||
|
for (int i = 0; i < 20; i++) verdictsSuivants += paquet(EtatJoueur.normal(), plane()).size();
|
||||||
|
assertEquals(0, verdictsSuivants, "aucun verdict après l'expulsion");
|
||||||
|
// C6 : même si l'état du joueur est retiré pendant disconnect(), la marque d'expulsion reste.
|
||||||
|
moteur.retirer(joueur);
|
||||||
|
assertFalse(moteur.expulser(joueur, tick * 50L));
|
||||||
|
moteur.oublierExpulsion(joueur); // reconnexion
|
||||||
|
assertTrue(moteur.expulser(joueur, tick * 50L));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void jamaisDeBannissement() {
|
||||||
|
for (Sanction s : Sanction.values()) assertFalse(s.name().contains("BAN"), "sanction " + s);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void referenceEnObserveLeMemeIncidentNeToucheJamaisLeJoueur() {
|
||||||
|
cfg.mode(Controle.VOL, Mode.OBSERVE);
|
||||||
|
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(40);
|
||||||
|
for (List<Verdict> v : vs) {
|
||||||
|
assertNotEquals(Sanction.SETBACK, Verdict.pire(v));
|
||||||
|
assertNotEquals(Sanction.EXPULSION, Verdict.pire(v));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- C10 : sauts en l'air espacés --------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C10_unSautEnLAirTousLesDixTicksEstVuAvecLOption() {
|
||||||
|
cfg.volFenetreGlissante = true;
|
||||||
|
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||||
|
double total = 0;
|
||||||
|
double depart = y;
|
||||||
|
for (int cycle = 0; cycle < 30; cycle++) {
|
||||||
|
double v = 0.42; // « saut » en plein air
|
||||||
|
for (int i = 0; i < 10; i++) {
|
||||||
|
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
|
||||||
|
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertTrue(total > 0, "corrigé : les sauts en l'air répétés sont vus");
|
||||||
|
Mesures.noter(String.format(java.util.Locale.ROOT, "C10 corrige : %.1f points en 300 ticks", total));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C10_temoinSautsHonnetesRepetesAvecLOption() {
|
||||||
|
cfg.volFenetreGlissante = true;
|
||||||
|
double total = 0;
|
||||||
|
for (int cycle = 0; cycle < 30; cycle++) {
|
||||||
|
total += points(paquet(EtatJoueur.normal(), sol()), Controle.VOL);
|
||||||
|
double v = 0.42; // saut depuis le sol
|
||||||
|
double h = 0;
|
||||||
|
for (int i = 0; i < 40; i++) {
|
||||||
|
if (h + v <= 0) break; // retour au sol
|
||||||
|
h += v;
|
||||||
|
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
|
||||||
|
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
}
|
||||||
|
y = Y_SOL;
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9, "témoin : sauts honnêtes répétés, rien");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void CORRIGE_C10_alternerUnTickAnormalEtUnTickNormalEstVuAvecLOption() {
|
||||||
|
cfg.volFenetreGlissante = true;
|
||||||
|
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||||
|
double total = 0;
|
||||||
|
double depart = y;
|
||||||
|
for (int i = 0; i < 200; i++) {
|
||||||
|
// tick pair : plané (dy = -0,02, anormal) ; tick impair : la vraie gravité depuis ce plané (normal)
|
||||||
|
double dy = i % 2 == 0 ? -0.02 : (-0.02 - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||||
|
total += points(paquet(EtatJoueur.normal(), air(dy)), Controle.VOL);
|
||||||
|
}
|
||||||
|
assertTrue(total > 0, "corrigé : l'alternance plané / gravité est vue");
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,262 @@
|
|||||||
|
package com.gastinelgarde.core;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
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.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.UUID;
|
||||||
|
import org.junit.jupiter.api.BeforeEach;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* #92 (16/10/2026) : test hitbox / portée de Rednixxu non détecté.
|
||||||
|
*
|
||||||
|
* Cause reproduite ici : dès que la cible bouge (marche, sprint), l'ancien calcul ajoutait « vitesse × (3 + ping/50)
|
||||||
|
* ticks », plafonné à 1,0 bloc, aux deux seuils, dans toutes les directions. Une cible qui sprinte (0,28 bloc/tick)
|
||||||
|
* donnait donc une hitbox tolérée de 0,25 + 1,0 = 1,25 bloc et une portée de 3,0 + 0,3 + 1,0 = 4,3 blocs, au-delà
|
||||||
|
* même du refus vanilla (4,0) : portée et hitbox ne pouvaient plus rien voir.
|
||||||
|
*
|
||||||
|
* Correctif : contrôle coups-hors-boite, mesure contre les boîtes réellement occupées par la cible pendant la
|
||||||
|
* fenêtre où le client a pu la voir, et sanction seulement sur une série.
|
||||||
|
*/
|
||||||
|
class Garde92Test {
|
||||||
|
|
||||||
|
private static final double V = 0.28; // sprint, blocs/tick
|
||||||
|
private GardeConfig cfg;
|
||||||
|
private Moteur moteur;
|
||||||
|
private final UUID joueur = UUID.randomUUID();
|
||||||
|
|
||||||
|
@BeforeEach
|
||||||
|
void init() {
|
||||||
|
cfg = new GardeConfig();
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double[] boite(double x) {
|
||||||
|
return new double[] {x - 0.3, 0, -0.3, x + 0.3, 1.8, 0.3};
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Boîtes vues : cible qui avance de V par tick en x, arrivée en xNow. */
|
||||||
|
private static double[][] vues(double xNow, int fenetre) {
|
||||||
|
double[][] b = new double[fenetre + 2][];
|
||||||
|
for (int i = 0; i < b.length; i++) b[i] = boite(xNow - V * (b.length - 1 - i));
|
||||||
|
return b;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double points(List<Verdict> vs, Controle c) {
|
||||||
|
double p = 0;
|
||||||
|
for (Verdict v : vs) if (v.controle() == c) p += v.points();
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Un coup complet (coup + paquet de mouvement suivant) ; renvoie tous les verdicts. */
|
||||||
|
private List<Verdict> coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double xCible, double vitesse,
|
||||||
|
double[][] vues) {
|
||||||
|
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, etat, oeil, regard, boite(xCible), 3.0,
|
||||||
|
vitesse, true, false, oeil, vues));
|
||||||
|
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeil, regard));
|
||||||
|
return vs;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double[] vers(double[] de, double x, double y, double z) {
|
||||||
|
return new double[] {x - de[0], y - de[1], z - de[2]};
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Le cas de Rednixxu -----------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void hitboxGrossieSurCibleQuiSprinteEtaitInvisiblePourLAncienControleEtEstVueEnSerie() {
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||||
|
double ancien = 0, nouveau = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.0};
|
||||||
|
// Le client « hitbox » touche 0,45 bloc devant le bord avant de la cible : là où elle n'a jamais été.
|
||||||
|
double[] regard = vers(oeil, x + 0.75, 1.2, 0);
|
||||||
|
List<Verdict> vs = coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre));
|
||||||
|
ancien += points(vs, Controle.HITBOX) + points(vs, Controle.PORTEE);
|
||||||
|
nouveau += points(vs, Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertEquals(0, ancien, 1e-9, "l'ancien contrôle ne voit rien (c'est le bogue reproduit)");
|
||||||
|
// 4e coup hors boîte : la série commence à compter, puis chaque coup suivant.
|
||||||
|
assertEquals(7 * cfg.seriePoints, nouveau, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void porteeAllongeeSurCibleQuiSprinteEstVueEnSerie() {
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||||
|
double ancien = 0, nouveau = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.9}; // 3,6 blocs de la boîte : vanilla laisse passer (< 4,0)
|
||||||
|
double[] regard = vers(oeil, x, 1.2, 0);
|
||||||
|
List<Verdict> vs = coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre));
|
||||||
|
ancien += points(vs, Controle.HITBOX) + points(vs, Controle.PORTEE);
|
||||||
|
nouveau += points(vs, Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertEquals(0, ancien, 1e-9);
|
||||||
|
assertTrue(nouveau > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void leNouveauControleEstEnObserveParDefaut() {
|
||||||
|
assertEquals(Mode.OBSERVE, cfg.mode(Controle.COUPS_HORS_BOITE));
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Pas de faux positifs ---------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void joueurHonneteQuiViseLaCibleAfficheeEnRetardAvecPingNestJamaisCompte() {
|
||||||
|
int ping = 150;
|
||||||
|
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg);
|
||||||
|
for (int k = 0; k < 30; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
int retard = k % (fenetre + 1); // la cible affichée a 0 à « fenetre » ticks de retard
|
||||||
|
double xVu = x - V * retard;
|
||||||
|
double[] oeil = {xVu, 1.62, -2.9};
|
||||||
|
// Visée sur le bord arrière de la boîte affichée, à 0,1 bloc près (imprécision du modèle).
|
||||||
|
double[] regard = vers(oeil, xVu - 0.3 - 0.1, 1.0, -0.3);
|
||||||
|
assertEquals(0, points(coup(k * 600L, etat, oeil, regard, x, V, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE), 1e-9, "coup " + k);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void positionInterpoleeEntreDeuxPaquetsEstAcceptee() {
|
||||||
|
// Cible qui n'envoie sa position que toutes les 3 entrées : le client l'affiche entre deux.
|
||||||
|
double[][] b = {boite(0), boite(0), boite(0), boite(0.84), boite(0.84), boite(0.84)};
|
||||||
|
double[] oeil = {0.42, 1.62, -2.5};
|
||||||
|
double[] regard = vers(oeil, 0.42, 1.0, 0);
|
||||||
|
PorteeHitbox.Mesure m = PorteeHitbox.mesureCompensee(new double[][] {oeil}, new double[][] {regard}, b, 4.0, 1.0);
|
||||||
|
assertEquals(0, m.manque(), 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void unCoupHorsBoiteIsoleNeCompteJamais() {
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||||
|
double total = 0;
|
||||||
|
for (int k = 0; k < 40; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.0};
|
||||||
|
double[] regard = k % 4 == 0 ? vers(oeil, x + 0.75, 1.2, 0) : vers(oeil, x, 1.2, 0); // 1 sur 4
|
||||||
|
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void rotationEnRetardDUnTickRattrapeeParLeRegardSuivant() {
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||||
|
double total = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.0};
|
||||||
|
double[] ancienRegard = vers(oeil, x + 1.5, 1.2, 0); // regard du paquet d'avant
|
||||||
|
double[] regard = vers(oeil, x, 1.2, 0); // vrai regard, arrivé au paquet suivant
|
||||||
|
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, k * 600L, EtatJoueur.normal(), oeil,
|
||||||
|
ancienRegard, boite(x), 3.0, V, true, false, oeil, vues(x, fenetre)));
|
||||||
|
vs.addAll(moteur.regardPorteeHitbox(joueur, k * 600L + 50, oeil, regard));
|
||||||
|
total += points(vs, Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void exemptionsCreatifMontureElytresPingTeleportationEtGel() {
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||||
|
List<EtatJoueur> etats = List.of(
|
||||||
|
EtatJoueur.builder().creatif(true).build(),
|
||||||
|
EtatJoueur.builder().enVehicule(true).build(),
|
||||||
|
EtatJoueur.builder().elytres(true).build(),
|
||||||
|
EtatJoueur.builder().riptide(true).build(),
|
||||||
|
// Revue 1 (16/10) : un ping > seriePingMaxMs n'exempte plus (ping falsifiable) ; retiré de la liste,
|
||||||
|
// voir AutotestContournementsTest.CORRIGE_revue1_… [À VÉRIFIER] Théo.
|
||||||
|
EtatJoueur.builder().ticksDepuisTeleport(5).build(),
|
||||||
|
EtatJoueur.builder().ticksDepuisGel(5).build());
|
||||||
|
for (EtatJoueur etat : etats) {
|
||||||
|
moteur = new Moteur(cfg);
|
||||||
|
double total = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.0};
|
||||||
|
total += points(coup(k * 600L, etat, oeil, vers(oeil, x + 0.75, 1.2, 0), x, V, vues(x, fenetre)),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9, etat.toString());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void cibleTeleporteeOuTropRapideOuContraptionNonMesuree() {
|
||||||
|
double total = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.0};
|
||||||
|
double[] regard = vers(oeil, x + 0.75, 1.2, 0);
|
||||||
|
double[][] saut = {boite(x - 10), boite(x - 10), boite(x), boite(x)}; // /tp de la cible
|
||||||
|
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, 0, saut), Controle.COUPS_HORS_BOITE);
|
||||||
|
// null : historique incomplet, ou cible sur / près d'une contraption Create ou d'un vaisseau Sable.
|
||||||
|
total += points(coup(k * 600L + 300, EtatJoueur.normal(), oeil, regard, x, 0, null),
|
||||||
|
Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void controleOffNeMesureRien() {
|
||||||
|
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
|
||||||
|
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||||
|
double total = 0;
|
||||||
|
for (int k = 0; k < 10; k++) {
|
||||||
|
double x = 5 * k;
|
||||||
|
double[] oeil = {x, 1.62, -3.0};
|
||||||
|
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, vers(oeil, x + 0.75, 1.2, 0), x, V,
|
||||||
|
vues(x, fenetre)), Controle.COUPS_HORS_BOITE);
|
||||||
|
}
|
||||||
|
assertEquals(0, total, 1e-9);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Briques ----------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void historiqueBoitesFenetreIncompleteTamponCirculaireEtEntreeAnterieure() {
|
||||||
|
HistoriqueBoites h = new HistoriqueBoites();
|
||||||
|
assertNull(h.depuis(0));
|
||||||
|
for (int t = 10; t < 10 + HistoriqueBoites.CAPACITE + 5; t++) h.ajouter(t, boite(t));
|
||||||
|
assertEquals(HistoriqueBoites.CAPACITE, h.taille());
|
||||||
|
assertEquals(15, h.premierTick());
|
||||||
|
assertNull(h.depuis(14)); // plus ancien que l'historique : pas de mesure
|
||||||
|
double[][] d = h.depuis(40);
|
||||||
|
assertNotNull(d);
|
||||||
|
assertEquals(10 + HistoriqueBoites.CAPACITE + 5 - 40, d.length);
|
||||||
|
assertArrayEquals(boite(40), d[0], 1e-12);
|
||||||
|
h.ajouter(46, boite(0)); // même tick : remplacé
|
||||||
|
assertEquals(HistoriqueBoites.CAPACITE, h.taille());
|
||||||
|
h.ajouter(3, boite(0)); // horloge revenue en arrière : on repart
|
||||||
|
assertEquals(1, h.taille());
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void fenetreBorneeParLePingMax() {
|
||||||
|
assertEquals(cfg.ticksAffichageCible, PorteeHitbox.ticksFenetre(0, cfg));
|
||||||
|
assertEquals(cfg.ticksAffichageCible + 3, PorteeHitbox.ticksFenetre(150, cfg));
|
||||||
|
int max = PorteeHitbox.ticksFenetre(cfg.seriePingMaxMs, cfg);
|
||||||
|
assertEquals(max, PorteeHitbox.ticksFenetre(100000, cfg));
|
||||||
|
assertTrue(max + 1 < HistoriqueBoites.CAPACITE);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void serieCoupsOublieLesCoupsTropAnciens() {
|
||||||
|
SerieCoups s = new SerieCoups();
|
||||||
|
for (int k = 0; k < 3; k++) s.enregistrer(k * 1000L, true, cfg);
|
||||||
|
// 4e coup hors boîte, mais les 3 premiers sont hors de la fenêtre de 30 s.
|
||||||
|
assertEquals(0, s.enregistrer(3 * 1000L + cfg.serieFenetreMs + 1, true, cfg), 1e-9);
|
||||||
|
assertEquals(1, s.dernierTotal());
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,27 @@
|
|||||||
|
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;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Autotests du 16/10/2026 : note les valeurs mesurées par les tests (nombre de paquets avant expulsion, altitude du
|
||||||
|
* point de retour…) dans build/autotests-mesures.txt, pour le rapport. N'influence aucun résultat.
|
||||||
|
*/
|
||||||
|
final class Mesures {
|
||||||
|
|
||||||
|
private Mesures() { }
|
||||||
|
|
||||||
|
static void noter(String ligne) {
|
||||||
|
try {
|
||||||
|
Path p = Path.of("build", "autotests-mesures.txt");
|
||||||
|
Files.createDirectories(p.getParent());
|
||||||
|
Files.writeString(p, ligne + System.lineSeparator(), StandardCharsets.UTF_8,
|
||||||
|
StandardOpenOption.CREATE, StandardOpenOption.APPEND);
|
||||||
|
} catch (IOException | RuntimeException ignored) {
|
||||||
|
// mesure facultative
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,536 @@
|
|||||||
|
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(2, c.fiabilite(), c.id() + " : sujet aux faux positifs, plafond 15 dans le score");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- 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 velociteEtAutoTotemJamaisDeSanctionMemeEnEnforce() {
|
||||||
|
cfg.mode(Controle.VELOCITE, Mode.ENFORCE);
|
||||||
|
cfg.mode(Controle.AUTO_TOTEM, Mode.ENFORCE);
|
||||||
|
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(45, s.score(0), 1e-9);
|
||||||
|
assertFalse(s.niveau(0) == Suspicion.Niveau.SUSPECT);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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);
|
||||||
|
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));
|
||||||
|
}
|
||||||
|
}
|
||||||
Référencer dans un nouveau ticket
Bloquer un utilisateur