Comparer les révisions
20
Révisions
Aucun fichier ne correspond à votre recherche
@@ -7,3 +7,4 @@ run/
|
||||
|
||||
# sauvegardes avant modification
|
||||
*.avant-*
|
||||
livrable/
|
||||
@@ -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.
|
||||
@@ -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
@@ -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 :
|
||||
|
||||
@@ -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,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
|
||||
|
||||
|
||||
@@ -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 + ")");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -16,6 +16,7 @@ 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;
|
||||
@@ -77,13 +78,12 @@ public final class Garde {
|
||||
int vehiculeTick = Integer.MIN_VALUE;
|
||||
double vehiculeX, vehiculeY, vehiculeZ;
|
||||
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
|
||||
int contraptionTick = Integer.MIN_VALUE;
|
||||
int contraptionVuTick = Integer.MIN_VALUE;
|
||||
boolean contraptionProche;
|
||||
final Cablage.CacheDetection contraption = new Cablage.CacheDetection();
|
||||
// C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
|
||||
int solServeurTick = Integer.MIN_VALUE;
|
||||
final Cablage.Elytres elytres = new Cablage.Elytres();
|
||||
// Cache de la détection d'un courant d'air (ventilateur Create), même principe
|
||||
int courantTick = Integer.MIN_VALUE;
|
||||
int courantVuTick = Integer.MIN_VALUE;
|
||||
boolean courantProche;
|
||||
final Cablage.CacheDetection courant = new Cablage.CacheDetection();
|
||||
// #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux)
|
||||
double[] oeilDernier;
|
||||
double[] oeilAvant;
|
||||
@@ -116,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;
|
||||
@@ -134,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() {
|
||||
@@ -149,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();
|
||||
@@ -182,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);
|
||||
@@ -198,6 +235,9 @@ public final class Garde {
|
||||
m.vehiculeId = -1;
|
||||
m.oeilAvant = null;
|
||||
m.oeilDernier = null;
|
||||
// D1 (0.3.2) : réapparition, changement de dimension, connexion : la position actuelle devient le retour.
|
||||
Cablage.retourApresTeleport(MOTEUR.suivi(p.getUUID()), true, p.getX(), p.getY(), p.getZ(), p.getYRot(),
|
||||
p.getXRot(), p.level().dimension().location().toString());
|
||||
}
|
||||
|
||||
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
|
||||
@@ -210,10 +250,21 @@ 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;
|
||||
@@ -240,6 +291,8 @@ public final class Garde {
|
||||
SUIVIES.put(p.getId(), s);
|
||||
}
|
||||
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
|
||||
// Revue 4 (16/10) : ping noté chaque seconde, hors combat aussi, pour le plancher de ping.
|
||||
if (tick % 20 == 0) MOTEUR.pingFenetre(p.getUUID(), tick * 50L, p.connection.latency());
|
||||
}
|
||||
java.util.Iterator<Map.Entry<Integer, Suivie>> it = SUIVIES.entrySet().iterator();
|
||||
while (it.hasNext()) {
|
||||
@@ -273,7 +326,11 @@ public final class Garde {
|
||||
if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return null;
|
||||
Suivie s = SUIVIES.get(cible.getId());
|
||||
if (s == null || s.entite != cible) {
|
||||
if (!(cible instanceof Player) && SUIVIES.size() < SUIVIES_MAX) {
|
||||
if (!(cible instanceof Player)) {
|
||||
// Revue 3 (16/10) : table pleine, on évince la cible non joueur frappée il y a le plus longtemps
|
||||
// (avant : la nouvelle cible n'était jamais suivie, faire frapper beaucoup d'entités aveuglait le
|
||||
// contrôle). La cible qu'on frappe sans arrêt est la plus récente : jamais évincée.
|
||||
if (s == null && SUIVIES.size() >= SUIVIES_MAX) evincerPlusAncienne();
|
||||
s = new Suivie(cible);
|
||||
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
|
||||
SUIVIES.put(cible.getId(), s);
|
||||
@@ -282,10 +339,28 @@ public final class Garde {
|
||||
}
|
||||
if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
|
||||
if (s.niveau != cible.level()) return null;
|
||||
int fenetre = PorteeHitbox.ticksFenetre(attaquant.connection.latency(), CONFIG);
|
||||
// Revue 4 (16/10) : ping plancher des 2 dernières minutes + marge, pas le ping déclaré du moment.
|
||||
int fenetre = PorteeHitbox.ticksFenetre(
|
||||
MOTEUR.pingFenetre(attaquant.getUUID(), tick * 50L, attaquant.connection.latency()), CONFIG);
|
||||
return s.historique.depuis(tick - fenetre);
|
||||
}
|
||||
|
||||
/** Revue 3 : retire de la table l'entrée non joueur dont le dernier coup est le plus ancien. */
|
||||
private static void evincerPlusAncienne() {
|
||||
Integer cle = null;
|
||||
int plusTot = Integer.MAX_VALUE;
|
||||
for (Map.Entry<Integer, Suivie> e : SUIVIES.entrySet()) {
|
||||
Suivie v = e.getValue();
|
||||
if (v != null && v.entite instanceof Player) continue;
|
||||
int t = v == null ? Integer.MIN_VALUE : v.jusquaTick;
|
||||
if (cle == null || t < plusTot) {
|
||||
cle = e.getKey();
|
||||
plusTot = t;
|
||||
}
|
||||
}
|
||||
if (cle != null) SUIVIES.remove(cle);
|
||||
}
|
||||
|
||||
/** Œil de l'attaquant au paquet de mouvement d'avant le dernier (null si inconnu). */
|
||||
public static double[] oeilAvant(ServerPlayer p) {
|
||||
Marques m = MARQUES.get(p.getUUID());
|
||||
@@ -362,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())
|
||||
@@ -446,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);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -502,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()))
|
||||
@@ -546,22 +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 (MOTEUR.estExpulse(p.getUUID())) return; // C4 : expulsion en cours, plus rien à évaluer
|
||||
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;
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion
|
||||
// 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());
|
||||
@@ -579,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())) {
|
||||
@@ -604,8 +687,8 @@ 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.
|
||||
// C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air.
|
||||
if (m.dernierVerdictTick != tick && !vehiculeControle(p)
|
||||
&& MOTEUR.positionDeRetourAdmise(solServeur, em != null && em.milieuSpecial())) {
|
||||
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());
|
||||
}
|
||||
@@ -825,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);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -872,22 +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) {
|
||||
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
|
||||
if (!MOTEUR.expulser(p.getUUID(), p.server.getTickCount() * 50L)) return;
|
||||
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());
|
||||
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
|
||||
MOTEUR.apresSetback(p.getUUID(), p.server.getTickCount() * 50L);
|
||||
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); }
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -57,11 +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.moteur().estExpulse(p.getUUID())) { // C4 : expulsion en cours
|
||||
event.setCanceled(true);
|
||||
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 -> { }
|
||||
}
|
||||
if (Garde.estExempteManuellement(p.getUUID())) return;
|
||||
|
||||
Entity cible = event.getTarget();
|
||||
int tick = p.server.getTickCount();
|
||||
@@ -83,8 +88,9 @@ public final class GardeEvents {
|
||||
// (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere).
|
||||
// L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
|
||||
Entity racine = cible.getRootVehicle();
|
||||
boolean mesurerPH = !Garde.estContraption(cible) && !SableAcces.surSousNiveau(cible)
|
||||
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
|
||||
boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> Garde.estContraption(cible),
|
||||
() -> SableAcces.surSousNiveau(cible), racine == cible, () -> Garde.estContraption(racine),
|
||||
() -> SableAcces.surSousNiveau(racine));
|
||||
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
|
||||
+ Math.pow(cible.getZ() - cible.zo, 2));
|
||||
// #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge
|
||||
@@ -103,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). */
|
||||
|
||||
@@ -49,6 +49,14 @@ public final class GardeSpec {
|
||||
|
||||
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
|
||||
private static final ModConfigSpec.IntValue SERIE_PING_MAX;
|
||||
private static final ModConfigSpec.IntValue SERIE_PING_MARGE;
|
||||
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX;
|
||||
private static final ModConfigSpec.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;
|
||||
@@ -70,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;
|
||||
@@ -125,8 +148,10 @@ public final class GardeSpec {
|
||||
"Valeurs de départ prudentes, à régler avec les journaux en OBSERVE avant tout ENFORCE.").push("coupsHorsBoite");
|
||||
TICKS_AFFICHAGE = b.comment("Retard d'affichage de base de la cible chez le client (ticks) ; le ping s'ajoute (ping / 50).")
|
||||
.defineInRange("ticksAffichageCible", 7, 2, 12);
|
||||
SERIE_PING_MAX = b.comment("Ping (ms) au-delà duquel le coup n'est pas mesuré.")
|
||||
SERIE_PING_MAX = b.comment("Ping (ms) pris en compte au plus dans la fenêtre (au-delà, le coup est mesuré avec cette fenêtre).")
|
||||
.defineInRange("seriePingMaxMs", 500, 100, 500);
|
||||
SERIE_PING_MARGE = b.comment("Fenêtre selon le ping le plus bas des 2 dernières minutes + cette marge (ms), pas le ping du moment.")
|
||||
.defineInRange("seriePingMargeMs", 50, 0, 500);
|
||||
SERIE_MANQUE = b.comment("Coup hors boîte si le regard manque toutes les boîtes vues de plus de cette marge (blocs).")
|
||||
.defineInRange("serieManqueBlocs", 0.15, 0.05, 2.0);
|
||||
SERIE_PORTEE = b.comment("... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs).")
|
||||
@@ -140,12 +165,29 @@ public final class GardeSpec {
|
||||
b.push("timer");
|
||||
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
|
||||
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
|
||||
TIMER_SOLDE_MAX = b.comment("C15 : solde de paquets (reçus - ticks écoulés) au-delà duquel le timer compte (timer 1,05-1,10).",
|
||||
"0 = désactivé (défaut). Essai conseillé : 20, en OBSERVE.")
|
||||
.defineInRange("timerSoldeMax", 0, 0, 1000);
|
||||
b.pop();
|
||||
|
||||
b.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");
|
||||
@@ -195,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();
|
||||
@@ -207,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();
|
||||
}
|
||||
|
||||
@@ -248,6 +322,13 @@ public final class GardeSpec {
|
||||
c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
|
||||
c.ticksAffichageCible = TICKS_AFFICHAGE.get();
|
||||
c.seriePingMaxMs = SERIE_PING_MAX.get();
|
||||
c.seriePingMargeMs = SERIE_PING_MARGE.get();
|
||||
c.timerSoldeMax = TIMER_SOLDE_MAX.get();
|
||||
c.volFenetreGlissante = VOL_FENETRE_GLISSANTE.get();
|
||||
c.vitesseMoyenne = VITESSE_MOYENNE.get();
|
||||
c.elytresExemptionStricte = ELYTRES_STRICTE.get();
|
||||
c.elytresAirMinTicks = ELYTRES_AIR_MIN.get();
|
||||
c.combatMesureEnVehicule = COMBAT_VEHICULE.get();
|
||||
c.serieManqueBlocs = SERIE_MANQUE.get();
|
||||
c.seriePorteeMargeBlocs = SERIE_PORTEE.get();
|
||||
c.serieCoups = SERIE_COUPS.get();
|
||||
@@ -322,6 +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;
|
||||
}
|
||||
|
||||
@@ -342,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);
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -15,6 +15,24 @@ final class CoupDiffere {
|
||||
/** Le paquet de mouvement du même tick arrive normalement juste après ; 2 ticks de marge pour la gigue. */
|
||||
static final int TICKS_MAX = 2;
|
||||
|
||||
/**
|
||||
* Revue 2 / C13 (16/10) : au-delà de cet angle entre le regard du coup et celui du paquet suivant (rotation
|
||||
* silencieuse : regard ailleurs au coup, ramené sur la cible juste après), le regard suivant n'est plus pris par
|
||||
* coups-hors-boite, et le coup est compté comme « sauvé par le regard suivant » pour l'angle killaura (série, voir
|
||||
* {@link Suivi#regardsSauves}). Un coup isolé garde le bénéfice du doute (demi-tour honnête possible).
|
||||
* [À VÉRIFIER] en jeu : 90° couvre un « flick » honnête.
|
||||
*/
|
||||
static final double REGARD_SUIVANT_MAX_DEGRES = 90.0;
|
||||
/**
|
||||
* Revue 2 / C13 : l'œil du paquet suivant est ramené à au plus un tick de déplacement de l'œil du coup :
|
||||
* déplacement horizontal du tick précédent + cette marge (accélération, élan d'un saut en courant)...
|
||||
*/
|
||||
static final double OEIL_SUIVANT_MARGE_H = 0.4;
|
||||
/** ... déplacement vertical du tick précédent + cette marge (saut : 0,42)... */
|
||||
static final double OEIL_SUIVANT_MARGE_V = 0.5;
|
||||
/** ... ou, sans œil précédent connu, ce déplacement (horizontal et vertical). */
|
||||
static final double OEIL_SUIVANT_DEFAUT = 0.6;
|
||||
|
||||
final long nowMs;
|
||||
final EtatJoueur etat;
|
||||
final double[] boite;
|
||||
@@ -34,6 +52,11 @@ final class CoupDiffere {
|
||||
/** Regard au coup et au paquet suivant (null si inconnu). */
|
||||
double[] regardCoup, regardSuivant;
|
||||
|
||||
/** Le regard du paquet suivant a été refusé (trop loin du regard du coup). */
|
||||
boolean regardSuivantRefuse;
|
||||
/** Excédent d'angle killaura avec le regard du coup seul (avant affinage), -1 si non mesuré. */
|
||||
double excedentCoup = -1;
|
||||
|
||||
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
|
||||
double distance, double manque, double excedent, boolean porteeHitbox) {
|
||||
this.nowMs = nowMs;
|
||||
@@ -52,10 +75,18 @@ final class CoupDiffere {
|
||||
return d >= 0 && d <= TICKS_MAX;
|
||||
}
|
||||
|
||||
/** Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. */
|
||||
void affiner(double[] oeil, double[] regard) {
|
||||
oeilSuivant = oeil.clone();
|
||||
regardSuivant = regard.clone();
|
||||
/**
|
||||
* Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. Revue 2 / C13 (16/10) : l'œil
|
||||
* suivant est borné à un tick de déplacement depuis l'œil du coup, et le regard suivant n'est pris que s'il reste
|
||||
* à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup.
|
||||
*/
|
||||
void affiner(double[] oeilRecu, double[] regardRecu) {
|
||||
double[] oeil = oeilCoup == null ? oeilRecu.clone() : bornerOeil(oeilCoup, oeilPrecedent, oeilRecu);
|
||||
double[] regard = regardRecu.clone();
|
||||
regardSuivantRefuse = regardCoup != null && !regardAdmis(regardCoup, regardRecu);
|
||||
excedentCoup = excedent;
|
||||
oeilSuivant = oeil;
|
||||
regardSuivant = regardSuivantRefuse ? null : regard;
|
||||
double[] b = boite;
|
||||
double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]);
|
||||
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
||||
@@ -68,4 +99,33 @@ final class CoupDiffere {
|
||||
if (a >= 0) excedent = Math.min(excedent, a);
|
||||
}
|
||||
}
|
||||
|
||||
/** Le regard suivant est-il à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup ? */
|
||||
static boolean regardAdmis(double[] coup, double[] suivant) {
|
||||
double n1 = Math.sqrt(coup[0] * coup[0] + coup[1] * coup[1] + coup[2] * coup[2]);
|
||||
double n2 = Math.sqrt(suivant[0] * suivant[0] + suivant[1] * suivant[1] + suivant[2] * suivant[2]);
|
||||
if (n1 < 1e-9 || n2 < 1e-9) return true;
|
||||
double c = (coup[0] * suivant[0] + coup[1] * suivant[1] + coup[2] * suivant[2]) / (n1 * n2);
|
||||
return c >= Math.cos(Math.toRadians(REGARD_SUIVANT_MAX_DEGRES)) - 1e-9;
|
||||
}
|
||||
|
||||
/** Œil suivant ramené à un tick de déplacement de l'œil du coup (horizontal et vertical à part). */
|
||||
static double[] bornerOeil(double[] coup, double[] precedent, double[] suivant) {
|
||||
double bornH, bornV;
|
||||
if (precedent == null) {
|
||||
bornH = OEIL_SUIVANT_DEFAUT;
|
||||
bornV = OEIL_SUIVANT_DEFAUT;
|
||||
} else {
|
||||
bornH = Math.hypot(coup[0] - precedent[0], coup[2] - precedent[2]) + OEIL_SUIVANT_MARGE_H;
|
||||
bornV = Math.abs(coup[1] - precedent[1]) + OEIL_SUIVANT_MARGE_V;
|
||||
}
|
||||
double dx = suivant[0] - coup[0], dz = suivant[2] - coup[2], dy = suivant[1] - coup[1];
|
||||
double h = Math.hypot(dx, dz);
|
||||
if (h > bornH) {
|
||||
dx *= bornH / h;
|
||||
dz *= bornH / h;
|
||||
}
|
||||
if (Math.abs(dy) > bornV) dy = Math.copySign(bornV, dy);
|
||||
return new double[] {coup[0] + dx, coup[1] + dy, coup[2] + dz};
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -72,7 +72,7 @@ public final class GardeConfig {
|
||||
* 3 ticks (mob), interpolation sur 3 ticks, plus 1 tick de gigue. Le ping s'ajoute (voir seriePingMaxMs).
|
||||
*/
|
||||
public int ticksAffichageCible = 7;
|
||||
/** Ping (ms) au-delà duquel la mesure compensée n'est pas faite (fenêtre plus large que l'historique fiable). */
|
||||
/** Ping (ms) pris en compte au plus dans la fenêtre (revue 1, 16/10 : au-delà, mesuré quand même, fenêtre bornée). */
|
||||
public int seriePingMaxMs = 500;
|
||||
/** Un coup est « hors boîte » si le regard manque toutes les boîtes vues de plus de cette marge (blocs). */
|
||||
public double serieManqueBlocs = 0.15;
|
||||
@@ -86,6 +86,30 @@ public final class GardeConfig {
|
||||
public long serieFenetreMs = 30000;
|
||||
/** Points par coup hors boîte dans une série suspecte. */
|
||||
public double seriePoints = 2.0;
|
||||
/**
|
||||
* Revue 4 (16/10) : la fenêtre d'historique suit le ping le plus bas vu ces 2 dernières minutes, plus cette marge
|
||||
* (ms), et non le ping déclaré : gonfler son ping pendant un combat n'élargit plus la fenêtre.
|
||||
*/
|
||||
public int seriePingMargeMs = 50;
|
||||
|
||||
// --- C10 / C15 (16/10) : détections supplémentaires, DÉSACTIVÉES par défaut (à valider en OBSERVE) ---
|
||||
/** C10 : vol, ticks anormaux comptés sur une fenêtre glissante et sauts en l'air sans appui. */
|
||||
public boolean volFenetreGlissante = false;
|
||||
/** C15 : vitesse moyenne sur 2 s comparée à la moyenne vanilla (course, sprint-saut). */
|
||||
public boolean vitesseMoyenne = false;
|
||||
|
||||
// --- C7 / C8 (16/10, constats hauts) : DÉSACTIVÉS par défaut (à valider en OBSERVE) ---
|
||||
/**
|
||||
* C7 : élytres. Pas d'exemption de mouvement si le plané a été déclenché sans au moins
|
||||
* {@link #elytresAirMinTicks} ticks en l'air (sol serveur), et portée / hitbox mesurées pendant le plané.
|
||||
*/
|
||||
public boolean elytresExemptionStricte = false;
|
||||
/** C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres. */
|
||||
public int elytresAirMinTicks = 2;
|
||||
/** C8 : le combat d'un passager de véhicule (bateau, cheval, minecart…) est mesuré comme à pied. */
|
||||
public boolean combatMesureEnVehicule = false;
|
||||
/** C15 : solde de paquets de mouvement (reçus - ticks écoulés) au-delà duquel le timer compte ; 0 = désactivé. */
|
||||
public int timerSoldeMax = 0;
|
||||
|
||||
// --- Exemptions ---
|
||||
public int graceTeleportTicks = 40;
|
||||
|
||||
@@ -121,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;
|
||||
}
|
||||
|
||||
@@ -185,12 +194,11 @@ public final class Moteur {
|
||||
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
||||
porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
|
||||
CoupDiffere c = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
|
||||
if (serie) {
|
||||
c.boitesVues = boitesVues;
|
||||
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
|
||||
c.oeilCoup = oeil.clone();
|
||||
c.regardCoup = regard.clone();
|
||||
}
|
||||
// Revue 2 / C13 : œil et regard du coup gardés dans tous les cas, pour borner ceux du paquet suivant.
|
||||
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
|
||||
c.oeilCoup = oeil.clone();
|
||||
c.regardCoup = regard.clone();
|
||||
if (serie) c.boitesVues = boitesVues;
|
||||
suivi(joueur).coupDiffere = c;
|
||||
return verdicts;
|
||||
}
|
||||
@@ -222,11 +230,23 @@ public final class Moteur {
|
||||
double pts = s.serie.enregistrer(c.nowMs, hors, cfg);
|
||||
List<Verdict> verdicts = new ArrayList<>(1);
|
||||
ajouter(verdicts, s, Controle.COUPS_HORS_BOITE, pts, c.nowMs, ex, String.format(Locale.ROOT,
|
||||
"manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d",
|
||||
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal()));
|
||||
"manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d%s",
|
||||
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal(),
|
||||
c.regardSuivantRefuse ? ", regard suivant refuse" : ""));
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Revue 4 (16/10) : ping à utiliser pour la fenêtre d'historique de coups-hors-boite (voir
|
||||
* {@link PorteeHitbox#ticksFenetre}). Note aussi le ping déclaré.
|
||||
*/
|
||||
public int pingFenetre(UUID joueur, long nowMs, int pingDeclare) {
|
||||
Suivi s = suivi(joueur);
|
||||
int plancher = s.pingPlancher.noter(nowMs, pingDeclare);
|
||||
long avecMarge = (long) plancher + Math.max(0, cfg.seriePingMargeMs);
|
||||
return (int) Math.max(0, Math.min(pingDeclare, avecMarge));
|
||||
}
|
||||
|
||||
/** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */
|
||||
public List<Verdict> regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
@@ -250,6 +270,12 @@ public final class Moteur {
|
||||
double seuil = cfg.angleMaxDegres * ex.facteur();
|
||||
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, KillauraAngle.points(c.excedent, seuil), c.nowMs, ex,
|
||||
String.format(Locale.ROOT, "excedent=%.1f deg (seuil %.0f, mesure differee)", c.excedent, seuil));
|
||||
// C13 : coup « sauvé » seulement par un regard suivant à plus de 90° du regard du coup.
|
||||
boolean sauve = c.regardSuivantRefuse && c.excedentCoup > seuil && !(c.excedent > seuil);
|
||||
double ptsSauves = s.regardsSauves.enregistrer(c.nowMs, sauve, cfg);
|
||||
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, ptsSauves, c.nowMs, ex, String.format(Locale.ROOT,
|
||||
"regard ramene sur la cible au paquet suivant (excedent au coup %.1f deg), %d coups sur %d",
|
||||
c.excedentCoup, s.regardsSauves.dernierCompte(), s.regardsSauves.dernierTotal()));
|
||||
}
|
||||
}
|
||||
if (c.porteeHitbox) {
|
||||
@@ -324,6 +350,7 @@ 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;
|
||||
@@ -332,10 +359,13 @@ public final class Moteur {
|
||||
}
|
||||
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(),
|
||||
@@ -350,6 +380,7 @@ public final class Moteur {
|
||||
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()));
|
||||
}
|
||||
@@ -427,6 +458,7 @@ public final class Moteur {
|
||||
Suivi s = suivi(joueur);
|
||||
s.vol.vider();
|
||||
s.vitesse.vider();
|
||||
s.dyChute = 0;
|
||||
s.graceElytresJusquaMs = Long.MIN_VALUE;
|
||||
s.vl.remettreAZero(Controle.VOL);
|
||||
s.vl.remettreAZero(Controle.VITESSE);
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -98,7 +98,7 @@ public final class PorteeHitbox {
|
||||
*/
|
||||
public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) {
|
||||
if (e.riptide()) return "riptide";
|
||||
if (e.elytres()) return "elytres";
|
||||
if (e.elytres() && !cfg.elytresExemptionStricte) return "elytres"; // C7 : mesuré avec l'option
|
||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) return "teleportation";
|
||||
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul";
|
||||
if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide";
|
||||
@@ -205,14 +205,15 @@ public final class PorteeHitbox {
|
||||
|
||||
/**
|
||||
* Situations où la mesure compensée n'est pas fiable (en plus de {@link #raisonNonMesure}, sans la vitesse
|
||||
* instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées), ping au-delà
|
||||
* de {@link GardeConfig#seriePingMaxMs} (la fenêtre ne couvrirait plus le retard d'affichage).
|
||||
* instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées).
|
||||
*
|
||||
* Revue 1 (16/10) : un ping au-delà de {@link GardeConfig#seriePingMaxMs} n'exempte plus le coup (le ping est
|
||||
* falsifiable) ; la fenêtre reste bornée à ce ping par {@link #ticksFenetre}.
|
||||
*/
|
||||
public static String raisonNonMesureSerie(EtatJoueur e, GardeConfig cfg) {
|
||||
String r = raisonNonMesure(e, 0, cfg);
|
||||
if (r != null) return r;
|
||||
if (e.ticksDepuisGel() <= cfg.graceGelTicks) return "gel-serveur";
|
||||
if (e.pingMs() > cfg.seriePingMaxMs) return "ping";
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -16,6 +16,13 @@ public final class Suivi {
|
||||
public final VehiculeMouvement vehicule = new VehiculeMouvement();
|
||||
/** #92 : derniers coups mesurés avec l'historique de la cible (contrôle coups-hors-boite). */
|
||||
public final SerieCoups serie = new SerieCoups();
|
||||
/** Revue 4 (16/10) : ping le plus bas des 2 dernières minutes (fenêtre de coups-hors-boite). */
|
||||
final PingPlancher pingPlancher = new PingPlancher();
|
||||
/**
|
||||
* C13 (16/10) : derniers coups dont l'angle killaura n'était bon que grâce à un regard suivant à plus de 90° du
|
||||
* regard du coup (rotation silencieuse). Mêmes réglages de série que coups-hors-boite.
|
||||
*/
|
||||
public final SerieCoups regardsSauves = new SerieCoups();
|
||||
|
||||
/** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
|
||||
CoupDiffere coupDiffere;
|
||||
@@ -23,6 +30,8 @@ public final class Suivi {
|
||||
long coupsBloquesJusqua = Long.MIN_VALUE;
|
||||
/** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */
|
||||
long graceElytresJusquaMs = Long.MIN_VALUE;
|
||||
/** D3 (0.3.2) : vitesse verticale du dernier paquet qui a bougé pendant une chute (0 au sol). */
|
||||
double dyChute;
|
||||
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
|
||||
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
|
||||
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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_.-]", "?");
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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.'''
|
||||
|
||||
@@ -16,8 +16,8 @@ import org.junit.jupiter.api.Test;
|
||||
/**
|
||||
* Autotests du 16/10/2026, nuit : contournement n°3 de la revue de sécurité (table SUIVIES pleine).
|
||||
*
|
||||
* Garde.boitesVues n'ajoute une cible non joueur à la table que si elle compte moins de SUIVIES_MAX entrées ; sinon
|
||||
* elle renvoie null (pas de mesure) et ne la suivra jamais tant que la table reste pleine. La table est commune à
|
||||
* 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é
|
||||
@@ -28,7 +28,7 @@ class AutotestSuiviesTest {
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Test
|
||||
void FAILLE_revue3_tablePleineLesNouvellesCiblesNeSontJamaisSuivies() throws Exception {
|
||||
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);
|
||||
@@ -52,11 +52,9 @@ class AutotestSuiviesTest {
|
||||
|
||||
table.clear();
|
||||
for (int i = 0; i < max; i++) table.put(-1 - i, null);
|
||||
for (int k = 0; k < 5; k++) {
|
||||
assertNull(Garde.boitesVues(cible, null, 1000 + 20 * k), "coup " + k + " non mesuré");
|
||||
}
|
||||
assertFalse(table.containsKey(cible.getId()), "prouvé : table pleine, la cible n'est jamais suivie");
|
||||
assertEquals(max, table.size(), "aucune éviction");
|
||||
assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet");
|
||||
assertTrue(table.containsKey(cible.getId()), "corrigé : table pleine, la cible est quand même suivie");
|
||||
assertEquals(max, table.size(), "une entrée évincée, la table ne grandit pas");
|
||||
} finally {
|
||||
table.clear();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,336 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import com.gastinelgarde.core.GardeConfig;
|
||||
import java.io.InputStream;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Proxy;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import net.neoforged.neoforge.common.ModConfigSpec;
|
||||
import org.junit.jupiter.api.Assumptions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.objectweb.asm.ClassReader;
|
||||
import org.objectweb.asm.tree.AbstractInsnNode;
|
||||
import org.objectweb.asm.tree.ClassNode;
|
||||
import org.objectweb.asm.tree.InvokeDynamicInsnNode;
|
||||
import org.objectweb.asm.tree.MethodInsnNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
|
||||
/**
|
||||
* Câblage Minecraft (constat C4 ⚠️), partie qui demande les classes du jeu mais pas de serveur : événements
|
||||
* NeoForge abonnés, gardes d'expulsion lues dans le bytecode, types d'entités (C18, F20), options (C7, C8, C10, C15,
|
||||
* C18) du fichier toml jusqu'à la configuration du moteur.
|
||||
*/
|
||||
class CablageMinecraftTest {
|
||||
|
||||
// --- Bytecode ---
|
||||
|
||||
private static ClassNode lire(Class<?> c) throws Exception {
|
||||
try (InputStream in = c.getResourceAsStream("/" + c.getName().replace('.', '/') + ".class")) {
|
||||
assertNotNull(in, c.getName());
|
||||
ClassNode n = new ClassNode();
|
||||
new ClassReader(in).accept(n, 0);
|
||||
return n;
|
||||
}
|
||||
}
|
||||
|
||||
/** Méthodes appelées par une méthode et par ses lambdas (récursivement, dans la même classe). */
|
||||
private static Set<String> appels(ClassNode classe, String methode) {
|
||||
Set<String> sortie = new HashSet<>();
|
||||
Set<String> vues = new HashSet<>();
|
||||
parcourir(classe, methode, sortie, vues);
|
||||
return sortie;
|
||||
}
|
||||
|
||||
private static void parcourir(ClassNode classe, String methode, Set<String> sortie, Set<String> vues) {
|
||||
if (!vues.add(methode)) return;
|
||||
boolean trouvee = false;
|
||||
for (MethodNode m : classe.methods) {
|
||||
if (!m.name.equals(methode)) continue;
|
||||
trouvee = true;
|
||||
for (AbstractInsnNode i : m.instructions) {
|
||||
if (i instanceof MethodInsnNode mi) {
|
||||
sortie.add(mi.owner.substring(mi.owner.lastIndexOf('/') + 1) + "." + mi.name);
|
||||
} else if (i instanceof InvokeDynamicInsnNode d) {
|
||||
for (Object a : d.bsmArgs) {
|
||||
if (a instanceof org.objectweb.asm.Handle h && h.getOwner().equals(classe.name)) {
|
||||
parcourir(classe, h.getName(), sortie, vues);
|
||||
} else if (a instanceof org.objectweb.asm.Handle h) {
|
||||
sortie.add(h.getOwner().substring(h.getOwner().lastIndexOf('/') + 1) + "." + h.getName());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
assertTrue(trouvee, methode);
|
||||
}
|
||||
|
||||
@Test
|
||||
void C4_lesPointsDEntreeConsultentLaMarqueDExpulsion() throws Exception {
|
||||
ClassNode garde = lire(Garde.class);
|
||||
ClassNode events = lire(GardeEvents.class);
|
||||
assertTrue(appels(garde, "avantMouvement").contains("Moteur.estExpulse"));
|
||||
assertTrue(appels(garde, "avantMouvement").contains("Cablage.evaluerAvantMouvement"));
|
||||
assertTrue(appels(garde, "apresMouvement").contains("Moteur.estExpulse"));
|
||||
assertTrue(appels(garde, "apresMouvement").contains("Cablage.traiterApresMouvement"));
|
||||
assertTrue(appels(events, "onAttaque").contains("Moteur.estExpulse"));
|
||||
assertTrue(appels(events, "onAttaque").contains("Cablage.entreeAttaque"));
|
||||
assertTrue(appels(events, "onConnexion").contains("Moteur.oublierExpulsion"), "reconnexion : marque effacée");
|
||||
assertFalse(appels(events, "onDeconnexion").contains("Moteur.oublierExpulsion"),
|
||||
"la marque survit à la déconnexion (C6)");
|
||||
assertTrue(appels(garde, "appliquerSanctionMouvement").contains("Cablage.appliquerSanction"));
|
||||
Set<String> sanction = appels(lire(Cablage.class), "appliquerSanction");
|
||||
assertTrue(sanction.contains("Moteur.expulser"));
|
||||
assertTrue(sanction.contains("Moteur.apresSetback"));
|
||||
assertFalse(appels(garde, "appliquerSanctionMouvement").stream().anyMatch(a -> a.toLowerCase().contains("ban")),
|
||||
"jamais de bannissement");
|
||||
}
|
||||
|
||||
/**
|
||||
* FAILLE (16/10, trouvée en écrivant ces tests) : apresVehicule ne regarde pas la marque d'expulsion, à la
|
||||
* différence de avantMouvement / apresMouvement / onAttaque. Un paquet de véhicule traité après l'expulsion
|
||||
* (même lot de paquets, avant la fermeture de la connexion) est encore évalué : journal, alerte aux ops,
|
||||
* stopRiding + setback, et l'état du moteur (Suivi) est recréé. L'expulsion elle-même reste unique
|
||||
* (Moteur.expulser). Ce test est vert tant que le défaut existe. Proposition : en tête d'apresVehicule,
|
||||
* {@code if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;}
|
||||
* (même garde, et idem pour auSolPourChute, qui peut encore appeler le moteur). Non corrigé : décision de Théo.
|
||||
*/
|
||||
@Test
|
||||
void FAILLE_C4_apresVehiculeNeConsultePasLaMarqueDExpulsion() throws Exception {
|
||||
ClassNode garde = lire(Garde.class);
|
||||
Set<String> a = appels(garde, "apresVehicule");
|
||||
assertTrue(a.contains("Moteur.vehicule"), "le paquet de véhicule est bien évalué par le moteur");
|
||||
assertFalse(a.contains("Moteur.estExpulse"), "défaut corrigé : inverser en CORRIGE_");
|
||||
assertFalse(appels(garde, "auSolPourChute").contains("Moteur.estExpulse"));
|
||||
}
|
||||
|
||||
// --- Événements NeoForge abonnés ---
|
||||
|
||||
@Test
|
||||
void evenementsAbonnes() {
|
||||
Set<Class<?>> ev = new HashSet<>();
|
||||
for (Method m : GardeEvents.class.getDeclaredMethods()) {
|
||||
if (m.isAnnotationPresent(net.neoforged.bus.api.SubscribeEvent.class)) {
|
||||
assertEquals(1, m.getParameterCount(), m.getName());
|
||||
assertTrue(java.lang.reflect.Modifier.isStatic(m.getModifiers()), m.getName());
|
||||
ev.add(m.getParameterTypes()[0]);
|
||||
}
|
||||
}
|
||||
for (Class<?> c : new Class<?>[] {
|
||||
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class,
|
||||
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent.class,
|
||||
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedOutEvent.class,
|
||||
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerChangedDimensionEvent.class,
|
||||
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerRespawnEvent.class,
|
||||
net.neoforged.neoforge.event.tick.ServerTickEvent.Pre.class,
|
||||
net.neoforged.neoforge.event.tick.ServerTickEvent.Post.class,
|
||||
net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent.Stop.class,
|
||||
net.neoforged.neoforge.event.server.ServerStartingEvent.class,
|
||||
net.neoforged.neoforge.event.server.ServerStoppedEvent.class}) {
|
||||
assertTrue(ev.contains(c), c.getName());
|
||||
}
|
||||
assertTrue(net.neoforged.bus.api.ICancellableEvent.class.isAssignableFrom(
|
||||
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class), "un coup peut être annulé");
|
||||
}
|
||||
|
||||
@Test
|
||||
void lesFauxJoueursNeSontJamaisControles() {
|
||||
// GardeEvents filtre « p instanceof FakePlayer » : un FakePlayer est un ServerPlayer.
|
||||
assertTrue(net.minecraft.server.level.ServerPlayer.class.isAssignableFrom(
|
||||
net.neoforged.neoforge.common.util.FakePlayer.class));
|
||||
}
|
||||
|
||||
// --- Types d'entités (C18 GardeAntiCrash, F20 vehiculeControle / etatVehicule) ---
|
||||
|
||||
@Test
|
||||
void C18_seulsLesMinecartsContenantsSontGardesImmobiles() {
|
||||
Class<?> container = net.minecraft.world.Container.class;
|
||||
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartChest.class));
|
||||
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartHopper.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.Minecart.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartTNT.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartFurnace.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartSpawner.class));
|
||||
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartCommandBlock.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
void F20_vehiculesControles() {
|
||||
Class<?> bateau = net.minecraft.world.entity.vehicle.Boat.class;
|
||||
Class<?> monture = net.minecraft.world.entity.LivingEntity.class;
|
||||
assertTrue(bateau.isAssignableFrom(net.minecraft.world.entity.vehicle.ChestBoat.class), "bateau à coffre, radeau");
|
||||
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.horse.Horse.class));
|
||||
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.Pig.class));
|
||||
Class<?> minecart = net.minecraft.world.entity.vehicle.AbstractMinecart.class;
|
||||
assertFalse(bateau.isAssignableFrom(minecart) || monture.isAssignableFrom(minecart),
|
||||
"minecart : non contrôlé (type AUTRE), la position de retour suit le joueur");
|
||||
}
|
||||
|
||||
// --- Options : du fichier toml au moteur ---
|
||||
|
||||
private static Object valeur(String champ) throws Exception {
|
||||
Field f = GardeSpec.class.getDeclaredField(champ);
|
||||
f.setAccessible(true);
|
||||
return f.get(null);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static <T> T defaut(String champ) throws Exception {
|
||||
return ((ModConfigSpec.ConfigValue<T>) valeur(champ)).getDefault();
|
||||
}
|
||||
|
||||
@Test
|
||||
void optionsDesactiveesParDefautDansLeFichierEtLeMoteur() throws Exception {
|
||||
GardeConfig c = new GardeConfig();
|
||||
assertEquals(false, defaut("ELYTRES_STRICTE"));
|
||||
assertEquals(c.elytresExemptionStricte, defaut("ELYTRES_STRICTE"));
|
||||
assertEquals(2, (int) defaut("ELYTRES_AIR_MIN"));
|
||||
assertEquals(c.elytresAirMinTicks, (int) defaut("ELYTRES_AIR_MIN"));
|
||||
assertEquals(false, defaut("COMBAT_VEHICULE"));
|
||||
assertEquals(c.combatMesureEnVehicule, defaut("COMBAT_VEHICULE"));
|
||||
assertEquals(false, defaut("VOL_FENETRE_GLISSANTE"));
|
||||
assertEquals(c.volFenetreGlissante, defaut("VOL_FENETRE_GLISSANTE"));
|
||||
assertEquals(false, defaut("VITESSE_MOYENNE"));
|
||||
assertEquals(c.vitesseMoyenne, defaut("VITESSE_MOYENNE"));
|
||||
assertEquals(0, (int) defaut("TIMER_SOLDE_MAX"));
|
||||
assertEquals(c.timerSoldeMax, (int) defaut("TIMER_SOLDE_MAX"));
|
||||
assertEquals(c.seriePingMargeMs, (int) defaut("SERIE_PING_MARGE"));
|
||||
assertEquals(false, defaut("AC_EMPILEMENT_MOUVEMENT"));
|
||||
assertFalse(new com.gastinelgarde.core.AntiCrashEntites.Reglages().empilementSeulementEnMouvement);
|
||||
assertFalse(GardeSpec.antiCrash().empilementSeulementEnMouvement, "fichier non chargé : défaut");
|
||||
}
|
||||
|
||||
@Test
|
||||
void laConfigProposeeNActivePasLesNouvellesOptions() throws Exception {
|
||||
// Les tests tournent dans build/minecraft-junit : on remonte jusqu'à la racine du projet.
|
||||
Path toml = null;
|
||||
for (Path d = Path.of("").toAbsolutePath(); d != null && toml == null; d = d.getParent()) {
|
||||
Path f = d.resolve("config-proposee").resolve("gastinelgarde-server.toml");
|
||||
if (Files.exists(f)) toml = f;
|
||||
}
|
||||
Assumptions.assumeTrue(toml != null, "config-proposee introuvable depuis " + Path.of("").toAbsolutePath());
|
||||
String t = Files.readString(toml, StandardCharsets.UTF_8);
|
||||
for (String cle : new String[] {"elytresExemptionStricte", "combatMesureEnVehicule", "volFenetreGlissante",
|
||||
"vitesseMoyenne", "empilementSeulementEnMouvement"}) {
|
||||
assertFalse(t.matches("(?s).*\\b" + cle + "\\s*=\\s*true.*"), cle);
|
||||
}
|
||||
assertFalse(t.matches("(?s).*\\btimerSoldeMax\\s*=\\s*[1-9].*"), "timerSoldeMax");
|
||||
}
|
||||
|
||||
/**
|
||||
* GardeSpec.appliquer recopie bien chaque option dans GardeConfig. On charge le fichier en mémoire
|
||||
* (ModConfigSpec.acceptConfig, par réflexion : signature propre à NeoForge 21.1), puis on le décharge.
|
||||
*/
|
||||
@Test
|
||||
void appliquerRecopieLesOptionsDuFichier() throws Exception {
|
||||
Object charge = chargerEnMemoire();
|
||||
Assumptions.assumeTrue(charge != null, "[À VÉRIFIER] chargement en mémoire du ModConfigSpec impossible ici");
|
||||
try {
|
||||
assertTrue(GardeSpec.SPEC.isLoaded());
|
||||
GardeConfig vide = new GardeConfig();
|
||||
GardeSpec.appliquer(vide);
|
||||
assertFalse(vide.elytresExemptionStricte);
|
||||
assertFalse(vide.combatMesureEnVehicule);
|
||||
assertFalse(vide.volFenetreGlissante);
|
||||
assertFalse(vide.vitesseMoyenne);
|
||||
assertEquals(0, vide.timerSoldeMax);
|
||||
for (com.gastinelgarde.core.Controle k : com.gastinelgarde.core.Controle.values()) {
|
||||
assertEquals(new GardeConfig().mode(k), vide.mode(k), "mode par défaut inchangé : " + k);
|
||||
}
|
||||
|
||||
((ModConfigSpec.BooleanValue) valeur("ELYTRES_STRICTE")).set(true);
|
||||
((ModConfigSpec.IntValue) valeur("ELYTRES_AIR_MIN")).set(5);
|
||||
((ModConfigSpec.BooleanValue) valeur("COMBAT_VEHICULE")).set(true);
|
||||
((ModConfigSpec.BooleanValue) valeur("VOL_FENETRE_GLISSANTE")).set(true);
|
||||
((ModConfigSpec.BooleanValue) valeur("VITESSE_MOYENNE")).set(true);
|
||||
((ModConfigSpec.IntValue) valeur("TIMER_SOLDE_MAX")).set(20);
|
||||
GardeConfig c = new GardeConfig();
|
||||
GardeSpec.appliquer(c);
|
||||
assertTrue(c.elytresExemptionStricte, "C7");
|
||||
assertEquals(5, c.elytresAirMinTicks, "C7");
|
||||
assertTrue(c.combatMesureEnVehicule, "C8");
|
||||
assertTrue(c.volFenetreGlissante, "C10");
|
||||
assertTrue(c.vitesseMoyenne, "C15");
|
||||
assertEquals(20, c.timerSoldeMax, "C15");
|
||||
} finally {
|
||||
dechargerEnMemoire();
|
||||
}
|
||||
assertFalse(GardeSpec.SPEC.isLoaded(), "les autres tests attendent un fichier non chargé");
|
||||
}
|
||||
|
||||
/** null si l'API n'est pas celle attendue (le test est alors ignoré, pas faux). */
|
||||
private static Object chargerEnMemoire() {
|
||||
try {
|
||||
Method accept = null;
|
||||
for (Method m : ModConfigSpec.class.getMethods()) {
|
||||
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) accept = m;
|
||||
}
|
||||
if (accept == null) return null;
|
||||
Class<?> type = accept.getParameterTypes()[0];
|
||||
com.electronwill.nightconfig.core.CommentedConfig cc =
|
||||
com.electronwill.nightconfig.core.CommentedConfig.inMemory();
|
||||
// Fichier déjà corrigé (valeurs par défaut) : acceptConfig n'a rien à sauvegarder.
|
||||
for (Method m : ModConfigSpec.class.getMethods()) {
|
||||
if (m.getName().equals("correct") && m.getParameterCount() == 1
|
||||
&& m.getParameterTypes()[0].isInstance(cc)) {
|
||||
m.invoke(GardeSpec.SPEC, cc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
Object config = null;
|
||||
if (type.isInstance(cc)) {
|
||||
config = cc;
|
||||
} else if (type.isSealed()) {
|
||||
// NeoForge 21.1 : IConfigSpec.ILoadedConfig est scellée, seule implémentation LoadedConfig.
|
||||
for (Class<?> impl : type.getPermittedSubclasses()) {
|
||||
for (java.lang.reflect.Constructor<?> k : impl.getDeclaredConstructors()) {
|
||||
Class<?>[] p = k.getParameterTypes();
|
||||
if (p.length == 0 || !p[0].isInstance(cc)) continue;
|
||||
Object[] args = new Object[p.length];
|
||||
args[0] = cc;
|
||||
k.setAccessible(true);
|
||||
config = k.newInstance(args);
|
||||
break;
|
||||
}
|
||||
if (config != null) break;
|
||||
}
|
||||
} else if (type.isInterface()) {
|
||||
config = Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[] {type}, (o, m, a) -> switch (m.getName()) {
|
||||
case "config" -> cc;
|
||||
case "hashCode" -> System.identityHashCode(o);
|
||||
case "equals" -> o == a[0];
|
||||
case "toString" -> "config-en-memoire";
|
||||
default -> null;
|
||||
});
|
||||
}
|
||||
if (config == null) return null;
|
||||
accept.invoke(GardeSpec.SPEC, config);
|
||||
return GardeSpec.SPEC.isLoaded() ? config : null;
|
||||
} catch (ReflectiveOperationException | RuntimeException | LinkageError e) {
|
||||
System.out.println("[CablageMinecraftTest] chargement en mémoire impossible : " + e);
|
||||
dechargerEnMemoire();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static void dechargerEnMemoire() {
|
||||
try {
|
||||
for (Method m : ModConfigSpec.class.getMethods()) {
|
||||
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) {
|
||||
m.invoke(GardeSpec.SPEC, new Object[] {null});
|
||||
}
|
||||
}
|
||||
} catch (ReflectiveOperationException | RuntimeException e) {
|
||||
System.out.println("[CablageMinecraftTest] déchargement : " + e);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,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);
|
||||
}
|
||||
}
|
||||
@@ -336,12 +336,14 @@ class AutotestCasLimitesTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
|
||||
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});
|
||||
assertTrue(total > 0);
|
||||
assertEquals(0, total, 1e-9);
|
||||
Mesures.noter("Lag 3,0,0 : " + total + " points de vol sur une chute de 80 paquets");
|
||||
}
|
||||
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -13,8 +13,9 @@ 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.
|
||||
*
|
||||
* Un test {@code FAILLE_…} passe tant que le contournement marche ; il échouera quand il sera corrigé (inverser
|
||||
* alors l'assertion). Chaque faille a un test « témoin » qui montre que, sans le contournement, la triche est vue.
|
||||
* 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 {
|
||||
@@ -78,16 +79,16 @@ class AutotestContournementsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_revue1_pingDeclareAuDessusDe500msExempteTotalementLesCoups() {
|
||||
void CORRIGE_revue1_pingDeclareAuDessusDe500msNExemptePlusLesCoups() {
|
||||
assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs) > 0, "témoin : à 500 ms, la série est vue");
|
||||
assertEquals(0, serieHitboxAvecPing(cfg.seriePingMaxMs + 1), 1e-9,
|
||||
"prouvé : à 501 ms (ping falsifiable, F07), aucun coup n'est mesuré");
|
||||
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 FAILLE_revue2_regardSuivantRameneSurLaCibleEffaceLeCoupHorsBoite() {
|
||||
void CORRIGE_revue2_regardSuivantRameneSurLaCibleNEffacePlusLeCoupHorsBoite() {
|
||||
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||
double temoin = 0, triche = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
@@ -107,11 +108,11 @@ class AutotestContournementsTest {
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
assertTrue(temoin > 0, "témoin : le même regard gardé au paquet suivant est vu");
|
||||
assertEquals(0, triche, 1e-9, "prouvé : un demi-tour du regard au paquet suivant efface tout (aucune borne d'angle)");
|
||||
assertTrue(triche > 0, "corrigé : un demi-tour du regard au paquet suivant n'est plus accepté");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_revue2_oeilSuivantAvanceDe09BlocEffaceLaPorteeAllongee() {
|
||||
void CORRIGE_revue2_oeilSuivantAvanceDe09BlocNEffacePlusLaPorteeAllongee() {
|
||||
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||
double temoin = 0, triche = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
@@ -131,11 +132,11 @@ class AutotestContournementsTest {
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
assertTrue(temoin > 0);
|
||||
assertEquals(0, triche, 1e-9, "prouvé : l'œil suivant n'est pas borné à un déplacement légal");
|
||||
assertTrue(triche > 0, "corrigé : l'œil suivant est borné à un déplacement d'un tick");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C13_porteeEtHitboxGardentLeMinimumAvecLePaquetSuivant() {
|
||||
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
|
||||
@@ -151,49 +152,88 @@ class AutotestContournementsTest {
|
||||
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)));
|
||||
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "prouvé : s'avancer au paquet suivant efface la portée");
|
||||
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.
|
||||
// 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};
|
||||
List<Verdict> a = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil, new double[] {0, 0, -1},
|
||||
b, 3.0, 0, false, true));
|
||||
a.addAll(moteur.regardPorteeHitbox(joueur, 50, oeil, vers(oeil, 0, 1.0, 0)));
|
||||
assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "prouvé : rotation silencieuse effacée");
|
||||
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 FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee() {
|
||||
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
|
||||
double[] b = boite(0);
|
||||
double[] oeil33 = {0, 1.62, -3.59}; // 3,29 blocs
|
||||
List<Verdict> v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil33,
|
||||
vers(oeil33, 0, 1.0, 0), b, 3.0, 0, true, false));
|
||||
v.addAll(moteur.terminerCoup(joueur));
|
||||
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,29 blocs sur cible immobile : rien");
|
||||
|
||||
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);
|
||||
double[] oeil40 = {0, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte
|
||||
v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil40, vers(oeil40, 0, 1.0, 0), b, 3.0,
|
||||
V, true, false));
|
||||
v.addAll(moteur.terminerCoup(joueur));
|
||||
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,99 blocs sur cible qui sprinte : rien pour portee");
|
||||
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é ------------------------------------------
|
||||
|
||||
private double serieDerriereLaCible(int ping) {
|
||||
/** 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();
|
||||
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); // ce que Garde.boitesVues calcule depuis latency()
|
||||
// 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 3,3 blocs DERRIÈRE le centre de la cible (là où elle était il y a ~12 ticks).
|
||||
double[] regard = vers(oeil, x - 3.6, 1.2, 0);
|
||||
// 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);
|
||||
}
|
||||
@@ -201,13 +241,21 @@ class AutotestContournementsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_revue4_pingDeclareA450msElargitLaFenetreEtCacheLaTriche() {
|
||||
void CORRIGE_revue4_pingGonflePendantLeCombatNElargitPlusLaFenetre() {
|
||||
assertEquals(8, PorteeHitbox.ticksFenetre(30, cfg));
|
||||
assertEquals(16, PorteeHitbox.ticksFenetre(450, cfg));
|
||||
assertEquals(17, PorteeHitbox.ticksFenetre(500, cfg));
|
||||
assertTrue(serieDerriereLaCible(30) > 0, "témoin : à 30 ms, la série est vue");
|
||||
assertEquals(0, serieDerriereLaCible(450), 1e-9,
|
||||
"prouvé : le même client qui annonce 450 ms de ping n'est plus vu (fenêtre 16 ticks au lieu de 8)");
|
||||
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 ---------------------------------------------------------
|
||||
@@ -230,16 +278,21 @@ class AutotestContournementsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C15_bhopA040BlocParTickNestJamaisVu() {
|
||||
// 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (un sprint-saut honnête fait en moyenne ~0,28 à 0,33).
|
||||
assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9);
|
||||
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 FAILLE_C15_speedAuSolA037BlocParTickNestJamaisVu() {
|
||||
void CORRIGE_C15_speedAuSolA037BlocParTickEstVuAvecLOption() {
|
||||
assertTrue(vitesse(0.45, 0.45, 1, 200) > 0, "témoin : 0,45 au sol (+50 %) est vu");
|
||||
// 0,37 au sol : +23 % sur le sprint (0,30), l'excès (0,06/tick) reste sous le tampon de 1,5 bloc / 20 ticks.
|
||||
assertEquals(0, vitesse(0.37, 0.37, 1, 400), 1e-9);
|
||||
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) {
|
||||
@@ -252,8 +305,24 @@ class AutotestContournementsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C15_timerA109NestJamaisVu() {
|
||||
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, "prouvé : 21,7 paquets/s (timer 1,09) pendant 30 s, aucun point");
|
||||
assertEquals(0, timer(46, 30), 1e-9, "option coupée : rien (comme avant)");
|
||||
cfg.timerSoldeMax = 20;
|
||||
assertTrue(timer(46, 30) > 0, "corrigé : 21,7 paquets/s (timer 1,09) pendant 30 s vu par le solde");
|
||||
assertEquals(0, timer(50, 60), 1e-9, "témoin : 20 paquets/s, rien");
|
||||
// Témoin lag : 1 s sans paquet, puis rafale de 20 paquets d'un coup, à répéter.
|
||||
moteur = new Moteur(cfg);
|
||||
double lag = 0;
|
||||
long t = 10_000;
|
||||
for (int r = 0; r < 20; r++) {
|
||||
t += 1000;
|
||||
for (int i = 0; i < 20; i++) lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
|
||||
for (int i = 0; i < 40; i++) {
|
||||
t += 50;
|
||||
lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
|
||||
}
|
||||
}
|
||||
assertEquals(0, lag, 1e-9, "témoin : rafales de rattrapage après un lag, rien");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* Autotests du 16/10/2026 : rafales réseau (paquets de mouvement groupés après un lag). Chaque paquet couvre UN tick
|
||||
* client, mais le serveur voit {@code motif[i]} ticks écoulés avant lui (3, 0, 0 : trois paquets arrivés ensemble).
|
||||
*
|
||||
* {@code CORRIGE_…} : anciens FAUX_POSITIF_ (joueur honnête puni), inversés : aucun point attendu.
|
||||
* {@code temoin_…} : la triche équivalente (chute ralentie) doit rester vue, avant comme après le correctif.
|
||||
*/
|
||||
class AutotestRafalesTest {
|
||||
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
private long tick;
|
||||
private boolean sanctionLourde;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.mode(Controle.VOL, Mode.ENFORCE);
|
||||
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||
cfg.mode(Controle.NO_FALL, Mode.OBSERVE);
|
||||
moteur = new Moteur(cfg);
|
||||
tick = 5000;
|
||||
sanctionLourde = false;
|
||||
}
|
||||
|
||||
private static EtatMouvement m(double dy, int ticks, boolean sol) {
|
||||
return new EtatMouvement(0.1, dy, ticks, sol, sol, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
private double paquet(EtatMouvement mv) {
|
||||
tick += mv.ticks();
|
||||
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, EtatJoueur.normal(), mv);
|
||||
double p = 0;
|
||||
for (Verdict v : vs) {
|
||||
if (v.controle() == Controle.VOL) p += v.points();
|
||||
if (v.palier() == Sanction.SETBACK || v.palier() == Sanction.EXPULSION) sanctionLourde = true;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
/** Chute honnête de {@code paquets} ticks client depuis la vitesse v0, avec la gigue donnée. */
|
||||
private double chute(double v0, int paquets, int[] motif) {
|
||||
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
|
||||
double total = 0, v = v0;
|
||||
for (int p = 0; p < paquets; p++) {
|
||||
total += paquet(m(v, motif[p % motif.length], false));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_rafalesDeTroisLongueChuteSansPointNiSanction() {
|
||||
double total = chute(0, 80, new int[] {3, 0, 0});
|
||||
Mesures.noter("Rafales 3,0,0 chute 80 : " + total + " points, sanction lourde=" + sanctionLourde);
|
||||
assertEquals(0, total, 1e-9);
|
||||
assertTrue(!sanctionLourde, "aucun setback ni expulsion pour un joueur honnête");
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_sautPuisChuteEnRafalesDeTrois() {
|
||||
double total = chute(0.42, 80, new int[] {3, 0, 0});
|
||||
Mesures.noter("Rafales 3,0,0 saut + chute 80 : " + total + " points");
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_gigueIrreguliereApresUnLag() {
|
||||
// Gigue irrégulière (rafales de 3 et 4 mêlées) : mesurée à 0 point avant le correctif, doit le rester.
|
||||
double total = chute(0, 90, new int[] {3, 0, 0, 4, 0, 0, 0, 1, 2, 0, 3, 0, 0});
|
||||
Mesures.noter("Gigue irreguliere chute 90 : " + total + " points");
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void temoin_chuteRalentieUnPaquetDUnTickToutesLesTroisTicksResteVue() {
|
||||
// Triche « slow fall / timer lent » : un paquet d'un tick de gravité toutes les 3 ticks serveur, sans rattrapage.
|
||||
double total = chute(0, 80, new int[] {3});
|
||||
Mesures.noter("Temoin chute ralentie 1/3 : " + total + " points");
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void temoin_planeEnRafalesResteVu() {
|
||||
// Plané (dy = 0) livré en rafales : doit être vu, quelle que soit la gigue.
|
||||
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
|
||||
double total = 0;
|
||||
int[] motif = {3, 0, 0};
|
||||
for (int p = 0; p < 60; p++) total += paquet(m(-0.01, motif[p % 3], false));
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_chuteSansGigueReference() {
|
||||
assertEquals(0, chute(0, 80, new int[] {1}), 1e-9);
|
||||
}
|
||||
}
|
||||
@@ -15,8 +15,8 @@ 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 n'est pas corrigé : ses tests {@code FAILLE_…} passent tant que
|
||||
* le défaut existe.
|
||||
* 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
|
||||
@@ -253,7 +253,8 @@ class AutotestVolIncidentTest {
|
||||
// --- C10 : sauts en l'air espacés --------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAILLE_C10_unSautEnLAirTousLesDixTicksMonteSansFinSansAucunPoint() {
|
||||
void CORRIGE_C10_unSautEnLAirTousLesDixTicksEstVuAvecLOption() {
|
||||
cfg.volFenetreGlissante = true;
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double total = 0;
|
||||
double depart = y;
|
||||
@@ -264,14 +265,32 @@ class AutotestVolIncidentTest {
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
}
|
||||
assertEquals(0, total, 1e-9, "prouvé : aucun point");
|
||||
// ~0,5 bloc gagné par cycle de 10 ticks : ~15 blocs en 15 s, sans limite.
|
||||
assertTrue(y - depart > 10, "et le tricheur a gagné " + (y - depart) + " blocs en 15 s");
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT, "C10 : +%.1f blocs en 300 ticks, 0 point", y - depart));
|
||||
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 FAILLE_C10_alternerUnTickAnormalEtUnTickNormalPlaneSansPoint() {
|
||||
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;
|
||||
@@ -280,8 +299,6 @@ class AutotestVolIncidentTest {
|
||||
double dy = i % 2 == 0 ? -0.02 : (-0.02 - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
total += points(paquet(EtatJoueur.normal(), air(dy)), Controle.VOL);
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
// 200 ticks de chute vanilla depuis l'arrêt : plus de 200 blocs. Ici : ~6 blocs.
|
||||
assertTrue(depart - y < 15, "descente de " + (depart - y) + " blocs en 10 s (chute lente illimitée)");
|
||||
assertTrue(total > 0, "corrigé : l'alternance plané / gravité est vue");
|
||||
}
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
@@ -175,7 +175,8 @@ class Garde92Test {
|
||||
EtatJoueur.builder().enVehicule(true).build(),
|
||||
EtatJoueur.builder().elytres(true).build(),
|
||||
EtatJoueur.builder().riptide(true).build(),
|
||||
EtatJoueur.builder().pingMs(cfg.seriePingMaxMs + 1).build(),
|
||||
// Revue 1 (16/10) : un ping > seriePingMaxMs n'exempte plus (ping falsifiable) ; retiré de la liste,
|
||||
// voir AutotestContournementsTest.CORRIGE_revue1_… [À VÉRIFIER] Théo.
|
||||
EtatJoueur.builder().ticksDepuisTeleport(5).build(),
|
||||
EtatJoueur.builder().ticksDepuisGel(5).build());
|
||||
for (EtatJoueur etat : etats) {
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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éé");
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur