Comparer les révisions

..
28 Révisions
Auteur SHA1 Message Date

2026-10-20

gastineltetClaude Sonnet 5.5 9e0e1dee5b Test : l'envoi au Hub est coupé dans la configuration générée
Vérifie sur la vraie définition GardeSpec (compilée avec NeoForge) que
hub.envoi vaut false par défaut dans le TOML généré, que la clé de la
source n'y figure pas (seulement le chemin du fichier), et qu'avec
envoi = false aucun fil d'envoi n'est créé.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 15:07:35 +02:00
gastineltetClaude Sonnet 5.5 12bb2704db Tests du Hub : le faux serveur écoute explicitement sur 127.0.0.1
Sous le lanceur de test NeoForge (-Djava.net.preferIPv6Addresses=system),
InetAddress.getLoopbackAddress() donne ::1 alors que l'adresse du faux Hub
est en IPv4 : connexion refusée, 14 tests de EnvoiHubServeurTest en échec.
Aucun changement du code de production.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 15:07:35 +02:00
gastineltetClaude Sonnet 5.5 fb0643f0a3 GastinelGarde : signalement des detections au Hub (desactive par defaut)
Nouveau paquet hub (Java pur) : envoi asynchrone des franchissements de palier
(alerte, setback, expulsion) vers POST /internal/detections du Hub, selon la
conception du bloc 2 (section 2) et les contraintes de la revue de securite du Hub.

- fil d'envoi a part, file bornee sans verrou, copie sur disque, nouvelles tentatives
  exponentielles (1 s a 5 min), Retry-After, identifiant d'idempotence conserve ;
- le tick serveur n'ajoute qu'un objet en file : aucune entree-sortie, aucune attente ;
- cle de la source lue dans un fichier, jamais en dur, jamais journalisee ;
- champs conformes au Hub (controle, dimension, version_mod, exemptions), aucune IP ;
- reglages [hub] (envoi = false par defaut), commande /garde hub, ANNEXE-HUB.md ;
- 55 tests unitaires hors ligne (faux serveur HTTP local).

Non compile avec NeoForge ici (Garde, GardeSpec, GardeCommands) : a verifier au build.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 02:42:52 +02:00

2026-10-19

Theo GastineletClaude Opus 5.5 b2e5189d8a GastinelGarde 0.3.2 : version, CHANGELOG
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:56:31 +02:00
Theo GastineletClaude Opus 5.5 86d4d56a52 GastinelGarde 0.3.2 D3 : no-fall voit le paquet d'etat au sol
Un paquet sans deplacement (dy = 0) qui declare au sol sans bloc dessous est
juge avec la vitesse verticale du dernier paquet qui a bouge pendant la chute
(remise a zero au sol, en milieu special, en exemption et apres un setback).
Avant, NoFall.points exigeait dy <= -0,3 sur le paquet meme : aucune ligne
no-fall contre le NoFall par paquet d'etat (rapport test 19/10, T5).
Test : Garde1015Test.D3_noFallVoitLePaquetDEtatAuSolPendantUneChute

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:55:56 +02:00
Theo GastineletClaude Opus 5.5 2325250fd2 GastinelGarde 0.3.2 D2 : expulsion de combat apres 4 setbacks en 60 s
Un setback portee/hitbox (coups annules) remet le VL de ce controle a zero
et compte pour la regle C5, comme le vol (C2). Avant, le VL de combat
montait a 20 en ~5 s et l'expulsion arrivait sans la regle des 4 setbacks.
Test : Garde1015Test.D2_hitboxEnforceExpulseApresQuatreSetbacksPasAuBoutDe5s

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:55:51 +02:00
Theo GastineletClaude Opus 5.5 963e01fc87 GastinelGarde 0.3.2 D1 : setback vers le point d'arrivee d'une teleportation
Une teleportation externe (/tp, TPA, perle, mod), une reapparition, un
changement de dimension ou une connexion prennent le point d'arrivee comme
position de retour. Avant, un setback avant le premier contact au sol
ramenait a la position d'avant la teleportation (rapport test 19/10, T3).
Test : CablageTest.D1_setbackApresTpRameneAuPointDArriveePasAvantLaTeleportation

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 11:55:26 +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
gastineltetClaude Opus 5.5 937d43d499 GastinelGarde #92 : tests du controle coups-hors-boite (cas Rednixxu, faux positifs)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 00:55:32 +02:00
gastineltetClaude Opus 5.5 7a5a1c92c8 GastinelGarde #92 : controle coups-hors-boite (historique des boites des cibles)
Le test hitbox/portee de Rednixxu passait sous portee et hitbox : sur une cible
qui bouge, la marge vitesse x ticks (plafond 1,0 bloc) noyait tout. Nouveau
controle : regard et distance testes contre les boites reellement occupees
par la cible pendant la fenetre d affichage (7 ticks + ping), serie de 4 coups
hors boite sur 10. OBSERVE par defaut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 00:55:31 +02:00
60 fichiers modifiés avec 6638 ajouts et 72 suppressions

Aucun fichier ne correspond à votre recherche

+1
Voir le fichier
@@ -7,3 +7,4 @@ run/
# sauvegardes avant modification
*.avant-*
livrable/
+57
Voir le fichier
@@ -0,0 +1,57 @@
# Annexe : contrat d'envoi des détections au Hub (GastinelGarde, branche feat/signalement-hub)
Source du contrat : `conception-hub-bloc2-20261019.md` §2, plus la revue de sécurité du Hub (branche `feat/sanctions-bloc2`,
fichier `stacks/accounts/internal/sanctions/ingest.go`). Aucune valeur secrète dans ce fichier.
## Ce que fait GastinelGarde
- **Désactivé par défaut** : `[hub] envoi = false`. Sans cela, `Signalement.surVerdict` ne fait qu'une lecture de variable.
- **Quoi** : un franchissement de palier (ALERTE, SETBACK ou EXPULSION) par joueur et par contrôle, pas chaque infraction, et jamais un bannissement. Un même palier n'est pas répété pendant `episodeMinutes` (10) ; seul un palier plus haut repart.
- **ENFORCE seulement** par défaut. OBSERVE seulement si `envoyerObserve = true` ; ces détections portent `mode = observe` (le Hub ne doit jamais les compter).
- **Gravité** : ALERTE = 1, SETBACK = 2, EXPULSION = 3. En ENFORCE, c'est la sanction réellement appliquée ; en OBSERVE, le palier mérité.
- **Quand** : dans un fil à part (`GastinelGarde-Hub`, priorité basse). Le tick ajoute un objet dans une file sans verrou.
- **Où** : `POST <url>/internal/detections`, `Content-Type: application/json`, en-tête `X-Source-Cle: <clé>`. Pas de redirection suivie.
- **Clé** : lue dans `fichierCle` (une ligne, 32 à 256 caractères ASCII visibles, droits 600 conseillés). Jamais dans la configuration, jamais journalisée, jamais écrite dans la file sur disque.
- **Reprise sur panne** : file bornée (`fileMax` = 10 000, les plus anciennes sont abandonnées), copie sur disque à l'arrêt et en panne, relue au démarrage ; attente 1 s, 2 s, 4 s … 5 min (+ 25 % au hasard) ; `Retry-After` respecté (5 min au plus) ; 401 / 403 : nouvel essai toutes les 5 min ; 400 : lot abandonné ; 413 : lot divisé par deux ; détections de plus de 23 h abandonnées (le Hub refuse au-delà de 24 h).
- **Débit** : `debitMaxParMinute` = 50 (le Hub accepte 60 par défaut) ; lots de 50 au plus et 15 000 octets (le Hub refuse 16 Kio).
## Corps envoyé
```json
{"detections":[{
"id_externe":"<uuid joueur>:<contrôle>:<palier>:<ms>",
"sujet":{"type":"uuid_minecraft","valeur":"<uuid joueur>"},
"type":"<contrôle>", "gravite":1, "mode":"enforce", "points":9.5,
"survenue_le":"2026-10-19T10:00:00Z",
"details":{"controle":"…","palier":3,"exemptions":["…"],"version_mod":"0.3.2","x":0,"y":0,"z":0,"dimension":"minecraft:overworld"}
}]}
```
Aucun champ `service` ni `source` (le Hub les déduit de la clé). `id_externe` est fixé à la création : toutes les tentatives
d'une même détection portent le même identifiant (idempotence côté Hub).
## Conformité aux contraintes du Hub
| Champ | Motif Hub | Côté mod |
|---|---|---|
| `type` | `^[a-z0-9_-]{1,48}$`, dans `types_autorises` de la source | identifiants des contrôles (`killaura-angle`, `no-fall`…) |
| `id_externe` | `^[A-Za-z0-9:._-]{8,128}$` | vérifié à la création |
| `details.controle`, `details.dimension` | `^[a-z0-9_.:-]{1,64}$` | minuscules, autre caractère remplacé par `_`, 64 au plus |
| `details.version_mod` | `^[0-9A-Za-z.+-]{1,32}$` | autre caractère remplacé par `-`, « inconnue » si impossible |
| `details.exemptions` | 10 au plus, chacune `^[a-z0-9_.-]{1,32}$` | nettoyées, doublons retirés |
| `details.palier` | entier 0 à 100 | rang de la sanction (ALERTE 2, SETBACK 3, EXPULSION 4) |
| `details.x/y/z` | entiers ±30 000 000 | position arrondie au bloc, seulement si `coordonnees = true` |
| texte | aucune adresse IPv4 / IPv6 / préfixe | mêmes motifs que le Hub ; une valeur qui en ressemble est omise |
| `points` | 0 à 99 999 | borné |
| `survenue_le` | RFC 3339, de −24 h à +5 min | heure serveur, secondes |
| autre clé de `details` | retirée par le Hub | liste blanche appliquée aussi à la création et à la relecture du disque |
Le texte libre du moteur (`Verdict.details()`, qui peut contenir un pseudo) n'est **jamais** envoyé.
## À aligner avec le Hub (hypothèses du mod, à confirmer quand la route HTTP du Hub sera écrite)
1. **Enveloppe** : `{"detections":[…]}`. Le Hub (`Service.Ingerer`) prend un tableau de détections mais la route HTTP n'était pas encore écrite à la lecture ; si elle attend un tableau nu, changer `EnvoiHub.envoyer` (une ligne).
2. **Réponse 200** : tableau d'objets `{id_externe, statut: cree|doublon|refuse, code}` ; le mod accepte un tableau à la racine ou sous `resultats` / `results` / `detections` / `items`. Une réponse 200 illisible est tenue pour acceptée.
3. **`details.palier`** : le Hub veut un entier ; le mod envoie le rang de l'énumération `Sanction`. À confirmer.
4. **`types_autorises`** de la source `gastinelgarde` : doit contenir les 15 contrôles (`Signalement.typesAttendus()` donne la liste). `gravite_max` ≥ 3.
5. **Restriction réseau (D5-B)** : côté Hub, par réseau Docker du conteneur Minecraft ; rien à faire dans le mod.
+71
Voir le fichier
@@ -0,0 +1,71 @@
# Journal des versions
## Non publié (branche feat/signalement-hub, dérivée de fix/0.3.2-d1-d3)
Signalement des détections au Hub (bloc 2 de l'architecture des sanctions, GastinelGarde = première source).
**Désactivé par défaut** (`[hub] envoi = false`) : sans changement de configuration, aucun comportement ne change.
Testé hors jeu seulement (tests unitaires, faux serveur HTTP local) ; rien n'a été essayé sur un serveur Minecraft.
- Nouveau paquet `hub` (Java pur, sans Minecraft) : à chaque franchissement de palier (alerte, setback, expulsion) d'un
contrôle en ENFORCE, une détection est mise en file ; un fil à part l'envoie par lots à `POST /internal/detections`.
- Le tick du serveur ne fait qu'ajouter un objet dans une file sans verrou : jamais d'entrée-sortie, d'attente ni d'exception.
- File bornée (10 000), copie sur disque (`gastinelgarde-hub/file-attente.jsonl`) à l'arrêt et pendant une panne,
attente exponentielle de 1 s à 5 min, `Retry-After` respecté, identifiant d'idempotence conservé à chaque tentative.
- Clé de la source lue dans un fichier (`config/gastinelgarde-hub.key`), jamais dans la configuration, jamais journalisée.
- Champs texte conformes au Hub (`controle`, `dimension`, `version_mod`, exemptions), aucune adresse IP.
- Commande `/garde hub` : état de l'envoi. Contrat et points à aligner avec le Hub : `ANNEXE-HUB.md`.
## 0.3.2 (19/10/2026)
Correctifs des défauts D1 à D3 trouvés aux essais en jeu du 19/10 (rapport-garde-test-1019). Modes et options
inchangés. Testé hors jeu seulement (tests unitaires) ; rien n'a été rejoué en jeu.
- D1 : après une téléportation externe (/tp, TPA, perle, mod), une réapparition, un changement de dimension ou une
connexion, le point d'arrivée devient la position de retour. Avant, un setback avant le premier contact au sol
ramenait à la position d'avant la téléportation.
- D2 : un setback `portee` / `hitbox` (coups annulés) remet le VL de ce contrôle à zéro et compte pour C5 : l'expulsion
de combat vient après 4 setbacks en 60 s (avant : ~5 s, VL à 20 sans passer par C5). Les setbacks de combat et de
mouvement sont comptés ensemble pour C5.
- D3 : no-fall voit le NoFall « paquet d'état » : un paquet sans déplacement qui déclare « au sol » sans bloc dessous
est jugé avec la vitesse verticale du dernier paquet de la chute.
## 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`).
+11 -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,
@@ -222,6 +222,14 @@ mais n'élargit plus rien (la clé `pingLagMs` est ignorée).
Plafond configurable (`sanctionMax`). Les points décroissent de 0,5 par seconde. `rotation` ne peut que
journaliser et alerter (le coup a déjà eu lieu quand l'aller-retour est vu).
## Signalement au Hub (désactivé par défaut)
Voir `ANNEXE-HUB.md` pour le contrat. Résumé : si `[hub] envoi = true`, que `url` pointe vers le Hub (réseau Docker interne)
et que le fichier `fichierCle` contient la clé de la source, chaque franchissement de palier (alerte, setback, expulsion)
d'un contrôle en ENFORCE est envoyé au Hub, dans un fil à part, par lots, avec nouvelles tentatives. Le Hub ne reçoit ni
pseudo, ni adresse IP, ni texte libre. Une panne du Hub ne ralentit jamais le serveur et ne perd rien tant que la file
(10 000, 23 h au plus) n'est pas pleine. Le bannissement reste une décision humaine.
## Commandes (ops, niveau 2)
```
@@ -231,6 +239,7 @@ journaliser et alerter (le coup a déjà eu lieu quand l'aller-retour est vu).
/garde mode <contrôle> off|observe|enforce (écrit dans la configuration)
/garde exempter <joueur> <minutes>
/garde traces on|off enregistreur (jusqu'au redémarrage)
/garde hub état du signalement au Hub (désactivé par défaut)
/garde reload
```
@@ -251,7 +260,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
+41
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.
@@ -171,3 +173,42 @@
# Default: 1024
# Range: 16 ~ 102400
tailleMaxMo = 1024
#Signalement des détections au Hub (API d'ingestion). DÉSACTIVÉ PAR DÉFAUT : rien n'est lu ni envoyé tant que envoi = false.
#Seul un franchissement de palier (alerte, setback, expulsion) est signalé, jamais chaque infraction, jamais un bannissement.
#La clé de la source n'est PAS dans ce fichier : elle est lue dans fichierCle (une ligne, 32 caractères au moins, droits 600).
[hub]
#Interrupteur général. false = rien n'est lu, rien n'est envoyé.
envoi = false
#Adresse de base du Hub sur le réseau Docker interne, sans le chemin (http ou https, sans identifiants). Vide = pas d'envoi.
url = ""
#Fichier de la clé de la source (chemin relatif au dossier du serveur, ou absolu). Ne jamais le commiter ni le copier.
fichierCle = "config/gastinelgarde-hub.key"
#Envoyer aussi les contrôles en OBSERVE (marqués observe : le Hub ne les compte jamais pour une sanction). Conseillé false.
envoyerObserve = false
#Plus petit palier signalé : ALERTE, SETBACK ou EXPULSION.
palierMin = "ALERTE"
#Détections par requête (le Hub accepte 1 à 50 et 16 Kio).
# Range: 1 ~ 50
lotMax = 50
#Attente entre deux envois quand tout va bien (ms).
# Range: 200 ~ 60000
intervalleMs = 2000
#Détections gardées au plus en attente (les plus anciennes sont abandonnées au-delà).
# Range: 10 ~ 100000
fileMax = 10000
#Âge au-delà duquel une détection n'est plus envoyée (le Hub refuse plus de 24 h).
# Range: 1 ~ 23
ageMaxHeures = 23
#Détections envoyées au plus par minute (le Hub limite à 60 par défaut).
# Range: 1 ~ 600
debitMaxParMinute = 50
#Minutes pendant lesquelles un même palier d'un même contrôle et d'un même joueur n'est signalé qu'une fois.
# Range: 1 ~ 1440
episodeMinutes = 10
# Range: 200 ~ 30000
delaiConnexionMs = 3000
# Range: 500 ~ 60000
delaiRequeteMs = 5000
#Joindre la position (arrondie au bloc) et la dimension à chaque signalement.
coordonnees = true
+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.3.2
mod_group_id=com.gastinelgarde
mod_id=gastinelgarde
+169
Voir le fichier
@@ -0,0 +1,169 @@
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);
}
}
// --- 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);
}
/**
* D1 (0.3.2) : après une téléportation externe (/tp, TPA, perle, réapparition, dimension), le point d'arrivée
* devient la position de retour. Les autres (setback, refus vanilla) ne la changent pas.
*/
static void retourApresTeleport(Suivi sv, boolean externe, double x, double y, double z, float yaw, float pitch,
String dimension) {
if (externe) sv.memoriserPosition(x, y, z, yaw, pitch, dimension);
}
// --- 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);
}
/** Expulsion à usage unique (C4) ; setback vers la position de retour de la même dimension, puis remise à zéro (C2). */
static void appliquerSanction(Moteur moteur, Joueur p, Sanction s, List<Verdict> verdicts) {
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
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 + ")");
}
}
}
}
+241 -38
Voir le fichier
@@ -8,12 +8,15 @@ import com.gastinelgarde.core.EtatVehicule;
import com.gastinelgarde.core.GardeConfig;
import com.gastinelgarde.core.GraceRecul;
import com.gastinelgarde.core.GraceTeleport;
import com.gastinelgarde.core.HistoriqueBoites;
import com.gastinelgarde.core.PorteeHitbox;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.RiptideSuivi;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Suivi;
import com.gastinelgarde.core.TraceFichier;
import com.gastinelgarde.hub.Signalement;
import com.gastinelgarde.core.TraceLigne;
import com.gastinelgarde.core.Verdict;
import java.io.IOException;
@@ -75,15 +78,37 @@ 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;
}
/** #92 : historique des boîtes d'une entité suivie (joueurs, et entités frappées récemment). */
private static final class Suivie {
final Entity entite;
final HistoriqueBoites historique = new HistoriqueBoites();
net.minecraft.world.level.Level niveau;
int jusquaTick;
Suivie(Entity e) {
this.entite = e;
this.niveau = e.level();
}
}
/** Entités dont on garde les boîtes, par identifiant (unique sur le serveur). */
private static final Map<Integer, Suivie> SUIVIES = new HashMap<>();
/** Une entité non joueur frappée est suivie pendant 10 s après le dernier coup. */
private static final int SUIVI_ENTITE_TICKS = 200;
/** Garde-fou mémoire : au plus ce nombre d'entités non joueur suivies. */
private static final int SUIVIES_MAX = 256;
private static final GardeConfig CONFIG = new GardeConfig();
private static final Moteur MOTEUR = new Moteur(CONFIG);
private static final Map<UUID, Marques> MARQUES = new HashMap<>();
@@ -91,6 +116,7 @@ public final class Garde {
private static TraceFichier traces;
private static Path journal;
private static volatile boolean serveurDemarre;
private static boolean tracesEnCours;
private static int gelTick = Integer.MIN_VALUE;
private static double tpsEstime = 20.0;
@@ -109,6 +135,37 @@ public final class Garde {
public static void surConfigChargee() {
GastinelGarde.LOGGER.info("[GastinelGarde] Configuration appliquée.");
if (serveurDemarre) redemarrerHub(); // /garde reload ou fichier modifié : le Hub relit ses réglages
}
/**
* (Re)lance le signalement au Hub selon la configuration. Coupé par défaut ; ne lève jamais d'exception.
* Fait dans un fil à part : l'arrêt de l'ancienne instance attend jusqu'à 2 s et écrit sur disque, ce qui ne doit
* jamais arriver dans le tick (ex. {@code /garde reload}, exécuté par le fil du serveur).
*/
private static void redemarrerHub() {
Thread t = new Thread(() -> {
try {
if (!serveurDemarre) return; // le serveur s'est arrêté entre-temps
Path jeu = FMLPaths.GAMEDIR.get();
com.gastinelgarde.hub.HubConfig h = GardeSpec.hub(jeu.resolve("gastinelgarde-hub"));
Signalement.demarrer(h, jeu.resolve(h.fichierCle()),
ligne -> GastinelGarde.LOGGER.info("[GastinelGarde] {}", ligne), versionMod());
} catch (Throwable e) {
GastinelGarde.LOGGER.warn("[GastinelGarde] Hub : démarrage impossible ({})", e.getClass().getSimpleName());
}
}, "GastinelGarde-Hub-config");
t.setDaemon(true);
t.start();
}
private static String versionMod() {
try {
return net.neoforged.fml.ModList.get().getModContainerById(GastinelGarde.MOD_ID)
.map(c -> c.getModInfo().getVersion().toString()).orElse("inconnue");
} catch (RuntimeException e) {
return "inconnue";
}
}
public static synchronized void demarrer() {
@@ -124,9 +181,13 @@ public final class Garde {
traces = null;
tracesEnCours = false;
}
serveurDemarre = true;
redemarrerHub();
}
public static synchronized void arreter() {
serveurDemarre = false;
Signalement.arreter(); // écrit sur disque ce qui n'est pas parti (2 s d'attente au plus)
if (traces != null) {
try {
traces.close();
@@ -136,6 +197,7 @@ public final class Garde {
traces = null;
}
MARQUES.clear();
SUIVIES.clear();
}
public static synchronized void flushTraces() {
@@ -156,6 +218,7 @@ public final class Garde {
}
public static void joueurParti(UUID id) {
Signalement.joueurParti(id);
MOTEUR.retirer(id);
MARQUES.remove(id);
ALERTES_COUPEES.remove(id);
@@ -170,6 +233,11 @@ public final class Garde {
m.teleportTick = p.server.getTickCount();
m.mouvementTick = Integer.MIN_VALUE;
m.vehiculeId = -1;
m.oeilAvant = null;
m.oeilDernier = null;
// D1 (0.3.2) : réapparition, changement de dimension, connexion : la position actuelle devient le retour.
Cablage.retourApresTeleport(MOTEUR.suivi(p.getUUID()), true, p.getX(), p.getY(), p.getZ(), p.getYRot(),
p.getXRot(), p.level().dimension().location().toString());
}
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
@@ -182,12 +250,133 @@ public final class Garde {
* Tout teleport() du joueur (mixin) : la grâce ne s'ouvre que pour une origine externe (F05). Le mouvement
* suivant n'est jamais comparé à la position d'avant la téléportation.
*/
public static void teleportVanilla(ServerPlayer p) {
public static void teleportVanilla(ServerPlayer p, double x, double y, double z, float yaw, float pitch,
Set<?> relatifs) {
if (!surThreadServeur(p)) return;
Marques m = marques(p.getUUID());
if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount();
boolean externe = m.graceTeleport.teleport();
if (externe) m.teleportTick = p.server.getTickCount();
// D1 (0.3.2) : téléportation externe (/tp, TPA, perle, mod) : le point d'arrivée devient la position de
// retour (avant : un setback ramenait à la position d'avant la téléportation).
Cablage.retourApresTeleport(MOTEUR.suivi(p.getUUID()), externe,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.X) ? p.getX() + x : x,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Y) ? p.getY() + y : y,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Z) ? p.getZ() + z : z,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.Y_ROT) ? p.getYRot() + yaw : yaw,
relatifs.contains(net.minecraft.world.entity.RelativeMovement.X_ROT) ? p.getXRot() + pitch : pitch,
p.level().dimension().location().toString());
m.mouvementTick = Integer.MIN_VALUE;
m.vehiculeId = -1;
m.oeilAvant = null;
m.oeilDernier = null;
}
// --- Historique des cibles (#92, contrôle coups-hors-boite) ---
/**
* Début de tick (après les paquets reçus entre deux ticks, avant l'envoi des positions aux clients) : boîte de
* chaque joueur et de chaque entité frappée récemment. C'est ce que les clients vont recevoir pendant ce tick.
* Coût : quelques joueurs et quelques mobs, 6 doubles chacun.
*/
public static void enregistrerHistoriques(MinecraftServer server) {
if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) {
if (!SUIVIES.isEmpty()) SUIVIES.clear();
return;
}
int tick = server.getTickCount();
for (ServerPlayer p : server.getPlayerList().getPlayers()) {
Suivie s = SUIVIES.get(p.getId());
if (s == null || s.entite != p) {
s = new Suivie(p); // connexion, ou réapparition (nouvel objet joueur, même identifiant)
SUIVIES.put(p.getId(), s);
}
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
// Revue 4 (16/10) : ping noté chaque seconde, hors combat aussi, pour le plancher de ping.
if (tick % 20 == 0) MOTEUR.pingFenetre(p.getUUID(), tick * 50L, p.connection.latency());
}
java.util.Iterator<Map.Entry<Integer, Suivie>> it = SUIVIES.entrySet().iterator();
while (it.hasNext()) {
Suivie s = it.next().getValue();
Entity e = s.entite;
if (e.isRemoved() || tick > s.jusquaTick) {
it.remove();
continue;
}
if (e.level() != s.niveau) { // changement de dimension : les anciennes boîtes ne veulent plus rien dire
s.historique.vider();
s.niveau = e.level();
}
net.minecraft.world.phys.AABB b = boiteVisee(e);
s.historique.ajouter(tick, b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ);
}
}
/** Boîte que le client vise (vanilla : boîte gonflée du rayon de visée de l'entité, 0 pour presque toutes). */
static net.minecraft.world.phys.AABB boiteVisee(Entity e) {
float r = e.getPickRadius();
return r > 0 ? e.getBoundingBox().inflate(r) : e.getBoundingBox();
}
/**
* Boîtes de la cible sur la fenêtre où l'attaquant a pu la voir (selon son ping), ou null si l'historique ne
* couvre pas toute la fenêtre (entité jamais frappée jusque-là, connexion récente) : on ne mesure pas.
* Une entité non joueur frappée commence ici à être suivie.
*/
public static double[][] boitesVues(Entity cible, ServerPlayer attaquant, int tick) {
if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return null;
Suivie s = SUIVIES.get(cible.getId());
if (s == null || s.entite != cible) {
if (!(cible instanceof Player)) {
// Revue 3 (16/10) : table pleine, on évince la cible non joueur frappée il y a le plus longtemps
// (avant : la nouvelle cible n'était jamais suivie, faire frapper beaucoup d'entités aveuglait le
// contrôle). La cible qu'on frappe sans arrêt est la plus récente : jamais évincée.
if (s == null && SUIVIES.size() >= SUIVIES_MAX) evincerPlusAncienne();
s = new Suivie(cible);
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
SUIVIES.put(cible.getId(), s);
}
return null;
}
if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
if (s.niveau != cible.level()) return null;
// Revue 4 (16/10) : ping plancher des 2 dernières minutes + marge, pas le ping déclaré du moment.
int fenetre = PorteeHitbox.ticksFenetre(
MOTEUR.pingFenetre(attaquant.getUUID(), tick * 50L, attaquant.connection.latency()), CONFIG);
return s.historique.depuis(tick - fenetre);
}
/** Revue 3 : retire de la table l'entrée non joueur dont le dernier coup est le plus ancien. */
private static void evincerPlusAncienne() {
Integer cle = null;
int plusTot = Integer.MAX_VALUE;
for (Map.Entry<Integer, Suivie> e : SUIVIES.entrySet()) {
Suivie v = e.getValue();
if (v != null && v.entite instanceof Player) continue;
int t = v == null ? Integer.MIN_VALUE : v.jusquaTick;
if (cle == null || t < plusTot) {
cle = e.getKey();
plusTot = t;
}
}
if (cle != null) SUIVIES.remove(cle);
}
/** Œil de l'attaquant au paquet de mouvement d'avant le dernier (null si inconnu). */
public static double[] oeilAvant(ServerPlayer p) {
Marques m = MARQUES.get(p.getUUID());
return m == null ? null : m.oeilAvant;
}
/**
* La cible est-elle sur ou près d'une contraption Create / d'un vaisseau Sable ? Sa position affichée chez les
* autres clients peut alors suivre la contraption autrement que ses positions serveur : on ne mesure pas.
*/
public static boolean cibleProcheContraption(Entity cible, int tick) {
if (cible instanceof ServerPlayer j) return pocheContraptionEnCache(j, marques(j.getUUID()), tick);
if (SableAcces.surSousNiveau(cible)) return true;
int dist = GardeSpec.distanceContraption();
if (dist <= 0) return false;
return !cible.level().getEntities(cible, cible.getBoundingBox().inflate(dist), Garde::estContraption).isEmpty();
}
/** Recul réel (F06). Auto-infligé (charge de vent à ses pieds) : grâce limitée, voir GraceRecul. */
@@ -248,12 +437,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())
@@ -332,12 +525,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);
}
/**
@@ -388,9 +576,17 @@ public final class Garde {
}
if (v.notifier()) alerterOps(p, v);
}
if (Signalement.actif()) { // coupé par défaut : une simple lecture de variable
for (Verdict v : verdicts) Signalement.surVerdict(p.getUUID(), v, () -> positionPour(p));
}
return Verdict.pire(verdicts);
}
private static Signalement.Position positionPour(ServerPlayer p) {
return new Signalement.Position(p.getBlockX(), p.getBlockY(), p.getBlockZ(),
p.level().dimension().location().toString());
}
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()))
@@ -432,20 +628,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());
@@ -463,7 +662,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())) {
@@ -476,6 +675,9 @@ public final class Garde {
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z});
Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques)
if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh);
// #92 : œil des deux derniers paquets, pour le prochain coup.
m.oeilAvant = m.oeilDernier;
m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z};
}
m.mouvementTick = tick;
m.mouvementX = p.getX();
@@ -484,7 +686,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());
}
@@ -704,12 +908,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);
}
/**
@@ -751,18 +950,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,
+6 -1
Voir le fichier
@@ -19,7 +19,7 @@ import net.neoforged.neoforge.event.RegisterCommandsEvent;
/**
* /garde status [joueur] | alertes on|off | mode <contrôle> off|observe|enforce | exempter <joueur> <minutes>
* | traces on|off | reload (réservé aux ops, niveau 2)
* | traces on|off | hub | reload (réservé aux ops, niveau 2)
*/
public final class GardeCommands {
@@ -64,6 +64,11 @@ public final class GardeCommands {
.then(Commands.argument("minutes", IntegerArgumentType.integer(1, 1440))
.executes(GardeCommands::exempter))));
racine.then(Commands.literal("hub").executes(ctx -> {
ok(ctx, com.gastinelgarde.hub.Signalement.resume());
return 1;
}));
racine.then(Commands.literal("reload").executes(GardeCommands::recharger));
d.register(racine);
+26 -10
Voir le fichier
@@ -44,6 +44,7 @@ public final class GardeEvents {
@SubscribeEvent
public static void onTickPre(ServerTickEvent.Pre event) {
debutTickNs = System.nanoTime();
Garde.enregistrerHistoriques(event.getServer()); // #92 : boîtes des cibles possibles
}
@SubscribeEvent
@@ -56,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();
@@ -78,14 +88,19 @@ 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
// « vitesse × ticks » dans toutes les directions. Null (pas de mesure) si l'historique est incomplet ou si
// la cible est sur ou près d'une contraption / d'un vaisseau.
double[][] vues = mesurerPH && !Garde.cibleProcheContraption(cible, tick) ? Garde.boitesVues(cible, p, tick) : null;
verdicts.addAll(Garde.moteur().coupDiffere(p.getUUID(), tick * 50L, etat,
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z},
new double[] {bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ}, p.entityInteractionRange(),
vitesseCible, mesurerPH, true));
vitesseCible, mesurerPH, true, Garde.oeilAvant(p), vues));
if (Garde.tracesEnCours()) {
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
@@ -94,11 +109,9 @@ public final class GardeEvents {
}
Sanction s = Garde.traiter(p, verdicts);
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). */
@@ -130,7 +143,10 @@ public final class GardeEvents {
@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
+138
Voir le fichier
@@ -47,6 +47,23 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue PING_LATENCE_MAX;
private static final ModConfigSpec.DoubleValue VITESSE_CIBLE_MAX;
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
private static final ModConfigSpec.IntValue SERIE_PING_MAX;
private static final ModConfigSpec.IntValue SERIE_PING_MARGE;
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX;
private static final ModConfigSpec.BooleanValue VOL_FENETRE_GLISSANTE;
private static final ModConfigSpec.BooleanValue VITESSE_MOYENNE;
private static final ModConfigSpec.BooleanValue ELYTRES_STRICTE;
private static final ModConfigSpec.IntValue ELYTRES_AIR_MIN;
private static final ModConfigSpec.BooleanValue COMBAT_VEHICULE;
private static final ModConfigSpec.BooleanValue AC_EMPILEMENT_MOUVEMENT;
private static final ModConfigSpec.DoubleValue SERIE_MANQUE;
private static final ModConfigSpec.DoubleValue SERIE_PORTEE;
private static final ModConfigSpec.IntValue SERIE_COUPS;
private static final ModConfigSpec.IntValue SERIE_HORS_MIN;
private static final ModConfigSpec.IntValue SERIE_FENETRE_MS;
private static final ModConfigSpec.DoubleValue SERIE_POINTS;
private static final ModConfigSpec.ConfigValue<String> PREFIXES_CONTRAPTION;
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
private static final ModConfigSpec.ConfigValue<String> BLOCS_COURANT_AIR;
@@ -61,6 +78,21 @@ public final class GardeSpec {
private static final ModConfigSpec.DoubleValue AC_VITESSE_MINECART;
private static final ModConfigSpec.IntValue AC_EMPILEMENT_MAX;
private static final ModConfigSpec.BooleanValue HUB_ENVOI;
private static final ModConfigSpec.ConfigValue<String> HUB_URL;
private static final ModConfigSpec.ConfigValue<String> HUB_FICHIER_CLE;
private static final ModConfigSpec.BooleanValue HUB_OBSERVE;
private static final ModConfigSpec.EnumValue<Sanction> HUB_PALIER_MIN;
private static final ModConfigSpec.IntValue HUB_LOT_MAX;
private static final ModConfigSpec.IntValue HUB_INTERVALLE_MS;
private static final ModConfigSpec.IntValue HUB_FILE_MAX;
private static final ModConfigSpec.IntValue HUB_AGE_MAX_HEURES;
private static final ModConfigSpec.IntValue HUB_DEBIT_MAX;
private static final ModConfigSpec.IntValue HUB_EPISODE_MIN;
private static final ModConfigSpec.IntValue HUB_DELAI_CONNEXION_MS;
private static final ModConfigSpec.IntValue HUB_DELAI_REQUETE_MS;
private static final ModConfigSpec.BooleanValue HUB_COORDONNEES;
private static final ModConfigSpec.BooleanValue TRACES_ACTIVES;
private static final ModConfigSpec.IntValue TRACES_JOURS;
private static final ModConfigSpec.IntValue TRACES_TAILLE_MO;
@@ -110,15 +142,52 @@ public final class GardeSpec {
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
b.pop();
b.comment("Contrôle coups-hors-boite (#92) : le regard est testé contre toutes les positions où le client a pu",
"voir la cible (historique des boîtes), au lieu d'une marge « vitesse × ticks » dans toutes les directions.",
"Un coup isolé ne compte pas : seulement une série (serieHorsMin coups hors boîte sur les serieCoups derniers).",
"Valeurs de départ prudentes, à régler avec les journaux en OBSERVE avant tout ENFORCE.").push("coupsHorsBoite");
TICKS_AFFICHAGE = b.comment("Retard d'affichage de base de la cible chez le client (ticks) ; le ping s'ajoute (ping / 50).")
.defineInRange("ticksAffichageCible", 7, 2, 12);
SERIE_PING_MAX = b.comment("Ping (ms) pris en compte au plus dans la fenêtre (au-delà, le coup est mesuré avec cette fenêtre).")
.defineInRange("seriePingMaxMs", 500, 100, 500);
SERIE_PING_MARGE = b.comment("Fenêtre selon le ping le plus bas des 2 dernières minutes + cette marge (ms), pas le ping du moment.")
.defineInRange("seriePingMargeMs", 50, 0, 500);
SERIE_MANQUE = b.comment("Coup hors boîte si le regard manque toutes les boîtes vues de plus de cette marge (blocs).")
.defineInRange("serieManqueBlocs", 0.15, 0.05, 2.0);
SERIE_PORTEE = b.comment("... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs).")
.defineInRange("seriePorteeMargeBlocs", 0.15, 0.05, 2.0);
SERIE_COUPS = b.defineInRange("serieCoups", 10, 3, 32);
SERIE_HORS_MIN = b.defineInRange("serieHorsMin", 4, 2, 32);
SERIE_FENETRE_MS = b.defineInRange("serieFenetreMs", 30000, 1000, 600000);
SERIE_POINTS = b.defineInRange("seriePoints", 2.0, 0.1, 20.0);
b.pop();
b.push("timer");
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.push("mouvement");
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");
@@ -168,6 +237,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();
@@ -180,6 +252,35 @@ public final class GardeSpec {
TRACES_TAILLE_MO = b.defineInRange("tailleMaxMo", 1024, 16, 102400);
b.pop();
b.comment("Signalement des détections au Hub (API d'ingestion, conception-hub-bloc2 §2). DÉSACTIVÉ PAR DÉFAUT.",
"Seul un franchissement de palier (alerte, setback, expulsion) est signalé, jamais chaque infraction, et jamais",
"un bannissement. L'envoi se fait dans un fil à part : une panne du Hub ne ralentit jamais le serveur.",
"La clé de la source n'est PAS dans ce fichier : elle est lue dans le fichier « fichierCle » (une ligne,",
"32 caractères au moins, droits 600), qui ne doit jamais être commité ni copié.").push("hub");
HUB_ENVOI = b.comment("Interrupteur général. false = rien n'est lu, rien n'est envoyé.").define("envoi", false);
HUB_URL = b.comment("Adresse de base du Hub sur le réseau Docker interne, sans le chemin (http ou https, sans identifiants).",
"Forme : http://<service>:<port>. Vide = pas d'envoi.").define("url", "");
HUB_FICHIER_CLE = b.comment("Fichier de la clé de la source (chemin relatif au dossier du serveur, ou absolu).")
.define("fichierCle", "config/gastinelgarde-hub.key");
HUB_OBSERVE = b.comment("Envoyer aussi les contrôles en OBSERVE (marqués « observe » : le Hub ne les compte jamais pour une sanction).",
"Conseillé false : ces contrôles ne sont pas validés en jeu.").define("envoyerObserve", false);
HUB_PALIER_MIN = b.comment("Plus petit palier signalé : ALERTE, SETBACK ou EXPULSION.").defineEnum("palierMin", Sanction.ALERTE);
HUB_LOT_MAX = b.comment("Détections par requête (le Hub accepte 1 à 50 et 16 Kio).").defineInRange("lotMax", 50, 1, 50);
HUB_INTERVALLE_MS = b.comment("Attente entre deux envois quand tout va bien (ms).").defineInRange("intervalleMs", 2000, 200, 60000);
HUB_FILE_MAX = b.comment("Détections gardées au plus en attente (les plus anciennes sont abandonnées au-delà).")
.defineInRange("fileMax", 10000, 10, 100000);
HUB_AGE_MAX_HEURES = b.comment("Âge au-delà duquel une détection n'est plus envoyée. Le Hub refuse plus de 24 h : 23 au plus.")
.defineInRange("ageMaxHeures", 23, 1, 23);
HUB_DEBIT_MAX = b.comment("Détections envoyées au plus par minute (le Hub limite à 60 par défaut).")
.defineInRange("debitMaxParMinute", 50, 1, 600);
HUB_EPISODE_MIN = b.comment("Durée (minutes) pendant laquelle un même palier d'un même contrôle et d'un même joueur n'est signalé qu'une fois.")
.defineInRange("episodeMinutes", 10, 1, 1440);
HUB_DELAI_CONNEXION_MS = b.defineInRange("delaiConnexionMs", 3000, 200, 30000);
HUB_DELAI_REQUETE_MS = b.defineInRange("delaiRequeteMs", 5000, 500, 60000);
HUB_COORDONNEES = b.comment("Joindre la position (arrondie au bloc) et la dimension à chaque signalement.")
.define("coordonnees", true);
b.pop();
SPEC = b.build();
}
@@ -219,6 +320,21 @@ public final class GardeSpec {
c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
c.ticksAffichageCible = TICKS_AFFICHAGE.get();
c.seriePingMaxMs = SERIE_PING_MAX.get();
c.seriePingMargeMs = SERIE_PING_MARGE.get();
c.timerSoldeMax = TIMER_SOLDE_MAX.get();
c.volFenetreGlissante = VOL_FENETRE_GLISSANTE.get();
c.vitesseMoyenne = VITESSE_MOYENNE.get();
c.elytresExemptionStricte = ELYTRES_STRICTE.get();
c.elytresAirMinTicks = ELYTRES_AIR_MIN.get();
c.combatMesureEnVehicule = COMBAT_VEHICULE.get();
c.serieManqueBlocs = SERIE_MANQUE.get();
c.seriePorteeMargeBlocs = SERIE_PORTEE.get();
c.serieCoups = SERIE_COUPS.get();
c.serieHorsMin = Math.min(SERIE_HORS_MIN.get(), c.serieCoups);
c.serieFenetreMs = SERIE_FENETRE_MS.get();
c.seriePoints = SERIE_POINTS.get();
c.graceTeleportTicks = GRACE_TELEPORT.get();
c.graceReculTicks = GRACE_RECUL.get();
c.graceGelTicks = GRACE_GEL.get();
@@ -287,6 +403,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;
}
@@ -307,6 +424,27 @@ public final class GardeSpec {
return mo * 1024L * 1024L;
}
/** Réglages du signalement au Hub (valeurs par défaut, donc envoi coupé, si le fichier n'est pas chargé). */
public static com.gastinelgarde.hub.HubConfig hub(java.nio.file.Path dossierEtat) {
boolean l = SPEC.isLoaded();
return new com.gastinelgarde.hub.HubConfig(
l ? HUB_ENVOI.get() : HUB_ENVOI.getDefault(),
l ? HUB_URL.get() : HUB_URL.getDefault(),
java.nio.file.Path.of(l ? HUB_FICHIER_CLE.get() : HUB_FICHIER_CLE.getDefault()),
l ? HUB_OBSERVE.get() : HUB_OBSERVE.getDefault(),
l ? HUB_PALIER_MIN.get() : HUB_PALIER_MIN.getDefault(),
l ? HUB_LOT_MAX.get() : HUB_LOT_MAX.getDefault(),
l ? HUB_INTERVALLE_MS.get() : HUB_INTERVALLE_MS.getDefault(),
l ? HUB_FILE_MAX.get() : HUB_FILE_MAX.getDefault(),
(l ? HUB_AGE_MAX_HEURES.get() : HUB_AGE_MAX_HEURES.getDefault()) * 3600_000L,
l ? HUB_DEBIT_MAX.get() : HUB_DEBIT_MAX.getDefault(),
(l ? HUB_EPISODE_MIN.get() : HUB_EPISODE_MIN.getDefault()) * 60_000L,
l ? HUB_DELAI_CONNEXION_MS.get() : HUB_DELAI_CONNEXION_MS.getDefault(),
l ? HUB_DELAI_REQUETE_MS.get() : HUB_DELAI_REQUETE_MS.getDefault(),
l ? HUB_COORDONNEES.get() : HUB_COORDONNEES.getDefault(),
dossierEtat);
}
/** Modifie un mode dans le fichier de configuration (conservé au prochain démarrage). */
public static void definirMode(Controle c, Mode m) {
ModConfigSpec.EnumValue<Mode> v = MODES.get(c);
+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) {
+4 -1
Voir le fichier
@@ -10,6 +10,8 @@ public enum Controle {
ROTATION("rotation"),
PORTEE("portee"),
HITBOX("hitbox"),
/** #92 : série de coups qui manquent toutes les positions où la cible a pu être vue (hitbox, reach). */
COUPS_HORS_BOITE("coups-hors-boite"),
TIMER("timer"),
NO_FALL("no-fall"),
VITESSE("vitesse"),
@@ -33,7 +35,8 @@ public enum Controle {
* correction de l'interdiction du 15/10, qui empêchait aussi la correction no-fall de d0c001d).
*/
public boolean observeParDefaut() {
return this == NO_FALL || this == VITESSE || this == VOL || this == PORTEE || this == HITBOX;
return this == NO_FALL || this == VITESSE || this == VOL || this == PORTEE || this == HITBOX
|| this == COUPS_HORS_BOITE;
}
public static Controle parse(String texte) {
+71 -2
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;
@@ -27,6 +45,18 @@ final class CoupDiffere {
/** Excédent d'angle killaura (degrés), -1 si non mesuré. */
double excedent;
// #92 : mesure compensée par l'historique de la cible (contrôle coups-hors-boite). Null : pas d'historique.
double[][] boitesVues;
/** Œil au paquet d'avant, au coup, au paquet suivant (null si inconnu). */
double[] oeilPrecedent, oeilCoup, oeilSuivant;
/** Regard au coup et au paquet suivant (null si inconnu). */
double[] regardCoup, regardSuivant;
/** Le regard du paquet suivant a été refusé (trop loin du regard du coup). */
boolean regardSuivantRefuse;
/** Excédent d'angle killaura avec le regard du coup seul (avant affinage), -1 si non mesuré. */
double excedentCoup = -1;
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
double distance, double manque, double excedent, boolean porteeHitbox) {
this.nowMs = nowMs;
@@ -45,8 +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) {
/**
* 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],
@@ -59,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};
}
}
+5 -2
Voir le fichier
@@ -15,6 +15,7 @@ public record EtatJoueur(
boolean enVehicule,
boolean pocheContraption,
boolean utiliseObjet,
boolean elytresDeploiementSuspect,
int ticksDepuisTeleport,
int ticksDepuisRecul,
int ticksDepuisGel,
@@ -34,7 +35,7 @@ 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;
@@ -49,6 +50,8 @@ 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; }
@@ -57,7 +60,7 @@ public record EtatJoueur(
public EtatJoueur build() {
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
enVehicule, pocheContraption, utiliseObjet, ticksDepuisTeleport, ticksDepuisRecul,
enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect, ticksDepuisTeleport, ticksDepuisRecul,
ticksDepuisGel, tps, pingMs);
}
}
+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");
+53
Voir le fichier
@@ -17,6 +17,14 @@ 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;
// --- Killaura ---
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
@@ -58,6 +66,51 @@ public final class GardeConfig {
/** Cible plus rapide que ça (blocs/tick : élytres, riptide, téléportation, recul fort) : pas de mesure. */
public double vitesseCibleMaxMesure = 1.0;
// --- Coups hors boîte (#92, 16/10 : le cas de Rednixxu passait sous portee et hitbox) ---
/**
* Retard d'affichage de base de la cible chez le client (ticks) : envoi de sa position toutes les 2 (joueur) à
* 3 ticks (mob), interpolation sur 3 ticks, plus 1 tick de gigue. Le ping s'ajoute (voir seriePingMaxMs).
*/
public int ticksAffichageCible = 7;
/** Ping (ms) pris en compte au plus dans la fenêtre (revue 1, 16/10 : au-delà, mesuré quand même, fenêtre bornée). */
public int seriePingMaxMs = 500;
/** Un coup est « hors boîte » si le regard manque toutes les boîtes vues de plus de cette marge (blocs). */
public double serieManqueBlocs = 0.15;
/** ... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs). */
public double seriePorteeMargeBlocs = 0.15;
/** Nombre de derniers coups mesurés examinés. */
public int serieCoups = 10;
/** Coups hors boîte, parmi les serieCoups derniers, à partir desquels un coup hors boîte compte. */
public int serieHorsMin = 4;
/** Âge maximal (ms) d'un coup encore compté dans la série. */
public long serieFenetreMs = 30000;
/** Points par coup hors boîte dans une série suspecte. */
public double seriePoints = 2.0;
/**
* Revue 4 (16/10) : la fenêtre d'historique suit le ping le plus bas vu ces 2 dernières minutes, plus cette marge
* (ms), et non le ping déclaré : gonfler son ping pendant un combat n'élargit plus la fenêtre.
*/
public int seriePingMargeMs = 50;
// --- C10 / C15 (16/10) : détections supplémentaires, DÉSACTIVÉES par défaut (à valider en OBSERVE) ---
/** C10 : vol, ticks anormaux comptés sur une fenêtre glissante et sauts en l'air sans appui. */
public boolean volFenetreGlissante = false;
/** C15 : vitesse moyenne sur 2 s comparée à la moyenne vanilla (course, sprint-saut). */
public boolean vitesseMoyenne = false;
// --- C7 / C8 (16/10, constats hauts) : DÉSACTIVÉS par défaut (à valider en OBSERVE) ---
/**
* C7 : élytres. Pas d'exemption de mouvement si le plané a été déclenché sans au moins
* {@link #elytresAirMinTicks} ticks en l'air (sol serveur), et portée / hitbox mesurées pendant le plané.
*/
public boolean elytresExemptionStricte = false;
/** C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres. */
public int elytresAirMinTicks = 2;
/** C8 : le combat d'un passager de véhicule (bateau, cheval, minecart…) est mesuré comme à pied. */
public boolean combatMesureEnVehicule = false;
/** C15 : solde de paquets de mouvement (reçus - ticks écoulés) au-delà duquel le timer compte ; 0 = désactivé. */
public int timerSoldeMax = 0;
// --- Exemptions ---
public int graceTeleportTicks = 40;
public int graceReculTicks = 20;
+94
Voir le fichier
@@ -0,0 +1,94 @@
package com.gastinelgarde.core;
/**
* Boîtes successives d'une entité, une par tick serveur (#92, 16/10/2026). Tampon circulaire de taille fixe (D4) :
* aucune allocation à l'enregistrement.
*
* Sert à savoir où un client a pu VOIR la cible au moment de son coup : le client affiche les autres entités avec
* du retard (envoi de position toutes les 2 ticks pour un joueur, 3 pour la plupart des mobs, interpolation sur
* 3 ticks, plus le ping). Au lieu d'élargir la boîte réelle dans toutes les directions de « vitesse × ticks »
* (ancien calcul, qui donnait jusqu'à 1 bloc de marge partout dès que la cible bouge), on teste le regard contre
* les boîtes réellement occupées pendant cette fenêtre.
*/
public final class HistoriqueBoites {
/** 32 ticks (1,6 s) : couvre la fenêtre la plus large (7 ticks + 500 ms de ping = 17 ticks) avec de la marge. */
public static final int CAPACITE = 32;
private final int[] ticks = new int[CAPACITE];
private final double[] boites = new double[CAPACITE * 6];
/** Nombre d'entrées valides. */
private int taille;
/** Indice de la prochaine écriture. */
private int tete;
/** Enregistre la boîte du tick ; un second enregistrement au même tick remplace le premier. */
public void ajouter(int tick, double minX, double minY, double minZ, double maxX, double maxY, double maxZ) {
int i;
if (taille > 0 && ticks[indice(taille - 1)] == tick) {
i = indice(taille - 1);
} else {
if (taille > 0 && tick < ticks[indice(taille - 1)]) vider(); // horloge revenue en arrière : on repart
i = tete;
tete = (tete + 1) % CAPACITE;
if (taille < CAPACITE) taille++;
}
ticks[i] = tick;
int o = i * 6;
boites[o] = minX;
boites[o + 1] = minY;
boites[o + 2] = minZ;
boites[o + 3] = maxX;
boites[o + 4] = maxY;
boites[o + 5] = maxZ;
}
public void ajouter(int tick, double[] b) {
ajouter(tick, b[0], b[1], b[2], b[3], b[4], b[5]);
}
public void vider() {
taille = 0;
tete = 0;
}
public int taille() {
return taille;
}
/** Tick de l'entrée la plus récente, ou {@link Integer#MIN_VALUE} si vide. */
public int dernierTick() {
return taille == 0 ? Integer.MIN_VALUE : ticks[indice(taille - 1)];
}
/** Tick de l'entrée la plus ancienne, ou {@link Integer#MAX_VALUE} si vide. */
public int premierTick() {
return taille == 0 ? Integer.MAX_VALUE : ticks[indice(0)];
}
/**
* Boîtes de la fenêtre [tickMin, ...], dans l'ordre chronologique, plus la dernière entrée antérieure à tickMin
* (la cible affichée peut être en cours d'interpolation depuis cette position).
*
* @return null si l'historique ne remonte pas jusqu'à tickMin (fenêtre incomplète : on ne sait pas où le client
* a pu voir la cible, donc on ne mesure pas)
*/
public double[][] depuis(int tickMin) {
if (taille == 0 || premierTick() > tickMin) return null;
int debut = 0;
for (int k = taille - 1; k >= 0; k--) {
if (ticks[indice(k)] <= tickMin) { debut = k; break; }
}
double[][] sortie = new double[taille - debut][];
for (int k = debut; k < taille; k++) {
int o = indice(k) * 6;
sortie[k - debut] = new double[] {boites[o], boites[o + 1], boites[o + 2], boites[o + 3], boites[o + 4], boites[o + 5]};
}
return sortie;
}
/** Indice dans le tampon de la k-ième entrée valide (0 = la plus ancienne). */
private int indice(int k) {
return ((tete - taille + k) % CAPACITE + CAPACITE) % CAPACITE;
}
}
+165 -5
Voir le fichier
@@ -21,6 +21,8 @@ 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<>();
public Moteur(GardeConfig cfg) {
this.cfg = cfg;
@@ -54,6 +56,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 +100,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();
@@ -117,11 +121,20 @@ public final class Moteur {
ajouter(verdicts, s, Controle.HITBOX, PorteeHitbox.pointsHitbox(manque, seuil), nowMs, ex,
String.format(Locale.ROOT, "regard hors boite de %.2f (seuil %.2f)", manque, seuil));
}
boolean setback = false;
for (Verdict v : verdicts) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
s.coupsBloquesJusqua = nowMs + DUREE_BLOCAGE_COUPS_MS;
}
// D2 (0.3.2) : un setback de combat (coups annulés) compte comme un setback (C5) et remet le VL de ce
// contrôle à zéro, comme pour le vol (C2). Avant, le VL montait à 20 en ~5 s : expulsion directe, sans
// la règle « 4 setbacks en 60 s ».
if (v.applicable() == Sanction.SETBACK) {
s.vl.remettreAZero(v.controle());
setback = true;
}
}
if (setback) s.noterSetback(nowMs);
return verdicts;
}
@@ -149,11 +162,30 @@ public final class Moteur {
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
double[] boite, double porteeJoueur, double vitesseCible,
boolean porteeHitbox, boolean angle) {
return coupDiffere(joueur, nowMs, etat, oeil, regard, boite, porteeJoueur, vitesseCible, porteeHitbox, angle,
null, null);
}
/**
* Idem, avec ce qu'il faut pour la mesure compensée du contrôle coups-hors-boite (#92).
*
* @param oeilPrecedent œil au paquet de mouvement d'avant le dernier (null si inconnu)
* @param boitesVues boîtes de la cible sur la fenêtre où le client a pu la voir, dans l'ordre chronologique
* (voir {@link HistoriqueBoites#depuis} et {@link PorteeHitbox#ticksFenetre}) ; null si
* l'historique est incomplet : le contrôle ne mesure pas ce coup
*/
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
double[] boite, double porteeJoueur, double vitesseCible,
boolean porteeHitbox, boolean angle, double[] oeilPrecedent,
double[][] boitesVues) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
List<Verdict> verdicts = terminerCoup(joueur);
boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0
&& cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF;
boolean ph = porteeHitbox
&& (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
boolean an = angle && cfg.mode(Controle.KILLAURA_ANGLE) != Mode.OFF;
if (!ph && !an) return verdicts;
if (!ph && !an && !serie) return verdicts;
double ex = an ? KillauraAngle.excedentDegres(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]) : -1;
if (an && ex < 0) ex = -1;
@@ -161,12 +193,63 @@ public final class Moteur {
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
suivi(joueur).coupDiffere = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
CoupDiffere c = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
// Revue 2 / C13 : œil et regard du coup gardés dans tous les cas, pour borner ceux du paquet suivant.
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
c.oeilCoup = oeil.clone();
c.regardCoup = regard.clone();
if (serie) c.boitesVues = boitesVues;
suivi(joueur).coupDiffere = c;
return verdicts;
}
/**
* Contrôle coups-hors-boite (#92) : mesure compensée du coup (toutes les positions où la cible a pu être vue,
* tous les yeux et regards plausibles de l'attaquant), puis série sur les derniers coups.
*/
private List<Verdict> coupsHorsBoite(Suivi s, CoupDiffere c) {
if (c.boitesVues == null || cfg.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return List.of();
Exemptions.Resultat ex = Exemptions.evaluer(c.etat, cfg, Exemptions.Famille.COMBAT);
if (ex.exempt()) return List.of();
if (PorteeHitbox.raisonNonMesureSerie(c.etat, cfg) != null) return List.of();
double[][] boites = new double[c.boitesVues.length + 1][];
System.arraycopy(c.boitesVues, 0, boites, 0, c.boitesVues.length);
boites[c.boitesVues.length] = c.boite; // boîte au moment du coup
PorteeHitbox.Mesure m = PorteeHitbox.mesureCompensee(
new double[][] {c.oeilPrecedent, c.oeilCoup, c.oeilSuivant},
new double[][] {c.regardCoup, c.regardSuivant},
boites, c.porteeJoueur + 1.0, cfg.vitesseCibleMaxMesure);
// Cible qui a sauté (téléportation) ou file trop vite dans la fenêtre : on ne sait pas ce que le client a vu.
if (m.deplacementMax() > cfg.vitesseCibleMaxMesure) return List.of();
double f = ex.facteur();
double seuilManque = cfg.serieManqueBlocs * f;
double seuilPortee = c.porteeJoueur + cfg.seriePorteeMargeBlocs * f;
boolean hors = m.manque() > seuilManque || m.distance() > seuilPortee;
double pts = s.serie.enregistrer(c.nowMs, hors, cfg);
List<Verdict> verdicts = new ArrayList<>(1);
ajouter(verdicts, s, Controle.COUPS_HORS_BOITE, pts, c.nowMs, ex, String.format(Locale.ROOT,
"manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d%s",
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal(),
c.regardSuivantRefuse ? ", regard suivant refuse" : ""));
return verdicts;
}
/**
* Revue 4 (16/10) : ping à utiliser pour la fenêtre d'historique de coups-hors-boite (voir
* {@link PorteeHitbox#ticksFenetre}). Note aussi le ping déclaré.
*/
public int pingFenetre(UUID joueur, long nowMs, int pingDeclare) {
Suivi s = suivi(joueur);
int plancher = s.pingPlancher.noter(nowMs, pingDeclare);
long avecMarge = (long) plancher + Math.max(0, cfg.seriePingMargeMs);
return (int) Math.max(0, Math.min(pingDeclare, avecMarge));
}
/** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */
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);
@@ -187,11 +270,18 @@ 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) {
verdicts.addAll(porteeHitbox(joueur, c.nowMs, c.etat, c.distance, c.manque, c.porteeJoueur, c.vitesseCible));
}
verdicts.addAll(coupsHorsBoite(s, c));
for (Verdict v : verdicts) { // le coup est déjà passé : en ENFORCE, on annule les suivants
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS);
@@ -212,6 +302,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);
@@ -227,6 +318,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()) {
@@ -246,6 +338,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;
@@ -257,20 +350,37 @@ 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();
s.dyChute = 0;
// C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore.
if (ex.raisons().contains("elytres")) {
s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L;
}
return List.of();
}
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");
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m, s.dyChute), nowMs, ex,
NoFall.sansDeplacement(m) ? "au sol declare sans bloc dessous pendant une chute (paquet d'etat)"
: "au sol declare sans bloc dessous pendant une chute");
}
s.dyChute = NoFall.dyApres(m, s.dyChute);
if (vitesse) {
s.vitesse.moyenne = cfg.vitesseMoyenne; // C15, désactivé par défaut
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
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
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()));
}
@@ -292,6 +402,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();
@@ -337,6 +448,50 @@ public final class Moteur {
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
}
// --- 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.dyChute = 0;
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,
@@ -345,6 +500,11 @@ 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);
boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal()
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
+21 -1
Voir le fichier
@@ -48,7 +48,27 @@ public final class NoFall {
}
public static double points(EtatMouvement e) {
if (e.auSolClient() && !e.auSolServeur() && e.dy() <= DY_CHUTE && !e.milieuSpecial()) return 0.5;
return points(e, 0);
}
/**
* D3 (0.3.2) : idem, mais un paquet sans déplacement (paquet d'état « au sol » ajouté par un NoFall, dy = 0) est
* jugé avec la vitesse verticale du dernier paquet qui a bougé ({@code dyPrecedent}).
*/
public static double points(EtatMouvement e, double dyPrecedent) {
double dy = sansDeplacement(e) ? dyPrecedent : e.dy();
if (e.auSolClient() && !e.auSolServeur() && dy <= DY_CHUTE && !e.milieuSpecial()) return 0.5;
return 0;
}
/** Paquet qui ne change pas la position (paquet d'état ou de rotation seule). */
public static boolean sansDeplacement(EtatMouvement e) {
return e.dy() == 0 && e.dxz() == 0;
}
/** Vitesse verticale de chute à retenir après ce paquet : remise à zéro au sol ou en milieu spécial. */
public static double dyApres(EtatMouvement e, double dyPrecedent) {
if (e.auSolServeur() || e.milieuSpecial()) return 0;
return sansDeplacement(e) ? dyPrecedent : e.dy();
}
}
+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;
}
}
+91 -1
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";
@@ -126,4 +126,94 @@ public final class PorteeHitbox {
if (!(manque > seuil)) return 0;
return 1.0 + Math.min(2.0, (manque - seuil) / 0.3);
}
// --- Mesure compensée par l'historique de la cible (#92, contrôle coups-hors-boite) ----------------------
/**
* Écart maximal (en entrées d'historique) entre deux boîtes réunies : la cible affichée est interpolée en
* ligne droite entre deux positions reçues, espacées de 2 ticks (joueur) à 3 ticks (mob) ; la boîte englobante
* de deux boîtes contient tout le segment qui les relie.
*/
public static final int ECART_REUNION_MAX = 3;
/**
* Mesure compensée.
*
* @param distance distance minimale œil – boîte, sur tous les yeux et toutes les boîtes candidates
* @param manque gonflement minimal pour que l'un des regards touche l'une des boîtes candidates
* @param deplacementMax plus grand déplacement de la cible d'une entrée d'historique à la suivante (blocs)
*/
public record Mesure(double distance, double manque, double deplacementMax) { }
/**
* Fenêtre d'historique (ticks) où le client a pu voir la cible : retard d'affichage de base, plus le ping
* (aller-retour : la position part vers l'attaquant, le coup revient), borné.
*/
public static int ticksFenetre(int pingMs, GardeConfig cfg) {
int ping = Math.min(Math.max(0, pingMs), Math.max(0, cfg.seriePingMaxMs));
return Math.max(0, cfg.ticksAffichageCible) + (int) Math.ceil(ping / 50.0);
}
/**
* Distance et manque minimaux sur toutes les combinaisons (œil, regard, boîte candidate). Boîtes candidates :
* chaque boîte de l'historique, et la boîte englobante de deux boîtes distantes d'au plus
* {@link #ECART_REUNION_MAX} entrées (position interpolée entre les deux), sauf si la cible a « sauté » plus
* de {@code sautMax} blocs par entrée entre elles (téléportation : pas d'interpolation).
*
* Toutes les sources d'écart honnêtes sont prises du côté favorable au joueur : œil précédent, actuel et
* suivant (le client vise depuis une position interpolée entre deux paquets), regard actuel et suivant.
*/
public static Mesure mesureCompensee(double[][] yeux, double[][] regards, double[][] boites, double longueur,
double sautMax) {
double distance = Double.MAX_VALUE;
double manque = MANQUE_MAX;
double deplacementMax = 0;
for (int i = 1; i < boites.length; i++) deplacementMax = Math.max(deplacementMax, ecartCentres(boites[i - 1], boites[i]));
for (int i = 0; i < boites.length; i++) {
for (int k = 0; k <= ECART_REUNION_MAX && i + k < boites.length; k++) {
double[] b;
if (k == 0) {
b = boites[i];
} else {
if (ecartCentres(boites[i], boites[i + k]) > sautMax * k) continue;
b = reunion(boites[i], boites[i + k]);
}
for (double[] oeil : yeux) {
if (oeil == null) continue;
distance = Math.min(distance, distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]));
for (double[] r : regards) {
if (r == null || manque == 0) continue;
manque = Math.min(manque, manqueRegard(oeil[0], oeil[1], oeil[2], r[0], r[1], r[2], longueur,
b[0], b[1], b[2], b[3], b[4], b[5]));
}
}
}
}
if (distance == Double.MAX_VALUE) distance = 0;
return new Mesure(distance, manque, deplacementMax);
}
static double ecartCentres(double[] a, double[] b) {
double dx = (a[0] + a[3] - b[0] - b[3]) / 2, dy = (a[1] + a[4] - b[1] - b[4]) / 2, dz = (a[2] + a[5] - b[2] - b[5]) / 2;
return Math.sqrt(dx * dx + dy * dy + dz * dz);
}
static double[] reunion(double[] a, double[] b) {
return new double[] {Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.min(a[2], b[2]),
Math.max(a[3], b[3]), Math.max(a[4], b[4]), Math.max(a[5], b[5])};
}
/**
* Situations où la mesure compensée n'est pas fiable (en plus de {@link #raisonNonMesure}, sans la vitesse
* instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées).
*
* Revue 1 (16/10) : un ping au-delà de {@link GardeConfig#seriePingMaxMs} n'exempte plus le coup (le ping est
* falsifiable) ; la fenêtre reste bornée à ce ping par {@link #ticksFenetre}.
*/
public static String raisonNonMesureSerie(EtatJoueur e, GardeConfig cfg) {
String r = raisonNonMesure(e, 0, cfg);
if (r != null) return r;
if (e.ticksDepuisGel() <= cfg.graceGelTicks) return "gel-serveur";
return null;
}
}
+62
Voir le fichier
@@ -0,0 +1,62 @@
package com.gastinelgarde.core;
/**
* Contrôle « coups-hors-boite » (#92, 16/10/2026) : sur les derniers coups mesurés, combien ont touché une cible
* que le regard ne touchait nulle part, même en tenant compte de toutes les positions où le client a pu la voir.
*
* Un joueur honnête vise ce qu'il voit : sa mesure compensée vaut 0 (aux erreurs de modèle près, rares et isolées).
* Un client « hitbox » (boîtes grossies) ou « reach » touche régulièrement à côté ou trop loin. Un coup isolé ne
* prouve rien ; une proportion soutenue, si. Tampon de taille fixe, aucune allocation.
*/
public final class SerieCoups {
public static final int TAILLE_MAX = 32;
private final long[] instants = new long[TAILLE_MAX];
private final boolean[] hors = new boolean[TAILLE_MAX];
private int taille;
private int tete;
private int dernierCompte;
private int dernierTotal;
/**
* Enregistre un coup mesuré.
*
* @return points : {@link GardeConfig#seriePoints} si ce coup est hors boîte ET qu'au moins
* {@link GardeConfig#serieHorsMin} des {@link GardeConfig#serieCoups} derniers coups (dans
* {@link GardeConfig#serieFenetreMs}) le sont aussi ; 0 sinon.
*/
public double enregistrer(long nowMs, boolean horsBoite, GardeConfig cfg) {
int n = Math.max(1, Math.min(TAILLE_MAX, cfg.serieCoups));
instants[tete] = nowMs;
hors[tete] = horsBoite;
tete = (tete + 1) % TAILLE_MAX;
if (taille < TAILLE_MAX) taille++;
int compte = 0, total = 0;
for (int k = 0; k < Math.min(n, taille); k++) {
int i = ((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX;
if (nowMs - instants[i] > cfg.serieFenetreMs || instants[i] > nowMs) break;
total++;
if (hors[i]) compte++;
}
dernierCompte = compte;
dernierTotal = total;
return horsBoite && compte >= cfg.serieHorsMin ? cfg.seriePoints : 0;
}
/** Coups hors boîte parmi les derniers comptés (pour le journal). */
public int dernierCompte() {
return dernierCompte;
}
/** Coups comptés au dernier enregistrement (pour le journal). */
public int dernierTotal() {
return dernierTotal;
}
public void vider() {
taille = 0;
tete = 0;
}
}
+27
Voir le fichier
@@ -14,11 +14,38 @@ public final class Suivi {
public final VitesseHorizontale vitesse = new VitesseHorizontale();
public final VolVertical vol = new VolVertical();
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;
/** D3 (0.3.2) : vitesse verticale du dernier paquet qui a bougé pendant une chute (0 au sol). */
double dyChute;
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
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;
+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;
}
}
+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;
+76 -1
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;
@@ -35,6 +62,7 @@ public final class VolVertical {
int n = e.ticks();
if (n > TICKS_MAX || n < 0) {
aVitesse = false;
avance = 0;
return 0;
}
boolean enAir = !e.auSolServeur();
@@ -44,27 +72,38 @@ 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)));
}
}
derniereVitesse = vitesseFin;
@@ -73,10 +112,46 @@ public final class VolVertical {
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;
}
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;
viderFenetre();
}
}
+120
Voir le fichier
@@ -0,0 +1,120 @@
package com.gastinelgarde.hub;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.regex.Pattern;
/**
* Mise en conformité des champs texte avec ce que le Hub accepte (revue de sécurité du Hub, 19/10/2026) :
* <ul>
* <li>{@code controle} et {@code dimension} : {@code ^[a-z0-9_.:-]{1,64}$} ;</li>
* <li>{@code version_mod} : {@code ^[0-9A-Za-z.+-]{1,32}$} ;</li>
* <li>exemptions : 10 au plus, chacune {@code ^[a-z0-9_.-]{1,32}$} (une seule invalide fait rejeter toute la liste
* côté Hub, d'où le nettoyage ici) ;</li>
* <li>aucune valeur qui ressemble à une adresse IP (v4, v6, ou préfixe) dans un champ texte.</li>
* </ul>
* Une valeur qui ne peut pas devenir conforme est omise : un détail en moins vaut mieux qu'une détection refusée.
*/
public final class Assainir {
public static final Pattern CONTROLE = Pattern.compile("^[a-z0-9_.:-]{1,64}$");
public static final Pattern VERSION_MOD = Pattern.compile("^[0-9A-Za-z.+-]{1,32}$");
public static final Pattern EXEMPTION = Pattern.compile("^[a-z0-9_.-]{1,32}$");
public static final Pattern TYPE_DETECTION = Pattern.compile("^[a-z0-9_-]{1,48}$");
public static final Pattern ID_EXTERNE = Pattern.compile("^[A-Za-z0-9:._-]{8,128}$");
public static final int EXEMPTIONS_MAX = 10;
// Mêmes motifs que le Hub : IPv4 isolée dans la chaîne, ou suite « hex:hex:hex » (IPv6 et préfixes).
private static final Pattern IPV4_DANS = Pattern.compile("(^|[^0-9])[0-9]{1,3}(\\.[0-9]{1,3}){3}($|[^0-9])");
private static final Pattern IPV6_DANS = Pattern.compile("[0-9A-Fa-f]{0,4}(:[0-9A-Fa-f]{0,4}){2,}");
private static final Pattern CARACTERE_NON_ADMIS = Pattern.compile("[^a-z0-9_.:-]");
private static final Pattern CARACTERE_NON_ADMIS_EXEMPTION = Pattern.compile("[^a-z0-9_.-]");
private static final Pattern CARACTERE_NON_ADMIS_VERSION = Pattern.compile("[^0-9A-Za-z.+-]");
private Assainir() { }
/** Vrai si la chaîne est, ou contient, une adresse IPv4 / IPv6 / un préfixe CIDR. */
public static boolean ressembleAdresseIp(String s) {
if (s == null) return false;
return IPV4_DANS.matcher(s).find() || IPV6_DANS.matcher(s).find();
}
/** Identifiant de contrôle conforme, ou {@code null}. */
public static String controle(String brut) {
return conforme(brut, CARACTERE_NON_ADMIS, CONTROLE, 64);
}
/** Dimension (« minecraft:overworld ») conforme : les « / » d'un chemin de dimension deviennent « _ ». */
public static String dimension(String brut) {
return conforme(brut, CARACTERE_NON_ADMIS, CONTROLE, 64);
}
/** Version du mod conforme ; « inconnue » si elle ne peut pas l'être. */
public static String versionMod(String brut) {
String v = brut == null ? "" : CARACTERE_NON_ADMIS_VERSION.matcher(brut.strip()).replaceAll("-");
if (v.length() > 32) v = v.substring(0, 32);
if (!VERSION_MOD.matcher(v).matches() || ressembleAdresseIp(v)) return "inconnue";
return v;
}
/** Liste d'exemptions conforme : 10 au plus, chacune valide, sans doublon ; les valeurs inexploitables sont ignorées. */
public static List<String> exemptions(Iterable<String> brutes) {
List<String> sortie = new ArrayList<>();
if (brutes == null) return sortie;
for (String b : brutes) {
if (sortie.size() >= EXEMPTIONS_MAX) break;
String e = conforme(b, CARACTERE_NON_ADMIS_EXEMPTION, EXEMPTION, 32);
if (e != null && !sortie.contains(e)) sortie.add(e);
}
return sortie;
}
/**
* Liste blanche des clés de {@code details} (celles que le Hub conserve), avec leur type et leurs bornes ; toute
* autre clé, ou valeur mal formée, est retirée. Sert de dernier garde-fou à la création d'une {@link Detection}
* et à la relecture de la file d'attente sur disque.
*/
public static java.util.Map<String, Object> details(java.util.Map<String, Object> brut) {
java.util.Map<String, Object> sortie = new java.util.LinkedHashMap<>();
if (brut == null) return sortie;
String c = brut.get("controle") instanceof String t ? controle(t) : null;
if (c != null) sortie.put("controle", c);
Long palier = entier(brut.get("palier"), 0, 100);
if (palier != null) sortie.put("palier", palier);
if (brut.get("exemptions") instanceof Iterable<?> it) {
List<String> l = new ArrayList<>();
for (Object o : it) if (o instanceof String t) l.add(t);
List<String> ex = exemptions(l);
if (!ex.isEmpty()) sortie.put("exemptions", ex);
}
if (brut.get("version_mod") instanceof String t && VERSION_MOD.matcher(t).matches() && !ressembleAdresseIp(t)) {
sortie.put("version_mod", t);
}
for (String k : new String[] {"x", "y", "z"}) {
Long v = entier(brut.get(k), -30_000_000L, 30_000_000L);
if (v != null) sortie.put(k, v);
}
if (brut.get("dimension") instanceof String t) {
String d = dimension(t);
if (d != null) sortie.put("dimension", d);
}
return sortie;
}
private static Long entier(Object o, long min, long max) {
if (!(o instanceof Number n)) return null;
double d = n.doubleValue();
if (Double.isNaN(d) || Double.isInfinite(d) || d != Math.rint(d)) return null;
long v = n.longValue();
return v >= min && v <= max ? v : null;
}
private static String conforme(String brut, Pattern interdits, Pattern attendu, int max) {
if (brut == null) return null;
String s = interdits.matcher(brut.strip().toLowerCase(Locale.ROOT)).replaceAll("_");
if (s.length() > max) s = s.substring(0, max);
if (s.isEmpty() || !attendu.matcher(s).matches() || ressembleAdresseIp(s)) return null;
return s;
}
}
+79
Voir le fichier
@@ -0,0 +1,79 @@
package com.gastinelgarde.hub;
import java.time.Instant;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Pattern;
/**
* Une détection prête à être envoyée au Hub (contrat : conception-hub-bloc2 §2.1). Immuable.
* Pas de champ « service » ni « source » : le Hub les déduit de la clé.
*
* @param idExterne clé d'idempotence côté Hub, 8 à 128 caractères, fixée une fois pour toutes à la création
* (une nouvelle tentative renvoie exactement le même identifiant)
* @param sujetUuid UUID Minecraft du joueur
* @param type identifiant du contrôle (liste blanche côté Hub, voir ANNEXE-HUB.md)
* @param gravite 1 à 3
* @param mode {@code observe} ou {@code enforce} (mode du contrôle au moment des faits)
* @param points points d'infraction du contrôle au franchissement du palier
* @param survenueMs instant des faits (epoch ms)
* @param details clés de la liste blanche seulement ; valeurs String, Number, Boolean ou liste de String
*/
public record Detection(String idExterne, String sujetUuid, String type, int gravite, String mode,
double points, long survenueMs, Map<String, Object> details) {
public static final int ID_MIN = 8;
public static final int ID_MAX = 128;
private static final Pattern UUID_TEXTE =
Pattern.compile("[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}");
public Detection {
if (idExterne == null || idExterne.length() < ID_MIN || idExterne.length() > ID_MAX
|| !Assainir.ID_EXTERNE.matcher(idExterne).matches()) {
throw new IllegalArgumentException("id_externe : " + ID_MIN + " à " + ID_MAX + " caractères parmi A-Z a-z 0-9 : . _ -");
}
if (sujetUuid == null || !UUID_TEXTE.matcher(sujetUuid).matches()) {
throw new IllegalArgumentException("sujet : UUID attendu");
}
if (type == null || !Assainir.TYPE_DETECTION.matcher(type).matches()) throw new IllegalArgumentException("type : [a-z0-9_-], 1 à 48");
if (gravite < 1 || gravite > 3) throw new IllegalArgumentException("gravité : 1 à 3");
if (!"observe".equals(mode) && !"enforce".equals(mode)) throw new IllegalArgumentException("mode : observe ou enforce");
if (Double.isNaN(points) || Double.isInfinite(points)) points = 0;
points = Math.max(0, Math.min(99_999, points)); // le Hub refuse hors de 0 à 99 999
details = java.util.Collections.unmodifiableMap(Assainir.details(details)); // liste blanche de clés, valeurs conformes
}
/** L'objet JSON de la détection, tel qu'envoyé dans le lot. */
public String json() {
Map<String, Object> sujet = new LinkedHashMap<>();
sujet.put("type", "uuid_minecraft");
sujet.put("valeur", sujetUuid);
Map<String, Object> m = new LinkedHashMap<>();
m.put("id_externe", idExterne);
m.put("sujet", sujet);
m.put("type", type);
m.put("gravite", gravite);
m.put("mode", mode);
m.put("points", Math.round(points * 100.0) / 100.0);
m.put("survenue_le", Instant.ofEpochSecond(Math.floorDiv(survenueMs, 1000L)).toString()); // RFC 3339, UTC
m.put("details", details);
return MiniJson.ecrire(m);
}
/** Relit une détection écrite par {@link #json()} (file d'attente sur disque). */
@SuppressWarnings("unchecked")
public static Detection depuisJson(Object racine) {
if (!(racine instanceof Map<?, ?> m)) throw new IllegalArgumentException("objet attendu");
Map<String, Object> sujet = (Map<String, Object>) m.get("sujet");
Object d = m.get("details");
return new Detection(
(String) m.get("id_externe"),
(String) sujet.get("valeur"),
(String) m.get("type"),
((Number) m.get("gravite")).intValue(),
(String) m.get("mode"),
((Number) m.get("points")).doubleValue(),
Instant.parse((String) m.get("survenue_le")).toEpochMilli(),
d instanceof Map<?, ?> dm ? (Map<String, Object>) dm : Map.of());
}
}
+341
Voir le fichier
@@ -0,0 +1,341 @@
package com.gastinelgarde.hub;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayDeque;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Consumer;
import java.util.function.LongSupplier;
/**
* Fil d'envoi vers le Hub. Tout ce qui est lent (réseau, disque, attente) se passe ici, jamais dans le tick du
* serveur : le tick ne fait qu'ajouter une détection dans {@link FileEnvoi} (sans verrou).
*
* <p>Comportement (conception-hub-bloc2 §2) :
* <ul>
* <li>lots de 1 à 50 détections et 15 000 octets au plus (le Hub refuse plus de 16 Kio) ;</li>
* <li>au plus {@code debitMaxParMinute} détections par minute (le Hub répond 429 au-delà de sa limite) ;</li>
* <li>panne réseau, 5xx, 404 : attente exponentielle de 1 s à 5 min (+ jusqu'à 25 % au hasard), le lot est
* remis en tête, l'identifiant de chaque détection ne change pas (le Hub ignore les doublons) ;</li>
* <li>429 : on attend {@code Retry-After} (au plus 5 min) ; 401 / 403 : clé refusée ou source inactive,
* on réessaie toutes les 5 min sans rien jeter (la file reste bornée) ;</li>
* <li>400 : le lot est invalide, il est abandonné (le renvoyer ne servirait à rien) ; 413 : lot divisé par deux ;</li>
* <li>réponse 200 : {@code cree} et {@code doublon} sont acquittés, {@code refuse} est abandonné.</li>
* </ul>
* La clé n'est jamais écrite dans un message. Les messages au journal sont limités (un par type et par 5 minutes).
*/
public final class EnvoiHub {
/** Limite du Hub : 16 Kio par requête ; on garde de la marge pour l'enveloppe. */
public static final int OCTETS_CORPS_MAX = 15_000;
public static final long ATTENTE_MIN_MS = 1_000;
public static final long ATTENTE_MAX_MS = 300_000;
private static final long INTERVALLE_SPOOL_MS = 30_000;
private static final long INTERVALLE_MESSAGE_MS = 300_000;
private final HubConfig cfg;
private final URI adresse;
private final String cle;
private final Transport transport;
private final FileEnvoi file;
private final Spool spool;
private final LongSupplier horloge;
private final Consumer<String> journal;
// État du fil d'envoi (modifié par ce fil seulement).
private int echecs;
private long prochainEssaiMs;
private int lotCourant;
private final ArrayDeque<Long> envoyesRecents = new ArrayDeque<>();
private long dernierSpoolMs = Long.MIN_VALUE / 2;
private final Map<String, Long> derniersMessages = new java.util.concurrent.ConcurrentHashMap<>();
private boolean enPanne;
private volatile List<Detection> enVol = List.of();
private volatile boolean arret;
private Thread fil;
// Compteurs lisibles de n'importe où.
private final AtomicLong envoyees = new AtomicLong();
private final AtomicLong doublons = new AtomicLong();
private final AtomicLong refusees = new AtomicLong();
private final AtomicLong perimees = new AtomicLong();
private final AtomicLong lotsRejetes = new AtomicLong();
private final AtomicLong echecsTotal = new AtomicLong();
public EnvoiHub(HubConfig cfg, String cle, Transport transport, FileEnvoi file, LongSupplier horloge,
Consumer<String> journal) {
this.cfg = cfg;
this.adresse = cfg.adresseApi();
if (this.adresse == null) throw new IllegalArgumentException("adresse du Hub invalide");
this.cle = cle;
this.transport = transport;
this.file = file;
this.spool = new Spool(cfg.dossierEtat().resolve("file-attente.jsonl"));
this.horloge = horloge;
this.journal = journal;
this.lotCourant = cfg.lotMax();
}
// --- Cycle de vie ---
/** Reprend la file écrite sur disque, puis lance le fil d'envoi (daemon, priorité basse). */
public synchronized void demarrer() {
if (fil != null) return;
List<Detection> reprises = spool.lire(horloge.getAsLong() - cfg.ageMaxMs());
if (!reprises.isEmpty()) {
file.ajouterTout(reprises);
journal.accept("Hub : " + reprises.size() + " détection(s) reprise(s) de la file d'attente du disque.");
}
arret = false;
fil = new Thread(this::boucle, "GastinelGarde-Hub");
fil.setDaemon(true);
fil.setPriority(Thread.MIN_PRIORITY);
fil.start();
}
/** Arrête le fil (au plus 2 s d'attente) et écrit ce qui n'est pas parti sur le disque. */
public synchronized void arreter() {
arret = true;
Thread t = fil;
fil = null;
if (t != null) {
t.interrupt();
try {
t.join(2000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
sauverSpool(true);
}
private void boucle() {
while (!arret) {
long attente;
try {
attente = cycle();
} catch (Throwable t) { // le fil ne doit jamais mourir ni rien lâcher vers le serveur
limite("bug", "Hub : erreur interne du client (" + t.getClass().getSimpleName() + "), nouvel essai dans 5 s.");
attente = 5000;
}
try {
Thread.sleep(Math.max(50, attente));
} catch (InterruptedException e) {
break;
}
}
}
// --- Un tour de boucle (public pour les tests : horloge et transport injectés) ---
/** Fait ce qu'il y a à faire maintenant et renvoie le temps à attendre avant le prochain tour (ms). */
public long cycle() {
long now = horloge.getAsLong();
int vieilles = file.purgerAvant(now - cfg.ageMaxMs());
if (vieilles > 0) {
perimees.addAndGet(vieilles);
limite("age", "Hub : " + vieilles + " détection(s) trop ancienne(s) abandonnée(s) (le Hub refuse au-delà de 24 h).");
}
if (file.vide()) {
if (spool.existe()) sauverSpool(false);
return cfg.intervalleMs();
}
if (now < prochainEssaiMs) return prochainEssaiMs - now;
while (!envoyesRecents.isEmpty() && now - envoyesRecents.peekFirst() >= 60_000) envoyesRecents.pollFirst();
int dispo = cfg.debitMaxParMinute() - envoyesRecents.size();
if (dispo <= 0) return Math.max(200, 60_000 - (now - envoyesRecents.peekFirst()));
List<Detection> lot = file.prendre(Math.min(lotCourant, dispo), OCTETS_CORPS_MAX - 64);
if (lot.isEmpty()) return cfg.intervalleMs();
enVol = lot;
try {
return envoyer(lot, now);
} finally {
enVol = List.of();
}
}
private long envoyer(List<Detection> lot, long now) {
StringBuilder corps = new StringBuilder(64 + lot.size() * 400).append("{\"detections\":[");
for (int i = 0; i < lot.size(); i++) {
if (i > 0) corps.append(',');
corps.append(lot.get(i).json());
}
corps.append("]}");
Transport.Reponse r;
try {
r = transport.envoyer(adresse, cle, corps.toString());
} catch (InterruptedException e) {
file.remettre(lot);
Thread.currentThread().interrupt();
return cfg.intervalleMs();
} catch (IOException | RuntimeException e) {
return echec(lot, now, "Hub injoignable (" + e.getClass().getSimpleName() + ")");
}
int s = r.statut();
if (s == 200) return succes(lot, r, now);
if (s == 429) {
file.remettre(lot);
long ra = r.retryAfterSec().isPresent() ? r.retryAfterSec().getAsLong() * 1000 : delaiExponentiel(++echecs);
long attente = Math.max(ATTENTE_MIN_MS, Math.min(ATTENTE_MAX_MS, ra));
prochainEssaiMs = now + attente;
echecsTotal.incrementAndGet();
limite("429", "Hub : débit limité (429), reprise dans " + attente / 1000 + " s.");
return attente;
}
if (s == 401 || s == 403) {
file.remettre(lot);
echecs++;
echecsTotal.incrementAndGet();
prochainEssaiMs = now + ATTENTE_MAX_MS;
limite("auth" + s, s == 401
? "Hub : clé refusée (401). Vérifier le fichier de clé ; on réessaie dans 5 min."
: "Hub : source désactivée côté Hub (403). Elle doit être activée dans le Portail ; on réessaie dans 5 min.");
sauverSpoolSiBesoin(now);
return ATTENTE_MAX_MS;
}
if (s == 400) {
lotsRejetes.incrementAndGet();
perimees.addAndGet(lot.size());
limite("400", "Hub : lot de " + lot.size() + " détection(s) refusé comme invalide (400), abandonné.");
return 200;
}
if (s == 413) {
if (lot.size() > 1) {
lotCourant = Math.max(1, lot.size() / 2);
file.remettre(lot);
limite("413", "Hub : lot trop gros (413), lots réduits à " + lotCourant + ".");
} else {
lotsRejetes.incrementAndGet();
perimees.addAndGet(1);
limite("413", "Hub : une détection est trop grosse (413), abandonnée.");
}
return 200;
}
return echec(lot, now, "Hub : réponse inattendue (HTTP " + s + ")");
}
private long succes(List<Detection> lot, Transport.Reponse r, long now) {
ReponseHub rh = ReponseHub.analyser(r.corps());
envoyees.addAndGet(lot.size());
if (rh.lue()) {
doublons.addAndGet(rh.doublons());
refusees.addAndGet(rh.refusees());
if (rh.refusees() > 0) {
limite("refus", "Hub : " + rh.refusees() + " détection(s) refusée(s) par le Hub : " + rh.codesRefus()
+ " (abandonnées, à corriger côté réglages du Hub).");
}
}
for (int i = 0; i < lot.size(); i++) envoyesRecents.addLast(now);
if (enPanne) {
journal.accept("Hub : liaison rétablie, " + lot.size() + " détection(s) envoyée(s).");
enPanne = false;
}
echecs = 0;
prochainEssaiMs = 0;
lotCourant = cfg.lotMax();
derniersMessages.clear(); // un futur incident sera de nouveau signalé tout de suite
if (file.vide()) sauverSpool(false);
return file.vide() ? cfg.intervalleMs() : 200;
}
private long echec(List<Detection> lot, long now, String raison) {
file.remettre(lot);
echecs++;
echecsTotal.incrementAndGet();
long base = delaiExponentiel(echecs);
long attente = base + ThreadLocalRandom.current().nextLong(base / 4 + 1);
prochainEssaiMs = now + attente;
enPanne = true;
limite("reseau", raison + ", nouvel essai dans " + attente / 1000 + " s, " + (file.taille()) + " en attente.");
sauverSpoolSiBesoin(now);
return attente;
}
static long delaiExponentiel(int echecs) {
int puissance = Math.min(Math.max(echecs - 1, 0), 20);
return Math.min(ATTENTE_MAX_MS, ATTENTE_MIN_MS << puissance);
}
// --- Disque ---
private void sauverSpoolSiBesoin(long now) {
if (now - dernierSpoolMs >= INTERVALLE_SPOOL_MS) {
dernierSpoolMs = now;
sauverSpool(false);
}
}
/** Écrit (ou efface, si plus rien) la copie sur disque. {@code arret} : inclut le lot en vol. */
private void sauverSpool(boolean arret) {
try {
List<Detection> l = file.instantane();
if (arret) {
List<Detection> v = enVol;
if (!v.isEmpty()) {
java.util.ArrayList<Detection> tout = new java.util.ArrayList<>(v);
tout.addAll(l);
l = tout;
}
}
spool.ecrire(l);
} catch (IOException | RuntimeException e) {
limite("disque", "Hub : écriture de la file d'attente impossible (" + e.getClass().getSimpleName() + ").");
}
}
// --- Journal limité ---
private void limite(String type, String message) {
long now = horloge.getAsLong();
Long dernier = derniersMessages.get(type);
if (dernier != null && now - dernier < INTERVALLE_MESSAGE_MS) return;
derniersMessages.put(type, now);
journal.accept(message);
}
// --- État ---
public String resume() {
long attente = Math.max(0, prochainEssaiMs - horloge.getAsLong());
return "Hub : " + file.taille() + " en attente, " + envoyees.get() + " envoyée(s) (" + doublons.get() + " doublons, "
+ refusees.get() + " refusées), " + perimees.get() + " périmées, " + file.abandonnees() + " perdues (file pleine), "
+ echecs + " échec(s) de suite"
+ (attente > 0 ? ", prochain essai dans " + attente / 1000 + " s" : "");
}
public long envoyees() {
return envoyees.get();
}
public long refusees() {
return refusees.get();
}
public long doublons() {
return doublons.get();
}
public long perimees() {
return perimees.get();
}
public long lotsRejetes() {
return lotsRejetes.get();
}
public int echecsDeSuite() {
return echecs;
}
public FileEnvoi file() {
return file;
}
}
+110
Voir le fichier
@@ -0,0 +1,110 @@
package com.gastinelgarde.hub;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
/**
* File d'attente bornée des détections à envoyer. Sans verrou : {@link #ajouter} ne bloque jamais, même si le fil
* d'envoi est occupé ou bloqué sur le réseau (le tick serveur n'attend rien ici). Pleine, elle abandonne les plus
* anciennes (les récentes comptent le plus) et le compte.
*/
public final class FileEnvoi {
private final ConcurrentLinkedDeque<Detection> file = new ConcurrentLinkedDeque<>();
private final AtomicInteger taille = new AtomicInteger();
private final AtomicLong abandonnees = new AtomicLong();
private volatile int max;
public FileEnvoi(int max) {
this.max = Math.max(10, max);
}
public void definirMax(int max) {
this.max = Math.max(10, max);
}
/** Ajoute une détection (ne bloque jamais). Renvoie vrai si une plus ancienne a dû être abandonnée. */
public boolean ajouter(Detection d) {
file.addLast(d);
boolean abandon = false;
if (taille.incrementAndGet() > max) {
if (file.pollFirst() != null) {
taille.decrementAndGet();
abandonnees.incrementAndGet();
abandon = true;
}
}
return abandon;
}
/**
* Retire au plus {@code n} détections, et au plus {@code octetsMax} octets de JSON (une détection au moins).
* Fil d'envoi seulement.
*/
public List<Detection> prendre(int n, int octetsMax) {
List<Detection> lot = new ArrayList<>(Math.min(n, 64));
int octets = 0;
while (lot.size() < n) {
Detection d = file.pollFirst();
if (d == null) break;
taille.decrementAndGet();
int t = d.json().getBytes(StandardCharsets.UTF_8).length + 1;
if (!lot.isEmpty() && octets + t > octetsMax) {
file.addFirst(d);
taille.incrementAndGet();
break;
}
lot.add(d);
octets += t;
}
return lot;
}
/** Remet un lot non envoyé en tête, dans son ordre d'origine. */
public void remettre(List<Detection> lot) {
for (int i = lot.size() - 1; i >= 0; i--) {
file.addFirst(lot.get(i));
taille.incrementAndGet();
}
}
/** Retire les détections survenues avant {@code limiteMs}. Renvoie leur nombre. */
public int purgerAvant(long limiteMs) {
int n = 0;
for (Iterator<Detection> it = file.iterator(); it.hasNext();) {
Detection d = it.next();
if (d.survenueMs() < limiteMs) {
it.remove();
taille.decrementAndGet();
n++;
}
}
return n;
}
public void ajouterTout(Collection<Detection> l) {
for (Detection d : l) ajouter(d);
}
public List<Detection> instantane() {
return new ArrayList<>(file);
}
public int taille() {
return Math.max(0, taille.get());
}
public boolean vide() {
return file.isEmpty();
}
public long abandonnees() {
return abandonnees.get();
}
}
+72
Voir le fichier
@@ -0,0 +1,72 @@
package com.gastinelgarde.hub;
import com.gastinelgarde.core.Sanction;
import java.net.URI;
import java.nio.file.Path;
/**
* Réglages du signalement au Hub. Valeurs par défaut : tout est coupé ({@code envoi = false}) ; rien ne part tant
* que Théo n'a pas activé, renseigné l'adresse et posé le fichier de clé.
*
* @param envoi interrupteur général (défaut : false)
* @param url adresse de base du Hub (réseau Docker interne), sans le chemin ; vide = pas d'envoi
* @param fichierCle fichier qui contient la clé de la source (jamais dans le fichier de réglages)
* @param envoyerObserve envoyer aussi les contrôles en OBSERVE (marqués {@code observe}, jamais comptés par le Hub)
* @param palierMin plus petit palier envoyé : ALERTE, SETBACK ou EXPULSION
* @param lotMax détections par requête (le Hub accepte 1 à 50)
* @param intervalleMs attente entre deux envois quand tout va bien
* @param fileMax détections gardées au plus ; au-delà, les plus anciennes sont abandonnées
* @param ageMaxMs âge au-delà duquel une détection n'est plus envoyée (le Hub refuse plus de 24 h)
* @param debitMaxParMinute détections envoyées au plus par minute (le Hub limite à 60 par défaut)
* @param episodeMs durée pendant laquelle un même palier d'un même contrôle n'est signalé qu'une fois
* @param delaiConnexionMs délai de connexion
* @param delaiRequeteMs délai total d'une requête
* @param coordonnees joindre la position arrondie au bloc et la dimension
* @param dossierEtat dossier de la file d'attente sur disque
*/
public record HubConfig(boolean envoi, String url, Path fichierCle, boolean envoyerObserve, Sanction palierMin,
int lotMax, long intervalleMs, int fileMax, long ageMaxMs, int debitMaxParMinute,
long episodeMs, int delaiConnexionMs, int delaiRequeteMs, boolean coordonnees,
Path dossierEtat) {
public static final String CHEMIN_API = "/internal/detections";
public static final long AGE_MAX_API_MS = 24L * 3600_000L;
public HubConfig {
if (palierMin == null || palierMin.ordinal() < Sanction.ALERTE.ordinal()) palierMin = Sanction.ALERTE;
lotMax = Math.max(1, Math.min(50, lotMax));
intervalleMs = Math.max(200, intervalleMs);
fileMax = Math.max(10, fileMax);
// le Hub refuse toute détection de plus de 24 h : inutile d'en garder (ni d'en renvoyer) plus longtemps
ageMaxMs = Math.max(60_000L, Math.min(ageMaxMs, AGE_MAX_API_MS - 3600_000L));
debitMaxParMinute = Math.max(1, debitMaxParMinute);
episodeMs = Math.max(1000, episodeMs);
delaiConnexionMs = Math.max(200, delaiConnexionMs);
delaiRequeteMs = Math.max(500, delaiRequeteMs);
url = url == null ? "" : url.trim();
}
/** Tout coupé. */
public static HubConfig defaut(Path dossierEtat) {
return new HubConfig(false, "", Path.of("config", "gastinelgarde-hub.key"), false, Sanction.ALERTE,
50, 2000, 10_000, 23L * 3600_000L, 50, 600_000L, 3000, 5000, true, dossierEtat);
}
/**
* Adresse complète de l'API, ou {@code null} si l'adresse de base est absente ou refusée (http/https seulement,
* pas d'identifiants dans l'adresse, ni paramètre, ni fragment).
*/
public URI adresseApi() {
if (url.isEmpty()) return null;
try {
URI u = URI.create(url);
String s = u.getScheme();
if (s == null || !(s.equalsIgnoreCase("http") || s.equalsIgnoreCase("https"))) return null;
if (u.getHost() == null || u.getUserInfo() != null || u.getRawQuery() != null || u.getRawFragment() != null) return null;
String base = url.endsWith("/") ? url.substring(0, url.length() - 1) : url;
return URI.create(base + CHEMIN_API);
} catch (IllegalArgumentException e) {
return null;
}
}
}
+105
Voir le fichier
@@ -0,0 +1,105 @@
package com.gastinelgarde.hub;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.PosixFilePermission;
import java.util.List;
import java.util.Set;
/**
* Lit la clé de la source dans son fichier (une ligne ; les lignes vides et celles qui commencent par # sont
* ignorées). La clé n'est jamais dans le fichier de réglages, jamais dans le code, jamais dans un message :
* les erreurs ci-dessous ne contiennent que le CHEMIN du fichier et une raison générale.
*/
public final class LecteurCle {
/** Le Hub exige au moins 32 caractères (modèle de relaykey.go). */
public static final int LONGUEUR_MIN = 32;
public static final int LONGUEUR_MAX = 256;
public enum Raison { OK, ABSENTE, ILLISIBLE, VIDE, TROP_COURTE, TROP_LONGUE, CARACTERES_INVALIDES }
/** La clé n'apparaît pas dans {@link #toString()}. */
public static final class Resultat {
private final Raison raison;
private final String cle;
private final boolean droitsTropLarges;
Resultat(Raison raison, String cle, boolean droitsTropLarges) {
this.raison = raison;
this.cle = cle;
this.droitsTropLarges = droitsTropLarges;
}
public Raison raison() {
return raison;
}
public boolean ok() {
return raison == Raison.OK;
}
/** La clé (seulement si {@link #ok()}), à passer au transport et nulle part ailleurs. */
public String cle() {
return cle;
}
/** Vrai si le fichier est lisible par le groupe ou les autres (système POSIX seulement). */
public boolean droitsTropLarges() {
return droitsTropLarges;
}
@Override
public String toString() {
return "Resultat[" + raison + "]";
}
}
private LecteurCle() { }
public static Resultat lire(Path fichier) {
if (fichier == null || !Files.isRegularFile(fichier)) return new Resultat(Raison.ABSENTE, null, false);
boolean large = false;
try {
Set<PosixFilePermission> p = Files.getPosixFilePermissions(fichier);
large = p.contains(PosixFilePermission.GROUP_READ) || p.contains(PosixFilePermission.OTHERS_READ)
|| p.contains(PosixFilePermission.GROUP_WRITE) || p.contains(PosixFilePermission.OTHERS_WRITE);
} catch (UnsupportedOperationException | IOException e) {
// pas de droits POSIX (Windows) : rien à signaler
}
List<String> lignes;
try {
if (Files.size(fichier) > 4096) return new Resultat(Raison.TROP_LONGUE, null, large);
lignes = Files.readAllLines(fichier, StandardCharsets.UTF_8);
} catch (IOException | RuntimeException e) {
return new Resultat(Raison.ILLISIBLE, null, large);
}
for (String l : lignes) {
String t = l.strip();
if (t.isEmpty() || t.startsWith("#")) continue;
if (t.length() < LONGUEUR_MIN) return new Resultat(Raison.TROP_COURTE, null, large);
if (t.length() > LONGUEUR_MAX) return new Resultat(Raison.TROP_LONGUE, null, large);
for (int i = 0; i < t.length(); i++) {
char c = t.charAt(i);
if (c < 0x21 || c > 0x7e) return new Resultat(Raison.CARACTERES_INVALIDES, null, large); // pas d'espace ni d'en-tête piégé
}
return new Resultat(Raison.OK, t, large);
}
return new Resultat(Raison.VIDE, null, large);
}
/** Phrase à mettre dans le journal : le chemin et la raison, jamais le contenu. */
public static String message(Path fichier, Raison r) {
return switch (r) {
case OK -> "clé lue";
case ABSENTE -> "fichier de clé absent : " + fichier;
case ILLISIBLE -> "fichier de clé illisible : " + fichier;
case VIDE -> "fichier de clé vide : " + fichier;
case TROP_COURTE -> "clé trop courte dans " + fichier + " (au moins " + LONGUEUR_MIN + " caractères)";
case TROP_LONGUE -> "clé trop longue dans " + fichier;
case CARACTERES_INVALIDES -> "clé avec des caractères non admis dans " + fichier;
};
}
}
+235
Voir le fichier
@@ -0,0 +1,235 @@
package com.gastinelgarde.hub;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* JSON minimal, sans dépendance (le cœur du client Hub reste du Java pur, testable sans Minecraft).
* Écriture : Map, List, String, Number, Boolean, null. Lecture : tout JSON valide, borné en taille et en profondeur
* (la réponse du Hub vient du réseau : on ne la croit pas).
*/
public final class MiniJson {
private static final int PROFONDEUR_MAX = 32;
private static final int TAILLE_MAX = 1 << 20;
private MiniJson() { }
// --- Écriture ---
public static String ecrire(Object o) {
StringBuilder sb = new StringBuilder(128);
ecrire(sb, o);
return sb.toString();
}
private static void ecrire(StringBuilder sb, Object o) {
if (o == null) {
sb.append("null");
} else if (o instanceof String s) {
chaine(sb, s);
} else if (o instanceof Boolean b) {
sb.append(b ? "true" : "false");
} else if (o instanceof Double || o instanceof Float) {
double d = ((Number) o).doubleValue();
if (Double.isNaN(d) || Double.isInfinite(d)) sb.append("null");
else sb.append(java.math.BigDecimal.valueOf(d).stripTrailingZeros().toPlainString());
} else if (o instanceof Number n) {
sb.append(n.toString());
} else if (o instanceof Map<?, ?> m) {
sb.append('{');
boolean premier = true;
for (Map.Entry<?, ?> e : m.entrySet()) {
if (!premier) sb.append(',');
premier = false;
chaine(sb, String.valueOf(e.getKey()));
sb.append(':');
ecrire(sb, e.getValue());
}
sb.append('}');
} else if (o instanceof Iterable<?> it) {
sb.append('[');
boolean premier = true;
for (Object x : it) {
if (!premier) sb.append(',');
premier = false;
ecrire(sb, x);
}
sb.append(']');
} else {
chaine(sb, o.toString());
}
}
private static void chaine(StringBuilder sb, String s) {
sb.append('"');
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
switch (c) {
case '"' -> sb.append("\\\"");
case '\\' -> sb.append("\\\\");
case '\n' -> sb.append("\\n");
case '\r' -> sb.append("\\r");
case '\t' -> sb.append("\\t");
case '\b' -> sb.append("\\b");
case '\f' -> sb.append("\\f");
default -> {
if (c < 0x20 || c == 0x2028 || c == 0x2029) sb.append(String.format("\\u%04x", (int) c));
else sb.append(c);
}
}
}
sb.append('"');
}
// --- Lecture ---
/** Analyse un JSON complet. Lève {@link IllegalArgumentException} si invalide, trop gros ou trop profond. */
public static Object lire(String texte) {
if (texte == null) throw new IllegalArgumentException("texte absent");
if (texte.length() > TAILLE_MAX) throw new IllegalArgumentException("JSON trop gros");
Lecteur l = new Lecteur(texte);
l.espaces();
Object v = l.valeur(0);
l.espaces();
if (l.i != texte.length()) throw new IllegalArgumentException("texte après la valeur JSON");
return v;
}
private static final class Lecteur {
final String t;
int i;
Lecteur(String t) {
this.t = t;
}
void espaces() {
while (i < t.length()) {
char c = t.charAt(i);
if (c == ' ' || c == '\n' || c == '\r' || c == '\t') i++;
else break;
}
}
IllegalArgumentException erreur(String m) {
return new IllegalArgumentException(m + " (position " + i + ")");
}
Object valeur(int prof) {
if (prof > PROFONDEUR_MAX) throw erreur("JSON trop profond");
if (i >= t.length()) throw erreur("fin inattendue");
char c = t.charAt(i);
switch (c) {
case '{': return objet(prof);
case '[': return tableau(prof);
case '"': return chaine();
case 't': mot("true"); return Boolean.TRUE;
case 'f': mot("false"); return Boolean.FALSE;
case 'n': mot("null"); return null;
default: return nombre();
}
}
void mot(String m) {
if (!t.startsWith(m, i)) throw erreur("valeur inconnue");
i += m.length();
}
Map<String, Object> objet(int prof) {
Map<String, Object> m = new LinkedHashMap<>();
i++;
espaces();
if (i < t.length() && t.charAt(i) == '}') {
i++;
return m;
}
while (true) {
espaces();
if (i >= t.length() || t.charAt(i) != '"') throw erreur("clé attendue");
String k = chaine();
espaces();
if (i >= t.length() || t.charAt(i) != ':') throw erreur("':' attendu");
i++;
espaces();
m.put(k, valeur(prof + 1));
espaces();
if (i >= t.length()) throw erreur("fin inattendue");
char c = t.charAt(i++);
if (c == '}') return m;
if (c != ',') throw erreur("',' ou '}' attendu");
}
}
List<Object> tableau(int prof) {
List<Object> l = new ArrayList<>();
i++;
espaces();
if (i < t.length() && t.charAt(i) == ']') {
i++;
return l;
}
while (true) {
espaces();
l.add(valeur(prof + 1));
espaces();
if (i >= t.length()) throw erreur("fin inattendue");
char c = t.charAt(i++);
if (c == ']') return l;
if (c != ',') throw erreur("',' ou ']' attendu");
}
}
String chaine() {
StringBuilder sb = new StringBuilder();
i++; // guillemet ouvrant
while (true) {
if (i >= t.length()) throw erreur("chaîne non terminée");
char c = t.charAt(i++);
if (c == '"') return sb.toString();
if (c < 0x20) throw erreur("caractère de contrôle dans une chaîne");
if (c != '\\') {
sb.append(c);
continue;
}
if (i >= t.length()) throw erreur("échappement incomplet");
char e = t.charAt(i++);
switch (e) {
case '"' -> sb.append('"');
case '\\' -> sb.append('\\');
case '/' -> sb.append('/');
case 'b' -> sb.append('\b');
case 'f' -> sb.append('\f');
case 'n' -> sb.append('\n');
case 'r' -> sb.append('\r');
case 't' -> sb.append('\t');
case 'u' -> {
if (i + 4 > t.length()) throw erreur("\\u incomplet");
try {
sb.append((char) Integer.parseInt(t.substring(i, i + 4), 16));
} catch (NumberFormatException ex) {
throw erreur("\\u invalide");
}
i += 4;
}
default -> throw erreur("échappement inconnu");
}
}
}
Number nombre() {
int debut = i;
while (i < t.length() && "+-0123456789.eE".indexOf(t.charAt(i)) >= 0) i++;
if (debut == i) throw erreur("valeur inattendue");
String s = t.substring(debut, i);
try {
if (s.indexOf('.') < 0 && s.indexOf('e') < 0 && s.indexOf('E') < 0) return Long.parseLong(s);
return Double.parseDouble(s);
} catch (NumberFormatException ex) {
throw erreur("nombre invalide");
}
}
}
}
+71
Voir le fichier
@@ -0,0 +1,71 @@
package com.gastinelgarde.hub;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/**
* Lecture de la réponse 200 du Hub : un résultat par détection (conception §2.3 : {@code cree}, {@code doublon},
* {@code refuse} + code). Le format exact du tableau n'est pas figé dans la conception ; on accepte donc un tableau
* à la racine ou un objet qui contient un tableau, et le statut sous plusieurs noms de champ. Une réponse 200
* illisible est tenue pour acceptée (HTTP 200 = lot pris en compte), jamais pour une raison de renvoyer.
*/
public record ReponseHub(int creees, int doublons, int refusees, Map<String, Integer> codesRefus, boolean lue) {
private static final String[] CLES_TABLEAU = {"resultats", "resultat", "results", "detections", "items"};
private static final String[] CLES_STATUT = {"statut", "status", "resultat", "etat", "result"};
private static final String[] CLES_CODE = {"code", "raison", "motif", "reason"};
public static ReponseHub analyser(String corps) {
try {
Object racine = MiniJson.lire(corps);
List<?> liste = null;
if (racine instanceof List<?> l) {
liste = l;
} else if (racine instanceof Map<?, ?> m) {
for (String k : CLES_TABLEAU) {
if (m.get(k) instanceof List<?> l) {
liste = l;
break;
}
}
}
if (liste == null) return new ReponseHub(0, 0, 0, Map.of(), false);
int c = 0;
int d = 0;
int r = 0;
Map<String, Integer> codes = new TreeMap<>();
for (Object o : liste) {
if (!(o instanceof Map<?, ?> m)) continue;
String statut = premier(m, CLES_STATUT);
if (statut == null) continue;
switch (statut.toLowerCase(java.util.Locale.ROOT)) {
case "cree", "created" -> c++;
case "doublon", "duplicate" -> d++;
case "refuse", "rejected" -> {
r++;
String code = premier(m, CLES_CODE);
codes.merge(code == null ? "inconnu" : borner(code), 1, Integer::sum);
}
default -> { }
}
}
return new ReponseHub(c, d, r, codes, true);
} catch (RuntimeException e) {
return new ReponseHub(0, 0, 0, Map.of(), false);
}
}
private static String premier(Map<?, ?> m, String[] cles) {
for (String k : cles) {
if (m.get(k) instanceof String s) return s;
}
return null;
}
/** Le code vient du réseau et finit dans un journal : court et sans retour à la ligne. */
private static String borner(String s) {
String t = s.length() > 40 ? s.substring(0, 40) : s;
return t.replaceAll("[^A-Za-z0-9_.-]", "?");
}
}
+214
Voir le fichier
@@ -0,0 +1,214 @@
package com.gastinelgarde.hub;
import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Verdict;
import java.net.URI;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.function.LongSupplier;
import java.util.function.Supplier;
/**
* Point d'entrée du signalement au Hub, appelé par GastinelGarde. Désactivé par défaut : tant que
* {@link #demarrer} n'a pas créé d'instance, {@link #surVerdict} ne fait qu'une lecture de variable.
*
* <p>Ce que le tick serveur paie quand c'est actif : une comparaison de palier (verrou très court) et, seulement
* à un franchissement, la construction d'une petite détection et un ajout sans verrou dans {@link FileEnvoi}.
* Aucune entrée-sortie, aucune attente, aucune exception ne remonte.
*/
public final class Signalement {
/** Position du joueur au moment des faits (fournie à la demande, seulement à un franchissement). */
public record Position(int x, int y, int z, String dimension) { }
private static volatile Signalement instance;
private final HubConfig cfg;
private final SuiviPaliers suivi;
private final FileEnvoi file;
private final EnvoiHub envoi;
private final String versionMod;
private final LongSupplier horloge;
private final Consumer<String> journal;
private volatile long dernierMessageBugMs;
private Signalement(HubConfig cfg, SuiviPaliers suivi, FileEnvoi file, EnvoiHub envoi, String versionMod,
LongSupplier horloge, Consumer<String> journal) {
this.cfg = cfg;
this.suivi = suivi;
this.file = file;
this.envoi = envoi;
this.versionMod = versionMod;
this.horloge = horloge;
this.journal = journal;
}
// --- Cycle de vie ---
public static boolean actif() {
return instance != null;
}
/**
* (Re)démarre le signalement selon ces réglages. Ne démarre RIEN (et le dit au journal) si l'envoi est coupé, si
* l'adresse est absente ou refusée, ou si la clé est absente, illisible ou trop courte. Peut être rappelé à chaque
* rechargement de la configuration : l'instance précédente est arrêtée et sa file écrite sur disque d'abord.
*/
public static synchronized void demarrer(HubConfig cfg, Path fichierCle, Transport transport, LongSupplier horloge,
Consumer<String> journal, String versionMod) {
arreter();
if (!cfg.envoi()) {
journal.accept("Hub : envoi des détections désactivé (hub.envoi = false).");
return;
}
URI api = cfg.adresseApi();
if (api == null) {
journal.accept("Hub : adresse absente ou refusée (http/https sans identifiants), envoi désactivé.");
return;
}
LecteurCle.Resultat k = LecteurCle.lire(fichierCle);
if (!k.ok()) {
journal.accept("Hub : " + LecteurCle.message(fichierCle, k.raison()) + ". Envoi désactivé.");
return;
}
if (k.droitsTropLarges()) {
journal.accept("Hub : ATTENTION, le fichier de clé est lisible par d'autres comptes : " + fichierCle
+ " (le protéger, par exemple chmod 600).");
}
FileEnvoi file = new FileEnvoi(cfg.fileMax());
EnvoiHub envoi = new EnvoiHub(cfg, k.cle(), transport, file, horloge, journal);
Signalement s = new Signalement(cfg, new SuiviPaliers(cfg.episodeMs(), cfg.palierMin()), file, envoi,
Assainir.versionMod(versionMod),
horloge, journal);
envoi.demarrer();
instance = s;
journal.accept("Hub : envoi des détections actif vers " + api.getScheme() + "://" + api.getHost()
+ (api.getPort() > 0 ? ":" + api.getPort() : "") + " (palier minimum " + cfg.palierMin()
+ (cfg.envoyerObserve() ? ", contrôles en OBSERVE inclus" : ", contrôles en ENFORCE seulement") + ").");
}
/** Réglages de production : transport HTTP du JDK, horloge système. */
public static void demarrer(HubConfig cfg, Path fichierCle, Consumer<String> journal, String versionMod) {
String version = Assainir.versionMod(versionMod); // sert aussi d'en-tête User-Agent : jamais de caractère piégé
demarrer(cfg, fichierCle, new Transport.Http(cfg.delaiConnexionMs(), cfg.delaiRequeteMs(), version),
System::currentTimeMillis, journal, version);
}
public static synchronized void arreter() {
Signalement s = instance;
instance = null;
if (s != null) s.envoi.arreter();
}
// --- Appel depuis GastinelGarde ---
/**
* Examine un verdict. Si c'est un franchissement de palier à signaler, met une détection en file. Ne bloque
* jamais, ne lève jamais d'exception.
*
* @param position fournie à la demande (appelée seulement si une détection est créée, et seulement si le
* réglage « coordonnées » est actif)
*/
public static void surVerdict(UUID joueur, Verdict v, Supplier<Position> position) {
Signalement s = instance;
if (s == null) return;
try {
s.examiner(joueur, v, position);
} catch (Throwable t) {
long now = System.currentTimeMillis();
if (now - s.dernierMessageBugMs > 300_000) {
s.dernierMessageBugMs = now;
s.journal.accept("Hub : erreur lors du signalement (" + t.getClass().getSimpleName() + "), ignorée.");
}
}
}
public static void joueurParti(UUID joueur) {
Signalement s = instance;
if (s != null) s.suivi.oublier(joueur);
}
public static String resume() {
Signalement s = instance;
return s == null ? "Hub : envoi désactivé." : s.envoi.resume();
}
// --- Interne ---
private void examiner(UUID joueur, Verdict v, Supplier<Position> position) {
if (v.mode() == Mode.OFF) return;
boolean observe = v.mode() == Mode.OBSERVE;
if (observe && !cfg.envoyerObserve()) return;
// ENFORCE : la sanction réellement appliquée ; OBSERVE : le palier mérité (rien n'est appliqué, c'est une information)
Sanction palier = observe ? v.palier() : v.applicable();
int gravite = gravite(palier);
if (gravite == 0) return;
String controle = Assainir.controle(v.controle().id());
if (controle == null) return; // identifiant de contrôle inexploitable : pas de signalement plutôt qu'un refus du Hub
long now = horloge.getAsLong();
if (!suivi.franchit(joueur, v.controle(), palier, now)) return;
Map<String, Object> details = new LinkedHashMap<>();
details.put("controle", controle);
details.put("palier", numeroPalier(palier));
List<String> ex = Assainir.exemptions(v.exemptions());
if (!ex.isEmpty()) details.put("exemptions", ex);
details.put("version_mod", versionMod);
if (cfg.coordonnees() && position != null) {
Position p = position.get();
if (p != null) {
details.put("x", p.x());
details.put("y", p.y());
details.put("z", p.z());
String dim = Assainir.dimension(p.dimension());
if (dim != null) details.put("dimension", dim);
}
}
String id = joueur + ":" + controle + ":" + palier.name().toLowerCase(java.util.Locale.ROOT) + ":" + now;
file.ajouter(new Detection(id, joueur.toString(), controle, gravite,
observe ? "observe" : "enforce", v.vl(), now, details));
}
/** Numéro envoyé dans {@code details.palier} (entier, 0 à 100 côté Hub) : rang de la sanction, ALERTE = 2 … EXPULSION = 4. */
static int numeroPalier(Sanction palier) {
return palier == null ? 0 : palier.ordinal();
}
/** ALERTE = 1, SETBACK = 2, EXPULSION = 3 ; les autres paliers ne sont pas signalés. */
static int gravite(Sanction palier) {
if (palier == null) return 0;
return switch (palier) {
case ALERTE -> 1;
case SETBACK -> 2;
case EXPULSION -> 3;
default -> 0;
};
}
/** Pour les tests. */
static Signalement instanceCourante() {
return instance;
}
EnvoiHub envoi() {
return envoi;
}
FileEnvoi file() {
return file;
}
/** Pour les tests : les 15 contrôles que le Hub doit accepter comme types. */
public static List<String> typesAttendus() {
List<String> l = new ArrayList<>();
for (Controle c : Controle.values()) l.add(c.id());
return l;
}
}
+75
Voir le fichier
@@ -0,0 +1,75 @@
package com.gastinelgarde.hub;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.List;
/**
* Copie sur disque de la file d'attente (une détection par ligne, au format de l'API). Écrite par le fil d'envoi
* seulement (jamais par le tick) quand le Hub ne répond pas et à l'arrêt du serveur ; relue au démarrage. Contient
* des UUID de joueurs et des positions : donnée personnelle, d'où l'âge maximal et l'effacement dès que tout est
* accusé. Ne contient jamais la clé.
*/
public final class Spool {
private final Path fichier;
public Spool(Path fichier) {
this.fichier = fichier;
}
public Path fichier() {
return fichier;
}
/** Remplace le contenu par ces détections (écriture atomique) ; liste vide = fichier supprimé. */
public void ecrire(List<Detection> l) throws IOException {
if (l.isEmpty()) {
supprimer();
return;
}
Files.createDirectories(fichier.toAbsolutePath().getParent());
Path tmp = fichier.resolveSibling(fichier.getFileName() + ".tmp");
StringBuilder sb = new StringBuilder();
for (Detection d : l) sb.append(d.json()).append('\n');
Files.writeString(tmp, sb.toString(), StandardCharsets.UTF_8);
try {
Files.move(tmp, fichier, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);
} catch (java.nio.file.AtomicMoveNotSupportedException e) {
Files.move(tmp, fichier, StandardCopyOption.REPLACE_EXISTING);
}
}
/** Relit les détections valides plus récentes que {@code limiteMs} ; les lignes illisibles sont ignorées. */
public List<Detection> lire(long limiteMs) {
List<Detection> sortie = new ArrayList<>();
if (!Files.isRegularFile(fichier)) return sortie;
try {
for (String ligne : Files.readAllLines(fichier, StandardCharsets.UTF_8)) {
if (ligne.isBlank()) continue;
try {
Detection d = Detection.depuisJson(MiniJson.lire(ligne));
if (d.survenueMs() >= limiteMs) sortie.add(d);
} catch (RuntimeException ignoree) {
// ligne abîmée (coupure pendant l'écriture) : on continue avec les suivantes
}
}
} catch (IOException e) {
// fichier illisible : on repart d'une file vide
}
return sortie;
}
public void supprimer() throws IOException {
Files.deleteIfExists(fichier);
Files.deleteIfExists(fichier.resolveSibling(fichier.getFileName() + ".tmp"));
}
public boolean existe() {
return Files.exists(fichier);
}
}
+78
Voir le fichier
@@ -0,0 +1,78 @@
package com.gastinelgarde.hub;
import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.Sanction;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.UUID;
/**
* Décide si un verdict est un « franchissement de palier » à signaler au Hub : le Hub ne reçoit pas chaque
* infraction (conception §0), seulement le moment où un joueur atteint, pour un contrôle donné, un palier plus
* élevé que celui déjà signalé pendant l'épisode en cours.
*
* Un épisode dure {@code episodeMs} depuis le premier signalement ; ensuite la mémoire s'efface. Ainsi un joueur
* qui enchaîne les setbacks produit au plus 3 signalements (alerte, setback, expulsion) par contrôle et par épisode,
* et non un par infraction.
*/
public final class SuiviPaliers {
private record Cle(UUID joueur, Controle controle) { }
private static final class Episode {
Sanction signale;
long debutMs;
}
private static final int ENTREES_MAX = 4096;
private final long episodeMs;
private final Sanction palierMin;
private final Map<Cle, Episode> episodes = new HashMap<>();
public SuiviPaliers(long episodeMs, Sanction palierMin) {
this.episodeMs = episodeMs;
this.palierMin = palierMin;
}
/** Vrai si ce verdict doit être signalé ; enregistre alors le palier signalé. Thread-safe. */
public synchronized boolean franchit(UUID joueur, Controle controle, Sanction palier, long nowMs) {
if (palier == null || palier.ordinal() < palierMin.ordinal()) return false;
Cle cle = new Cle(joueur, controle);
Episode e = episodes.get(cle);
if (e != null && nowMs - e.debutMs > episodeMs) {
episodes.remove(cle);
e = null;
}
if (e == null) {
if (episodes.size() >= ENTREES_MAX) nettoyer(nowMs);
e = new Episode();
e.signale = palier;
e.debutMs = nowMs;
episodes.put(cle, e);
return true;
}
if (palier.ordinal() > e.signale.ordinal()) {
e.signale = palier;
return true;
}
return false;
}
/** Oublie un joueur (déconnexion). */
public synchronized void oublier(UUID joueur) {
episodes.keySet().removeIf(k -> k.joueur().equals(joueur));
}
private void nettoyer(long nowMs) {
for (Iterator<Episode> it = episodes.values().iterator(); it.hasNext();) {
if (nowMs - it.next().debutMs > episodeMs) it.remove();
}
if (episodes.size() >= ENTREES_MAX) episodes.clear(); // garde-fou mémoire : mieux vaut un doublon qu'une fuite
}
public synchronized int taille() {
return episodes.size();
}
}
+71
Voir le fichier
@@ -0,0 +1,71 @@
package com.gastinelgarde.hub;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.OptionalLong;
/** Envoi d'un lot au Hub. Interface pour pouvoir la remplacer dans les tests. */
public interface Transport {
/** Réponse HTTP : statut, corps (borné) et {@code Retry-After} en secondes s'il est présent. */
record Reponse(int statut, String corps, OptionalLong retryAfterSec) { }
/** Envoie le corps JSON. Lève {@link IOException} pour toute panne réseau (connexion, délai, coupure). */
Reponse envoyer(URI adresse, String cle, String corpsJson) throws IOException, InterruptedException;
/**
* Implémentation JDK ({@code java.net.http}). Aucune redirection n'est suivie (la clé ne doit pas partir
* ailleurs), délais courts, réponse lue sur 64 Kio au plus.
*/
final class Http implements Transport {
private static final int REPONSE_MAX = 64 * 1024;
private final HttpClient client;
private final Duration delaiRequete;
private final String agent;
public Http(int delaiConnexionMs, int delaiRequeteMs, String versionMod) {
this.client = HttpClient.newBuilder()
.connectTimeout(Duration.ofMillis(delaiConnexionMs))
.followRedirects(HttpClient.Redirect.NEVER)
.version(HttpClient.Version.HTTP_1_1)
.build();
this.delaiRequete = Duration.ofMillis(delaiRequeteMs);
this.agent = "GastinelGarde/" + versionMod;
}
@Override
public Reponse envoyer(URI adresse, String cle, String corpsJson) throws IOException, InterruptedException {
HttpRequest rq = HttpRequest.newBuilder(adresse)
.timeout(delaiRequete)
.header("Content-Type", "application/json; charset=utf-8")
.header("Accept", "application/json")
.header("X-Source-Cle", cle)
.header("User-Agent", agent)
.POST(HttpRequest.BodyPublishers.ofString(corpsJson, StandardCharsets.UTF_8))
.build();
HttpResponse<InputStream> r = client.send(rq, HttpResponse.BodyHandlers.ofInputStream());
String corps;
try (InputStream in = r.body()) {
corps = new String(in.readNBytes(REPONSE_MAX), StandardCharsets.UTF_8);
}
OptionalLong ra = OptionalLong.empty();
String h = r.headers().firstValue("Retry-After").orElse(null);
if (h != null) {
try {
ra = OptionalLong.of(Math.max(0, Long.parseLong(h.trim())));
} catch (NumberFormatException ignoree) {
// date HTTP ou valeur illisible : on retombe sur l'attente exponentielle
}
}
return new Reponse(r.statusCode(), corps, ra);
}
}
}
+1 -1
Voir le fichier
@@ -67,7 +67,7 @@ public abstract class MovePacketMixin {
@Inject(method = "teleport(DDDFFLjava/util/Set;)V", at = @At("HEAD"))
private void gastinelgarde$marqueTeleport(double x, double y, double z, float yaw, float pitch,
java.util.Set<?> relatifs, CallbackInfo ci) {
if (player != null) Garde.teleportVanilla(player);
if (player != null) Garde.teleportVanilla(player, x, y, z, yaw, pitch, relatifs);
}
// Les 3 teleport() de handleMovePlayer (lit, « moved too quickly », « moved wrongly ») : refus d'un paquet,
+1 -1
Voir le fichier
@@ -4,7 +4,7 @@ license="MIT"
[[mods]]
modId="gastinelgarde"
version="0.3.0"
version="0.3.2"
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);
}
}
}
+324
Voir le fichier
@@ -0,0 +1,324 @@
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));
}
// --- D1 (0.3.2) : position de retour après une téléportation ---
@Test
void D1_setbackApresTpRameneAuPointDArriveePasAvantLaTeleportation() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
GraceTeleport grace = new GraceTeleport();
moteur.suivi(ID).memoriserPosition(0.5, -60.0, 31.0, 0f, 0f, MONDE); // au sol avant le /tp (rapport T3)
// /tp en l'air (origine externe, aucune annonce)
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 100.5, 80.0, 200.5, 45f, 0f, MONDE);
// vol stationnaire, setback avant tout contact au sol
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertTrue(p.actions.contains("teleport 100.5 80.0 200.5 45 0"), p.actions.toString());
// Le teleport du setback lui-même (et un refus vanilla) ne changent pas le retour.
grace.annoncer(GraceTeleport.Origine.SETBACK);
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 7, 7, 7, 0f, 0f, MONDE);
grace.annoncer(GraceTeleport.Origine.REFUS_VANILLA);
Cablage.retourApresTeleport(moteur.suivi(ID), grace.teleport(), 8, 8, 8, 0f, 0f, MONDE);
assertEquals(100.5, moteur.suivi(ID).x(), 1e-9);
assertEquals(80.0, moteur.suivi(ID).y(), 1e-9);
}
}
+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");
}
}
+54
Voir le fichier
@@ -260,4 +260,58 @@ class Garde1015Test {
init();
triche(Controle.NO_FALL, mvt(0, -0.6, true, false), Mode.ENFORCE);
}
// --- D2 (0.3.2) : expulsion de combat seulement après 4 setbacks en 60 s (C5) ---
@Test
void D2_hitboxEnforceExpulseApresQuatreSetbacksPasAuBoutDe5s() {
GardeConfig c = new GardeConfig();
c.mode(Controle.HITBOX, Mode.ENFORCE);
Moteur m = new Moteur(c);
UUID j = UUID.randomUUID();
int setbacks = 0;
long expulsionMs = -1;
// Rapport T2 : regard décalé de 30° (manque 0,72 bloc), un coup toutes les 600 ms.
for (int i = 0; i < 200 && expulsionMs < 0; i++) {
long t = i * 600L;
Sanction s = Verdict.pire(m.porteeHitbox(j, t, EtatJoueur.normal(), 2.5, 0.72, 3.0, 0.0));
if (s == Sanction.SETBACK) setbacks++;
if (s == Sanction.EXPULSION) expulsionMs = t;
}
assertEquals(c.setbacksAvantExpulsion, setbacks, "4 setbacks avant l'expulsion");
assertTrue(expulsionMs > 5000, "expulsion trop tôt : " + expulsionMs + " ms");
assertTrue(expulsionMs <= c.fenetreSetbacksMs, "expulsion dans la fenêtre C5 : " + expulsionMs + " ms");
}
// --- D3 (0.3.2) : NoFall par paquet d'état ---
@Test
void D3_noFallVoitLePaquetDEtatAuSolPendantUneChute() {
GardeConfig c = new GardeConfig();
c.mode(Controle.NO_FALL, Mode.OBSERVE);
c.mode(Controle.VOL, Mode.OFF);
c.mode(Controle.VITESSE, Mode.OFF);
Moteur m = new Moteur(c);
UUID j = UUID.randomUUID();
int lignes = 0;
// Rapport T5 : à chaque tick de chute, un paquet de position (en l'air) puis un paquet d'état « au sol ».
double[] dys = {-0.08, -0.16, -0.23, -0.30, -0.38, -0.45, -0.52, -0.58};
for (int i = 0; i < dys.length; i++) {
long t = i * 50L;
lignes += m.mouvement(j, t, EtatJoueur.normal(), new EtatMouvement(0, dys[i], 1, false, false,
false, false, false, 0, 0, false, false)).size();
lignes += m.mouvement(j, t, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, false,
false, false, false, 0, 0, false, false)).size();
}
assertTrue(lignes >= 4, "paquets d'état au sol pendant la chute rapide : " + lignes);
// Honnête : posé au sol, puis paquets d'état « au sol » immobiles (bloc dessous) ; et saut au sommet.
Moteur h = new Moteur(c);
assertTrue(h.mouvement(j, 0, EtatJoueur.normal(), new EtatMouvement(0, -0.5, 1, true, true,
false, false, false, 0, 0, false, false)).isEmpty());
assertTrue(h.mouvement(j, 50, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, true,
false, false, false, 0, 0, false, false)).isEmpty());
assertTrue(h.mouvement(j, 100, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, false,
false, false, false, 0, 0, false, false)).isEmpty(), "après le sol, la chute est oubliée");
}
}
+262
Voir le fichier
@@ -0,0 +1,262 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* #92 (16/10/2026) : test hitbox / portée de Rednixxu non détecté.
*
* Cause reproduite ici : dès que la cible bouge (marche, sprint), l'ancien calcul ajoutait « vitesse × (3 + ping/50)
* ticks », plafonné à 1,0 bloc, aux deux seuils, dans toutes les directions. Une cible qui sprinte (0,28 bloc/tick)
* donnait donc une hitbox tolérée de 0,25 + 1,0 = 1,25 bloc et une portée de 3,0 + 0,3 + 1,0 = 4,3 blocs, au-delà
* même du refus vanilla (4,0) : portée et hitbox ne pouvaient plus rien voir.
*
* Correctif : contrôle coups-hors-boite, mesure contre les boîtes réellement occupées par la cible pendant la
* fenêtre où le client a pu la voir, et sanction seulement sur une série.
*/
class Garde92Test {
private static final double V = 0.28; // sprint, blocs/tick
private GardeConfig cfg;
private Moteur moteur;
private final UUID joueur = UUID.randomUUID();
@BeforeEach
void init() {
cfg = new GardeConfig();
moteur = new Moteur(cfg);
}
private static double[] boite(double x) {
return new double[] {x - 0.3, 0, -0.3, x + 0.3, 1.8, 0.3};
}
/** Boîtes vues : cible qui avance de V par tick en x, arrivée en xNow. */
private static double[][] vues(double xNow, int fenetre) {
double[][] b = new double[fenetre + 2][];
for (int i = 0; i < b.length; i++) b[i] = boite(xNow - V * (b.length - 1 - i));
return b;
}
private static double points(List<Verdict> vs, Controle c) {
double p = 0;
for (Verdict v : vs) if (v.controle() == c) p += v.points();
return p;
}
/** Un coup complet (coup + paquet de mouvement suivant) ; renvoie tous les verdicts. */
private List<Verdict> coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double xCible, double vitesse,
double[][] vues) {
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, etat, oeil, regard, boite(xCible), 3.0,
vitesse, true, false, oeil, vues));
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeil, regard));
return vs;
}
private static double[] vers(double[] de, double x, double y, double z) {
return new double[] {x - de[0], y - de[1], z - de[2]};
}
// --- Le cas de Rednixxu -----------------------------------------------------------------------------------
@Test
void hitboxGrossieSurCibleQuiSprinteEtaitInvisiblePourLAncienControleEtEstVueEnSerie() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double ancien = 0, nouveau = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
// Le client « hitbox » touche 0,45 bloc devant le bord avant de la cible : là où elle n'a jamais été.
double[] regard = vers(oeil, x + 0.75, 1.2, 0);
List<Verdict> vs = coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre));
ancien += points(vs, Controle.HITBOX) + points(vs, Controle.PORTEE);
nouveau += points(vs, Controle.COUPS_HORS_BOITE);
}
assertEquals(0, ancien, 1e-9, "l'ancien contrôle ne voit rien (c'est le bogue reproduit)");
// 4e coup hors boîte : la série commence à compter, puis chaque coup suivant.
assertEquals(7 * cfg.seriePoints, nouveau, 1e-9);
}
@Test
void porteeAllongeeSurCibleQuiSprinteEstVueEnSerie() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double ancien = 0, nouveau = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.9}; // 3,6 blocs de la boîte : vanilla laisse passer (< 4,0)
double[] regard = vers(oeil, x, 1.2, 0);
List<Verdict> vs = coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre));
ancien += points(vs, Controle.HITBOX) + points(vs, Controle.PORTEE);
nouveau += points(vs, Controle.COUPS_HORS_BOITE);
}
assertEquals(0, ancien, 1e-9);
assertTrue(nouveau > 0);
}
@Test
void leNouveauControleEstEnObserveParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.COUPS_HORS_BOITE));
}
// --- Pas de faux positifs ---------------------------------------------------------------------------------
@Test
void joueurHonneteQuiViseLaCibleAfficheeEnRetardAvecPingNestJamaisCompte() {
int ping = 150;
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg);
for (int k = 0; k < 30; k++) {
double x = 5 * k;
int retard = k % (fenetre + 1); // la cible affichée a 0 à « fenetre » ticks de retard
double xVu = x - V * retard;
double[] oeil = {xVu, 1.62, -2.9};
// Visée sur le bord arrière de la boîte affichée, à 0,1 bloc près (imprécision du modèle).
double[] regard = vers(oeil, xVu - 0.3 - 0.1, 1.0, -0.3);
assertEquals(0, points(coup(k * 600L, etat, oeil, regard, x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE), 1e-9, "coup " + k);
}
}
@Test
void positionInterpoleeEntreDeuxPaquetsEstAcceptee() {
// Cible qui n'envoie sa position que toutes les 3 entrées : le client l'affiche entre deux.
double[][] b = {boite(0), boite(0), boite(0), boite(0.84), boite(0.84), boite(0.84)};
double[] oeil = {0.42, 1.62, -2.5};
double[] regard = vers(oeil, 0.42, 1.0, 0);
PorteeHitbox.Mesure m = PorteeHitbox.mesureCompensee(new double[][] {oeil}, new double[][] {regard}, b, 4.0, 1.0);
assertEquals(0, m.manque(), 1e-9);
}
@Test
void unCoupHorsBoiteIsoleNeCompteJamais() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double total = 0;
for (int k = 0; k < 40; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
double[] regard = k % 4 == 0 ? vers(oeil, x + 0.75, 1.2, 0) : vers(oeil, x, 1.2, 0); // 1 sur 4
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
@Test
void rotationEnRetardDUnTickRattrapeeParLeRegardSuivant() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
double[] ancienRegard = vers(oeil, x + 1.5, 1.2, 0); // regard du paquet d'avant
double[] regard = vers(oeil, x, 1.2, 0); // vrai regard, arrivé au paquet suivant
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, k * 600L, EtatJoueur.normal(), oeil,
ancienRegard, boite(x), 3.0, V, true, false, oeil, vues(x, fenetre)));
vs.addAll(moteur.regardPorteeHitbox(joueur, k * 600L + 50, oeil, regard));
total += points(vs, Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
@Test
void exemptionsCreatifMontureElytresPingTeleportationEtGel() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
List<EtatJoueur> etats = List.of(
EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().riptide(true).build(),
// Revue 1 (16/10) : un ping > seriePingMaxMs n'exempte plus (ping falsifiable) ; retiré de la liste,
// voir AutotestContournementsTest.CORRIGE_revue1_… [À VÉRIFIER] Théo.
EtatJoueur.builder().ticksDepuisTeleport(5).build(),
EtatJoueur.builder().ticksDepuisGel(5).build());
for (EtatJoueur etat : etats) {
moteur = new Moteur(cfg);
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
total += points(coup(k * 600L, etat, oeil, vers(oeil, x + 0.75, 1.2, 0), x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9, etat.toString());
}
}
@Test
void cibleTeleporteeOuTropRapideOuContraptionNonMesuree() {
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
double[] regard = vers(oeil, x + 0.75, 1.2, 0);
double[][] saut = {boite(x - 10), boite(x - 10), boite(x), boite(x)}; // /tp de la cible
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, 0, saut), Controle.COUPS_HORS_BOITE);
// null : historique incomplet, ou cible sur / près d'une contraption Create ou d'un vaisseau Sable.
total += points(coup(k * 600L + 300, EtatJoueur.normal(), oeil, regard, x, 0, null),
Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
@Test
void controleOffNeMesureRien() {
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, vers(oeil, x + 0.75, 1.2, 0), x, V,
vues(x, fenetre)), Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
// --- Briques ----------------------------------------------------------------------------------------------
@Test
void historiqueBoitesFenetreIncompleteTamponCirculaireEtEntreeAnterieure() {
HistoriqueBoites h = new HistoriqueBoites();
assertNull(h.depuis(0));
for (int t = 10; t < 10 + HistoriqueBoites.CAPACITE + 5; t++) h.ajouter(t, boite(t));
assertEquals(HistoriqueBoites.CAPACITE, h.taille());
assertEquals(15, h.premierTick());
assertNull(h.depuis(14)); // plus ancien que l'historique : pas de mesure
double[][] d = h.depuis(40);
assertNotNull(d);
assertEquals(10 + HistoriqueBoites.CAPACITE + 5 - 40, d.length);
assertArrayEquals(boite(40), d[0], 1e-12);
h.ajouter(46, boite(0)); // même tick : remplacé
assertEquals(HistoriqueBoites.CAPACITE, h.taille());
h.ajouter(3, boite(0)); // horloge revenue en arrière : on repart
assertEquals(1, h.taille());
}
@Test
void fenetreBorneeParLePingMax() {
assertEquals(cfg.ticksAffichageCible, PorteeHitbox.ticksFenetre(0, cfg));
assertEquals(cfg.ticksAffichageCible + 3, PorteeHitbox.ticksFenetre(150, cfg));
int max = PorteeHitbox.ticksFenetre(cfg.seriePingMaxMs, cfg);
assertEquals(max, PorteeHitbox.ticksFenetre(100000, cfg));
assertTrue(max + 1 < HistoriqueBoites.CAPACITE);
}
@Test
void serieCoupsOublieLesCoupsTropAnciens() {
SerieCoups s = new SerieCoups();
for (int k = 0; k < 3; k++) s.enregistrer(k * 1000L, true, cfg);
// 4e coup hors boîte, mais les 3 premiers sont hors de la fenêtre de 30 s.
assertEquals(0, s.enregistrer(3 * 1000L + cfg.serieFenetreMs + 1, true, cfg), 1e-9);
assertEquals(1, s.dernierTotal());
}
}
+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
}
}
}
+187
Voir le fichier
@@ -0,0 +1,187 @@
package com.gastinelgarde.hub;
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.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.Sanction;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
/** Conformité aux contraintes du Hub : motifs des champs texte, aucune adresse IP, clés de details en liste blanche. */
class ContratHubTest {
private static final String UUID_J = "123e4567-e89b-12d3-a456-426614174000";
@Test
void tousLesControlesDuModSontAcceptesTelsQuels() {
for (Controle c : Controle.values()) {
assertEquals(c.id(), Assainir.controle(c.id()), c.id());
assertTrue(Assainir.TYPE_DETECTION.matcher(c.id()).matches(), "type Hub : " + c.id());
}
}
@Test
void controleEtDimensionNonConformesSontCorriges() {
assertEquals("killaura_angle_", Assainir.controle("KillAura Angle!"));
assertEquals("minecraft:overworld", Assainir.dimension("minecraft:overworld"));
assertEquals("monmod:aether_ciel", Assainir.dimension("monmod:aether/ciel"));
assertEquals("monmod:aether_ciel", Assainir.dimension("MonMod:Aether/Ciel"));
assertEquals(64, Assainir.dimension("a".repeat(200)).length());
assertNull(Assainir.controle(""));
assertNull(Assainir.controle(null));
assertNull(Assainir.dimension(" "));
}
@Test
void uneDimensionOuUnControleQuiRessembleAUneAdresseEstOmis() {
assertNull(Assainir.controle("192.0.2.10"));
assertNull(Assainir.dimension("2001:db8::1"));
assertNull(Assainir.controle("x10.1.2.3x"));
assertTrue(Assainir.ressembleAdresseIp("2001:db8::/32"));
assertTrue(Assainir.ressembleAdresseIp("::1"));
assertTrue(Assainir.ressembleAdresseIp("a 198.51.100.7 b"));
assertFalse(Assainir.ressembleAdresseIp("minecraft:overworld"));
assertFalse(Assainir.ressembleAdresseIp("0.3.2"));
assertFalse(Assainir.ressembleAdresseIp("1.21.1"));
}
@Test
void versionDuMod() {
assertEquals("0.3.2", Assainir.versionMod("0.3.2"));
assertEquals("0.3.2-beta.1+abc", Assainir.versionMod("0.3.2-beta.1+abc"));
assertEquals("0.3.2-x", Assainir.versionMod("0.3.2 x"));
assertEquals("inconnue", Assainir.versionMod(null));
assertEquals("inconnue", Assainir.versionMod(""));
assertEquals("inconnue", Assainir.versionMod("192.0.2.1"));
assertEquals(32, Assainir.versionMod("1".repeat(100)).length());
// saut de ligne dans une version : jamais de caractère piégé (elle sert aussi d'en-tête User-Agent)
assertTrue(Assainir.VERSION_MOD.matcher(Assainir.versionMod("1.0\r\nX-Evil: 1")).matches());
}
@Test
void exemptionsConformesEtBornees() {
List<String> entree = new ArrayList<>(List.of("creatif", "peut-voler", "Chute Lente", "teleportation", "creatif",
"198.51.100.9", "", "x".repeat(50)));
for (int i = 0; i < 20; i++) entree.add("raison" + i);
List<String> sortie = Assainir.exemptions(entree);
assertEquals(Assainir.EXEMPTIONS_MAX, sortie.size());
assertEquals(List.of("creatif", "peut-voler", "chute_lente", "teleportation"), sortie.subList(0, 4));
assertFalse(sortie.contains("198.51.100.9"));
for (String e : sortie) assertTrue(Assainir.EXEMPTION.matcher(e).matches(), e);
}
@Test
void detailsGardeSeulementLaListeBlanche() {
Map<String, Object> d = new LinkedHashMap<>();
d.put("controle", "portee");
d.put("palier", 3);
d.put("x", 120);
d.put("y", 64);
d.put("z", -5000);
d.put("dimension", "minecraft:the_nether");
d.put("version_mod", "0.3.2");
d.put("exemptions", List.of("creatif"));
d.put("pseudo", "Steve");
d.put("ip", "198.51.100.7");
d.put("chat", "salut");
Map<String, Object> propre = Assainir.details(d);
assertEquals(List.of("controle", "palier", "exemptions", "version_mod", "x", "y", "z", "dimension"),
new ArrayList<>(propre.keySet()));
assertEquals(3L, propre.get("palier"));
assertEquals(-5000L, propre.get("z"));
}
@Test
void detailsRetireLesValeursMalFormees() {
Map<String, Object> d = new LinkedHashMap<>();
d.put("controle", "portee");
d.put("palier", "alerte"); // le Hub veut un entier
d.put("x", 1.5); // pas un entier
d.put("y", 99_000_000L); // hors bornes
d.put("z", Double.NaN);
d.put("dimension", 12);
d.put("version_mod", "1.0 \n");
d.put("exemptions", "creatif"); // pas une liste
Map<String, Object> propre = Assainir.details(d);
assertEquals(List.of("controle"), new ArrayList<>(propre.keySet()));
}
@Test
void uneAdresseDansUnChampTexteNePasseJamais() {
Map<String, Object> d = new LinkedHashMap<>();
d.put("controle", "portee");
d.put("version_mod", "10.1.2.3");
d.put("dimension", "2001:db8:0:1::5");
d.put("exemptions", List.of("192.0.2.1", "creatif"));
Map<String, Object> propre = Assainir.details(d);
String json = MiniJson.ecrire(propre);
assertFalse(Assainir.ressembleAdresseIp(json.replace("\"", " ")), json);
assertEquals(List.of("creatif"), propre.get("exemptions"));
assertFalse(propre.containsKey("version_mod"));
assertFalse(propre.containsKey("dimension"));
}
@Test
void detectionRefuseUnIdentifiantOuUnTypeHorsContrat() {
Map<String, Object> d = Map.of();
assertThrows(IllegalArgumentException.class, () -> new Detection("court", UUID_J, "portee", 1, "enforce", 1, 0, d));
assertThrows(IllegalArgumentException.class, () -> new Detection("a b c d e f g h", UUID_J, "portee", 1, "enforce", 1, 0, d));
assertThrows(IllegalArgumentException.class, () -> new Detection("x".repeat(129), UUID_J, "portee", 1, "enforce", 1, 0, d));
assertThrows(IllegalArgumentException.class, () -> new Detection("identifiant-ok", UUID_J, "Portee!", 1, "enforce", 1, 0, d));
assertThrows(IllegalArgumentException.class, () -> new Detection("identifiant-ok", "pas-un-uuid", "portee", 1, "enforce", 1, 0, d));
assertThrows(IllegalArgumentException.class, () -> new Detection("identifiant-ok", UUID_J, "portee", 4, "enforce", 1, 0, d));
assertThrows(IllegalArgumentException.class, () -> new Detection("identifiant-ok", UUID_J, "portee", 1, "ban", 1, 0, d));
new Detection("identifiant-ok", UUID_J, "portee", 1, "enforce", 1, 0, d);
}
@Test
void detectionBorneLesPoints() {
assertEquals(0.0, new Detection("identifiant-ok", UUID_J, "portee", 1, "enforce", -5, 0, Map.of()).points());
assertEquals(99_999.0, new Detection("identifiant-ok", UUID_J, "portee", 1, "enforce", 1e9, 0, Map.of()).points());
assertEquals(0.0, new Detection("identifiant-ok", UUID_J, "portee", 1, "enforce", Double.NaN, 0, Map.of()).points());
}
@Test
void jsonEnvoyeSansChampServiceNiSourceEtAvecHorodatageRfc3339() {
Detection d = new Detection("identifiant-ok", UUID_J, "portee", 2, "enforce", 7.126, 1_760_000_000_123L,
Map.of("controle", "portee"));
@SuppressWarnings("unchecked")
Map<String, Object> m = (Map<String, Object>) MiniJson.lire(d.json());
assertEquals(List.of("id_externe", "sujet", "type", "gravite", "mode", "points", "survenue_le", "details"),
new ArrayList<>(m.keySet()));
assertEquals("2025-10-09T08:53:20Z", m.get("survenue_le"));
assertEquals(7.13, ((Number) m.get("points")).doubleValue(), 1e-9);
@SuppressWarnings("unchecked")
Map<String, Object> sujet = (Map<String, Object>) m.get("sujet");
assertEquals("uuid_minecraft", sujet.get("type"));
assertEquals(UUID_J, sujet.get("valeur"));
}
@Test
void relectureDuDisqueRefiltreLesDetails() {
String json = "{\"id_externe\":\"identifiant-ok\",\"sujet\":{\"type\":\"uuid_minecraft\",\"valeur\":\"" + UUID_J
+ "\"},\"type\":\"portee\",\"gravite\":1,\"mode\":\"enforce\",\"points\":1.0,"
+ "\"survenue_le\":\"2026-10-19T10:00:00Z\",\"details\":{\"controle\":\"portee\",\"ip\":\"198.51.100.7\","
+ "\"pseudo\":\"Steve\"}}";
Detection d = Detection.depuisJson(MiniJson.lire(json));
assertEquals(List.of("controle"), new ArrayList<>(d.details().keySet()));
}
@Test
void graviteEtPalierNumerotes() {
assertEquals(0, Signalement.gravite(Sanction.AUCUNE));
assertEquals(0, Signalement.gravite(Sanction.JOURNAL));
assertEquals(1, Signalement.gravite(Sanction.ALERTE));
assertEquals(2, Signalement.gravite(Sanction.SETBACK));
assertEquals(3, Signalement.gravite(Sanction.EXPULSION));
assertEquals(2, Signalement.numeroPalier(Sanction.ALERTE));
assertEquals(4, Signalement.numeroPalier(Sanction.EXPULSION));
}
}
+447
Voir le fichier
@@ -0,0 +1,447 @@
package com.gastinelgarde.hub;
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.Sanction;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicLong;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
/**
* Envoi réel (java.net.http) vers un FAUX serveur HTTP local, hors ligne : aucune connexion hors de cette machine.
* Le fil d'envoi n'est pas lancé : on appelle {@link EnvoiHub#cycle()} avec une horloge simulée, pour des essais
* exacts et sans attente.
*/
class EnvoiHubServeurTest {
/** Clé factice des essais. Pas une vraie clé. */
static final String CLE = "cle-de-test-0123456789-0123456789-ABCDEF";
/** Une requête reçue par le faux Hub. */
record Recue(String methode, String chemin, String cle, String contentType, String corps) { }
/** Réponse programmée : statut, corps, en-tête Retry-After facultatif, délai facultatif. */
record Reponse(int statut, String corps, String retryAfter, long delaiMs) {
static Reponse ok(String corps) {
return new Reponse(200, corps, null, 0);
}
static Reponse statut(int s) {
return new Reponse(s, "{}", null, 0);
}
}
HttpServer serveur;
final List<Recue> recues = new CopyOnWriteArrayList<>();
final ConcurrentLinkedQueue<Reponse> scenario = new ConcurrentLinkedQueue<>();
volatile Reponse parDefaut = Reponse.ok("{\"resultats\":[]}");
final AtomicLong horloge = new AtomicLong(1_760_000_000_000L);
final List<String> journal = new CopyOnWriteArrayList<>();
String url;
@BeforeEach
void demarrerFauxHub() throws IOException {
// 127.0.0.1 explicite : sous le lanceur NeoForge de test (-Djava.net.preferIPv6Addresses=system), getLoopbackAddress()
// peut donner ::1, alors que l'adresse du Hub ci-dessous est en IPv4 (connexion refusée, 14 tests en échec).
serveur = HttpServer.create(new InetSocketAddress(InetAddress.getByAddress(new byte[] {127, 0, 0, 1}), 0), 0);
serveur.createContext("/", ex -> {
byte[] corps = ex.getRequestBody().readAllBytes();
recues.add(new Recue(ex.getRequestMethod(), ex.getRequestURI().getPath(),
ex.getRequestHeaders().getFirst("X-Source-Cle"), ex.getRequestHeaders().getFirst("Content-Type"),
new String(corps, StandardCharsets.UTF_8)));
Reponse r = scenario.poll();
if (r == null) r = parDefaut;
if (r.delaiMs() > 0) {
try {
Thread.sleep(r.delaiMs());
} catch (InterruptedException ignoree) {
// fin de l'essai
}
}
byte[] sortie = r.corps().getBytes(StandardCharsets.UTF_8);
if (r.retryAfter() != null) ex.getResponseHeaders().add("Retry-After", r.retryAfter());
ex.getResponseHeaders().add("Content-Type", "application/json");
try {
ex.sendResponseHeaders(r.statut(), sortie.length);
try (OutputStream os = ex.getResponseBody()) {
os.write(sortie);
}
} catch (IOException ignoree) {
// client parti (délai dépassé)
}
});
serveur.setExecutor(java.util.concurrent.Executors.newCachedThreadPool(r -> {
Thread t = new Thread(r, "faux-hub");
t.setDaemon(true);
return t;
}));
serveur.start();
url = "http://127.0.0.1:" + serveur.getAddress().getPort();
}
@AfterEach
void arreterFauxHub() {
serveur.stop(0);
}
HubConfig cfg(Path tmp) {
return new HubConfig(true, url, tmp.resolve("k"), false, Sanction.ALERTE, 50, 2000, 1000, 3600_000L, 50, 600_000L,
1000, 2000, true, tmp.resolve("etat"));
}
EnvoiHub envoi(HubConfig c, FileEnvoi f) {
return new EnvoiHub(c, CLE, new Transport.Http(c.delaiConnexionMs(), c.delaiRequeteMs(), "0.3.2"), f, horloge::get,
journal::add);
}
Detection det(int n) {
return FileEtCleTest.det(n, horloge.get());
}
static String resultats(String... statuts) {
StringBuilder sb = new StringBuilder("{\"resultats\":[");
for (int i = 0; i < statuts.length; i++) {
if (i > 0) sb.append(',');
String[] p = statuts[i].split(":");
sb.append("{\"id_externe\":\"x").append(i).append("\",\"statut\":\"").append(p[0]).append('"');
if (p.length > 1) sb.append(",\"code\":\"").append(p[1]).append('"');
sb.append('}');
}
return sb.append("]}").toString();
}
@SuppressWarnings("unchecked")
static List<Map<String, Object>> detectionsDe(Recue r) {
Map<String, Object> m = (Map<String, Object>) MiniJson.lire(r.corps());
return (List<Map<String, Object>>) m.get("detections");
}
// ------------------------------------------------------------------
@Test
void lotEnvoyeAuBonEndroitAvecLaCleEnEnTeteEtJamaisDansLeCorps(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
for (int i = 0; i < 3; i++) f.ajouter(det(i));
parDefaut = Reponse.ok(resultats("cree", "cree", "cree"));
e.cycle();
assertEquals(1, recues.size());
Recue r = recues.get(0);
assertEquals("POST", r.methode());
assertEquals("/internal/detections", r.chemin());
assertEquals(CLE, r.cle());
assertTrue(r.contentType().startsWith("application/json"));
assertFalse(r.corps().contains(CLE), "la clé ne doit jamais être dans le corps");
assertEquals(3, detectionsDe(r).size());
assertEquals(3, e.envoyees());
assertTrue(f.vide());
for (String l : journal) assertFalse(l.contains(CLE), "la clé ne doit jamais être dans le journal : " + l);
}
@Test
void chaqueDetectionEnvoyeeRespecteLesMotifsDuHub(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(new Detection("123e4567-e89b-12d3-a456-426614174000:portee:setback:1", "123e4567-e89b-12d3-a456-426614174000",
"portee", 2, "enforce", 12.5, horloge.get(),
new java.util.LinkedHashMap<>(Map.of("controle", "portee", "palier", 3, "x", 10, "y", 70, "z", -20,
"dimension", "minecraft:overworld", "version_mod", "0.3.2", "exemptions", List.of("creatif"),
"ip", "198.51.100.4"))));
e.cycle();
Map<String, Object> d = detectionsDe(recues.get(0)).get(0);
assertEquals(List.of("id_externe", "sujet", "type", "gravite", "mode", "points", "survenue_le", "details"),
new ArrayList<>(d.keySet()));
@SuppressWarnings("unchecked")
Map<String, Object> det = (Map<String, Object>) d.get("details");
assertFalse(det.containsKey("ip"));
assertTrue(Assainir.CONTROLE.matcher((String) det.get("controle")).matches());
assertTrue(Assainir.CONTROLE.matcher((String) det.get("dimension")).matches());
assertTrue(Assainir.VERSION_MOD.matcher((String) det.get("version_mod")).matches());
assertEquals(3L, ((Number) det.get("palier")).longValue());
for (Object valeur : det.values()) {
if (valeur instanceof String t) assertFalse(Assainir.ressembleAdresseIp(t), "adresse dans details : " + t);
if (valeur instanceof List<?> l) for (Object o : l) assertFalse(Assainir.ressembleAdresseIp(String.valueOf(o)), String.valueOf(o));
}
assertFalse(recues.get(0).corps().contains("198.51.100.4"), "l'adresse fournie dans details ne part pas");
}
@Test
void panneReseauNouvellesTentativesAvecLeMemeIdentifiantPuisSucces(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(det(1));
scenario.add(Reponse.statut(503));
scenario.add(Reponse.statut(500));
parDefaut = Reponse.ok(resultats("cree"));
long a1 = e.cycle();
assertEquals(1, f.taille(), "le lot est remis en file");
assertTrue(a1 >= 1000 && a1 <= 1250, "1re attente ~1 s : " + a1);
assertEquals(1, e.echecsDeSuite());
e.cycle(); // trop tôt : rien n'est envoyé
assertEquals(1, recues.size());
horloge.addAndGet(a1 + 1);
long a2 = e.cycle();
assertTrue(a2 >= 2000 && a2 <= 2500, "2e attente ~2 s (exponentielle) : " + a2);
horloge.addAndGet(a2 + 1);
e.cycle();
assertEquals(3, recues.size());
assertTrue(f.vide());
assertEquals(0, e.echecsDeSuite());
String id1 = (String) detectionsDe(recues.get(0)).get(0).get("id_externe");
assertEquals(id1, detectionsDe(recues.get(1)).get(0).get("id_externe"));
assertEquals(id1, detectionsDe(recues.get(2)).get(0).get("id_externe"), "même identifiant à chaque tentative (idempotence)");
assertTrue(journal.stream().anyMatch(l -> l.contains("liaison rétablie")));
}
@Test
void hubArreteConnexionRefuseLaFileResteEtTientLeCoup(@TempDir Path tmp) {
serveur.stop(0); // plus personne n'écoute sur ce port
FileEnvoi f = new FileEnvoi(50);
EnvoiHub e = envoi(cfg(tmp), f);
for (int i = 0; i < 80; i++) f.ajouter(det(i));
assertEquals(50, f.taille());
long attente = 0;
long debutSimule = horloge.get();
for (int tour = 0; tour < 12; tour++) {
attente = e.cycle();
horloge.addAndGet(attente + 1);
}
assertEquals(50, f.taille(), "rien n'est perdu pendant la panne (file bornée à 50)");
assertEquals(30, f.abandonnees());
assertEquals(12, e.echecsDeSuite());
assertTrue(attente <= EnvoiHub.ATTENTE_MAX_MS * 5 / 4, "l'attente plafonne à 5 min (+25 % au hasard) : " + attente);
long dureeSimuleeMin = (horloge.get() - debutSimule) / 60_000;
assertTrue(journal.size() <= dureeSimuleeMin / 5 + 1,
"journal limité à un message par type et par 5 min (" + dureeSimuleeMin + " min simulées) : " + journal);
assertTrue(journal.size() < 12, "bien moins de messages que de tentatives");
assertTrue(Files.exists(tmp.resolve("etat/file-attente.jsonl")), "la file est écrite sur disque pendant la panne");
}
@Test
void attenteExponentielleDe1sA5min() {
assertEquals(1000, EnvoiHub.delaiExponentiel(1));
assertEquals(2000, EnvoiHub.delaiExponentiel(2));
assertEquals(4000, EnvoiHub.delaiExponentiel(3));
assertEquals(64_000, EnvoiHub.delaiExponentiel(7));
assertEquals(300_000, EnvoiHub.delaiExponentiel(10));
assertEquals(300_000, EnvoiHub.delaiExponentiel(500));
}
@Test
void erreur429RespecteRetryAfter(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(det(1));
scenario.add(new Reponse(429, "{}", "17", 0));
long a = e.cycle();
assertEquals(17_000, a);
assertEquals(1, f.taille());
horloge.addAndGet(16_000);
e.cycle();
assertEquals(1, recues.size(), "avant l'échéance, rien ne part");
horloge.addAndGet(1_001);
parDefaut = Reponse.ok(resultats("cree"));
e.cycle();
assertEquals(2, recues.size());
assertTrue(f.vide());
}
@Test
void retryAfterAbsentOuAbsurdeEstBorne(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(det(1));
scenario.add(new Reponse(429, "{}", "99999999", 0));
assertEquals(EnvoiHub.ATTENTE_MAX_MS, e.cycle());
horloge.addAndGet(EnvoiHub.ATTENTE_MAX_MS + 1);
scenario.add(new Reponse(429, "{}", "0", 0));
assertEquals(EnvoiHub.ATTENTE_MIN_MS, e.cycle());
}
@Test
void cleRefusee401EtSourceInactive403GardentLaFileEtReessaientToutesLes5Min(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(det(1));
scenario.add(Reponse.statut(401));
assertEquals(EnvoiHub.ATTENTE_MAX_MS, e.cycle());
assertEquals(1, f.taille());
assertTrue(journal.stream().anyMatch(l -> l.contains("401")));
horloge.addAndGet(EnvoiHub.ATTENTE_MAX_MS + 1);
scenario.add(Reponse.statut(403));
assertEquals(EnvoiHub.ATTENTE_MAX_MS, e.cycle());
assertEquals(1, f.taille());
assertTrue(journal.stream().anyMatch(l -> l.contains("403")));
for (String l : journal) assertFalse(l.contains(CLE));
horloge.addAndGet(EnvoiHub.ATTENTE_MAX_MS + 1);
parDefaut = Reponse.ok(resultats("cree"));
e.cycle();
assertTrue(f.vide(), "dès que la source est activée côté Hub, la file part");
}
@Test
void lotInvalide400EstAbandonneSansBoucler(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(det(1));
f.ajouter(det(2));
scenario.add(Reponse.statut(400));
e.cycle();
assertTrue(f.vide());
assertEquals(1, e.lotsRejetes());
assertEquals(2, e.perimees());
assertEquals(1, recues.size());
}
@Test
void lotTropGros413EstDivise(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
for (int i = 0; i < 8; i++) f.ajouter(det(i));
scenario.add(Reponse.statut(413));
e.cycle();
assertEquals(8, f.taille());
parDefaut = Reponse.ok(resultats("cree", "cree", "cree", "cree"));
e.cycle();
assertEquals(4, detectionsDe(recues.get(1)).size(), "lot ramené à la moitié");
}
@Test
void doublonsEtRefusLusDansLaReponseSontAcquittesSansRenvoi(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
for (int i = 0; i < 3; i++) f.ajouter(det(i));
parDefaut = Reponse.ok(resultats("cree", "doublon", "refuse:horodatage_hors_fenetre"));
e.cycle();
assertTrue(f.vide());
assertEquals(1, e.doublons());
assertEquals(1, e.refusees());
assertTrue(journal.stream().anyMatch(l -> l.contains("horodatage_hors_fenetre")));
assertEquals(1, recues.size());
}
@Test
void reponse200IllisibleEstTenueCommeAcceptee(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(det(1));
parDefaut = Reponse.ok("<html>pas du json</html>");
e.cycle();
assertTrue(f.vide());
assertEquals(1, e.envoyees());
}
@Test
void lotsDe50EtDebitParMinute(@TempDir Path tmp) {
HubConfig c = new HubConfig(true, url, tmp.resolve("k"), false, Sanction.ALERTE, 50, 2000, 1000, 3600_000L, 60, 600_000L,
1000, 2000, true, tmp.resolve("etat"));
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(c, f);
for (int i = 0; i < 130; i++) f.ajouter(det(i));
parDefaut = Reponse.ok("{}");
e.cycle();
assertEquals(50, detectionsDe(recues.get(0)).size());
horloge.addAndGet(300);
e.cycle();
assertEquals(10, detectionsDe(recues.get(1)).size(), "60 par minute au plus : 10 seulement dans la même minute");
horloge.addAndGet(300);
long att = e.cycle();
assertEquals(2, recues.size(), "limite atteinte : rien ne part avant la fin de la minute");
assertTrue(att > 50_000 && att <= 60_000, "attente jusqu'à la fin de la minute : " + att);
horloge.addAndGet(60_001);
e.cycle();
assertEquals(3, recues.size());
assertEquals(50, detectionsDe(recues.get(2)).size());
}
@Test
void detectionsTropVieillesAbandonneesAvantEnvoi(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(FileEtCleTest.det(1, horloge.get() - 2 * 3600_000L)); // plus vieille que ageMax (1 h ici)
f.ajouter(det(2));
e.cycle();
assertEquals(1, e.perimees());
assertEquals(1, detectionsDe(recues.get(0)).size());
}
@Test
void fileSurDisqueSurvitAUnRedemarrageHubArrete(@TempDir Path tmp) {
HubConfig c = cfg(tmp);
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(c, f);
for (int i = 0; i < 4; i++) f.ajouter(det(i));
serveur.stop(0);
e.cycle(); // échec : copie sur disque
e.arreter(); // arrêt du serveur Minecraft : tout est écrit
assertTrue(Files.exists(tmp.resolve("etat/file-attente.jsonl")));
FileEnvoi f2 = new FileEnvoi(1000);
EnvoiHub e2 = envoi(c, f2);
e2.demarrer(); // relit le disque (lance le fil, arrêté tout de suite)
e2.arreter();
assertEquals(4, f2.taille());
List<Detection> l = f2.prendre(50, 1_000_000);
assertEquals(4, l.size());
assertEquals(det(0).idExterne(), l.get(0).idExterne(), "mêmes identifiants après redémarrage");
}
@Test
void fileEffaceeDuDisqueUneFoisToutAccuse(@TempDir Path tmp) throws Exception {
HubConfig c = cfg(tmp);
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(c, f);
f.ajouter(det(1));
scenario.add(Reponse.statut(500));
long a = e.cycle();
assertTrue(Files.exists(tmp.resolve("etat/file-attente.jsonl")));
horloge.addAndGet(a + 1);
parDefaut = Reponse.ok(resultats("cree"));
e.cycle();
assertFalse(Files.exists(tmp.resolve("etat/file-attente.jsonl")), "plus de donnée personnelle sur disque une fois accusé");
}
@Test
void jamaisDeRedirectionSuivie(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(det(1));
scenario.add(new Reponse(302, "{}", null, 0));
e.cycle();
assertEquals(1, recues.size());
assertEquals(1, f.taille(), "302 = réponse inattendue : on réessaie plus tard, sans suivre la redirection");
}
@Test
void hubLentLeCycleSArreteAuDelaiDeRequete(@TempDir Path tmp) {
FileEnvoi f = new FileEnvoi(1000);
EnvoiHub e = envoi(cfg(tmp), f);
f.ajouter(det(1));
scenario.add(new Reponse(200, resultats("cree"), null, 6000)); // délai de requête : 2 s
long t0 = System.nanoTime();
e.cycle();
long ms = (System.nanoTime() - t0) / 1_000_000;
assertTrue(ms < 4000, "coupé au délai de requête : " + ms + " ms");
assertEquals(1, f.taille());
}
}
+195
Voir le fichier
@@ -0,0 +1,195 @@
package com.gastinelgarde.hub;
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.Controle;
import com.gastinelgarde.core.Sanction;
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.Map;
import java.util.UUID;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
/** File bornée, file sur disque, suivi des paliers, lecture de la clé. */
class FileEtCleTest {
static Detection det(int n, long survenueMs) {
return new Detection(String.format("00000000-0000-0000-0000-%012d:portee:alerte:%d", n, survenueMs),
"123e4567-e89b-12d3-a456-426614174000", "portee", 1, "enforce", 1.0, survenueMs, Map.of("controle", "portee"));
}
// --- File bornée ---
@Test
void laFileEstBorneeEtAbandonneLesPlusAnciennes() {
FileEnvoi f = new FileEnvoi(10);
for (int i = 0; i < 25; i++) f.ajouter(det(i, 1000 + i));
assertEquals(10, f.taille());
assertEquals(15, f.abandonnees());
List<Detection> lot = f.prendre(50, 1_000_000);
assertEquals(10, lot.size());
assertEquals(1015, lot.get(0).survenueMs()); // les plus récentes sont gardées
assertEquals(1024, lot.get(9).survenueMs());
}
@Test
void lotBorneEnNombreEtEnOctets() {
FileEnvoi f = new FileEnvoi(1000);
for (int i = 0; i < 100; i++) f.ajouter(det(i, 1000 + i));
assertEquals(50, f.prendre(50, 1_000_000).size());
int un = det(0, 1000).json().getBytes(StandardCharsets.UTF_8).length + 1;
List<Detection> petit = f.prendre(50, un * 3 + 1);
assertEquals(3, petit.size());
assertEquals(47, f.taille());
// une seule détection plus grosse que la limite part quand même (sinon la file serait bloquée)
assertEquals(1, f.prendre(50, 1).size());
}
@Test
void remettreRetrouveLOrdreEtPurgerEnleveLesVieilles() {
FileEnvoi f = new FileEnvoi(100);
for (int i = 0; i < 6; i++) f.ajouter(det(i, 1000 + i));
List<Detection> lot = f.prendre(3, 1_000_000);
f.remettre(lot);
assertEquals(6, f.taille());
List<Detection> tout = f.prendre(6, 1_000_000);
for (int i = 0; i < 6; i++) assertEquals(1000 + i, tout.get(i).survenueMs());
f.remettre(tout);
assertEquals(3, f.purgerAvant(1003));
assertEquals(3, f.taille());
}
// --- Disque ---
@Test
void fileSurDisqueEcritureAtomiqueEtRelecture(@TempDir Path tmp) throws IOException {
Spool s = new Spool(tmp.resolve("sous/dossier/file.jsonl"));
assertTrue(s.lire(0).isEmpty());
s.ecrire(List.of(det(1, 5000), det(2, 6000), det(3, 100)));
assertTrue(s.existe());
assertFalse(Files.exists(tmp.resolve("sous/dossier/file.jsonl.tmp")));
List<Detection> l = s.lire(1000); // la 3e est trop ancienne
assertEquals(2, l.size());
assertEquals(det(1, 5000), l.get(0)); // même identifiant, mêmes valeurs : la relecture ne change rien
s.ecrire(List.of());
assertFalse(s.existe());
}
@Test
void ligneAbimeeIgnoreeLesSuivantesRestent(@TempDir Path tmp) throws IOException {
Path p = tmp.resolve("file.jsonl");
Files.writeString(p, det(1, 5000).json() + "\n{pas du json\n" + det(2, 6000).json().substring(0, 40) + "\n"
+ det(3, 7000).json() + "\n", StandardCharsets.UTF_8);
List<Detection> l = new Spool(p).lire(0);
assertEquals(2, l.size());
assertEquals(5000, l.get(0).survenueMs());
assertEquals(7000, l.get(1).survenueMs());
}
// --- Suivi des paliers ---
@Test
void unPalierEstSignaleUneFoisParEpisodePuisSeulementSiPlusHaut() {
SuiviPaliers s = new SuiviPaliers(600_000, Sanction.ALERTE);
UUID j = UUID.randomUUID();
assertTrue(s.franchit(j, Controle.PORTEE, Sanction.ALERTE, 0));
assertFalse(s.franchit(j, Controle.PORTEE, Sanction.ALERTE, 1000));
assertTrue(s.franchit(j, Controle.PORTEE, Sanction.SETBACK, 2000));
assertFalse(s.franchit(j, Controle.PORTEE, Sanction.SETBACK, 3000));
assertFalse(s.franchit(j, Controle.PORTEE, Sanction.ALERTE, 4000)); // jamais de redescente
assertTrue(s.franchit(j, Controle.PORTEE, Sanction.EXPULSION, 5000));
assertTrue(s.franchit(j, Controle.VOL, Sanction.ALERTE, 5000)); // un autre contrôle : un autre épisode
assertTrue(s.franchit(j, Controle.PORTEE, Sanction.ALERTE, 700_000)); // l'épisode est fini
assertFalse(s.franchit(j, Controle.HITBOX, Sanction.JOURNAL, 0)); // sous le palier minimum
assertFalse(s.franchit(j, Controle.HITBOX, Sanction.AUCUNE, 0));
}
@Test
void joueurPartiOublieEtMemoireBornee() {
SuiviPaliers s = new SuiviPaliers(600_000, Sanction.ALERTE);
UUID j = UUID.randomUUID();
s.franchit(j, Controle.PORTEE, Sanction.ALERTE, 0);
s.oublier(j);
assertEquals(0, s.taille());
for (int i = 0; i < 20_000; i++) s.franchit(UUID.randomUUID(), Controle.PORTEE, Sanction.ALERTE, 0);
assertTrue(s.taille() <= 4096, "taille " + s.taille());
}
// --- Clé ---
private static final String CLE_TEST = "cle-de-test-0123456789-0123456789-ABCDEF"; // valeur factice, pas une vraie clé
@Test
void cleLueSansEtatsDAme(@TempDir Path tmp) throws IOException {
Path f = tmp.resolve("k.key");
Files.writeString(f, "# commentaire\n\n " + CLE_TEST + " \n", StandardCharsets.UTF_8);
LecteurCle.Resultat r = LecteurCle.lire(f);
assertTrue(r.ok());
assertEquals(CLE_TEST, r.cle());
assertFalse(r.toString().contains(CLE_TEST));
}
@Test
void cleAbsenteVideCourteOuPiegee(@TempDir Path tmp) throws IOException {
assertEquals(LecteurCle.Raison.ABSENTE, LecteurCle.lire(tmp.resolve("rien")).raison());
assertEquals(LecteurCle.Raison.ABSENTE, LecteurCle.lire(null).raison());
Path f = tmp.resolve("k.key");
Files.writeString(f, "# rien\n");
assertEquals(LecteurCle.Raison.VIDE, LecteurCle.lire(f).raison());
Files.writeString(f, "trop-court\n");
assertEquals(LecteurCle.Raison.TROP_COURTE, LecteurCle.lire(f).raison());
Files.writeString(f, CLE_TEST + " avec espace\n");
assertEquals(LecteurCle.Raison.CARACTERES_INVALIDES, LecteurCle.lire(f).raison());
Files.writeString(f, "x".repeat(5000));
assertEquals(LecteurCle.Raison.TROP_LONGUE, LecteurCle.lire(f).raison());
assertNull(LecteurCle.lire(f).cle());
}
@Test
void messagesDErreurSansLeContenuDeLaCle(@TempDir Path tmp) throws IOException {
Path f = tmp.resolve("k.key");
Files.writeString(f, CLE_TEST + " espace\n");
LecteurCle.Resultat r = LecteurCle.lire(f);
for (LecteurCle.Raison raison : LecteurCle.Raison.values()) {
assertFalse(LecteurCle.message(f, raison).contains("cle-de-test"), raison.name());
}
assertNull(r.cle());
}
// --- Réglages ---
@Test
void adresseDeLApiAcceptSeulementHttpSansIdentifiants(@TempDir Path tmp) {
assertEquals("http://hub:8080/internal/detections", cfg("http://hub:8080", tmp).adresseApi().toString());
assertEquals("https://hub/internal/detections", cfg("https://hub/", tmp).adresseApi().toString());
assertNull(cfg("", tmp).adresseApi());
assertNull(cfg("ftp://hub", tmp).adresseApi());
assertNull(cfg("http://utilisateur:secret@hub", tmp).adresseApi());
assertNull(cfg("http://hub?x=1", tmp).adresseApi());
assertNull(cfg("pas une adresse", tmp).adresseApi());
}
@Test
void reglagesBornes(@TempDir Path tmp) {
HubConfig c = new HubConfig(true, "http://hub", Path.of("k"), false, Sanction.JOURNAL, 999, 1, 1, Long.MAX_VALUE,
0, 0, 0, 0, true, tmp);
assertEquals(Sanction.ALERTE, c.palierMin());
assertEquals(50, c.lotMax());
assertTrue(c.ageMaxMs() < HubConfig.AGE_MAX_API_MS);
assertTrue(c.fileMax() >= 10);
assertTrue(c.debitMaxParMinute() >= 1);
assertFalse(HubConfig.defaut(tmp).envoi());
}
private static HubConfig cfg(String url, Path tmp) {
return new HubConfig(true, url, Path.of("k"), false, Sanction.ALERTE, 50, 2000, 100, 3600_000L, 50, 600_000L, 1000, 1000,
true, tmp);
}
}
+62
Voir le fichier
@@ -0,0 +1,62 @@
package com.gastinelgarde.hub;
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.electronwill.nightconfig.core.CommentedConfig;
import com.electronwill.nightconfig.toml.TomlFormat;
import com.gastinelgarde.GardeSpec;
import com.gastinelgarde.core.Sanction;
import java.io.StringWriter;
import java.nio.file.Path;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
/**
* Vérifie, sur la VRAIE définition de configuration (GardeSpec, compilée avec NeoForge), que l'envoi au Hub est
* coupé par défaut : fichier TOML généré à partir de zéro, et réglages lus quand rien n'est chargé.
*/
class HubDesactiveParDefautTest {
@Test
void fichierDeConfigurationGenereAvecEnvoiCoupe() {
CommentedConfig c = CommentedConfig.inMemory();
GardeSpec.SPEC.correct(c); // remplit les valeurs par défaut, comme à la première création du fichier
assertEquals(Boolean.FALSE, c.get("hub.envoi"), "hub.envoi doit valoir false par défaut");
assertEquals("", c.get("hub.url"), "aucune adresse par défaut");
assertEquals(Boolean.FALSE, c.get("hub.envoyerObserve"));
assertEquals("ALERTE", String.valueOf((Object) c.get("hub.palierMin")));
StringWriter sw = new StringWriter();
TomlFormat.instance().createWriter().write(c, sw);
String toml = sw.toString();
assertTrue(toml.contains("[hub]"), "section hub présente");
assertTrue(toml.matches("(?s).*\\[hub\\][^\\[]*\\benvoi = false\\b.*"), "envoi = false dans le TOML généré");
// la clé de source ne figure jamais dans la configuration : seulement le CHEMIN du fichier
assertFalse(toml.toLowerCase().matches("(?s).*\\n[ \\t]*(cle|key|secret|token)[ \\t]*=.*"), "aucun réglage ne porte la clé elle-même");
assertTrue(toml.contains("fichierCle = \"config/gastinelgarde-hub.key\""));
}
@Test
void reglagesParDefautSansConfigurationChargee(@TempDir Path tmp) {
HubConfig h = GardeSpec.hub(tmp);
assertFalse(h.envoi());
assertFalse(h.envoyerObserve());
assertEquals(Sanction.ALERTE, h.palierMin());
assertEquals(10_000, h.fileMax());
assertEquals(50, h.lotMax());
assertEquals(23L * 3600_000L, h.ageMaxMs());
}
@Test
void sansDemarrageOuAvecEnvoiCoupeRienNEstActifNiEnvoye(@TempDir Path tmp) {
Signalement.arreter();
assertFalse(Signalement.actif());
java.util.List<String> journal = new java.util.ArrayList<>();
Signalement.demarrer(GardeSpec.hub(tmp), tmp.resolve("absente.key"), journal::add, "0.3.2");
assertFalse(Signalement.actif(), "envoi = false : aucun fil, aucune file");
assertTrue(journal.stream().anyMatch(l -> l.contains("désactivé")));
assertTrue(Thread.getAllStackTraces().keySet().stream().noneMatch(t -> t.getName().equals("GastinelGarde-Hub")),
"aucun fil d'envoi créé");
}
}
+268
Voir le fichier
@@ -0,0 +1,268 @@
package com.gastinelgarde.hub;
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.Controle;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Verdict;
import java.io.IOException;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.OptionalLong;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
/** Le point d'entrée appelé par le tick : coupé par défaut, rapide, jamais d'exception, contrat respecté. */
class SignalementTest {
static final String CLE = EnvoiHubServeurTest.CLE;
final List<String> journal = new CopyOnWriteArrayList<>();
final List<String> corpsRecus = new CopyOnWriteArrayList<>();
final AtomicLong horloge = new AtomicLong(1_760_000_000_000L);
@AfterEach
void nettoyer() {
Signalement.arreter();
}
Path cle(Path tmp) throws IOException {
Path k = tmp.resolve("hub.key");
Files.writeString(k, CLE + "\n", StandardCharsets.UTF_8);
return k;
}
HubConfig cfg(Path tmp, boolean envoi, boolean observe) {
return new HubConfig(envoi, "http://hub:8080", tmp.resolve("hub.key"), observe, Sanction.ALERTE, 50, 200, 1000,
3600_000L, 50, 600_000L, 1000, 2000, true, tmp.resolve("etat"));
}
static Verdict verdict(Controle c, Mode m, Sanction palier, Sanction applicable, List<String> ex) {
return new Verdict(c, m, 1.0, 9.0, palier, applicable, false, "détail interne avec pseudo Steve et 198.51.100.7", ex);
}
/** Transport qui note les corps reçus et répond 200. */
Transport enregistreur(CountDownLatch recu) {
return (URI adresse, String cle, String corps) -> {
assertEquals(CLE, cle);
corpsRecus.add(corps);
if (recu != null) recu.countDown();
return new Transport.Reponse(200, "{\"resultats\":[]}", OptionalLong.empty());
};
}
@Test
void desactiveParDefautRienNeEstCree(@TempDir Path tmp) {
assertFalse(HubConfig.defaut(tmp).envoi());
assertFalse(Signalement.actif());
Signalement.surVerdict(UUID.randomUUID(), verdict(Controle.PORTEE, Mode.ENFORCE, Sanction.EXPULSION, Sanction.EXPULSION, List.of()),
() -> {
throw new AssertionError("la position ne doit pas être demandée quand c'est désactivé");
});
assertTrue(Signalement.resume().contains("désactivé"));
}
@Test
void envoiFauxNeDemarreRienMemeAvecUneCle(@TempDir Path tmp) throws IOException {
Signalement.demarrer(cfg(tmp, false, false), cle(tmp), enregistreur(null), horloge::get, journal::add, "0.3.2");
assertFalse(Signalement.actif());
assertTrue(journal.get(0).contains("désactivé"));
}
@Test
void sansCleOuAvecCleCourteOuMauvaiseAdresseOnNeDemarrePas(@TempDir Path tmp) throws IOException {
Signalement.demarrer(cfg(tmp, true, false), tmp.resolve("absent.key"), enregistreur(null), horloge::get, journal::add, "0.3.2");
assertFalse(Signalement.actif());
assertTrue(journal.get(0).contains("absent"));
Files.writeString(tmp.resolve("courte.key"), "courte\n");
Signalement.demarrer(cfg(tmp, true, false), tmp.resolve("courte.key"), enregistreur(null), horloge::get, journal::add, "0.3.2");
assertFalse(Signalement.actif());
HubConfig mauvaise = new HubConfig(true, "ftp://hub", tmp.resolve("hub.key"), false, Sanction.ALERTE, 50, 200, 1000,
3600_000L, 50, 600_000L, 1000, 2000, true, tmp.resolve("etat"));
Signalement.demarrer(mauvaise, cle(tmp), enregistreur(null), horloge::get, journal::add, "0.3.2");
assertFalse(Signalement.actif());
for (String l : journal) assertFalse(l.contains(CLE), l);
for (String l : journal) assertTrue(l.startsWith("Hub :"), l);
}
@Test
void franchissementEnEnforceEstEnvoyeAvecLeContrat(@TempDir Path tmp) throws Exception {
CountDownLatch recu = new CountDownLatch(1);
Signalement.demarrer(cfg(tmp, true, false), cle(tmp), enregistreur(recu), horloge::get, journal::add, "0.3.2");
assertTrue(Signalement.actif());
UUID j = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
Signalement.surVerdict(j, verdict(Controle.NO_FALL, Mode.ENFORCE, Sanction.SETBACK, Sanction.SETBACK,
List.of("elytres", "Chute Lente", "198.51.100.9")), () -> new Signalement.Position(10, 64, -3, "minecraft:overworld"));
assertTrue(recu.await(5, TimeUnit.SECONDS), "envoi attendu en moins de 5 s");
@SuppressWarnings("unchecked")
Map<String, Object> m = (Map<String, Object>) MiniJson.lire(corpsRecus.get(0));
@SuppressWarnings("unchecked")
Map<String, Object> d = (Map<String, Object>) ((List<?>) m.get("detections")).get(0);
assertEquals("no-fall", d.get("type"));
assertEquals(2L, ((Number) d.get("gravite")).longValue());
assertEquals("enforce", d.get("mode"));
assertTrue(((String) d.get("id_externe")).startsWith(j + ":no-fall:setback:"));
@SuppressWarnings("unchecked")
Map<String, Object> det = (Map<String, Object>) d.get("details");
assertEquals("no-fall", det.get("controle"));
assertEquals(3L, ((Number) det.get("palier")).longValue());
assertEquals(List.of("elytres", "chute_lente"), det.get("exemptions"));
assertEquals("0.3.2", det.get("version_mod"));
assertEquals("minecraft:overworld", det.get("dimension"));
assertEquals(10L, ((Number) det.get("x")).longValue());
// aucun texte libre du moteur (pseudo, adresse) dans ce qui part
String corps = corpsRecus.get(0);
assertFalse(corps.contains("Steve"));
assertFalse(corps.contains("198.51.100"));
assertFalse(corps.contains("détail"));
}
@Test
void observeNEstPasEnvoyeParDefautEtMarqueObserveSiOnLeDemande(@TempDir Path tmp) throws Exception {
Signalement.demarrer(cfg(tmp, true, false), cle(tmp), enregistreur(null), horloge::get, journal::add, "0.3.2");
UUID j = UUID.randomUUID();
Signalement.surVerdict(j, verdict(Controle.VOL, Mode.OBSERVE, Sanction.EXPULSION, Sanction.ALERTE, List.of()), null);
assertEquals(0, Signalement.instanceCourante().file().taille() + Signalement.instanceCourante().envoi().envoyees());
Signalement.arreter();
CountDownLatch recu = new CountDownLatch(1);
Signalement.demarrer(cfg(tmp, true, true), cle(tmp), enregistreur(recu), horloge::get, journal::add, "0.3.2");
Signalement.surVerdict(j, verdict(Controle.VOL, Mode.OBSERVE, Sanction.EXPULSION, Sanction.ALERTE, List.of()), null);
assertTrue(recu.await(5, TimeUnit.SECONDS));
assertTrue(corpsRecus.get(corpsRecus.size() - 1).contains("\"mode\":\"observe\""));
assertTrue(corpsRecus.get(corpsRecus.size() - 1).contains("\"gravite\":3"), "OBSERVE : palier mérité");
}
@Test
void enEnforceLaSanctionReellementAppliqueeFaitLaGravite(@TempDir Path tmp) throws Exception {
CountDownLatch recu = new CountDownLatch(1);
Signalement.demarrer(cfg(tmp, true, false), cle(tmp), enregistreur(recu), horloge::get, journal::add, "0.3.2");
Signalement.surVerdict(UUID.randomUUID(), verdict(Controle.PORTEE, Mode.ENFORCE, Sanction.EXPULSION, Sanction.SETBACK, List.of()), null);
assertTrue(recu.await(5, TimeUnit.SECONDS));
assertTrue(corpsRecus.get(0).contains("\"gravite\":2"));
}
@Test
void modeOffJournalEtAucuneNeSontJamaisEnvoyes(@TempDir Path tmp) throws Exception {
Signalement.demarrer(cfg(tmp, true, true), cle(tmp), enregistreur(null), horloge::get, journal::add, "0.3.2");
UUID j = UUID.randomUUID();
Signalement.surVerdict(j, verdict(Controle.PORTEE, Mode.OFF, Sanction.EXPULSION, Sanction.EXPULSION, List.of()), null);
Signalement.surVerdict(j, verdict(Controle.PORTEE, Mode.ENFORCE, Sanction.JOURNAL, Sanction.JOURNAL, List.of()), null);
Signalement.surVerdict(j, verdict(Controle.PORTEE, Mode.ENFORCE, Sanction.AUCUNE, Sanction.AUCUNE, List.of()), null);
assertEquals(0, Signalement.instanceCourante().file().taille());
}
@Test
void uneRafaleDInfractionsDonneAuPlusTroisSignalementsParControle(@TempDir Path tmp) throws Exception {
Signalement.demarrer(cfg(tmp, true, false), cle(tmp), (a, c, b) -> {
throw new IOException("hub arrêté");
}, horloge::get, journal::add, "0.3.2");
UUID j = UUID.randomUUID();
for (int i = 0; i < 5000; i++) {
Sanction s = i < 1000 ? Sanction.ALERTE : i < 2000 ? Sanction.SETBACK : Sanction.EXPULSION;
Signalement.surVerdict(j, verdict(Controle.PORTEE, Mode.ENFORCE, s, s, List.of()), null);
}
// le fil d'envoi peut déjà avoir pris un lot ; ce qui compte : 3 identifiants distincts au total
Thread.sleep(100);
int total = Signalement.instanceCourante().file().taille();
assertTrue(total <= 3 && total >= 1, "signalements en file : " + total);
}
@Test
void leTickNEstJamaisRalentiMemeSiLeHubBloque(@TempDir Path tmp) throws Exception {
CountDownLatch bloque = new CountDownLatch(1);
CountDownLatch entre = new CountDownLatch(1);
Transport bloquant = (a, c, corps) -> {
entre.countDown();
bloque.await(30, TimeUnit.SECONDS); // simule un Hub qui ne répond jamais
throw new IOException("délai dépassé");
};
Signalement.demarrer(cfg(tmp, true, false), cle(tmp), bloquant, horloge::get, journal::add, "0.3.2");
// une première détection pour que le fil d'envoi se bloque dans le transport
Signalement.surVerdict(UUID.randomUUID(), verdict(Controle.PORTEE, Mode.ENFORCE, Sanction.ALERTE, Sanction.ALERTE, List.of()), null);
assertTrue(entre.await(5, TimeUnit.SECONDS));
int joueurs = 20_000;
UUID[] ids = new UUID[joueurs];
for (int i = 0; i < joueurs; i++) ids[i] = UUID.randomUUID();
Verdict v = verdict(Controle.VITESSE, Mode.ENFORCE, Sanction.SETBACK, Sanction.SETBACK, List.of("elytres"));
long t0 = System.nanoTime();
for (UUID id : ids) Signalement.surVerdict(id, v, () -> new Signalement.Position(1, 2, 3, "minecraft:overworld"));
long ms = (System.nanoTime() - t0) / 1_000_000;
double microsParAppel = ms * 1000.0 / joueurs;
System.out.println("MESURE tick : " + joueurs + " signalements pendant que le Hub est bloqué : " + ms + " ms ("
+ String.format("%.1f", microsParAppel) + " µs par appel)");
assertTrue(ms < 1500, "20 000 signalements en " + ms + " ms : le tick attendrait le Hub");
assertTrue(microsParAppel < 100, "coût par appel : " + microsParAppel + " µs");
bloque.countDown();
}
@Test
void desactiverPendantLeJeuNeLeveAucuneException(@TempDir Path tmp) throws Exception {
Signalement.demarrer(cfg(tmp, true, false), cle(tmp), enregistreur(null), horloge::get, journal::add, "0.3.2");
UUID j = UUID.randomUUID();
Signalement.surVerdict(j, verdict(Controle.PORTEE, Mode.ENFORCE, Sanction.ALERTE, Sanction.ALERTE, List.of()), () -> {
throw new IllegalStateException("position indisponible");
});
Signalement.joueurParti(j);
Signalement.arreter();
Signalement.arreter();
Signalement.surVerdict(j, verdict(Controle.PORTEE, Mode.ENFORCE, Sanction.ALERTE, Sanction.ALERTE, List.of()), null);
Signalement.joueurParti(j);
assertFalse(Signalement.actif());
}
@Test
void redemarrageEcritLaFileSurDisqueEtLaReprend(@TempDir Path tmp) throws Exception {
AtomicInteger appels = new AtomicInteger();
Transport panne = (a, c, b) -> {
appels.incrementAndGet();
throw new IOException("hub arrêté");
};
Signalement.demarrer(cfg(tmp, true, false), cle(tmp), panne, horloge::get, journal::add, "0.3.2");
UUID j = UUID.randomUUID();
Signalement.surVerdict(j, verdict(Controle.PORTEE, Mode.ENFORCE, Sanction.ALERTE, Sanction.ALERTE, List.of()), null);
Signalement.surVerdict(j, verdict(Controle.VOL, Mode.ENFORCE, Sanction.SETBACK, Sanction.SETBACK, List.of()), null);
Signalement.arreter(); // arrêt du serveur
assertTrue(Files.exists(tmp.resolve("etat/file-attente.jsonl")));
String contenu = Files.readString(tmp.resolve("etat/file-attente.jsonl"));
assertFalse(contenu.contains(CLE), "la clé ne doit jamais être écrite dans la file sur disque");
assertEquals(2, contenu.lines().count());
CountDownLatch recu = new CountDownLatch(1);
Signalement.demarrer(cfg(tmp, true, false), cle(tmp), enregistreur(recu), horloge::get, journal::add, "0.3.2");
assertTrue(recu.await(5, TimeUnit.SECONDS));
assertEquals(2, ((List<?>) ((Map<?, ?>) MiniJson.lire(corpsRecus.get(0))).get("detections")).size());
assertNotNull(journal.stream().filter(l -> l.contains("reprise")).findFirst().orElse(null));
}
@Test
void lesMessagesDuJournalNeContiennentJamaisLaCle(@TempDir Path tmp) throws Exception {
Transport panne = (a, c, b) -> {
throw new IOException("échec contenant " + c); // pire cas : la bibliothèque réseau met la clé dans son message
};
Signalement.demarrer(cfg(tmp, true, false), cle(tmp), panne, horloge::get, journal::add, "0.3.2");
Signalement.surVerdict(UUID.randomUUID(), verdict(Controle.PORTEE, Mode.ENFORCE, Sanction.ALERTE, Sanction.ALERTE, List.of()), null);
Thread.sleep(800);
Signalement.arreter();
assertFalse(journal.isEmpty());
List<String> tout = new ArrayList<>(journal);
tout.add(Signalement.resume());
for (String l : tout) assertFalse(l.contains(CLE), l);
}
}