From b72e5717c5ee2d44ec08862844b600e09ea0d899 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Sat, 24 Oct 2026 00:19:39 +0200 Subject: [PATCH] P1.1 : journal, tout SETBACK/EXPULSION toujours ecrit, setback rate journalise MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Cablage.ecrireVerdict : le verdict qui declenche un SETBACK ou une EXPULSION passe outre la limite d'une ligne par seconde et par controle. - Cablage.appliquerSanction : « SETBACK impossible » ecrit (pas de position de retour, ou position dans une autre dimension). - Nouvelle section [journal] : toujoursEcrireSanctions (true), limiteLignesParSeconde (1). - Tests : JournalP1Test, CablageTest et CablageSuspicionTest mis a jour. Co-Authored-By: Claude Sonnet 5.5 --- src/main/java/com/gastinelgarde/Cablage.java | 25 ++++ src/main/java/com/gastinelgarde/Garde.java | 6 +- .../java/com/gastinelgarde/GardeSpec.java | 12 ++ .../com/gastinelgarde/core/GardeConfig.java | 6 + .../gastinelgarde/CablageSuspicionTest.java | 3 +- .../java/com/gastinelgarde/CablageTest.java | 7 +- .../java/com/gastinelgarde/JournalP1Test.java | 110 ++++++++++++++++++ 7 files changed, 165 insertions(+), 4 deletions(-) create mode 100644 src/test/java/com/gastinelgarde/JournalP1Test.java diff --git a/src/main/java/com/gastinelgarde/Cablage.java b/src/main/java/com/gastinelgarde/Cablage.java index f020f3e..c19645b 100644 --- a/src/main/java/com/gastinelgarde/Cablage.java +++ b/src/main/java/com/gastinelgarde/Cablage.java @@ -145,6 +145,25 @@ final class Cablage { && moteur.positionDeRetourAdmise(solServeur, milieuSpecial); } + // --- 0.5 (P1.1) : journal des verdicts --- + + /** + * Ligne de journal pour ce verdict ? Le journal est limité (une ligne par seconde et par contrôle, voir + * Suivi.autoriserJournal) pour ne pas écrire une ligne par tick pendant une chute ; mais le verdict qui déclenche + * un SETBACK ou une EXPULSION est toujours écrit si {@code toujoursSanctions} (diagnostic 0.4.0 : l'expulsion + * arrivait sans la ligne du verdict qui l'avait causée). Paresseux : la limite n'est pas consommée pour un + * verdict de sanction écrit d'office. + */ + static boolean ecrireVerdict(Verdict v, boolean toujoursSanctions, BooleanSupplier limiteAutorise) { + if (toujoursSanctions && v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) return true; + return limiteAutorise.getAsBoolean(); + } + + /** Délai (ms) entre deux lignes d'un même contrôle pour {@code lignesParSeconde} lignes par seconde (au moins 1). */ + static long delaiJournalMs(int lignesParSeconde) { + return 1000L / Math.max(1, lignesParSeconde); + } + // --- Sanctions (C2, C4) --- /** Ce que la sanction fait au joueur réel (adaptateur ServerPlayer dans Garde, doublure dans les tests). */ @@ -189,6 +208,12 @@ final class Cablage { // 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 + ")"); + } else { + // 0.5 (P1.1) : avant, rien n'était fait ni écrit (reconnexion en l'air) et le VL montait jusqu'à + // l'expulsion sans trace du setback raté. + String pourquoi = !sv.aPositionValide() ? "pas de position de retour valide" + : "position de retour dans une autre dimension (" + sv.dimension() + ")"; + p.journal(p.nom() + " SETBACK impossible (" + raison + ") : " + pourquoi); } } } diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 35c5bc7..df0f4e0 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -563,8 +563,12 @@ public final class Garde { marques(p.getUUID()).dernierVerdictTick = p.server.getTickCount(); long maintenant = System.currentTimeMillis(); Suivi suivi = MOTEUR.suivi(p.getUUID()); + long delai = Cablage.delaiJournalMs(CONFIG.journalLignesParSeconde); for (Verdict v : verdicts) { - if (suivi.autoriserJournal(v.controle(), maintenant, 1000)) { // au plus une ligne par seconde et par contrôle + // Au plus journalLignesParSeconde lignes par seconde et par contrôle ; 0.5 (P1.1) : sauf le verdict qui + // déclenche un SETBACK ou une EXPULSION, toujours écrit (journalToujoursSanctions). + if (Cablage.ecrireVerdict(v, CONFIG.journalToujoursSanctions, + () -> suivi.autoriserJournal(v.controle(), maintenant, delai))) { String ligne = String.format("%s %s mode=%s vl=%.1f (+%.1f) palier=%s applique=%s %s exemptions=%s", p.getGameProfile().getName(), v.controle().id(), v.mode(), v.vl(), v.points(), v.palier(), v.applicable(), v.details(), v.exemptions()); diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index 994490c..5465abf 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -22,6 +22,9 @@ public final class GardeSpec { private static final ModConfigSpec.DoubleValue SEUIL_EXPULSION; private static final ModConfigSpec.EnumValue SANCTION_MAX; + private static final ModConfigSpec.BooleanValue JOURNAL_TOUJOURS; + private static final ModConfigSpec.IntValue JOURNAL_LIMITE; + private static final ModConfigSpec.DoubleValue ANGLE_MAX; private static final ModConfigSpec.IntValue CIBLES_MAX; private static final ModConfigSpec.IntValue FENETRE_CIBLES_MS; @@ -110,6 +113,13 @@ public final class GardeSpec { .defineEnum("sanctionMax", Sanction.EXPULSION); b.pop(); + b.comment("0.5 : journal logs/gastinelgarde.log.").push("journal"); + JOURNAL_TOUJOURS = b.comment("Le verdict qui déclenche un SETBACK ou une EXPULSION est toujours écrit, malgré la limite ci-dessous.") + .define("toujoursEcrireSanctions", true); + JOURNAL_LIMITE = b.comment("Lignes au plus par seconde et par contrôle (évite une ligne par tick pendant une chute).") + .defineInRange("limiteLignesParSeconde", 1, 1, 20); + b.pop(); + b.push("combat"); ANGLE_MAX = b.comment("Excédent d'angle maximal entre le regard et la silhouette de la cible (degrés).") .defineInRange("angleMaxDegres", 60.0, 5.0, 180.0); @@ -322,6 +332,8 @@ public final class GardeSpec { c.seuilSetback = Math.max(SEUIL_SETBACK.get(), c.seuilAlerte); c.seuilExpulsion = Math.max(SEUIL_EXPULSION.get(), c.seuilSetback); c.sanctionMax = SANCTION_MAX.get(); + c.journalToujoursSanctions = JOURNAL_TOUJOURS.get(); + c.journalLignesParSeconde = JOURNAL_LIMITE.get(); c.angleMaxDegres = ANGLE_MAX.get(); c.ciblesMax = CIBLES_MAX.get(); c.fenetreCiblesMs = FENETRE_CIBLES_MS.get(); diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index 42ffdea..e579e44 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -26,6 +26,12 @@ public final class GardeConfig { /** C1 (16/10) : ticks de grâce du contrôle vol après la fin du plané en élytres (fin à l'atterrissage). */ public int graceFinElytresTicks = 50; + // --- 0.5 (P1.1, section [journal]) --- + /** Le verdict qui déclenche un SETBACK ou une EXPULSION est toujours écrit, malgré la limite de lignes. */ + public boolean journalToujoursSanctions = true; + /** Lignes de journal au plus par seconde et par contrôle (hors verdicts de sanction ci-dessus). */ + public int journalLignesParSeconde = 1; + // --- Score de suspicion (0.4.0, section [suspicion]) : information pour les humains, jamais de sanction --- public boolean suspicionActive = true; public double suspicionSeuilSurveiller = 25; diff --git a/src/test/java/com/gastinelgarde/CablageSuspicionTest.java b/src/test/java/com/gastinelgarde/CablageSuspicionTest.java index cd6e3d1..23aadf0 100644 --- a/src/test/java/com/gastinelgarde/CablageSuspicionTest.java +++ b/src/test/java/com/gastinelgarde/CablageSuspicionTest.java @@ -117,7 +117,8 @@ class CablageSuspicionTest { List vs = List.of(verdict(Controle.VOL, Mode.ENFORCE, Sanction.SETBACK, Sanction.SETBACK)); Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, vs); assertEquals(0, p.compte("teleport"), "pas de position valide : aucun setback possible"); - assertEquals(0, p.compte("journal")); + // 0.5 (P1.1) : le setback raté est désormais écrit (avant : aucune ligne). + assertEquals(1, p.compte("journal Tricheur SETBACK impossible (vol)")); // Le VL de vol n'est donc pas remis à zéro (apresSetback non appelé) et continue vers l'expulsion. } } diff --git a/src/test/java/com/gastinelgarde/CablageTest.java b/src/test/java/com/gastinelgarde/CablageTest.java index dcb113b..685b523 100644 --- a/src/test/java/com/gastinelgarde/CablageTest.java +++ b/src/test/java/com/gastinelgarde/CablageTest.java @@ -159,11 +159,14 @@ class CablageTest { FauxJoueur p = new FauxJoueur(); List v = List.of(verdict(Controle.VOL, Sanction.SETBACK)); Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v); - assertTrue(p.actions.isEmpty(), "aucune position de retour : rien"); + // 0.5 (P1.1) : aucun téléport, mais le setback raté est journalisé. + assertEquals(0, p.compte("teleport"), "aucune position de retour : pas de teleport"); + assertEquals(1, p.compte("journal Tricheur SETBACK impossible")); moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether"); Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v); - assertTrue(p.actions.isEmpty(), "position dans une autre dimension : jamais de teleport inter-dimension"); + assertEquals(0, p.compte("teleport"), "position dans une autre dimension : jamais de teleport inter-dimension"); + assertEquals(2, p.compte("journal Tricheur SETBACK impossible")); } @Test diff --git a/src/test/java/com/gastinelgarde/JournalP1Test.java b/src/test/java/com/gastinelgarde/JournalP1Test.java new file mode 100644 index 0000000..204a85b --- /dev/null +++ b/src/test/java/com/gastinelgarde/JournalP1Test.java @@ -0,0 +1,110 @@ +package com.gastinelgarde; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.gastinelgarde.core.Controle; +import com.gastinelgarde.core.EtatJoueur; +import com.gastinelgarde.core.GardeConfig; +import com.gastinelgarde.core.Mode; +import com.gastinelgarde.core.Moteur; +import com.gastinelgarde.core.Sanction; +import com.gastinelgarde.core.Suivi; +import com.gastinelgarde.core.Verdict; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import org.junit.jupiter.api.Test; + +/** 0.5, P1.1 : tout verdict de SETBACK / EXPULSION est écrit, et le setback raté aussi. */ +class JournalP1Test { + + private static Verdict verdict(Controle c, Sanction applicable) { + return new Verdict(c, Mode.ENFORCE, 1, 5, applicable, applicable, false, "", List.of()); + } + + /** Ce que fait Garde.traiter pour le journal, sans serveur : lignes écrites pour une suite de verdicts. */ + private static List ecrits(Suivi s, GardeConfig cfg, List vs, long nowMs) { + List out = new ArrayList<>(); + long delai = Cablage.delaiJournalMs(cfg.journalLignesParSeconde); + for (Verdict v : vs) { + if (Cablage.ecrireVerdict(v, cfg.journalToujoursSanctions, + () -> s.autoriserJournal(v.controle(), nowMs, delai))) out.add(v); + } + return out; + } + + @Test + void dixVerdictsDansLaMemeSecondeLaLigneDeLExpulsionExiste() { + GardeConfig cfg = new GardeConfig(); + cfg.mode(Controle.REGULARITE, Mode.ENFORCE); + Moteur moteur = new Moteur(cfg); + UUID id = UUID.randomUUID(); + Suivi s = moteur.suivi(id); + List tous = new ArrayList<>(); + Verdict expulsion = null; + long debut = 1_000_000; + for (int n = 1; n <= 200 && expulsion == null; n++) { + long now = debut + n * 50L; + List vs = new ArrayList<>(); + for (Verdict v : moteur.attaque(id, now, EtatJoueur.normal(), -1, 1, true)) { + if (v.controle() == Controle.REGULARITE) vs.add(v); + } + for (Verdict v : ecrits(s, cfg, vs, now)) tous.add(v); + for (Verdict v : vs) if (v.applicable() == Sanction.EXPULSION) expulsion = v; + } + assertTrue(expulsion != null); + assertTrue(tous.contains(expulsion), "la ligne du verdict qui expulse est écrite"); + assertTrue(tous.stream().anyMatch(v -> v.applicable() == Sanction.SETBACK), "le setback aussi"); + } + + @Test + void limiteToujoursAppliqueeAuxVerdictsOrdinaires() { + GardeConfig cfg = new GardeConfig(); + Suivi s = new Suivi(0.5, cfg); + List vs = new ArrayList<>(); + for (int i = 0; i < 10; i++) vs.add(verdict(Controle.VOL, Sanction.ALERTE)); + assertEquals(1, ecrits(s, cfg, vs, 5000).size()); + // Plusieurs lignes par seconde si réglé ainsi + cfg.journalLignesParSeconde = 4; + assertEquals(250, Cablage.delaiJournalMs(4)); + assertEquals(1000, Cablage.delaiJournalMs(0), "borne basse"); + } + + @Test + void optionCoupeeAncienComportement() { + GardeConfig cfg = new GardeConfig(); + cfg.journalToujoursSanctions = false; + Suivi s = new Suivi(0.5, cfg); + List vs = List.of(verdict(Controle.VOL, Sanction.ALERTE), verdict(Controle.VOL, Sanction.EXPULSION)); + assertEquals(1, ecrits(s, cfg, vs, 5000).size()); + cfg.journalToujoursSanctions = true; + Suivi s2 = new Suivi(0.5, cfg); + assertEquals(2, ecrits(s2, cfg, vs, 5000).size()); + } + + @Test + void verdictDeSanctionNeConsommePasLaLimite() { + GardeConfig cfg = new GardeConfig(); + Suivi s = new Suivi(0.5, cfg); + List vs = List.of(verdict(Controle.VOL, Sanction.SETBACK), verdict(Controle.VOL, Sanction.ALERTE)); + assertEquals(2, ecrits(s, cfg, vs, 5000).size(), "l'alerte suivante a encore sa ligne"); + } + + @Test + void setbackImpossibleEcritAvecLaRaison() { + Moteur moteur = new Moteur(new GardeConfig()); + CablageTest.FauxJoueur p = new CablageTest.FauxJoueur(); + Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK))); + assertEquals(List.of("journal Tricheur SETBACK impossible (vol) : pas de position de retour valide"), p.actions); + + // Position mémorisée dans une autre dimension + moteur.suivi(p.id()).memoriserPosition(1, 64, 1, 0, 0, "minecraft:the_nether"); + CablageTest.FauxJoueur p2 = new CablageTest.FauxJoueur(); + Cablage.appliquerSanction(moteur, p2, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK))); + assertEquals(0, p2.compte("teleport")); + assertTrue(p2.actions.get(0).contains("autre dimension (minecraft:the_nether)")); + assertFalse(p2.actions.get(0).contains("pas de position")); + } +}