Fusee : grace seulement si attachee au joueur en plane, vie reelle, compteurs suspendus ; velocite bridee (jamais de sanction), joueur coince ecarte

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Sonnet 5.5 a révisé 2026-10-23 16:04:49 +02:00
1 Parent 22ccc5fa59
révision c5bd0265f6
9 fichiers modifiés
+253 -21

Aucun fichier ne correspond à votre recherche

+19
Voir le fichier
@@ -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 ? */
+17 -6
Voir le fichier
@@ -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<Verdict> 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<Verdict> vt = MOTEUR.totemEnMain(p.getUUID(), maintenant, etatSup, totem);
+7 -2
Voir le fichier
@@ -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). */
+13 -3
Voir le fichier
@@ -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<Verdict> mesureRecul(UUID joueur, long nowMs, EtatJoueur etat, double dx, double dz, boolean milieuSpecial) {
public List<Verdict> 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);
+32 -1
Voir le fichier
@@ -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;
+5
Voir le fichier
@@ -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();
+5
Voir le fichier
@@ -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
+41
Voir le fichier
@@ -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");
}
}
+114 -9
Voir le fichier
@@ -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");