Comparer les révisions
6
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
3dc39c8043 | |||
|
|
5eeb916add | |||
|
|
f19fe6444b | |||
|
|
9c2814a30e | |||
|
|
e33225c0d0 | |||
|
|
b34a3b3aeb | |||
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";
|
||||
|
||||
@@ -19,6 +19,15 @@ public final class VolVertical {
|
||||
private boolean etaitEnAir;
|
||||
private int anormauxConsecutifs;
|
||||
|
||||
/**
|
||||
* Rafales réseau (16/10) : ticks serveur écoulés moins ticks client couverts par les paquets déjà vus. Un paquet
|
||||
* d'un tick client reçu après 3 ticks serveur laisse 2 ticks « dus », couverts ensuite par les paquets à 0 tick de
|
||||
* la même rafale. Borné à {@link #AVANCE_MAX} : au-delà, on revient à la règle stricte (n-1 ou n ticks), donc
|
||||
* un client qui ralentit durablement sa chute (un tick de gravité toutes les 3 ticks) reste vu.
|
||||
*/
|
||||
public static final int AVANCE_MAX = 4;
|
||||
private int avance;
|
||||
|
||||
// --- C10 (16/10) : option {@link GardeConfig#volFenetreGlissante}, désactivée par défaut ---
|
||||
/** Fenêtre glissante (ticks en l'air évalués) où l'on compte les ticks anormaux. */
|
||||
public static final int FENETRE_TICKS = 20;
|
||||
@@ -53,6 +62,7 @@ public final class VolVertical {
|
||||
int n = e.ticks();
|
||||
if (n > TICKS_MAX || n < 0) {
|
||||
aVitesse = false;
|
||||
avance = 0;
|
||||
return 0;
|
||||
}
|
||||
boolean enAir = !e.auSolServeur();
|
||||
@@ -62,11 +72,14 @@ public final class VolVertical {
|
||||
|
||||
if (exempt || e.milieuSpecial() || !enAir) {
|
||||
anormauxConsecutifs = 0;
|
||||
avance = 0;
|
||||
viderFenetre();
|
||||
} else if (etaitEnAir && aVitesse) {
|
||||
// Ticks candidats couverts par ce paquet : n exactement à l'heure ; n-1 ou n en retard ; 1 si 0.
|
||||
int kMin = n <= 1 ? 1 : n - 1;
|
||||
// Rafales : jusqu'à AVANCE_MAX ticks dus peuvent rester en attente ; la règle d'avant reste toujours admise.
|
||||
int kMin = Math.max(1, Math.min(n <= 1 ? 1 : n - 1, n + avance - AVANCE_MAX));
|
||||
int kMax = Math.max(1, n);
|
||||
int kRetenu = kMax;
|
||||
boolean ecart = true;
|
||||
double v = derniereVitesse;
|
||||
double somme = 0;
|
||||
@@ -78,8 +91,10 @@ public final class VolVertical {
|
||||
if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) {
|
||||
ecart = false;
|
||||
vitesseFin = n <= 1 ? dy : v;
|
||||
kRetenu = k;
|
||||
}
|
||||
}
|
||||
avance = Math.max(0, Math.min(AVANCE_MAX, avance + n - kRetenu));
|
||||
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08 par tick.
|
||||
if (ecart) anormauxConsecutifs++;
|
||||
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
|
||||
@@ -136,6 +151,7 @@ public final class VolVertical {
|
||||
aVitesse = false;
|
||||
etaitEnAir = false;
|
||||
anormauxConsecutifs = 0;
|
||||
avance = 0;
|
||||
viderFenetre();
|
||||
}
|
||||
}
|
||||
@@ -336,12 +336,14 @@ class AutotestCasLimitesTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
|
||||
void CORRIGE_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
|
||||
// Inversé le 16/10 (fix/rafales-reseau) : était FAUX_POSITIF_ (88,9 points).
|
||||
// Ancien commentaire :
|
||||
// Un paquet d'UN tick client arrivé après 3 ticks serveur n'est comparé qu'à 2 ou 3 ticks de gravité, et la
|
||||
// vitesse retenue est alors dy / 3 : le paquet suivant est faux aussi. Motif 3, 0, 0 : +1 anomalie par rafale,
|
||||
// premier point après ~31 paquets (1,5 s de chute, ~12 blocs). Simulé, à confirmer avec une trace réelle.
|
||||
double total = chuteAvecGigue(new int[] {3, 0, 0});
|
||||
assertTrue(total > 0);
|
||||
assertEquals(0, total, 1e-9);
|
||||
Mesures.noter("Lag 3,0,0 : " + total + " points de vol sur une chute de 80 paquets");
|
||||
}
|
||||
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* Autotests du 16/10/2026 : rafales réseau (paquets de mouvement groupés après un lag). Chaque paquet couvre UN tick
|
||||
* client, mais le serveur voit {@code motif[i]} ticks écoulés avant lui (3, 0, 0 : trois paquets arrivés ensemble).
|
||||
*
|
||||
* {@code CORRIGE_…} : anciens FAUX_POSITIF_ (joueur honnête puni), inversés : aucun point attendu.
|
||||
* {@code temoin_…} : la triche équivalente (chute ralentie) doit rester vue, avant comme après le correctif.
|
||||
*/
|
||||
class AutotestRafalesTest {
|
||||
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
private long tick;
|
||||
private boolean sanctionLourde;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.mode(Controle.VOL, Mode.ENFORCE);
|
||||
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||
cfg.mode(Controle.NO_FALL, Mode.OBSERVE);
|
||||
moteur = new Moteur(cfg);
|
||||
tick = 5000;
|
||||
sanctionLourde = false;
|
||||
}
|
||||
|
||||
private static EtatMouvement m(double dy, int ticks, boolean sol) {
|
||||
return new EtatMouvement(0.1, dy, ticks, sol, sol, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
private double paquet(EtatMouvement mv) {
|
||||
tick += mv.ticks();
|
||||
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, EtatJoueur.normal(), mv);
|
||||
double p = 0;
|
||||
for (Verdict v : vs) {
|
||||
if (v.controle() == Controle.VOL) p += v.points();
|
||||
if (v.palier() == Sanction.SETBACK || v.palier() == Sanction.EXPULSION) sanctionLourde = true;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
/** Chute honnête de {@code paquets} ticks client depuis la vitesse v0, avec la gigue donnée. */
|
||||
private double chute(double v0, int paquets, int[] motif) {
|
||||
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
|
||||
double total = 0, v = v0;
|
||||
for (int p = 0; p < paquets; p++) {
|
||||
total += paquet(m(v, motif[p % motif.length], false));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_rafalesDeTroisLongueChuteSansPointNiSanction() {
|
||||
double total = chute(0, 80, new int[] {3, 0, 0});
|
||||
Mesures.noter("Rafales 3,0,0 chute 80 : " + total + " points, sanction lourde=" + sanctionLourde);
|
||||
assertEquals(0, total, 1e-9);
|
||||
assertTrue(!sanctionLourde, "aucun setback ni expulsion pour un joueur honnête");
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_sautPuisChuteEnRafalesDeTrois() {
|
||||
double total = chute(0.42, 80, new int[] {3, 0, 0});
|
||||
Mesures.noter("Rafales 3,0,0 saut + chute 80 : " + total + " points");
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_gigueIrreguliereApresUnLag() {
|
||||
// Gigue irrégulière (rafales de 3 et 4 mêlées) : mesurée à 0 point avant le correctif, doit le rester.
|
||||
double total = chute(0, 90, new int[] {3, 0, 0, 4, 0, 0, 0, 1, 2, 0, 3, 0, 0});
|
||||
Mesures.noter("Gigue irreguliere chute 90 : " + total + " points");
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void temoin_chuteRalentieUnPaquetDUnTickToutesLesTroisTicksResteVue() {
|
||||
// Triche « slow fall / timer lent » : un paquet d'un tick de gravité toutes les 3 ticks serveur, sans rattrapage.
|
||||
double total = chute(0, 80, new int[] {3});
|
||||
Mesures.noter("Temoin chute ralentie 1/3 : " + total + " points");
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void temoin_planeEnRafalesResteVu() {
|
||||
// Plané (dy = 0) livré en rafales : doit être vu, quelle que soit la gigue.
|
||||
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
|
||||
double total = 0;
|
||||
int[] motif = {3, 0, 0};
|
||||
for (int p = 0; p < 60; p++) total += paquet(m(-0.01, motif[p % 3], false));
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_chuteSansGigueReference() {
|
||||
assertEquals(0, chute(0, 80, new int[] {1}), 1e-9);
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur