Comparer les révisions

...
9 fichiers modifiés avec 308 ajouts et 4 suppressions

Aucun fichier ne correspond à votre recherche

+1 -1
Voir le fichier
@@ -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
+8 -2
Voir le fichier
@@ -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 {
+24 -1
Voir le fichier
@@ -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();
+11
Voir le fichier
@@ -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();
+7
Voir le fichier
@@ -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. */
+60
Voir le fichier
@@ -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());
}
}
/**
+32
Voir le fichier
@@ -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. */
+19
Voir le fichier
@@ -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");
}
}
+146
Voir le fichier
@@ -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é");
}
}