0.6.1-dev : correctifs revue M1-M4 (setback unique par tick, VL de la cause remis a zero, blocs fantomes, exemption nuker configurable)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
67ddfff41a
révision
c2a0d5403d
9 fichiers modifiés
+308
-4
Aucun fichier ne correspond à votre recherche
@@ -1,7 +1,7 @@
|
||||
org.gradle.jvmargs=-Xmx2G
|
||||
org.gradle.parallel=true
|
||||
|
||||
mod_version=0.6.0-dev
|
||||
mod_version=0.6.1-dev
|
||||
mod_group_id=com.gastinelgarde
|
||||
mod_id=gastinelgarde
|
||||
|
||||
|
||||
@@ -225,19 +225,25 @@ final class Cablage {
|
||||
p.journal(p.nom() + " EXPULSE (" + motif + ")");
|
||||
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
|
||||
} else if (s == Sanction.SETBACK) {
|
||||
if (moteur.setbackDejaApplique(p.id(), p.tick() * 50L)) {
|
||||
// 0.6.1 (revue M1) : même paquet, second contrôle : pas de second retour ni de second compte.
|
||||
moteur.apresSetbackDuMemeTick(p.id(), verdicts);
|
||||
p.journal(p.nom() + " SETBACK deja applique ce tick (" + motif + ") : ni second retour ni second compte");
|
||||
return;
|
||||
}
|
||||
Suivi sv = moteur.suivi(p.id());
|
||||
double[] sol;
|
||||
if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) {
|
||||
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
|
||||
p.teleporter(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
|
||||
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
|
||||
moteur.apresSetback(p.id(), p.tick() * 50L);
|
||||
moteur.apresSetback(p.id(), p.tick() * 50L, verdicts);
|
||||
p.journal(p.nom() + " SETBACK (" + motif + ")");
|
||||
} else if (!sv.aPositionValide() && moteur.config().setbackSolSiPasDePosition && (sol = p.solSous()) != null) {
|
||||
// 0.5 (P1.2) : reconnexion en l'air (aucune position au sol connue) : retour au sol sous le joueur.
|
||||
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
|
||||
p.teleporter(sol[0], sol[1], sol[2], (float) sol[3], (float) sol[4]);
|
||||
moteur.apresSetback(p.id(), p.tick() * 50L);
|
||||
moteur.apresSetback(p.id(), p.tick() * 50L, verdicts);
|
||||
p.journal(String.format(java.util.Locale.ROOT, "%s SETBACK au sol (%s) : pas de position de retour, y=%.2f",
|
||||
p.nom(), motif, sol[1]));
|
||||
} else {
|
||||
|
||||
@@ -417,6 +417,8 @@ public final class Garde {
|
||||
* ligne de journal pour un ABORT sans START correspondant (message vanilla « Mismatch in destroy block pos »).
|
||||
*/
|
||||
public static void noterActionBloc(ServerPlayer p, boolean start, boolean abort, BlockPos pos, boolean annule) {
|
||||
// 0.6.1 (revue M2) : bloc visé par un paquet de casse (pour nukerIgnorerCassesSansPaquet).
|
||||
if (surThreadServeur(p)) MOTEUR.paquetCasse(p.getUUID(), pos.asLong(), p.server.getTickCount() * 50L);
|
||||
if (!CONFIG.diagnosticActionsBloc || !surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
|
||||
com.gastinelgarde.core.ActionsBloc a = MOTEUR.suivi(p.getUUID()).actionsBloc;
|
||||
if (start) {
|
||||
@@ -426,6 +428,22 @@ public final class Garde {
|
||||
if (ligne != null) ecrireJournal("DIAGNOSTIC " + p.getGameProfile().getName() + " casse de bloc : " + ligne);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* 0.6.1 (revue M3) : un bloc change (casse ou pose) : noté pour chaque joueur à moins de 16 blocs, dont l'auteur, car
|
||||
* le client d'un voisin peut encore voir l'ancien bloc (lag) et cliquer dessus.
|
||||
*/
|
||||
private static void changementProche(ServerPlayer auteur, BlockPos pos) {
|
||||
long cle = pos.asLong();
|
||||
long ms = auteur.server.getTickCount() * 50L;
|
||||
MOTEUR.changementBloc(auteur.getUUID(), cle, ms);
|
||||
if (!(auteur.level() instanceof net.minecraft.server.level.ServerLevel niveau)) return;
|
||||
for (ServerPlayer autre : niveau.players()) {
|
||||
if (autre != auteur && autre.distanceToSqr(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5) <= 256) {
|
||||
MOTEUR.changementBloc(autre.getUUID(), cle, ms);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** 0.5 (P2.3) : START de casse accepté : début de la mesure fast-break. */
|
||||
public static void noterDebutCasse(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face) {
|
||||
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
|
||||
@@ -450,6 +468,8 @@ public final class Garde {
|
||||
List<Verdict> v = verdictsInteraction(p, pos, face, impact, mainPrincipale ? 0 : 1);
|
||||
Sanction s = traiter(p, v);
|
||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||
// 0.6.1 (revue M3) : case où ce clic pose un bloc ; si la pose est refusée, le client garde un bloc fantôme.
|
||||
if (face != null) MOTEUR.changementBloc(p.getUUID(), pos.relative(face).asLong(), p.server.getTickCount() * 50L);
|
||||
boolean annulerScaffold = poseScaffold(p, pos, face, impact, mainPrincipale);
|
||||
return Cablage.sanctionDeMouvement(s) || annulerScaffold;
|
||||
}
|
||||
@@ -583,6 +603,7 @@ public final class Garde {
|
||||
*/
|
||||
public static boolean noterCasse(ServerPlayer p, BlockPos pos, BlockState state) {
|
||||
if (!surThreadServeur(p)) return false;
|
||||
changementProche(p, pos); // 0.6.1 (revue M3) : avant tout retour, pour tous les joueurs proches
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, casse annulée (C4)
|
||||
if (estExempteManuellement(p.getUUID())) return false;
|
||||
int tick = p.server.getTickCount();
|
||||
@@ -591,7 +612,8 @@ public final class Garde {
|
||||
traiter(p, MOTEUR.casseXray(p.getUUID(), tick * 50L, etat(p, false), pos.getY(), rare, rare && expose(p, pos)));
|
||||
}
|
||||
boolean annulerNuker = false;
|
||||
if (CONFIG.mode(Controle.NUKER) != Mode.OFF) { // 0.5 (P3.3)
|
||||
if (CONFIG.mode(Controle.NUKER) != Mode.OFF // 0.5 (P3.3) ; 0.6.1 (M2) : casse en chaîne d'un mod ignorée si réglé
|
||||
&& !MOTEUR.casseNukerSansPaquet(p.getUUID(), pos.asLong(), tick * 50L)) {
|
||||
List<Verdict> vn = MOTEUR.casseNuker(p.getUUID(), tick * 50L, tick, etat(p, true));
|
||||
Sanction sn = traiter(p, vn);
|
||||
if (sn == Sanction.EXPULSION) {
|
||||
@@ -647,6 +669,7 @@ 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, BlockPos pos) {
|
||||
if (!surThreadServeur(p)) return false;
|
||||
changementProche(p, pos); // 0.6.1 (revue M3)
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, pose annulée (C4)
|
||||
if (estExempteManuellement(p.getUUID())) return false;
|
||||
int tick = p.server.getTickCount();
|
||||
|
||||
@@ -36,6 +36,8 @@ public final class GardeSpec {
|
||||
private static final ModConfigSpec.IntValue FAST_BREAK_TICKS_MIN, FAST_BREAK_SERIE;
|
||||
private static final ModConfigSpec.IntValue FAST_PLACE_SERIE, FAST_PLACE_INTERVALLE;
|
||||
private static final ModConfigSpec.DoubleValue FAST_PLACE_REGULARITE, INTER_MARGE;
|
||||
private static final ModConfigSpec.IntValue INTER_GRACE;
|
||||
private static final ModConfigSpec.BooleanValue NUKER_SANS_PAQUET;
|
||||
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, TOWER_INTERVALLE, TOWER_SERIE,
|
||||
@@ -322,6 +324,9 @@ public final class GardeSpec {
|
||||
.defineInRange("autoTotemRegulierMaxMs", 300, 50, 2000);
|
||||
INTER_SERIE = b.comment("Interaction-bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter.")
|
||||
.defineInRange("interactionBlocSerieMin", 3, 1, 10);
|
||||
INTER_GRACE = b.comment("0.6.1 (revue M3) interaction-bloc : un clic sur un bloc devenu de l'air depuis moins de ce délai (ms)",
|
||||
"(casse, pose ou pose refusée : bloc fantôme côté client) ne compte pas comme « bloc-vide ».")
|
||||
.defineInRange("interactionBlocGraceChangementMs", 500, 0, 5000);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 (P3) : contrôles lourds. Nouveaux contrôles en OBSERVE par défaut, valeurs prudentes.").push("p3");
|
||||
@@ -331,6 +336,10 @@ public final class GardeSpec {
|
||||
.defineInRange("nukerBlocsParTickMax", 3, 1, 64);
|
||||
NUKER_SERIE = b.comment("Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter.")
|
||||
.defineInRange("nukerSerieMin", 3, 1, 20);
|
||||
NUKER_SANS_PAQUET = b.comment("0.6.1 (revue M2) nuker : true = ne compter que les casses visées par un paquet de casse du joueur",
|
||||
"dans le même tick (ignore les blocs cassés en chaîne par un mod d'abattage d'arbres ou de minage de filon).",
|
||||
"false par défaut (aucun mod de ce genre sur le serveur). Un nuker de client triche envoie un paquet par bloc : il reste vu.")
|
||||
.define("nukerIgnorerCassesSansPaquet", false);
|
||||
CRISTAL_DELAI = b.comment("0.5 (P3.1) auto-cristal : âge (ticks serveur) d'un cristal de l'End frappé sous lequel le coup est suspect.",
|
||||
"2 = frappé dans le tick de sa pose ou le suivant. Cristaux d'âge inconnu (rechargés, posés avant) non mesurés.",
|
||||
"Risque de faux positif élevé (PvP cristal rapide, paquets groupés) : longue observation avant tout ENFORCE.")
|
||||
@@ -592,11 +601,13 @@ public final class GardeSpec {
|
||||
c.fastPlaceIntervalleMaxTicks = FAST_PLACE_INTERVALLE.get();
|
||||
c.interactionBlocMarge = INTER_MARGE.get();
|
||||
c.interactionBlocSerieMin = INTER_SERIE.get();
|
||||
c.interactionBlocGraceChangementMs = INTER_GRACE.get();
|
||||
c.autoTotemEchantillons = TOTEM_ECHANT.get();
|
||||
c.autoTotemEcartTypeMinMs = TOTEM_ECART.get();
|
||||
c.autoTotemRegulierMaxMs = TOTEM_REG_MAX.get();
|
||||
c.nukerBlocsParTickMax = NUKER_MAX.get();
|
||||
c.nukerSerieMin = NUKER_SERIE.get();
|
||||
c.nukerIgnorerCassesSansPaquet = NUKER_SANS_PAQUET.get();
|
||||
c.cristalDelaiMinTicks = CRISTAL_DELAI.get();
|
||||
c.cristalSerieMin = CRISTAL_SERIE.get();
|
||||
c.towerIntervalleMinTicks = TOWER_INTERVALLE.get();
|
||||
|
||||
@@ -204,6 +204,8 @@ public final class GardeConfig {
|
||||
public double interactionBlocMarge = 0.5;
|
||||
/** Interaction de bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter. */
|
||||
public int interactionBlocSerieMin = 3;
|
||||
/** 0.6.1 (revue M3) : « bloc-vide » non compté si ce bloc a changé (casse, pose, clic de pose) depuis ce délai (ms). */
|
||||
public int interactionBlocGraceChangementMs = 500;
|
||||
/** Auto-totem régulier : délais (éclatement → totem en main) examinés. */
|
||||
public int autoTotemEchantillons = 5;
|
||||
/** Auto-totem régulier : écart type (ms) sous lequel ces délais sont ceux d'une machine. */
|
||||
@@ -230,6 +232,11 @@ public final class GardeConfig {
|
||||
public int nukerBlocsParTickMax = 3;
|
||||
/** Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter. */
|
||||
public int nukerSerieMin = 3;
|
||||
/**
|
||||
* 0.6.1 (revue M2) : vrai = le nuker ne compte que les casses visées par un paquet de casse du joueur dans le même
|
||||
* tick ; les blocs cassés par un mod d'abattage / de minage de filon au nom du joueur sont ignorés. Faux par défaut.
|
||||
*/
|
||||
public boolean nukerIgnorerCassesSansPaquet = false;
|
||||
/** Auto-cristal : âge (ticks serveur) d'un cristal de l'End frappé sous lequel le coup est suspect (2 : même tick ou suivant). */
|
||||
public int cristalDelaiMinTicks = 2;
|
||||
/** Auto-cristal : coups suspects parmi les 10 derniers coups sur un cristal récent (60 s) avant de compter. */
|
||||
|
||||
@@ -531,6 +531,28 @@ public final class Moteur {
|
||||
return v;
|
||||
}
|
||||
|
||||
/** 0.6.1 (revue M2) : paquet de casse (START/STOP/ABORT) du joueur sur ce bloc ({@code BlockPos.asLong}). */
|
||||
public void paquetCasse(UUID joueur, long cleBloc, long nowMs) {
|
||||
if (expulses.contains(joueur)) return;
|
||||
suivi(joueur).paquetsCasse.noter(cleBloc, nowMs);
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.6.1 (revue M2) : cette casse est-elle hors du nuker ? Vrai seulement si {@code nukerIgnorerCassesSansPaquet} est
|
||||
* activé et qu'aucun paquet de casse du joueur n'a visé ce bloc dans le même tick (casse en chaîne d'un mod).
|
||||
*/
|
||||
public boolean casseNukerSansPaquet(UUID joueur, long cleBloc, long nowMs) {
|
||||
if (!cfg.nukerIgnorerCassesSansPaquet) return false;
|
||||
Suivi s = suivis.get(joueur);
|
||||
return s == null || !s.paquetsCasse.contient(cleBloc, nowMs, 0);
|
||||
}
|
||||
|
||||
/** 0.6.1 (revue M3) : un bloc proche de ce joueur vient de changer (casse, pose, cible d'un clic de pose). */
|
||||
public void changementBloc(UUID joueur, long cleBloc, long nowMs) {
|
||||
if (expulses.contains(joueur)) return;
|
||||
suivi(joueur).changementsBloc.noter(cleBloc, nowMs);
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P3.3) : bloc cassé par le joueur, pour le nuker (plusieurs blocs dans le même tick serveur). Exemptions de la
|
||||
* famille MONDE (créatif, spectateur, contraption, vaisseau, gel) ; TPS bas : pas de mesure (paquets groupés).
|
||||
@@ -813,6 +835,12 @@ public final class Moteur {
|
||||
Suivi s = suivi(joueur);
|
||||
double marge = (cfg.interactionBlocMarge + Math.max(0, Math.min(deplacement, 5.0))) * ex.facteur();
|
||||
String a = InteractionBloc.anomalie(oeil, boite, face, impact, air, plein, portee, marge);
|
||||
// 0.6.1 (revue M3) : bloc fantôme (le client voit encore un bloc que le serveur vient de casser, ou une pose
|
||||
// refusée) : « bloc-vide » n'est pas compté si ce bloc a changé il y a peu.
|
||||
if ("bloc-vide".equals(a) && cleBloc != Long.MIN_VALUE
|
||||
&& s.changementsBloc.contient(cleBloc, nowMs, Math.max(0, cfg.interactionBlocGraceChangementMs))) {
|
||||
a = null;
|
||||
}
|
||||
// La vérification tourne toujours ; seul le comptage est sauté pour la main secondaire du même clic, et seulement
|
||||
// si elle donne la même anomalie que la principale : elle reprend alors ses verdicts (même décision d'annulation).
|
||||
if (cleBloc != Long.MIN_VALUE && s.interactionBloc.secondeMainDuMemeClic(nowMs, cleBloc, main, face, impact)
|
||||
@@ -1003,13 +1031,45 @@ public final class Moteur {
|
||||
* paquet suivant sert de référence) et leurs VL sont remis à zéro ; le setback est compté pour l'escalade (C5).
|
||||
*/
|
||||
public void apresSetback(UUID joueur, long nowMs) {
|
||||
apresSetback(joueur, nowMs, List.of());
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.6.1 (revue M4) : idem, et le VL de chaque contrôle qui a demandé ce setback (verdict applicable ≥ SETBACK) est
|
||||
* aussi remis à zéro. Avant, step, no-slow ou jesus restaient au-dessus du seuil et redonnaient un setback à chaque
|
||||
* paquet, jusqu'à l'expulsion. Le setback est noté pour l'escalade et pour {@link #setbackDejaApplique} (M1).
|
||||
*/
|
||||
public void apresSetback(UUID joueur, long nowMs, List<Verdict> causes) {
|
||||
Suivi s = suivi(joueur);
|
||||
s.vol.vider();
|
||||
s.vitesse.vider();
|
||||
s.graceElytresJusquaMs = Long.MIN_VALUE;
|
||||
s.vl.remettreAZero(Controle.VOL);
|
||||
s.vl.remettreAZero(Controle.VITESSE);
|
||||
remettreAZeroCauses(s, causes);
|
||||
s.noterSetback(nowMs);
|
||||
s.dernierSetbackMs = nowMs;
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.6.1 (revue M1) : un setback a-t-il déjà été appliqué à cet instant (même tick serveur) ? Un même paquet peut
|
||||
* donner SETBACK sur vol puis sur jesus/no-slow : un seul retour et un seul compte pour l'escalade.
|
||||
*/
|
||||
public boolean setbackDejaApplique(UUID joueur, long nowMs) {
|
||||
Suivi s = suivis.get(joueur);
|
||||
return s != null && s.dernierSetbackMs == nowMs;
|
||||
}
|
||||
|
||||
/** 0.6.1 (revue M1/M4) : second setback du même tick : seuls les VL de ses causes sont remis à zéro. */
|
||||
public void apresSetbackDuMemeTick(UUID joueur, List<Verdict> causes) {
|
||||
remettreAZeroCauses(suivi(joueur), causes);
|
||||
}
|
||||
|
||||
private static void remettreAZeroCauses(Suivi s, List<Verdict> causes) {
|
||||
if (causes == null) return;
|
||||
for (Verdict v : causes) {
|
||||
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) s.vl.remettreAZero(v.controle());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -33,6 +33,9 @@ public final class Suivi {
|
||||
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
|
||||
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
|
||||
|
||||
/** 0.6.1 (revue M1) : instant (ms) du dernier setback appliqué. */
|
||||
long dernierSetbackMs = Long.MIN_VALUE;
|
||||
|
||||
void noterSetback(long nowMs) {
|
||||
setbacks.addLast(nowMs);
|
||||
while (setbacks.size() > 32) setbacks.removeFirst();
|
||||
@@ -81,6 +84,35 @@ public final class Suivi {
|
||||
public final Omnisprint omnisprint = new Omnisprint();
|
||||
/** 0.5 (P2.10) : x-ray statistique. */
|
||||
public final XrayStats xray = new XrayStats();
|
||||
/** 0.6.1 (revue M3) : blocs récemment changés (casse, pose, cible d'un clic droit) près du joueur. */
|
||||
public final PositionsRecentes changementsBloc = new PositionsRecentes();
|
||||
/** 0.6.1 (revue M2) : blocs visés par un paquet de casse du joueur (START/STOP/ABORT). */
|
||||
public final PositionsRecentes paquetsCasse = new PositionsRecentes();
|
||||
|
||||
/** 0.6.1 : petite mémoire circulaire (32 entrées) de positions de bloc ({@code BlockPos.asLong}) datées. */
|
||||
public static final class PositionsRecentes {
|
||||
private static final int TAILLE = 32;
|
||||
private final long[] cles = new long[TAILLE];
|
||||
private final long[] instants = new long[TAILLE];
|
||||
private int suivant;
|
||||
private int remplies;
|
||||
|
||||
public void noter(long cle, long nowMs) {
|
||||
cles[suivant] = cle;
|
||||
instants[suivant] = nowMs;
|
||||
suivant = (suivant + 1) % TAILLE;
|
||||
if (remplies < TAILLE) remplies++;
|
||||
}
|
||||
|
||||
/** Vrai si {@code cle} a été notée dans les {@code fenetreMs} qui précèdent {@code nowMs} (bornes comprises). */
|
||||
public boolean contient(long cle, long nowMs, long fenetreMs) {
|
||||
for (int i = 0; i < remplies; i++) {
|
||||
if (cles[i] == cle && nowMs >= instants[i] && nowMs - instants[i] <= fenetreMs) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/** 0.5 (P3.3) : nuker. */
|
||||
public final Nuker nuker = new Nuker();
|
||||
/** 0.5 (P3.1) : auto-cristal. */
|
||||
|
||||
@@ -313,4 +313,23 @@ class CablageTest {
|
||||
Cablage.CacheDetection c = new Cablage.CacheDetection();
|
||||
assertFalse(c.lire(100, () -> false, 40));
|
||||
}
|
||||
|
||||
// --- 0.6.1 (revue M1/M4) ---
|
||||
|
||||
@Test
|
||||
void M1_deuxSetbacksDuMemePaquetUnSeulRetour() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
FauxJoueur p = new FauxJoueur();
|
||||
long ms = p.tick * 50L;
|
||||
moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE);
|
||||
moteur.suivi(ID).vl.ajouter(Controle.JESUS, 40, ms);
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.JESUS, Sanction.SETBACK)));
|
||||
assertEquals(1, p.compte("teleport"));
|
||||
assertEquals(1, p.compte("journal Tricheur SETBACK deja applique ce tick"));
|
||||
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.JESUS, ms), 1e-9, "M4 : VL de jesus remis à zéro");
|
||||
p.tick++;
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.JESUS, Sanction.SETBACK)));
|
||||
assertEquals(2, p.compte("teleport"), "tick suivant : nouveau setback");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
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.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.6.1 : correctifs de la revue de sécurité du 25/10 (M1 à M4), côté moteur. */
|
||||
class Revue061Test {
|
||||
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
private static Verdict v(Controle c, Sanction s) {
|
||||
return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of());
|
||||
}
|
||||
|
||||
// --- M1 : un seul setback par tick ---
|
||||
|
||||
@Test
|
||||
void M1_secondSetbackDuMemeTickReconnuEtNonCompte() {
|
||||
Moteur m = new Moteur(new GardeConfig());
|
||||
long t = 1000 * 50L;
|
||||
assertFalse(m.setbackDejaApplique(joueur, t));
|
||||
m.apresSetback(joueur, t, List.of(v(Controle.VOL, Sanction.SETBACK)));
|
||||
assertTrue(m.setbackDejaApplique(joueur, t));
|
||||
m.apresSetbackDuMemeTick(joueur, List.of(v(Controle.JESUS, Sanction.SETBACK)));
|
||||
assertEquals(1, m.suivi(joueur).setbacksRecents(t, 60_000), "un seul compte pour l'escalade");
|
||||
assertFalse(m.setbackDejaApplique(joueur, t + 50), "tick suivant : un nouveau setback est possible");
|
||||
}
|
||||
|
||||
@Test
|
||||
void M1_tricheurContinuEscaladeToujours() {
|
||||
// Un setback par tick sur 4 ticks distincts : l'escalade compte bien 4 (la triche répétée reste sanctionnée).
|
||||
Moteur m = new Moteur(new GardeConfig());
|
||||
for (int i = 0; i < 4; i++) m.apresSetback(joueur, (1000 + i) * 50L, List.of(v(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals(4, m.suivi(joueur).setbacksRecents(1003 * 50L, 60_000));
|
||||
}
|
||||
|
||||
// --- M4 : VL de la cause remis à zéro ---
|
||||
|
||||
@Test
|
||||
void M4_vlDuControleCauseRemisAZero() {
|
||||
Moteur m = new Moteur(new GardeConfig());
|
||||
long t = 50_000;
|
||||
Suivi s = m.suivi(joueur);
|
||||
s.vl.ajouter(Controle.STEP, 40, t);
|
||||
s.vl.ajouter(Controle.NO_SLOW, 30, t);
|
||||
s.vl.ajouter(Controle.KILLAURA_CIBLES, 7, t);
|
||||
m.apresSetback(joueur, t, List.of(v(Controle.STEP, Sanction.SETBACK), v(Controle.NO_SLOW, Sanction.ALERTE)));
|
||||
assertEquals(0, s.vl.valeur(Controle.STEP, t), 1e-9);
|
||||
assertEquals(30, s.vl.valeur(Controle.NO_SLOW, t), 1e-9, "verdict sous SETBACK : VL gardé");
|
||||
assertEquals(7, s.vl.valeur(Controle.KILLAURA_CIBLES, t), 1e-9, "contrôle sans rapport : VL gardé");
|
||||
}
|
||||
|
||||
@Test
|
||||
void M4_ancienneSignatureInchangee() {
|
||||
Moteur m = new Moteur(new GardeConfig());
|
||||
Suivi s = m.suivi(joueur);
|
||||
s.vl.ajouter(Controle.STEP, 40, 0);
|
||||
s.vl.ajouter(Controle.VOL, 40, 0);
|
||||
m.apresSetback(joueur, 0);
|
||||
assertEquals(40, s.vl.valeur(Controle.STEP, 0), 1e-9);
|
||||
assertEquals(0, s.vl.valeur(Controle.VOL, 0), 1e-9);
|
||||
}
|
||||
|
||||
// --- M2 : casses en chaîne d'un mod (exemption configurable, désactivée par défaut) ---
|
||||
|
||||
@Test
|
||||
void M2_desactiveParDefaut() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
assertFalse(cfg.nukerIgnorerCassesSansPaquet);
|
||||
assertFalse(new Moteur(cfg).casseNukerSansPaquet(joueur, 42L, 5000));
|
||||
}
|
||||
|
||||
@Test
|
||||
void M2_activee_cassesDUnModIgnoreesNukerAvecPaquetsVu() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.nukerIgnorerCassesSansPaquet = true;
|
||||
Moteur m = new Moteur(cfg);
|
||||
long t = 100 * 50L;
|
||||
// Abattage d'arbre : un paquet sur la bûche du bas, 12 bûches cassées par le mod.
|
||||
m.paquetCasse(joueur, 1L, t);
|
||||
assertFalse(m.casseNukerSansPaquet(joueur, 1L, t), "le bloc visé par le joueur compte");
|
||||
for (long k = 2; k <= 12; k++) assertTrue(m.casseNukerSansPaquet(joueur, k, t), "bûche du mod ignorée");
|
||||
// Nuker de client : un paquet par bloc, tous comptés.
|
||||
for (long k = 100; k < 110; k++) m.paquetCasse(joueur, k, t + 50);
|
||||
for (long k = 100; k < 110; k++) assertFalse(m.casseNukerSansPaquet(joueur, k, t + 50));
|
||||
// Un paquet d'un tick précédent ne couvre pas la casse de ce tick.
|
||||
assertTrue(m.casseNukerSansPaquet(joueur, 1L, t + 100));
|
||||
}
|
||||
|
||||
// --- M3 : blocs fantômes ---
|
||||
|
||||
private static final double[] CUBE = {0, 64, 0, 1, 65, 1};
|
||||
private static final double[] OEIL = {0.5, 66.62, 2};
|
||||
private static final double[] IMPACT = {0.5, 65, 0.5};
|
||||
|
||||
private double clicsAir(Moteur m, long cle, long debut, boolean changerAvant) {
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
long t = debut + i * 500L;
|
||||
if (changerAvant) m.changementBloc(joueur, cle + i, t - 100);
|
||||
for (Verdict x : m.interactionBloc(joueur, t, cle + i, 0, EtatJoueur.normal(), OEIL, CUBE, 1, IMPACT,
|
||||
true, true, 4.5, 0)) {
|
||||
if (x.controle() == Controle.INTERACTION_BLOC) pts += x.points();
|
||||
}
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void M3_blocFantomeApresCasseNonCompte() {
|
||||
assertEquals(0, clicsAir(new Moteur(new GardeConfig()), 1000, 10_000, true), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void M3_airPlaceSurBlocJamaisChangeToujoursVu() {
|
||||
assertTrue(clicsAir(new Moteur(new GardeConfig()), 1000, 10_000, false) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void M3_changementAncienNeCouvrePas() {
|
||||
Moteur m = new Moteur(new GardeConfig());
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
long t = 10_000 + i * 500L;
|
||||
m.changementBloc(joueur, 7, t - 2000); // changé il y a 2 s : plus un bloc fantôme
|
||||
for (Verdict x : m.interactionBloc(joueur, t, 7, 0, EtatJoueur.normal(), OEIL, CUBE, 1, IMPACT, true, true, 4.5, 0)) {
|
||||
if (x.controle() == Controle.INTERACTION_BLOC) pts += x.points();
|
||||
}
|
||||
}
|
||||
assertTrue(pts > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void M3_memoireCirculaire() {
|
||||
Suivi.PositionsRecentes r = new Suivi.PositionsRecentes();
|
||||
for (int i = 0; i < 40; i++) r.noter(i, 1000);
|
||||
assertFalse(r.contient(0, 1000, 0), "entrée la plus ancienne écrasée");
|
||||
assertTrue(r.contient(39, 1000, 0));
|
||||
assertFalse(r.contient(39, 999, 10), "instant futur refusé");
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur