Comparer les révisions

...
Auteur SHA1 Message Date

2026-10-23

gastineltetClaude Sonnet 5.5 59dea0d436 Plane : etat vide des qu'on n'est plus en plane ; refus de grace avec pause
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:11:55 +02:00
gastineltetClaude Sonnet 5.5 40c89825de Plane : pas de nouvelle fenetre de grace apres un refus avant une pause
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:11:11 +02:00
gastineltetClaude Sonnet 5.5 c92ebb055a Plane : fusees enchainees cumulees, reference de vitesse hors grace et reinitialisee
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:10:28 +02:00
gastineltetClaude Sonnet 5.5 1116f6137b Fusee : mediane du gain de vitesse ; velocite : blocage directionnel, 2 ticks pour abandonner
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:08:23 +02:00
gastineltetClaude Sonnet 5.5 c5bd0265f6 Fusee : grace seulement si attachee au joueur en plane, vie reelle, compteurs suspendus ; velocite bridee (jamais de sanction), joueur coince ecarte
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:04:49 +02:00
gastineltetClaude Sonnet 5.5 22ccc5fa59 GastinelGarde 0.4.0 : version et CHANGELOG
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:00:57 +02:00
gastineltetClaude Sonnet 5.5 334cc5b45c GastinelGarde 0.4.0 : controles elytres, velocite, auto-totem (OBSERVE par defaut)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:00:04 +02:00
gastineltetClaude Sonnet 5.5 80c9748a23 Vol : flottement durci contre les rafales a 0 tick et les trous de ticks
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 15:56:23 +02:00
gastineltetClaude Sonnet 5.5 c7b130ec1c GastinelGarde 0.4.0 : score de suspicion, flottement du vol, motif de sanction corrige
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 15:52:27 +02:00

2026-10-16

gastineltetClaude Sonnet 5.5 288087080f gitignore : livrable/
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 10:15:06 +02:00
gastineltetClaude Sonnet 5.5 9b5273f830 GastinelGarde 0.3.1 : version, CHANGELOG, README
Passe mod_version et neoforge.mods.toml en 0.3.1, ajoute CHANGELOG.md
(resume des correctifs, options nouvelles desactivees par defaut, modes inchanges).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 10:13:26 +02:00
gastineltetClaude Opus 5.5 d90e40c8b9 GastinelGarde tests : cablage NeoForge (evenements, bytecode, options, FAILLE_C4 vehicule)
CablageMinecraftTest (9 tests, sans serveur) : evenements abonnes, gardes
d'expulsion lues dans le bytecode, types d'entites C18/F20, options C7 C8
C10 C15 C18 desactivees par defaut et recopiees par GardeSpec.appliquer
(fichier charge en memoire). FAILLE_C4_apresVehicule... : vert tant que
apresVehicule ignore la marque d'expulsion (non corrige). 291 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
gastineltetClaude Opus 5.5 6e208dccd2 GastinelGarde : couche Cablage testable (Garde, GardeEvents) et ses tests
Decisions du cablage Minecraft sorties sans changement de comportement :
entrees des evenements (C4 expulsion, F01, exemption manuelle), annulation
du coup, exemption contraption de la cible, C7 transition elytres, cache des
detections, position de retour (C3), sanction setback/expulsion (C2, C4)
via une interface Joueur (doublure dans les tests). Evaluation paresseuse
conservee. CablageTest : 16 tests. 266 -> 282 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
gastineltetClaude Opus 5.5 3dc39c8043 GastinelGarde : correctifs C7, C8, C18 derriere options desactivees par defaut
- C7 elytresExemptionStricte : plane declenche moins de elytresAirMinTicks (2)
  ticks apres le dernier sol serveur = pas d exemption de mouvement ;
  portee/hitbox mesurees pendant le plane.
- C8 combatMesureEnVehicule : passager mesure comme a pied (contraption reste exemptee).
- C18 empilementSeulementEnMouvement : minecart contenant immobile non casse, journalise.
266 tests, 0 echec (cornafserver).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:02:09 +02:00
gastineltetClaude Opus 5.5 5eeb916add GastinelGarde tests inverses CORRIGE_C7, C8, C18 (rouges) et ebauches sans effet
Options desactivees par defaut : elytresExemptionStricte, elytresAirMinTicks,
combatMesureEnVehicule, empilementSeulementEnMouvement ; champ
EtatJoueur.elytresDeploiementSuspect ; AntiCrashEntites.empilementACasser.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:32:46 +02:00
gastineltetClaude Opus 5.5 f19fe6444b GastinelGarde tests : FAILLE_C7, FAILLE_C8, FAUX_POSITIF_C18 (verts tant que le defaut existe)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:31:36 +02:00
gastineltetClaude Opus 5.5 9c2814a30e GastinelGarde vol : rafales reseau, ticks dus bornes (AVANCE_MAX = 4)
Un paquet d un tick client recu apres n ticks serveur peut couvrir 1 tick ; les ticks dus
sont couverts par les paquets a 0 tick suivants. Ensemble de ticks candidats = sur-ensemble
de l ancien (jamais plus strict). Actif sans option : c est le correctif d un faux positif.
260 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:16:34 +02:00
gastineltetClaude Opus 5.5 e33225c0d0 GastinelGarde : tests rafales reseau inverses (CORRIGE_...), rouges avant correctif
3 echecs attendus : CORRIGE_lagRafalesDeTrois (ex FAUX_POSITIF_), CORRIGE_rafalesDeTrois, CORRIGE_sautPuisChute.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:15:33 +02:00
gastineltetClaude Opus 5.5 b34a3b3aeb GastinelGarde autotests : rafales reseau (FAUX_POSITIF_ verts tant que le defaut existe)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:14:38 +02:00
gastineltetClaude Opus 5.5 4be81eed65 GastinelGarde config : options C10/C15 (desactivees) et marge de ping dans le toml
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:11:22 +02:00
gastineltetClaude Opus 5.5 4776895371 GastinelGarde : correctif coups-hors-boite (revue 1-4), C13, C10, C15
- revue 1 : ping > seriePingMaxMs n'exempte plus, fenetre bornee
- revue 2 / C13 : oeil suivant borne a un tick de deplacement ; regard suivant > 90 deg refuse
  par coups-hors-boite, serie de coups sauves par le regard suivant comptee en killaura-angle
- revue 3 : table SUIVIES pleine -> eviction de la cible frappee le plus anciennement
- revue 4 : fenetre selon le ping plancher des 2 dernieres minutes + 50 ms (PingPlancher)
- C10 (option volFenetreGlissante, desactivee) : fenetre glissante + sauts en l'air repetes
- C15 (options vitesseMoyenne, timerSoldeMax, desactivees) : vitesse moyenne, solde timer
Temoins modifies (a valider) : Garde92Test ping, revue 4 (cible 4,2), C13 angle en serie.
cornafserver : 254 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:11:21 +02:00
gastineltetClaude Opus 5.5 080415c646 GastinelGarde : tests revue 1-4, C10, C13, C15 inverses (CORRIGE_...), rouges avant correctif
Tests FAILLE_ inverses en CORRIGE_ ; temoins honnetes ajoutes pour C10, C15.
Stubs sans effet pour compiler : options C10/C15 (desactivees), Moteur.pingFenetre.
cornafserver (conteneur jetable) : 254 tests, 11 echecs attendus.
Le test C13 seuils passe deja : reecrit pour verifier coups-hors-boite (a valider).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:05:45 +02:00
gastineltetClaude Opus 5.5 d9530d0661 GastinelGarde autotests : temoin C1 grace bornee corrige
L ancien temoin (acceleration 0,02/tick2 prolongee) entre dans la tolerance de VolVertical apres ~22 ticks
et ne pouvait pas etre puni apres la grace. Remplace par un plane constant a -0,05 bloc/tick.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 05:58:28 +02:00
gastineltetClaude Opus 5.5 9335654541 GastinelGarde vol : correctif incident elytres du 15/10 (C1-C5)
C1 grace du controle vol apres la fin du plane en elytres (bornee, finie a l atterrissage).
C2 setback : vol et vitesse remis a zero, VL VOL/VITESSE a zero.
C3 position de retour seulement au sol serveur ou milieu special.
C4 expulsion a usage unique jusqu a la reconnexion, plus aucune evaluation entre-temps.
C5 expulsion seulement apres plusieurs setbacks recents. Jamais de bannissement.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 05:58:27 +02:00
gastineltetClaude Opus 5.5 56a98f3a5c GastinelGarde vol : tests C1-C5 inverses (CORRIGE_...), rouges avant correctif
Les tests FAUX_POSITIF_/FAILLE_ de l'incident VOL du 15/10 (C1, C2, C3, C4, C5)
exigent maintenant le bon comportement : grace de fin d'elytres, setback vers
une position au sol avec remise a zero du vol et des VL, escalade en plusieurs
setbacks, expulsion a usage unique, jamais de bannissement.
Squelette d'API sans effet dans Moteur et GardeConfig pour que les tests
compilent. Resultat : 253 tests, 5 echecs (attendus).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 05:10:45 +02:00
gastineltetClaude Opus 5.5 44504eca0c GastinelGarde autotests : cas limites d'un joueur honnete
22 tests : fins d'elytres, bords de blocs, plafond, echelles, eau, slime, miel,
montures et bateaux, teleportations, Create / Aeronautics, riptide, lag.
Faux positifs documentes : plane d'elytres puni aussi par vitesse, miel ou
vaisseau non detectes, client fige apres la grace de teleportation, chute
recue en rafales de 3 paquets (gigue reseau). Code de production inchange.
250 tests, 0 echec (cornafserver, conteneur eclipse-temurin:21-jdk).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 01:10:46 +02:00
gastineltetClaude Opus 5.5 bbb08a95f8 GastinelGarde autotests : contournements de la revue de securite, C13, C15
Les 4 contournements de la revue des commits 7a5a1c9 / 937d43d sont prouves :
ping > 500 ms exempte, regard et oeil suivants sans borne, table SUIVIES pleine
sans eviction, fenetre d'historique elargie par le ping declare.
C13 (minimum avec le paquet suivant, reach 3,3 et 4,0 sur cible mobile) et C15
(bhop 0,40, speed sol 0,37, timer 1,09) prouves. Code de production inchange.
228 tests, 0 echec (cornafserver, conteneur eclipse-temurin:21-jdk).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 01:07:49 +02:00
gastineltetClaude Opus 5.5 bfc8f5719c GastinelGarde autotests : incident VOL de Rednixxu (C1 a C5, C10)
Tests qui documentent le comportement actuel sans toucher au code de production :
plane d'elytres sans drapeau puni au 12e tick (C1), point de retour en l'air (C3),
setback sans grace ni remise a zero (C2), 5 setbacks puis expulsion en 850 ms (C5),
expulsion rendue a chaque paquet (C4, partie moteur), sauts en l'air espaces non vus (C10).
218 tests, 0 echec (cornafserver, conteneur eclipse-temurin:21-jdk).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 01:04:25 +02:00
48 fichiers modifiés avec 4973 ajouts et 86 suppressions

Aucun fichier ne correspond à votre recherche

+1
Voir le fichier
@@ -7,3 +7,4 @@ run/
# sauvegardes avant modification
*.avant-*
livrable/
+56
Voir le fichier
@@ -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
Voir le fichier
@@ -1,7 +1,7 @@
# GastinelGarde
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/`).
**É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 :
```
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 :
+41
Voir le fichier
@@ -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
+2
Voir le fichier
@@ -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.
# Range: 0 ~ 64
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
#Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.
+1 -1
Voir le fichier
@@ -1,7 +1,7 @@
org.gradle.jvmargs=-Xmx2G
org.gradle.parallel=true
mod_version=0.3.0
mod_version=0.4.0
mod_group_id=com.gastinelgarde
mod_id=gastinelgarde
+193
Voir le fichier
@@ -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 + ")");
}
}
}
}
+146 -38
Voir le fichier
@@ -60,6 +60,8 @@ public final class Garde {
/** Marques propres à un joueur, côté adaptateur (ticks du serveur). */
private static final class Marques {
int teleportTick = Integer.MIN_VALUE;
/** 0.4.0 : jusqu'à ce tick, une fusée a propulsé le joueur (plané non contrôlé). */
int propulsionJusquaTick = Integer.MIN_VALUE;
int reculTick = Integer.MIN_VALUE;
int dernierVerdictTick = Integer.MIN_VALUE;
int dernierTraceTick = Integer.MIN_VALUE;
@@ -77,13 +79,12 @@ public final class Garde {
int vehiculeTick = Integer.MIN_VALUE;
double vehiculeX, vehiculeY, vehiculeZ;
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
int contraptionTick = Integer.MIN_VALUE;
int contraptionVuTick = Integer.MIN_VALUE;
boolean contraptionProche;
final Cablage.CacheDetection contraption = new Cablage.CacheDetection();
// C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
int solServeurTick = Integer.MIN_VALUE;
final Cablage.Elytres elytres = new Cablage.Elytres();
// Cache de la détection d'un courant d'air (ventilateur Create), même principe
int courantTick = Integer.MIN_VALUE;
int courantVuTick = Integer.MIN_VALUE;
boolean courantProche;
final Cablage.CacheDetection courant = new Cablage.CacheDetection();
// #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux)
double[] oeilDernier;
double[] oeilAvant;
@@ -144,6 +145,13 @@ public final class Garde {
Files.createDirectories(journal.getParent());
traces = new TraceFichier(jeu.resolve("gastinelgarde-traces"), GardeSpec.tracesJours(), GardeSpec.tracesTailleOctets());
tracesEnCours = GardeSpec.tracesActives();
// Historique de suspicion : même dossier de jeu que les traces et les journaux (voir HistoriqueSuspicion).
try {
MOTEUR.historique().ouvrir(jeu.resolve("gastinelgarde-suspicion").resolve("incidents.csv"),
System.currentTimeMillis(), CONFIG.suspicionHistoriqueJours);
} catch (IOException | RuntimeException e) {
GastinelGarde.LOGGER.warn("[GastinelGarde] historique de suspicion illisible, repart à vide : {}", e.toString());
}
} catch (IOException e) {
GastinelGarde.LOGGER.error("[GastinelGarde] Impossible d'ouvrir le dossier de traces", e);
traces = null;
@@ -240,6 +248,8 @@ public final class Garde {
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()) {
@@ -273,7 +283,11 @@ public final class Garde {
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) && SUIVIES.size() < SUIVIES_MAX) {
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);
@@ -282,10 +296,28 @@ public final class Garde {
}
if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
if (s.niveau != cible.level()) return null;
int fenetre = PorteeHitbox.ticksFenetre(attaquant.connection.latency(), CONFIG);
// 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());
@@ -312,6 +344,40 @@ public final class Garde {
if (m.graceRecul.recul(tick, autoInflige)) m.reculTick = tick;
}
/** Fusée de feu d'artifice tirée par ce joueur (propulsion en plané) : le plané n'est pas contrôlé pendant 6 s. */
public static void noterFusee(ServerPlayer p, int ticks) {
if (!surThreadServeur(p)) return;
Marques m = marques(p.getUUID());
m.propulsionJusquaTick = Math.max(m.propulsionJusquaTick, p.server.getTickCount() + ticks);
MOTEUR.nouvelleFusee(p.getUUID());
}
/** 0.4.0 : recul appliqué par le serveur (direction du déplacement attendu, force avant résistance). */
public static void noterVelocite(ServerPlayer p, double dirX, double dirZ, double force) {
if (!surThreadServeur(p)) return;
double resistance = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.KNOCKBACK_RESISTANCE);
// Le joueur est-il libre de reculer ? Boîte déplacée de 0,6 puis 1,2 bloc dans le sens du recul : un mur, un trou
// d'un bloc ou un plafond bas (coup d'un tiers qui coince le joueur) annulent la mesure.
double norme = Math.hypot(dirX, dirZ);
boolean libre = norme > 1e-6;
if (libre) {
net.minecraft.world.phys.AABB b = p.getBoundingBox();
double ux = dirX / norme, uz = dirZ / norme;
libre = p.level().noCollision(p, b.move(ux * 0.6, 0, uz * 0.6)) && p.level().noCollision(p, b.move(ux * 1.2, 0, uz * 1.2));
}
MOTEUR.reculApplique(p.getUUID(), p.server.getTickCount() * 50L, dirX, dirZ,
force * Math.max(0.0, 1.0 - resistance), libre);
}
/** 0.4.0 : un totem d'immortalité vient d'éclater (hand = main qui le tenait). */
public static void noterTotem(ServerPlayer p, net.minecraft.world.InteractionHand hand) {
if (!surThreadServeur(p)) return;
net.minecraft.world.InteractionHand autre = hand == net.minecraft.world.InteractionHand.MAIN_HAND
? net.minecraft.world.InteractionHand.OFF_HAND : net.minecraft.world.InteractionHand.MAIN_HAND;
boolean reserve = p.getItemInHand(autre).is(Items.TOTEM_OF_UNDYING);
MOTEUR.totemEclate(p.getUUID(), p.server.getTickCount() * 50L, reserve);
}
public static void noterTickServeur(MinecraftServer server, long dureeNs) {
double ms = dureeNs / 1_000_000.0;
if (ms > 250.0) gelTick = server.getTickCount();
@@ -362,12 +428,16 @@ public final class Garde {
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()
.creatif(p.isCreative())
.spectateur(p.isSpectator())
.peutVoler(p.getAbilities().mayfly)
.riptide(riptideRecent)
.elytres(p.isFallFlying())
.elytresDeploiementSuspect(m.elytres.suspectes)
.levitation(p.hasEffect(MobEffects.LEVITATION))
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
.enVehicule(p.isPassenger())
@@ -378,6 +448,7 @@ public final class Garde {
.ticksDepuisGel(depuis(tick, gelTick))
.tps(tpsEstime)
.pingMs(p.connection.latency())
.propulsionRecente(tick <= m.propulsionJusquaTick)
.build();
}
@@ -446,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. */
private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) {
if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) {
m.contraptionProche = pocheContraption(p);
m.contraptionTick = tick;
if (m.contraptionProche) m.contraptionVuTick = tick;
}
return m.contraptionProche || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS);
return m.contraption.lire(tick, () -> pocheContraption(p), GRACE_CONTRAPTION_TICKS);
}
/**
@@ -502,9 +568,31 @@ public final class Garde {
}
if (v.notifier()) alerterOps(p, v);
}
reagirSuspicion(p);
return Verdict.pire(verdicts);
}
/**
* Score de suspicion (0.4.0) : journal dès « à surveiller », message aux ops dès « suspect ». À « suspect fort »,
* seulement une proposition de sanction à valider dans le Portail : le mod ne sanctionne jamais à partir du score.
*/
private static void reagirSuspicion(ServerPlayer p) {
Moteur.AlerteSuspicion a = MOTEUR.alerteSuspicion(p.getUUID(), System.currentTimeMillis());
if (a == null) return;
String nom = p.getGameProfile().getName();
ecrireJournal(String.format("SUSPICION %s (%s) score=%d niveau=%s incidents7j=%d contributions=[%s]",
nom, p.getUUID(), a.score(), a.niveau(), a.incidents(), a.controles()));
if (a.niveau().ordinal() < com.gastinelgarde.core.Suspicion.Niveau.SUSPECT.ordinal()) return;
String texte = a.niveau() == com.gastinelgarde.core.Suspicion.Niveau.SUSPECT_FORT
? String.format("[Garde] %s : suspect fort (score %d). Proposition de sanction suspect_2, à valider dans le Portail.",
nom, a.score())
: String.format("[Garde] %s : suspect (score %d, %d incident(s) sur 7 jours).", nom, a.score(), a.incidents());
Component msg = Component.literal(texte).withStyle(ChatFormatting.RED);
for (ServerPlayer op : p.server.getPlayerList().getPlayers()) {
if (op.hasPermissions(2) && alertesActivesPour(op.getUUID())) op.sendSystemMessage(msg);
}
}
private static void alerterOps(ServerPlayer cible, Verdict v) {
Component msg = Component.literal(String.format("[Garde] %s : %s VL=%.1f (%s, %s)",
cible.getGameProfile().getName(), v.controle().id(), v.vl(), v.mode(), v.applicable()))
@@ -546,20 +634,23 @@ public final class Garde {
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */
public static void avantMouvement(ServerPlayer p) {
if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà)
if (estExempteManuellement(p.getUUID())) return;
// F01 : jamais depuis le thread réseau (le mixin l'évite déjà) ; C4 : expulsion en cours, plus rien à évaluer
if (!Cablage.evaluerAvantMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()),
() -> estExempteManuellement(p.getUUID()))) return;
EtatJoueur etat = etat(p, false);
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
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. */
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();
Marques m = marques(p.getUUID());
boolean solServeur = auSolServeur(p, m);
if (solServeur) m.solServeurTick = tick; // C7
// Phase 2 : no-fall (divergence), vitesse horizontale, vol.
boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID());
@@ -577,7 +668,7 @@ public final class Garde {
if (controler && em != null) {
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
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.
if (!estExempteManuellement(p.getUUID())) {
@@ -594,6 +685,22 @@ public final class Garde {
m.oeilAvant = m.oeilDernier;
m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z};
}
// 0.4.0 : recul mesuré (anti-recul) et totem remis en main (auto-totem), sur les mêmes paquets.
if (!estExempteManuellement(p.getUUID()) && (CONFIG.mode(Controle.VELOCITE) != Mode.OFF
|| CONFIG.mode(Controle.AUTO_TOTEM) != Mode.OFF)) {
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.mouvementX = p.getX();
m.mouvementY = p.getY();
@@ -601,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
// 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(),
p.level().dimension().location().toString());
}
@@ -821,12 +930,7 @@ public final class Garde {
/** 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) {
if (m.courantTick == Integer.MIN_VALUE || tick - m.courantTick >= 10 || tick < m.courantTick) {
m.courantProche = courantAir(p);
m.courantTick = tick;
if (m.courantProche) m.courantVuTick = tick;
}
return m.courantProche || DetectionContraption.dansLaGrace(tick, m.courantVuTick, GRACE_COURANT_TICKS);
return m.courant.lire(tick, () -> courantAir(p), GRACE_COURANT_TICKS);
}
/**
@@ -868,18 +972,22 @@ public final class Garde {
}
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
if (s == Sanction.EXPULSION) {
ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")");
p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ")."));
} else if (s == Sanction.SETBACK) {
Suivi sv = MOTEUR.suivi(p.getUUID());
String dim = p.level().dimension().location().toString();
if (sv.aPositionValide() && sv.dimension().equals(dim)) {
annoncerTeleport(p, GraceTeleport.Origine.SETBACK);
p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")");
Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts);
}
/** Adaptateur ServerPlayer de Cablage.appliquerSanction. */
private static Cablage.Joueur joueur(ServerPlayer p) {
return new Cablage.Joueur() {
@Override public UUID id() { return p.getUUID(); }
@Override public String nom() { return p.getGameProfile().getName(); }
@Override public String dimension() { return p.level().dimension().location().toString(); }
@Override public int tick() { return p.server.getTickCount(); }
@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); }
};
}
}
+11
Voir le fichier
@@ -137,6 +137,17 @@ public final class GardeAntiCrash {
if (!AntiCrashEntites.empilementExcessif(n, r)) return false;
if (cart.isVehicle() || Garde.estContraption(cart) || SableAcces.surSousNiveau(cart)) return false;
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());
String type = BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()).toString();
String ligne = String.format(java.util.Locale.ROOT,
+2
Voir le fichier
@@ -91,6 +91,8 @@ public final class GardeCommands {
sb.append("\n ").append(k.id()).append(" VL=")
.append(String.format(java.util.Locale.ROOT, "%.1f", suivi.vl.valeur(k, now)));
}
sb.append(String.format(java.util.Locale.ROOT, "\n suspicion = %.0f (%s)", Garde.moteur().scoreSuspicion(p.getUUID()),
suivi.suspicion.niveau(System.currentTimeMillis())));
if (Garde.estExempteManuellement(p.getUUID())) sb.append("\n (exempté manuellement)");
ok(ctx, sb.toString());
return 1;
+47 -10
Voir le fichier
@@ -57,7 +57,16 @@ public final class GardeEvents {
@SubscribeEvent
public static void onAttaque(AttackEntityEvent event) {
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();
int tick = p.server.getTickCount();
@@ -79,8 +88,9 @@ public final class GardeEvents {
// (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.
Entity racine = cible.getRootVehicle();
boolean mesurerPH = !Garde.estContraption(cible) && !SableAcces.surSousNiveau(cible)
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> Garde.estContraption(cible),
() -> 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)
+ 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
@@ -99,11 +109,9 @@ public final class GardeEvents {
}
Sanction s = Garde.traiter(p, verdicts);
if (Garde.moteur().coupsBloques(p.getUUID(), tick * 50L)) event.setCanceled(true); // portée / hitbox ENFORCE
if (s.ordinal() >= Sanction.SETBACK.ordinal()) {
event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé
if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts);
}
// portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé
if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true);
if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
}
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
@@ -121,7 +129,11 @@ public final class GardeEvents {
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onRecul(LivingKnockBackEvent event) {
if (event.isCanceled() || event.getStrength() <= 0.0F) return;
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterRecul(p, false);
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
Garde.noterRecul(p, false);
// Vanilla retire (ratioX, ratioZ) x force à la vitesse du joueur : il part à l'opposé.
Garde.noterVelocite(p, -event.getRatioX(), -event.getRatioZ(), event.getStrength());
}
}
/** Explosion, charge de vent (Wind Charge) : poussée vers le joueur. Celle qu'il s'inflige est limitée (GraceRecul). */
@@ -131,11 +143,36 @@ public final class GardeEvents {
if (!(event.getAffectedEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
boolean auto = event.getExplosion().getIndirectSourceEntity() == p || event.getExplosion().getDirectSourceEntity() == p;
Garde.noterRecul(p, auto);
Vec3 v = event.getKnockbackVelocity();
Garde.noterVelocite(p, v.x, v.z, Math.hypot(v.x, v.z));
}
/** Fusée de feu d'artifice tirée par un joueur : propulsion en plané, donc plané non contrôlé un moment. */
@SubscribeEvent
public static void onFusee(net.neoforged.neoforge.event.entity.EntityJoinLevelEvent event) {
if (!(event.getEntity() instanceof net.minecraft.world.entity.projectile.FireworkRocketEntity f)) return;
// Champ privé attachedToEntity lu via l'Access Transformer (META-INF/accesstransformer.cfg) : seule une fusée
// attachée au joueur le propulse (FireworkRocketEntity.tick), jamais une fusée d'arbalète ou posée au sol.
if (f.attachedToEntity instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
int ticks = Cablage.graceFusee(true, p.isFallFlying(), event.loadedFromDisk(), f.life, f.lifetime);
if (ticks > 0) Garde.noterFusee(p, ticks);
}
}
/** Totem éclaté : début de la mesure du délai de remise (auto-totem). */
@SubscribeEvent
public static void onTotem(net.neoforged.neoforge.event.entity.living.LivingUseTotemEvent event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
Garde.noterTotem(p, event.getHandHolding());
}
}
@SubscribeEvent
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
if (event.getEntity() instanceof ServerPlayer p) Garde.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
+110 -1
Voir le fichier
@@ -49,6 +49,20 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
private static final ModConfigSpec.IntValue SERIE_PING_MAX;
private static final ModConfigSpec.IntValue SERIE_PING_MARGE;
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX;
private static final ModConfigSpec.IntValue 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;
@@ -125,8 +139,10 @@ public final class GardeSpec {
"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) au-delà duquel le coup n'est pas mesuré.")
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).")
@@ -140,12 +156,74 @@ public final class GardeSpec {
b.push("timer");
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
TIMER_SOLDE_MAX = b.comment("C15 : solde de paquets (reçus - ticks écoulés) au-delà duquel le timer compte (timer 1,05-1,10).",
"0 = désactivé (défaut). Essai conseillé : 20, en OBSERVE.")
.defineInRange("timerSoldeMax", 0, 0, 1000);
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.push("mouvement");
VOL_FLOTTEMENT = b.comment("Vol : ticks consécutifs en l'air sans chute avant infraction (vanilla : 80, 'kicked for floating too long').",
"Remplace ce contrôle vanilla si allow-flight=true. 0 = coupé.")
.defineInRange("volFlottementTicks", 80, 0, 1200);
EXCES_VITESSE = b.comment("Total d'excès de vitesse horizontale (blocs) sur 20 ticks avant une infraction.",
"Valeurs de départ généreuses, à resserrer avec les traces réelles.")
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
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.push("exemptions");
@@ -195,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",
"excédentaires (sans passager) sont cassés et lâchent leur objet. 0 = pas de limite.")
.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).")
.define("alertesOps", true);
b.pop();
@@ -248,6 +329,33 @@ public final class GardeSpec {
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();
@@ -322,6 +430,7 @@ public final class GardeSpec {
r.margeBordure = l ? AC_MARGE_BORDURE.get() : AC_MARGE_BORDURE.getDefault();
r.vitesseMaxMinecart = l ? AC_VITESSE_MINECART.get() : AC_VITESSE_MINECART.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;
}
+19
Voir le fichier
@@ -48,6 +48,14 @@ public final class AntiCrashEntites {
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. */
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). */
@@ -136,6 +144,17 @@ public final class AntiCrashEntites {
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. */
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) {
+46
Voir le fichier
@@ -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;
}
}
+16 -1
Voir le fichier
@@ -17,7 +17,13 @@ public enum Controle {
VITESSE("vitesse"),
VOL("vol"),
VEHICULE_VITESSE("vehicule-vitesse"),
VEHICULE_VOL("vehicule-vol");
VEHICULE_VOL("vehicule-vol"),
/** 0.4.0 : plané en élytres (Elytra Hack) : montée sans perte de vitesse, plané immobile. */
ELYTRES("elytres"),
/** 0.4.0 : recul absent après un coup subi (Anti Knockback, Anti Push). */
VELOCITE("velocite"),
/** 0.4.0 : totem remis en main sans délai humain après l'éclatement (Auto Totem). */
AUTO_TOTEM("auto-totem");
private final String id;
@@ -39,6 +45,15 @@ public enum Controle {
|| this == COUPS_HORS_BOITE;
}
/** Fiabilité du contrôle pour le score de suspicion : 0 = fiable, 1 = moyen, 2 = sujet aux faux positifs. */
public int fiabilite() {
return switch (this) {
case VOL, VITESSE, NO_FALL, PORTEE, HITBOX, REGULARITE -> 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) {
if (texte == null) return null;
for (Controle c : values()) {
+64 -4
Voir le fichier
@@ -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. */
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 EtatJoueur etat;
final double[] boite;
@@ -34,6 +52,11 @@ final class CoupDiffere {
/** 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,
double distance, double manque, double excedent, boolean porteeHitbox) {
this.nowMs = nowMs;
@@ -52,10 +75,18 @@ final class CoupDiffere {
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) {
oeilSuivant = oeil.clone();
regardSuivant = regard.clone();
/**
* 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 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],
@@ -68,4 +99,33 @@ final class CoupDiffere {
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};
}
}
+11 -4
Voir le fichier
@@ -15,11 +15,13 @@ public record EtatJoueur(
boolean enVehicule,
boolean pocheContraption,
boolean utiliseObjet,
boolean elytresDeploiementSuspect,
int ticksDepuisTeleport,
int ticksDepuisRecul,
int ticksDepuisGel,
double tps,
int pingMs) {
int pingMs,
boolean propulsionRecente) {
public static final int JAMAIS = Integer.MAX_VALUE;
@@ -34,10 +36,11 @@ public record EtatJoueur(
public static final class Builder {
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 double tps = 20.0;
private int pingMs = 30;
private boolean propulsionRecente;
public Builder creatif(boolean v) { creatif = 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 pocheContraption(boolean v) { pocheContraption = 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 ticksDepuisRecul(int v) { ticksDepuisRecul = v; return this; }
public Builder ticksDepuisGel(int v) { ticksDepuisGel = v; return this; }
public Builder tps(double v) { tps = v; return this; }
public Builder pingMs(int v) { pingMs = v; return this; }
/** 0.4.0 : fusée de feu d'artifice (ou autre poussée connue du serveur) récente : plané non contrôlé. */
public Builder propulsionRecente(boolean v) { propulsionRecente = v; return this; }
public EtatJoueur build() {
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
enVehicule, pocheContraption, utiliseObjet, ticksDepuisTeleport, ticksDepuisRecul,
ticksDepuisGel, tps, pingMs);
enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect, ticksDepuisTeleport, ticksDepuisRecul,
ticksDepuisGel, tps, pingMs, propulsionRecente);
}
}
}
+5 -2
Voir le fichier
@@ -28,13 +28,16 @@ public final class Exemptions {
switch (famille) {
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");
}
case MOUVEMENT -> {
if (e.peutVoler()) raisons.add("peut-voler");
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.chuteLente()) raisons.add("chute-lente");
if (e.enVehicule()) raisons.add("vehicule");
+71 -1
Voir le fichier
@@ -17,6 +17,52 @@ public final class GardeConfig {
public double seuilExpulsion = 20.0;
/** Sanction la plus forte autorisée (T4 : setback puis expulsion, jamais de bannissement). */
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 ---
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
@@ -64,7 +110,7 @@ public final class GardeConfig {
* 3 ticks (mob), interpolation sur 3 ticks, plus 1 tick de gigue. Le ping s'ajoute (voir seriePingMaxMs).
*/
public int ticksAffichageCible = 7;
/** Ping (ms) au-delà duquel la mesure compensée n'est pas faite (fenêtre plus large que l'historique fiable). */
/** 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;
@@ -78,6 +124,30 @@ public final class GardeConfig {
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 ---
public int graceTeleportTicks = 40;
+86
Voir le fichier
@@ -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);
}
}
+213 -11
Voir le fichier
@@ -21,6 +21,47 @@ public final class Moteur {
private final GardeConfig cfg;
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) {
this.cfg = cfg;
@@ -31,7 +72,7 @@ public final class Moteur {
}
public Suivi suivi(UUID joueur) {
return suivis.computeIfAbsent(joueur, k -> new Suivi(cfg.vlDecroissanceParSeconde));
return suivis.computeIfAbsent(joueur, k -> new Suivi(cfg.vlDecroissanceParSeconde, cfg));
}
public void retirer(UUID joueur) {
@@ -54,6 +95,7 @@ public final class Moteur {
*/
public List<Verdict> attaque(UUID joueur, long nowMs, EtatJoueur etat, double excedentDegres,
int idCible, boolean cibleVisible) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
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,
double porteeJoueur, double vitesseCible) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
boolean portee = cfg.mode(Controle.PORTEE) != Mode.OFF;
boolean hitbox = cfg.mode(Controle.HITBOX) != Mode.OFF;
if (!portee && !hitbox) return List.of();
@@ -165,6 +208,7 @@ public final class Moteur {
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);
boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0
&& cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF;
@@ -180,12 +224,11 @@ public final class Moteur {
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]);
CoupDiffere c = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
if (serie) {
c.boitesVues = boitesVues;
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
c.oeilCoup = oeil.clone();
c.regardCoup = regard.clone();
}
// 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;
}
@@ -217,13 +260,26 @@ public final class Moteur {
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",
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal()));
"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. */
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);
if (s == null || s.coupDiffere == null) return List.of();
if (s.coupDiffere.encoreValable(nowMs)) s.coupDiffere.affiner(oeil, regard);
@@ -244,6 +300,12 @@ public final class Moteur {
double seuil = cfg.angleMaxDegres * ex.facteur();
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));
// 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) {
@@ -270,6 +332,7 @@ public final class Moteur {
*/
public List<Verdict> regard(UUID joueur, long nowMs, java.util.function.Supplier<EtatJoueur> etat,
float yaw, float pitch) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
if (cfg.mode(Controle.ROTATION) == Mode.OFF) return List.of();
Suivi s = suivi(joueur);
double pts = s.rotation.regard(nowMs / 50, yaw, pitch);
@@ -285,6 +348,7 @@ public final class Moteur {
/** 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) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
if (cfg.mode(Controle.TIMER) == Mode.OFF) return List.of();
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER);
if (ex.exempt()) {
@@ -304,6 +368,7 @@ public final class Moteur {
* Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout.
*/
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF;
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
@@ -315,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…).
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
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);
if (noFall) {
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m), nowMs, ex,
"au sol declare sans bloc dessous pendant une chute");
}
if (vitesse) {
s.vitesse.moyenne = cfg.vitesseMoyenne; // C15, désactivé par défaut
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
ajouter(verdicts, s, Controle.VITESSE, pts, nowMs, ex,
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)));
}
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);
ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy()));
}
@@ -350,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.
*/
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 vol = cfg.mode(Controle.VEHICULE_VOL) != Mode.OFF;
if (!vitesse && !vol) return List.of();
@@ -395,6 +486,108 @@ public final class Moteur {
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
}
// --- 0.4.0 : vélocité (recul) et auto-totem ---
/**
* Le serveur applique un recul au joueur (coup, explosion, charge de vent).
*
* @param dirX,dirZ direction du déplacement attendu ; {@code force} effective, résistance déduite
*/
public void reculApplique(UUID joueur, long nowMs, double dirX, double dirZ, double force, boolean libre) {
if (cfg.mode(Controle.VELOCITE) == Mode.OFF || expulses.contains(joueur)) return;
// Joueur coincé (mur, trou, plafond) : le recul n'a pas pu avoir lieu, rien à mesurer.
if (!libre) {
suivi(joueur).velocite.abandonner();
return;
}
suivi(joueur).velocite.recul(nowMs, dirX, dirZ, force, cfg);
}
/** 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 ----------------------------------------------------------------------------------------
private void ajouter(List<Verdict> sortie, Suivi s, Controle c, double points, long nowMs,
@@ -403,7 +596,16 @@ public final class Moteur {
Mode mode = cfg.mode(c);
double vl = s.vl.ajouter(c, points, nowMs);
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);
// 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()
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
sortie.add(new Verdict(c, mode, points, vl, palier, applicable, notifier, details, ex.raisons()));
+43
Voir le fichier
@@ -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;
}
}
+163
Voir le fichier
@@ -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;
}
}
+5 -4
Voir le fichier
@@ -98,7 +98,7 @@ public final class PorteeHitbox {
*/
public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) {
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.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul";
if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide";
@@ -205,14 +205,15 @@ public final class PorteeHitbox {
/**
* 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), ping au-delà
* de {@link GardeConfig#seriePingMaxMs} (la fenêtre ne couvrirait plus le retard d'affichage).
* 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";
if (e.pingMs() > cfg.seriePingMaxMs) return "ping";
return null;
}
}
+35
Voir le fichier
@@ -16,11 +16,34 @@ public final class Suivi {
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}). */
CoupDiffere coupDiffere;
/** Jusqu'à quand (ms) les coups sont annulés après une sanction portée / hitbox en ENFORCE. */
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).
private boolean positionValide;
@@ -30,8 +53,20 @@ public final class Suivi {
private final Map<Controle, Long> derniereAlerte = new EnumMap<>(Controle.class);
/** Score de suspicion (0.4.0). */
public final Suspicion suspicion;
/** 0.4.0 : plané, recul, totem. */
public final PlaneElytres plane = new PlaneElytres();
public final Velocite velocite = new Velocite();
public final AutoTotem totem = new AutoTotem();
public Suivi(double decroissanceParSeconde) {
this(decroissanceParSeconde, new GardeConfig());
}
public Suivi(double decroissanceParSeconde, GardeConfig cfg) {
this.vl = new VlCompteur(decroissanceParSeconde);
this.suspicion = new Suspicion(cfg);
}
public void memoriserPosition(double x, double y, double z, float yaw, float pitch, String dimension) {
+128
Voir le fichier
@@ -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();
}
}
+31
Voir le fichier
@@ -16,7 +16,36 @@ public final class TimerPaquets {
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) {
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);
int max = (int) Math.floor(cfg.paquetsParSecondeMax * facteur);
int secondes = Math.min(SECONDES_MAX, Math.max(1, cfg.timerSecondesSoutenues));
@@ -31,5 +60,7 @@ public final class TimerPaquets {
public void vider() {
compteur.vider();
solde = 0;
dernierMs = Long.MIN_VALUE;
}
}
+107
Voir le fichier
@@ -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();
}
}
+60 -3
Voir le fichier
@@ -56,6 +56,24 @@ public final class VitesseHorizontale {
private int ticksDepuisSortie = Integer.MAX_VALUE;
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. */
public static double vitesseMax(EtatMouvement e) {
double v;
@@ -84,6 +102,7 @@ public final class VitesseHorizontale {
double base = vitesseMax(e) * facteur;
if (e.milieuSpecial() || e.frictionAnormale()) {
// Glace, eau, échelle… : non contrôlé, mais l'élan qui en sort est légitime.
viderMoyenne();
pousser(0);
memoriser(e.dxz(), base, TRAINEE_AIR);
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
// 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);
boolean sortieRecente = ticksDepuisSortie < MOYENNE_PAQUETS;
avancerSortie(ticks);
double ptsMoyenne = moyenne ? moyenne(e, ticks, facteur, sortieRecente) : 0;
if (depasse <= 0) return 0;
if (depasse <= 0) return ptsMoyenne;
double total = 0;
for (double v : exces) total += v;
if (total <= seuilBlocs) return 0;
return 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0);
if (total <= seuilBlocs) return ptsMoyenne;
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) {
java.util.Arrays.fill(exces, 0);
index = 0;
viderMoyenne();
int ticks = Math.max(1, e.ticks());
memoriser(e.dxz(), vitesseMax(e) * facteur, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
if (sortieDEtat) ticksDepuisSortie = 0;
@@ -161,5 +217,6 @@ public final class VitesseHorizontale {
aElan = false;
elan = 0;
ticksDepuisSortie = Integer.MAX_VALUE;
viderMoyenne();
}
}
+5
Voir le fichier
@@ -42,6 +42,11 @@ public final class VlCompteur {
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) {
if (nowMs <= e.dernierMs) return e.valeur;
double perdu = (nowMs - e.dernierMs) / 1000.0 * decroissanceParSeconde;
+118 -2
Voir le fichier
@@ -19,6 +19,33 @@ public final class VolVertical {
private boolean etaitEnAir;
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. */
public static final int TICKS_MAX = 40;
@@ -33,9 +60,12 @@ public final class VolVertical {
*/
public double enregistrer(EtatMouvement e, boolean exempt) {
int n = e.ticks();
// Flottement : évalué avant tout retour anticipé, pour qu'un trou de ticks ne le remette pas à zéro.
double ptsFlottement = flottement(exempt || e.milieuSpecial() || e.auSolServeur(), e.dy(), n);
if (n > TICKS_MAX || n < 0) {
aVitesse = false;
return 0;
avance = 0;
return ptsFlottement;
}
boolean enAir = !e.auSolServeur();
double dy = e.dy();
@@ -44,39 +74,125 @@ public final class VolVertical {
if (exempt || e.milieuSpecial() || !enAir) {
anormauxConsecutifs = 0;
avance = 0;
viderFenetre();
} else if (etaitEnAir && aVitesse) {
// 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 kRetenu = kMax;
boolean ecart = true;
double v = derniereVitesse;
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++) {
v = (v - GRAVITE) * TRAINEE;
somme += v;
if (k >= kMin) sommeMax = Math.max(sommeMax, somme);
if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) {
ecart = false;
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.
if (ecart) anormauxConsecutifs++;
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
if (anormauxConsecutifs > TICKS_ANORMAUX) {
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;
aVitesse = true;
etaitEnAir = enAir;
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() {
derniereVitesse = 0;
aVitesse = false;
etaitEnAir = false;
anormauxConsecutifs = 0;
avance = 0;
flottementTicks = 0;
viderFenetre();
}
}
+5
Voir le fichier
@@ -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
+1 -1
Voir le fichier
@@ -4,7 +4,7 @@ license="MIT"
[[mods]]
modId="gastinelgarde"
version="0.3.0"
version="0.3.1"
displayName="GastinelGarde"
authors="Théo Gastinel"
description='''Anti-triche maison : combat, cadence, rotation, timer (phase 1), no-fall, vitesse, vol et véhicules (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
+62
Voir le fichier
@@ -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();
}
}
}
+336
Voir le fichier
@@ -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);
}
}
}
+123
Voir le fichier
@@ -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.
}
}
+300
Voir le fichier
@@ -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));
}
}
+41
Voir le fichier
@@ -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");
}
}
+365
Voir le fichier
@@ -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);
}
}
+91
Voir le fichier
@@ -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));
}
}
+328
Voir le fichier
@@ -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");
}
}
+107
Voir le fichier
@@ -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);
}
}
+304
Voir le fichier
@@ -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");
}
}
+213
Voir le fichier
@@ -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));
}
}
}
+2 -1
Voir le fichier
@@ -175,7 +175,8 @@ class Garde92Test {
EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().riptide(true).build(),
EtatJoueur.builder().pingMs(cfg.seriePingMaxMs + 1).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) {
+27
Voir le fichier
@@ -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
}
}
}
+536
Voir le fichier
@@ -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);
}
}
+294
Voir le fichier
@@ -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));
}
}