diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index b1c1031..c60c2c3 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -523,16 +523,29 @@ public final class Garde { } /** 0.5 (P2.4) : bloc posé par ce joueur. Vrai si la pose doit être annulée (ENFORCE, palier SETBACK ou plus). */ - public static boolean noterPose(ServerPlayer p) { + public static boolean noterPose(ServerPlayer p, BlockPos pos) { if (!surThreadServeur(p)) return false; if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, pose annulée (C4) if (estExempteManuellement(p.getUUID())) return false; - if (CONFIG.mode(Controle.FAST_PLACE) == Mode.OFF) return false; int tick = p.server.getTickCount(); + boolean annulerTower = false; + if (CONFIG.mode(Controle.TOWER) != Mode.OFF) { // 0.5 (P3.2) + Marques m = marques(p.getUUID()); + double dy = m.oeilDernier != null && m.oeilAvant != null ? m.oeilDernier[1] - m.oeilAvant[1] : 0; + List vt = MOTEUR.poseTower(p.getUUID(), tick * 50L, tick, etat(p, true), pos.getX(), pos.getY(), + pos.getZ(), p.getX(), p.getY(), p.getZ(), dy); + Sanction st = traiter(p, vt); + if (st == Sanction.EXPULSION) { + appliquerSanctionMouvement(p, st, vt); + return true; + } + annulerTower = Cablage.sanctionDeMouvement(st); + } + if (CONFIG.mode(Controle.FAST_PLACE) == Mode.OFF) return annulerTower; List v = MOTEUR.poseBloc(p.getUUID(), tick * 50L, tick, etat(p, true)); Sanction s = traiter(p, v); if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v); - return Cablage.sanctionDeMouvement(s); + return annulerTower || Cablage.sanctionDeMouvement(s); } /** 0.5 (P2.10) : une face du bloc touche l'air ou un fluide (minerai visible sans x-ray). */ diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index f23c9ba..70814f6 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -174,7 +174,7 @@ public final class GardeEvents { public static void onPose(net.neoforged.neoforge.event.level.BlockEvent.EntityPlaceEvent event) { if (event.getLevel().isClientSide()) return; if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; - if (Garde.noterPose(p)) event.setCanceled(true); + if (Garde.noterPose(p, event.getPos())) event.setCanceled(true); } /** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */ diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index 348bea1..bae54c7 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -38,7 +38,7 @@ public final class GardeSpec { private static final ModConfigSpec.DoubleValue FAST_PLACE_REGULARITE, INTER_MARGE; private static final ModConfigSpec.IntValue INTER_SERIE, TOTEM_ECHANT, TOTEM_ECART, TOTEM_REG_MAX; // 0.5 (P3) - private static final ModConfigSpec.IntValue NUKER_MAX, NUKER_SERIE, CRISTAL_DELAI, CRISTAL_SERIE; + private static final ModConfigSpec.IntValue NUKER_MAX, NUKER_SERIE, CRISTAL_DELAI, CRISTAL_SERIE, TOWER_INTERVALLE, TOWER_SERIE; private static final ModConfigSpec.DoubleValue ANGLE_MAX; private static final ModConfigSpec.IntValue CIBLES_MAX; @@ -334,6 +334,11 @@ public final class GardeSpec { .defineInRange("cristalDelaiMinTicks", 2, 1, 10); CRISTAL_SERIE = b.comment("Auto-cristal : coups suspects parmi les 10 derniers coups sur un cristal récent (60 s) avant de compter.") .defineInRange("cristalSerieMin", 6, 1, 10); + TOWER_INTERVALLE = b.comment("0.5 (P3.2) tower : intervalle (ticks) entre deux poses en pilier sous les pieds sous lequel il est court.", + "Vanilla : saut + retombée sur le bloc = 9 ticks, 10 espace maintenu ; le module Tower pose toutes les 2 à 4 ticks.") + .defineInRange("towerIntervalleMinTicks", 6, 2, 9); + TOWER_SERIE = b.comment("Tower : intervalles courts de suite avant que chaque pose rapide suivante compte (et soit annulable en ENFORCE).") + .defineInRange("towerSerie", 5, 1, 50); b.pop(); b.comment("0.5 (P2.10) x-ray statistique : alerte seulement, jamais de setback ni d'expulsion (même en ENFORCE).").push("xray"); @@ -541,6 +546,8 @@ public final class GardeSpec { c.nukerSerieMin = NUKER_SERIE.get(); c.cristalDelaiMinTicks = CRISTAL_DELAI.get(); c.cristalSerieMin = CRISTAL_SERIE.get(); + c.towerIntervalleMinTicks = TOWER_INTERVALLE.get(); + c.towerSerie = TOWER_SERIE.get(); c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get(); c.setbackSolSiPasDePosition = SETBACK_SOL.get(); c.graceReculTicks = GRACE_RECUL.get(); diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index 4a816bd..e644130 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -49,7 +49,9 @@ public enum Controle { /** 0.5 (P3.3) : plusieurs blocs cassés dans le même tick serveur, en série (Nuker). */ NUKER("nuker"), /** 0.5 (P3.1) : cristaux de l'End frappés en série dès leur apparition (AutoCrystal / CrystalAura). */ - AUTO_CRISTAL("auto-cristal"); + AUTO_CRISTAL("auto-cristal"), + /** 0.5 (P3.2) : pilier monté plus vite que le saut vanilla, blocs posés sous les pieds (Scaffold Tower). */ + TOWER("tower"); private final String id; @@ -79,7 +81,7 @@ public enum Controle { // 0.5 : nouveaux contrôles P1 au plafond « faible » tant qu'ils n'ont pas été validés en jeu. case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS, ANTI_FAIM, NO_SLOW, FAST_BREAK, FAST_PLACE, INTERACTION_BLOC, AUTO_TOTEM_REGULIER, - JESUS, OMNISPRINT, XRAY, NUKER, AUTO_CRISTAL -> 2; // 0.5 (P2) : idem + JESUS, OMNISPRINT, XRAY, NUKER, AUTO_CRISTAL, TOWER -> 2; // 0.5 (P2) : idem }; } diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index d8a2e8d..9469e1f 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -234,6 +234,10 @@ public final class GardeConfig { public int cristalDelaiMinTicks = 2; /** Auto-cristal : coups suspects parmi les 10 derniers coups sur un cristal récent (60 s) avant de compter. */ public int cristalSerieMin = 6; + /** Tower : intervalle (ticks) entre deux poses en pilier sous lequel il est court (vanilla : 9 à 10 au mieux). */ + public int towerIntervalleMinTicks = 6; + /** Tower : intervalles courts de suite avant que chaque pose rapide suivante compte. */ + public int towerSerie = 5; // --- 0.5 (P1.13, section [diagnostic]) : journal seulement, jamais de sanction --- /** Journaliser les ABORT de casse de bloc sans START correspondant (« Mismatch in destroy block pos »). */ diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 302abe6..9854a7c 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -586,6 +586,28 @@ public final class Moteur { return v; } + /** + * 0.5 (P3.2) : bloc posé, pour le tower. Exemptions MONDE et MOUVEMENT (lévitation, vol permis, élytres, riptide, + * véhicule, recul, téléportation…) : une montée qui ne vient pas du saut n'est pas mesurée. + */ + public List poseTower(UUID joueur, long nowMs, long tick, EtatJoueur etat, int bx, int by, int bz, + double px, double py, double pz, double dy) { + if (expulses.contains(joueur) || cfg.mode(Controle.TOWER) == Mode.OFF) return List.of(); + Suivi s = suivi(joueur); + Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE); + Exemptions.Resultat exM = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT); + if (ex.exempt() || exM.exempt() || etat.tps() < cfg.tpsLag) { + s.tower.vider(); + return List.of(); + } + double pts = s.tower.pose(tick, bx, by, bz, px, py, pz, dy, cfg); + List v = new ArrayList<>(1); + ajouter(v, s, Controle.TOWER, pts, nowMs, ex, String.format(Locale.ROOT, + "pilier : pose a %d tick(s) de la precedente (min %d), %d intervalles courts de suite", + s.tower.dernierIntervalle(), cfg.towerIntervalleMinTicks, s.tower.courts())); + return v; + } + /** Un bloc vient d'être posé par le joueur (BlockEvent.EntityPlaceEvent) : fast-place. */ public List poseBloc(UUID joueur, long nowMs, long tick, EtatJoueur etat) { if (expulses.contains(joueur) || cfg.mode(Controle.FAST_PLACE) == Mode.OFF) return List.of(); diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 960ffae..9eaa086 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -85,6 +85,8 @@ public final class Suivi { public final Nuker nuker = new Nuker(); /** 0.5 (P3.1) : auto-cristal. */ public final AutoCristal autoCristal = new AutoCristal(); + /** 0.5 (P3.2) : tower. */ + public final Tower tower = new Tower(); /** 0.5 (P1.6) : déploiements d'élytres répétés. */ public final DeploiementsElytres deploiements = new DeploiementsElytres(); /** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */ diff --git a/src/main/java/com/gastinelgarde/core/Tower.java b/src/main/java/com/gastinelgarde/core/Tower.java new file mode 100644 index 0000000..8713eda --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/Tower.java @@ -0,0 +1,66 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P3.2, partie « Tower » du Scaffold) : montée en pilier plus rapide que le saut vanilla. Calcul vanilla 1.21.1 + * (saut 0,42, puis v = (v − 0,08) × 0,98 par tick) : le joueur dépasse +1 bloc au 3e tick, retombe sur le bloc posé + * au 9e ; espace maintenu, {@code noJumpDelay} impose de toute façon 10 ticks entre deux sauts (LivingEntity, sources + * NeoForge 21.1.234). Un pilier honnête monte donc d'un bloc toutes les 9 à 10 ticks au mieux (Saut amélioré : plus + * lent, le saut est plus haut). Le module Tower pose un bloc toutes les 2 à 4 ticks. + * + * Signal : poses « en pilier » (bloc dans la colonne du joueur, juste sous ses pieds, chaque bloc un cran au-dessus du + * précédent, joueur en montée) séparées de moins de {@link GardeConfig#towerIntervalleMinTicks} (6) ticks. Après + * {@link GardeConfig#towerSerie} (5) intervalles courts de suite, chaque pose rapide suivante donne des points + * (donc un verdict, annulable en ENFORCE) : pas de « signalé une fois, le reste passe ». Toute autre pose, une pause + * ou un intervalle normal remet la chaîne à zéro. Le scaffold horizontal (pont) n'est pas couvert : face cachée et + * AirPlace le sont par interaction-bloc. OBSERVE par défaut. + */ +public final class Tower { + + private long dernierTick = Long.MIN_VALUE; + private int dernierY; + private int courts; + private int dernierIntervalle; + + /** + * @param bx, by, bz bloc posé + * @param px, py, pz position (pieds) du joueur + * @param dy déplacement vertical du dernier paquet de mouvement (montée > 0) + * @return points d'infraction + */ + public double pose(long tick, int bx, int by, int bz, double px, double py, double pz, double dy, GardeConfig cfg) { + boolean pilier = (int) Math.floor(px) == bx && (int) Math.floor(pz) == bz && py >= by + 1 - 0.01 + && py < by + 2.5 && dy > 0; + if (!pilier) { + vider(); + return 0; + } + boolean suite = dernierTick != Long.MIN_VALUE && by == dernierY + 1 && tick > dernierTick; + long ecart = suite ? tick - dernierTick : Long.MAX_VALUE; + dernierTick = tick; + dernierY = by; + if (!suite) { + courts = 0; + return 0; + } + dernierIntervalle = (int) Math.min(Integer.MAX_VALUE, ecart); + if (ecart >= Math.max(1, cfg.towerIntervalleMinTicks)) { + courts = 0; + return 0; + } + courts++; + return courts >= Math.max(1, cfg.towerSerie) ? 1.5 : 0; + } + + public int dernierIntervalle() { + return dernierIntervalle; + } + + public int courts() { + return courts; + } + + public void vider() { + dernierTick = Long.MIN_VALUE; + courts = 0; + } +} diff --git a/src/test/java/com/gastinelgarde/core/TowerP3Test.java b/src/test/java/com/gastinelgarde/core/TowerP3Test.java new file mode 100644 index 0000000..4542e11 --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/TowerP3Test.java @@ -0,0 +1,80 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.UUID; +import org.junit.jupiter.api.Test; + +/** 0.5, P3.2 : tower (pilier monté plus vite que le saut vanilla). */ +class TowerP3Test { + + private final GardeConfig cfg = new GardeConfig(); + private final UUID joueur = UUID.randomUUID(); + + /** n poses en pilier (x = 10, z = 20), une toutes les {@code pas} ticks ; renvoie le nombre de verdicts. */ + private int pilier(Moteur m, EtatJoueur etat, int n, int pas) { + int verdicts = 0; + for (int i = 0; i < n; i++) { + long t = 100 + (long) i * pas; + int by = 64 + i; + for (Verdict v : m.poseTower(joueur, t * 50L, t, etat, 10, by, 20, 10.5, by + 1.1, 20.5, 0.2)) { + if (v.controle() == Controle.TOWER) verdicts++; + } + } + return verdicts; + } + + @Test + void observeParDefaut() { + assertEquals(Mode.OBSERVE, cfg.mode(Controle.TOWER)); + assertEquals(Controle.TOWER, Controle.parse("tower")); + } + + @Test + void towerToutesLesTroisTicksVuEtChaquePoseCompte() { + // 5 intervalles courts pour armer, puis chaque pose rapide donne un verdict (annulable en ENFORCE). + assertEquals(20 - 1 - cfg.towerSerie + 1, pilier(new Moteur(cfg), EtatJoueur.normal(), 20, 3)); + } + + @Test + void pilierVanillaJamaisVu() { + assertEquals(0, pilier(new Moteur(cfg), EtatJoueur.normal(), 100, 9)); + assertEquals(0, pilier(new Moteur(cfg), EtatJoueur.normal(), 100, 10)); + } + + @Test + void poseHorsColonneOuSansMonteeNonMesuree() { + Moteur m = new Moteur(cfg); + int n = 0; + for (int i = 0; i < 30; i++) { + long t = 100 + i * 2L; + // pont horizontal : bloc devant, joueur qui ne monte pas + n += m.poseTower(joueur, t * 50L, t, EtatJoueur.normal(), 10 + i, 63, 20, 10.5 + i, 64, 20.5, 0).size(); + } + assertEquals(0, n); + } + + @Test + void levitationEtCreatifExemptes() { + for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(), + EtatJoueur.builder().levitation(true).build(), EtatJoueur.builder().peutVoler(true).build()}) { + assertEquals(0, pilier(new Moteur(cfg), e, 30, 2), e.toString()); + } + } + + @Test + void enforceChaquePoseRapideAtteintLePalier() { + cfg.mode(Controle.TOWER, Mode.ENFORCE); + Moteur m = new Moteur(cfg); + boolean setback = false; + for (int i = 0; i < 40; i++) { + long t = 100 + i * 2L; + int by = 64 + i; + for (Verdict v : m.poseTower(joueur, t * 50L, t, EtatJoueur.normal(), 10, by, 20, 10.5, by + 1.1, 20.5, 0.2)) { + if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) setback = true; + } + } + assertTrue(setback); + } +}