Comparer les révisions
3
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
3dc39c8043 | |||
|
|
5eeb916add | |||
|
|
f19fe6444b | |||
Aucun fichier ne correspond à votre recherche
@@ -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.
|
||||
|
||||
@@ -80,6 +80,10 @@ public final class Garde {
|
||||
int contraptionTick = Integer.MIN_VALUE;
|
||||
int contraptionVuTick = Integer.MIN_VALUE;
|
||||
boolean contraptionProche;
|
||||
// C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
|
||||
int solServeurTick = Integer.MIN_VALUE;
|
||||
boolean elytresVues;
|
||||
boolean elytresSuspectes;
|
||||
// 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;
|
||||
@@ -386,12 +390,25 @@ 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.
|
||||
if (p.isFallFlying()) {
|
||||
if (!m.elytresVues) {
|
||||
m.elytresVues = true;
|
||||
m.elytresSuspectes = m.solServeurTick != Integer.MIN_VALUE
|
||||
&& tick - m.solServeurTick < config().elytresAirMinTicks;
|
||||
}
|
||||
} else {
|
||||
m.elytresVues = false;
|
||||
m.elytresSuspectes = false;
|
||||
}
|
||||
|
||||
return EtatJoueur.builder()
|
||||
.creatif(p.isCreative())
|
||||
.spectateur(p.isSpectator())
|
||||
.peutVoler(p.getAbilities().mayfly)
|
||||
.riptide(riptideRecent)
|
||||
.elytres(p.isFallFlying())
|
||||
.elytresDeploiementSuspect(m.elytresSuspectes)
|
||||
.levitation(p.hasEffect(MobEffects.LEVITATION))
|
||||
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
|
||||
.enVehicule(p.isPassenger())
|
||||
@@ -586,6 +603,7 @@ public final class Garde {
|
||||
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());
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -53,6 +53,10 @@ public final class GardeSpec {
|
||||
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;
|
||||
@@ -161,6 +165,14 @@ public final class GardeSpec {
|
||||
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");
|
||||
@@ -210,6 +222,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();
|
||||
@@ -267,6 +282,9 @@ public final class GardeSpec {
|
||||
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();
|
||||
@@ -341,6 +359,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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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,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");
|
||||
|
||||
@@ -97,6 +97,17 @@ public final class GardeConfig {
|
||||
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;
|
||||
|
||||
|
||||
@@ -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";
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur