diff --git a/src/main/java/com/gastinelgarde/Cablage.java b/src/main/java/com/gastinelgarde/Cablage.java index 496383e..3823964 100644 --- a/src/main/java/com/gastinelgarde/Cablage.java +++ b/src/main/java/com/gastinelgarde/Cablage.java @@ -115,6 +115,25 @@ final class Cablage { } } + // --- 0.4.0 : grace de propulsion d'une fusee (plane en elytres) --- + + /** Ticks de marge après la fin de vie de la fusée (dernier tick de poussée, retard d'état). */ + static final int MARGE_FUSEE_TICKS = 5; + + /** + * Grâce de propulsion accordée à l'apparition d'une fusée : seulement si elle est réellement attachée au joueur + * (propulsion en plané, pas une fusée d'arbalète ou posée au sol), si le joueur plane à cet instant, et si elle + * ne vient pas d'être rechargée depuis le disque. Durée : vie restante réelle de la fusée + marge, au lieu de 6 s + * fixes (un tricheur qui tire une fusée toutes les quelques secondes n'obtient jamais plus que la vie de la fusée). + * + * @return nombre de ticks de grâce (0 = aucune) + */ + static int graceFusee(boolean attacheeAuJoueur, boolean joueurPlane, boolean rechargeeDuDisque, int vie, int dureeDeVie) { + if (!attacheeAuJoueur || !joueurPlane || rechargeeDuDisque) return 0; + int restant = Math.max(0, dureeDeVie - Math.max(0, vie)); + return Math.min(restant, 200) + MARGE_FUSEE_TICKS; + } + // --- Position de retour (C3) --- /** apresMouvement : la position de ce paquet devient-elle la position de retour ? */ diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index e1521b7..988bb5f 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -345,16 +345,27 @@ public final class Garde { } /** Fusée de feu d'artifice tirée par ce joueur (propulsion en plané) : le plané n'est pas contrôlé pendant 6 s. */ - public static void noterFusee(ServerPlayer p) { + public static void noterFusee(ServerPlayer p, int ticks) { if (!surThreadServeur(p)) return; - marques(p.getUUID()).propulsionJusquaTick = p.server.getTickCount() + 120; + Marques m = marques(p.getUUID()); + m.propulsionJusquaTick = Math.max(m.propulsionJusquaTick, p.server.getTickCount() + ticks); } /** 0.4.0 : recul appliqué par le serveur (direction du déplacement attendu, force avant résistance). */ public static void noterVelocite(ServerPlayer p, double dirX, double dirZ, double force) { if (!surThreadServeur(p)) return; double resistance = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.KNOCKBACK_RESISTANCE); - MOTEUR.reculApplique(p.getUUID(), p.server.getTickCount() * 50L, dirX, dirZ, force * Math.max(0.0, 1.0 - resistance)); + // Le joueur est-il libre de reculer ? Boîte déplacée de 0,6 puis 1,2 bloc dans le sens du recul : un mur, un trou + // d'un bloc ou un plafond bas (coup d'un tiers qui coince le joueur) annulent la mesure. + double norme = Math.hypot(dirX, dirZ); + boolean libre = norme > 1e-6; + if (libre) { + net.minecraft.world.phys.AABB b = p.getBoundingBox(); + double ux = dirX / norme, uz = dirZ / norme; + libre = p.level().noCollision(p, b.move(ux * 0.6, 0, uz * 0.6)) && p.level().noCollision(p, b.move(ux * 1.2, 0, uz * 1.2)); + } + MOTEUR.reculApplique(p.getUUID(), p.server.getTickCount() * 50L, dirX, dirZ, + force * Math.max(0.0, 1.0 - resistance), libre); } /** 0.4.0 : un totem d'immortalité vient d'éclater (hand = main qui le tenait). */ @@ -679,10 +690,10 @@ public final class Garde { EtatJoueur etatSup = etat(p, true); long maintenant = tick * 50L; if (m.mouvementTick != Integer.MIN_VALUE) { + // milieuSpecial toujours calculé ici, indépendamment de em (nul quand vol/vitesse/no-fall sont coupés). List v = MOTEUR.mesureRecul(p.getUUID(), maintenant, etatSup, p.getX() - m.mouvementX, - p.getZ() - m.mouvementZ, em != null && em.milieuSpecial()); - Sanction s = traiter(p, v); - if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v); + p.getZ() - m.mouvementZ, milieuSpecial(p, m, tick), p.horizontalCollision); + traiter(p, v); // information seulement : jamais de setback ni d'expulsion pour la vélocité } boolean totem = p.getMainHandItem().is(Items.TOTEM_OF_UNDYING) || p.getOffhandItem().is(Items.TOTEM_OF_UNDYING); List vt = MOTEUR.totemEnMain(p.getUUID(), maintenant, etatSup, totem); diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index 0d2192b..b0acc35 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -150,8 +150,13 @@ public final class GardeEvents { /** Fusée de feu d'artifice tirée par un joueur : propulsion en plané, donc plané non contrôlé un moment. */ @SubscribeEvent public static void onFusee(net.neoforged.neoforge.event.entity.EntityJoinLevelEvent event) { - if (event.getEntity() instanceof net.minecraft.world.entity.projectile.FireworkRocketEntity f - && f.getOwner() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterFusee(p); + if (!(event.getEntity() instanceof net.minecraft.world.entity.projectile.FireworkRocketEntity f)) return; + // Champ privé attachedToEntity lu via l'Access Transformer (META-INF/accesstransformer.cfg) : seule une fusée + // attachée au joueur le propulse (FireworkRocketEntity.tick), jamais une fusée d'arbalète ou posée au sol. + if (f.attachedToEntity instanceof ServerPlayer p && !(p instanceof FakePlayer)) { + int ticks = Cablage.graceFusee(true, p.isFallFlying(), event.loadedFromDisk(), f.life, f.lifetime); + if (ticks > 0) Garde.noterFusee(p, ticks); + } } /** Totem éclaté : début de la mesure du délai de remise (auto-totem). */ diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 7dcdb17..9e37e89 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -492,17 +492,24 @@ public final class Moteur { * * @param dirX,dirZ direction du déplacement attendu ; {@code force} effective, résistance déduite */ - public void reculApplique(UUID joueur, long nowMs, double dirX, double dirZ, double force) { + public void reculApplique(UUID joueur, long nowMs, double dirX, double dirZ, double force, boolean libre) { if (cfg.mode(Controle.VELOCITE) == Mode.OFF || expulses.contains(joueur)) return; + // Joueur coincé (mur, trou, plafond) : le recul n'a pas pu avoir lieu, rien à mesurer. + if (!libre) { + suivi(joueur).velocite.abandonner(); + return; + } suivi(joueur).velocite.recul(nowMs, dirX, dirZ, force, cfg); } /** Déplacement horizontal de ce paquet accepté (dx, dz signés), pour mesurer le recul en cours. */ - public List mesureRecul(UUID joueur, long nowMs, EtatJoueur etat, double dx, double dz, boolean milieuSpecial) { + public List mesureRecul(UUID joueur, long nowMs, EtatJoueur etat, double dx, double dz, boolean milieuSpecial, + boolean collisionHorizontale) { if (cfg.mode(Controle.VELOCITE) == Mode.OFF || expulses.contains(joueur)) return List.of(); Suivi s = suivis.get(joueur); if (s == null) return List.of(); - boolean neutre = milieuSpecial || etat.creatif() || etat.spectateur() || etat.peutVoler() || etat.elytres() + boolean neutre = milieuSpecial || collisionHorizontale || etat.ticksDepuisGel() <= cfg.graceGelTicks + || etat.tps() < cfg.tpsLag || etat.creatif() || etat.spectateur() || etat.peutVoler() || etat.elytres() || etat.enVehicule() || etat.riptide() || etat.pocheContraption() || etat.ticksDepuisTeleport() <= cfg.graceTeleportTicks; double pts = s.velocite.mouvement(nowMs, dx, dz, neutre, cfg); @@ -586,6 +593,9 @@ public final class Moteur { palier = Sanction.min(Sanction.EXPULSION, cfg.sanctionMax); } Sanction applicable = Paliers.applicable(palier, mode); + // 0.4.0 : vélocité et auto-totem sont bridés dans le code (un tiers peut provoquer de faux positifs) : jamais de + // setback ni d'expulsion, même si la configuration les passe en ENFORCE. Ils nourrissent le score de suspicion. + if (c == Controle.VELOCITE || c == Controle.AUTO_TOTEM) applicable = Sanction.min(applicable, Sanction.ALERTE); s.suspicion.noter(c, vl, palier.ordinal() >= Sanction.SETBACK.ordinal(), horloge.getAsLong()); boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal() && s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS); diff --git a/src/main/java/com/gastinelgarde/core/PlaneElytres.java b/src/main/java/com/gastinelgarde/core/PlaneElytres.java index 5f71158..59188fb 100644 --- a/src/main/java/com/gastinelgarde/core/PlaneElytres.java +++ b/src/main/java/com/gastinelgarde/core/PlaneElytres.java @@ -31,6 +31,16 @@ public final class PlaneElytres { /** Paquets au-delà de ce nombre de ticks : pas de mesure fiable (retard réseau). */ public static final int TICKS_MAX = 3; + /** Ticks de grâce après lesquels on exige que la fusée ait fait gagner de la vitesse. */ + public static final int GAIN_TICKS = 10; + /** Gain de vitesse horizontale (blocs par tick) attendu d'une fusée réelle. */ + public static final double GAIN_MIN = 0.05; + /** Au-dessus de cette vitesse (blocs par tick) la fusée n'a plus de gain possible : grâce maintenue. */ + public static final double VITESSE_FUSEE = 1.6; + + private int graceTicks; + private double vitesseGrace; + private double graceMax; private int monteeTicks; private double vitesseDebut; private int stationnaireTicks; @@ -42,10 +52,29 @@ public final class PlaneElytres { */ public double enregistrer(EtatMouvement m, boolean propulsion, GardeConfig cfg) { int n = m.ticks(); - if (propulsion || m.milieuSpecial() || m.auSolServeur()) { + if (m.milieuSpecial() || m.auSolServeur()) { vider(); return 0; } + if (propulsion) { + // Grâce de fusée : les compteurs sont SUSPENDUS (ni remis à zéro, ni avancés), pas effacés : tirer une fusée + // ne blanchit pas une montée ou un plané immobile déjà en cours. Grâce révoquée tôt si la fusée ne + // pousse pas réellement (vitesse horizontale sans gain au bout de GAIN_TICKS ticks). + if (n >= 1 && n <= TICKS_MAX) { + double vh = m.dxz() / n; + if (graceTicks == 0) vitesseGrace = vh; + graceTicks += n; + graceMax = Math.max(graceMax, vh); + boolean sansGain = graceTicks >= GAIN_TICKS && graceMax < vitesseGrace + GAIN_MIN && graceMax < VITESSE_FUSEE; + if (!sansGain) return 0; + // la fusée n'accélère pas : on contrôle comme sans fusée + } else { + return 0; + } + } else { + graceTicks = 0; + graceMax = 0; + } if (n < 1 || n > TICKS_MAX) return 0; // neutre : ni remise à zéro ni ajout double vh = m.dxz() / n; double vy = m.dy() / n; @@ -69,6 +98,8 @@ public final class PlaneElytres { } public void vider() { + graceTicks = 0; + graceMax = 0; monteeTicks = 0; vitesseDebut = 0; stationnaireTicks = 0; diff --git a/src/main/java/com/gastinelgarde/core/Velocite.java b/src/main/java/com/gastinelgarde/core/Velocite.java index ebeed35..027e4df 100644 --- a/src/main/java/com/gastinelgarde/core/Velocite.java +++ b/src/main/java/com/gastinelgarde/core/Velocite.java @@ -78,6 +78,11 @@ public final class Velocite { return n >= cfg.velociteSerieMin ? 2.0 : 0; } + /** Mesure impossible (joueur coincé) : rien n'est compté. */ + public void abandonner() { + actif = false; + } + public void vider() { actif = false; resultats.clear(); diff --git a/src/main/resources/META-INF/accesstransformer.cfg b/src/main/resources/META-INF/accesstransformer.cfg new file mode 100644 index 0000000..ef26591 --- /dev/null +++ b/src/main/resources/META-INF/accesstransformer.cfg @@ -0,0 +1,5 @@ +# 0.4.0 : lecture seule des champs prives de la fusee de feu d'artifice, pour n'accorder la grace de propulsion +# qu'a une fusee REELLEMENT attachee au joueur en plane (voir GardeEvents.onFusee). Aucune ecriture, aucun comportement change. +public net.minecraft.world.entity.projectile.FireworkRocketEntity attachedToEntity +public net.minecraft.world.entity.projectile.FireworkRocketEntity lifetime +public net.minecraft.world.entity.projectile.FireworkRocketEntity life diff --git a/src/test/java/com/gastinelgarde/FuseeElytresTest.java b/src/test/java/com/gastinelgarde/FuseeElytresTest.java new file mode 100644 index 0000000..5720ac0 --- /dev/null +++ b/src/test/java/com/gastinelgarde/FuseeElytresTest.java @@ -0,0 +1,41 @@ +package com.gastinelgarde; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +/** Grâce de propulsion d'une fusée (0.4.0, revue de sécurité) : seulement attachée, en plané, vie réelle. */ +class FuseeElytresTest { + + @Test + void fuseeNonAttacheeArbaleteOuPoseeAuSolPasDeGrace() { + assertEquals(0, Cablage.graceFusee(false, true, false, 0, 30)); + assertEquals(0, Cablage.graceFusee(false, false, false, 0, 30)); + } + + @Test + void fuseeAttacheeSansPlanePasDeGrace() { + assertEquals(0, Cablage.graceFusee(true, false, false, 0, 30)); + } + + @Test + void fuseeRechargeeDuDisquePasDeGrace() { + assertEquals(0, Cablage.graceFusee(true, true, true, 0, 30)); + } + + @Test + void fuseeAttacheeEnPlaneGraceLimiteeALaDureeDeVie() { + assertEquals(30 + Cablage.MARGE_FUSEE_TICKS, Cablage.graceFusee(true, true, false, 0, 30)); + assertEquals(10 + Cablage.MARGE_FUSEE_TICKS, Cablage.graceFusee(true, true, false, 20, 30), "vie restante"); + assertEquals(Cablage.MARGE_FUSEE_TICKS, Cablage.graceFusee(true, true, false, 50, 30), "déjà finie"); + assertTrue(Cablage.graceFusee(true, true, false, 0, 100_000) <= 205, "durée de vie aberrante bornée"); + } + + @Test + void uneFuseeParSecondeNeDonneJamaisPlusQueLaVieDeLaFusee() { + int graceMax = 0; + for (int i = 0; i < 20; i++) graceMax = Math.max(graceMax, Cablage.graceFusee(true, true, false, 0, 30)); + assertTrue(graceMax < 40, "chaque grâce vaut la vie de la fusée (~30 ticks) + 5, pas 120 ticks fixes"); + } +} diff --git a/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java b/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java index 4ac789b..315b780 100644 --- a/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java +++ b/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java @@ -77,13 +77,37 @@ class NouveauxControlesTest { } @Test - void elytresApresUneFuseeRienNeCompte() { + void elytresFuseeQuiAccelereVraimentSuspendLesCompteursSansLesEffacer() { + double total = 0; + for (int i = 0; i < 15; i++) total += plane(enPlane(), 1.0, 0.4, 1); // 15 ticks de montée suspecte + assertEquals(0, total, "sous les 20 ticks"); + EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build(); + double v = 1.0; + for (int i = 0; i < 60; i++) { // la fusée accélère réellement : 1,0 -> 1,6 + v = Math.min(1.6, v + 0.05); + total += plane(fusee, v, 0.4, 1); + } + assertEquals(0, total, "pendant la grâce rien ne compte"); + // grâce finie : les 15 ticks d'avant sont conservés, 6 ticks de plus suffisent (> 20) + double apres = 0; + for (int i = 0; i < 6; i++) apres += plane(enPlane(), 1.6, 0.4, 1); + assertTrue(apres > 0, "compteurs conservés, pas remis à zéro par la fusée"); + } + + @Test + void elytresFuseeQuiNAcceleratPasEstRevoqueeApres10Ticks() { EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build(); double total = 0; - for (int i = 0; i < 60; i++) total += plane(fusee, 1.2, 0.4, 1); + for (int i = 0; i < 60; i++) total += plane(fusee, 1.0, 0.4, 1); // vitesse constante : la fusée ne pousse pas + assertTrue(total > 0, "grâce révoquée, la montée à vitesse constante est vue malgré le drapeau"); + } + + @Test + void elytresFuseeDejaALaVitesseMaximaleGardeLaGrace() { + EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build(); + double total = 0; + for (int i = 0; i < 40; i++) total += plane(fusee, 1.8, 0.3, 1); assertEquals(0, total); - // la fusée finie, la montée n'est plus expliquée : le compteur repart de zéro (20 ticks) - for (int i = 0; i < 15; i++) assertEquals(0, plane(enPlane(), 1.2, 0.4, 1)); } @Test @@ -133,11 +157,11 @@ class NouveauxControlesTest { private double recul(double force, double dxParTick, int n, EtatJoueur etat, boolean milieu) { now += 50; moteur.suivi(j); - moteur.reculApplique(j, now, 1, 0, force); + moteur.reculApplique(j, now, 1, 0, force, true); double pts = 0; for (int i = 0; i < n; i++) { now += 50; - pts += moteur.mesureRecul(j, now, etat, dxParTick, 0, milieu).stream().mapToDouble(Verdict::points).sum(); + pts += moteur.mesureRecul(j, now, etat, dxParTick, 0, milieu, false).stream().mapToDouble(Verdict::points).sum(); } return pts; } @@ -157,6 +181,87 @@ class NouveauxControlesTest { assertTrue(recul(0.4, 0.0, 7, EtatJoueur.normal(), false) > 0, "3e recul absent sur 3 : infraction"); } + @Test + void velociteJoueurContreUnMurFrappeSouventNAJamaisDeVerdict() { + // griefing : un tiers coince le joueur contre un mur puis le frappe ; l'adaptateur passe libre = false + for (int k = 0; k < 12; k++) { + now += 50; + moteur.suivi(j); + moteur.reculApplique(j, now, 1, 0, 0.4, false); + for (int i = 0; i < 7; i++) { + now += 50; + assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, false).isEmpty()); + } + } + } + + @Test + void velociteJoueurDansUnTrouDUnBlocFrappeNAJamaisDeVerdict() { + for (int k = 0; k < 12; k++) { + now += 50; + moteur.suivi(j); + moteur.reculApplique(j, now, 0, 1, 0.9, false); + for (int i = 0; i < 7; i++) { + now += 50; + assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, false).isEmpty()); + } + } + } + + @Test + void velociteJoueurLibreSansReculDonneUnVerdict() { + recul(0.4, 0.0, 7, EtatJoueur.normal(), false); + recul(0.4, 0.0, 7, EtatJoueur.normal(), false); + assertTrue(recul(0.4, 0.0, 7, EtatJoueur.normal(), false) > 0); + } + + @Test + void velociteCollisionHorizontaleOuGelDuServeurAbandonneLaMesure() { + for (int k = 0; k < 6; k++) { + now += 50; + moteur.suivi(j); + moteur.reculApplique(j, now, 1, 0, 0.4, true); + for (int i = 0; i < 7; i++) { + now += 50; + assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, i == 2).isEmpty(), + "collision horizontale pendant la fenêtre"); + } + } + EtatJoueur gel = EtatJoueur.builder().ticksDepuisGel(10).build(); + for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, gel, false), "juste après un gel du serveur"); + EtatJoueur lag = EtatJoueur.builder().tps(10.0).build(); + for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, lag, false), "serveur qui rame"); + } + + @Test + void velociteEtAutoTotemJamaisDeSanctionMemeEnEnforce() { + cfg.mode(Controle.VELOCITE, Mode.ENFORCE); + cfg.mode(Controle.AUTO_TOTEM, Mode.ENFORCE); + boolean vu = false; + for (int k = 0; k < 40; k++) { + now += 50; + moteur.suivi(j); + moteur.reculApplique(j, now, 1, 0, 0.4, true); + for (int i = 0; i < 7; i++) { + now += 50; + for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, false)) { + vu = true; + assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal(), v.toString()); + } + } + } + assertTrue(vu); + boolean totemVu = false; + for (int k = 0; k < 30; k++) { + moteur.totemEclate(j, now += 1000, false); + for (Verdict v : moteur.totemEnMain(j, now += 50, EtatJoueur.normal(), true)) { + totemVu = true; + assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal(), v.toString()); + } + } + assertTrue(totemVu); + } + @Test void velociteUnMurOuUnContreIsoleNeSuffitPas() { assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false)); // contre un mur @@ -202,11 +307,11 @@ class NouveauxControlesTest { void velociteDeuxReculsDansLaFenetreOuForceNegligeableAnnulentLaMesure() { for (int k = 0; k < 5; k++) { now += 50; - moteur.reculApplique(j, now, 1, 0, 0.4); - moteur.reculApplique(j, now + 50, 1, 0, 0.4); // second coup pendant la fenêtre + moteur.reculApplique(j, now, 1, 0, 0.4, true); + moteur.reculApplique(j, now + 50, 1, 0, 0.4, true); // second coup pendant la fenêtre for (int i = 0; i < 7; i++) { now += 50; - assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false).isEmpty()); + assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, false).isEmpty()); } } for (int k = 0; k < 5; k++) assertEquals(0, recul(0.05, 0.0, 7, EtatJoueur.normal(), false), "force < 0,15");