P1.2 : grace de connexion, plus longue apres une expulsion, setback au sol
- Grace de connexion (mouvement, vehicule, timer ; pas le combat) : graceConnexionTicks (100), graceApresExpulsionTicks (200) si expulse il y a moins de 10 min (Moteur.graceConnexionTicks, memoire qui survit a la reconnexion). Ligne de journal a la reconnexion apres expulsion. - Sans position de retour valide, le SETBACK ramene au sol juste sous le joueur (meme x, z, au plus 64 blocs, jamais vers le haut ni de cote) : setbackSolSiPasDePosition (true). Sinon « SETBACK impossible » (P1.1). - Nouvelle section [graces]. - Tests : ReconnexionP1Test. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
b72e5717c5
révision
7b19f86ff9
10 fichiers modifiés
+226
-8
Aucun fichier ne correspond à votre recherche
@@ -176,6 +176,13 @@ final class Cablage {
|
||||
void teleporter(double x, double y, double z, float yaw, float pitch);
|
||||
void deconnecter(String message);
|
||||
void journal(String ligne);
|
||||
|
||||
/**
|
||||
* 0.5 (P1.2) : position au sol juste SOUS le joueur (même x, z ; y du premier bloc solide en dessous, au plus
|
||||
* 64 blocs), {x, y, z, yaw, pitch}, ou null si rien trouvé ou place insuffisante. Jamais de déplacement
|
||||
* horizontal : le setback de secours ne peut pas servir à se téléporter.
|
||||
*/
|
||||
default double[] solSous() { return null; }
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -202,12 +209,20 @@ final class Cablage {
|
||||
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
|
||||
} else if (s == Sanction.SETBACK) {
|
||||
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);
|
||||
p.journal(p.nom() + " SETBACK (" + raison + ")");
|
||||
} 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);
|
||||
p.journal(String.format(java.util.Locale.ROOT, "%s SETBACK au sol (%s) : pas de position de retour, y=%.2f",
|
||||
p.nom(), raison, sol[1]));
|
||||
} else {
|
||||
// 0.5 (P1.1) : avant, rien n'était fait ni écrit (reconnexion en l'air) et le VL montait jusqu'à
|
||||
// l'expulsion sans trace du setback raté.
|
||||
|
||||
@@ -60,6 +60,8 @@ public final class Garde {
|
||||
/** Marques propres à un joueur, côté adaptateur (ticks du serveur). */
|
||||
private static final class Marques {
|
||||
int teleportTick = Integer.MIN_VALUE;
|
||||
/** 0.5 (P1.2) : jusqu'à ce tick, grâce de connexion. */
|
||||
int connexionJusquaTick = Integer.MIN_VALUE;
|
||||
/** 0.4.0 : jusqu'à ce tick, une fusée a propulsé le joueur (plané non contrôlé). */
|
||||
int propulsionJusquaTick = Integer.MIN_VALUE;
|
||||
int reculTick = Integer.MIN_VALUE;
|
||||
@@ -208,6 +210,18 @@ public final class Garde {
|
||||
m.oeilDernier = null;
|
||||
}
|
||||
|
||||
/** 0.5 (P1.2) : connexion : grâce de connexion (plus longue après une expulsion récente), en plus de la téléportation. */
|
||||
public static void noterConnexion(ServerPlayer p) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
noterTeleport(p);
|
||||
int tick = p.server.getTickCount();
|
||||
int grace = MOTEUR.graceConnexionTicks(p.getUUID(), tick * 50L);
|
||||
marques(p.getUUID()).connexionJusquaTick = tick + grace;
|
||||
if (grace > CONFIG.graceConnexionTicks) {
|
||||
ecrireJournal(p.getGameProfile().getName() + " reconnexion apres expulsion recente : grace de " + grace + " ticks");
|
||||
}
|
||||
}
|
||||
|
||||
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
|
||||
public static void annoncerTeleport(ServerPlayer p, GraceTeleport.Origine origine) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
@@ -453,6 +467,7 @@ public final class Garde {
|
||||
.tps(tpsEstime)
|
||||
.pingMs(p.connection.latency())
|
||||
.propulsionRecente(tick <= m.propulsionJusquaTick)
|
||||
.connexionRecente(tick <= m.connexionJusquaTick)
|
||||
.build();
|
||||
}
|
||||
|
||||
@@ -981,6 +996,35 @@ public final class Garde {
|
||||
return sous.getBlock().getFriction() != 0.6F || sous.getBlock().getSpeedFactor() != 1.0F;
|
||||
}
|
||||
|
||||
/** Profondeur maximale (blocs) de la recherche du sol sous le joueur (setback de secours, P1.2). */
|
||||
private static final int SOL_SOUS_MAX_BLOCS = 64;
|
||||
|
||||
/**
|
||||
* 0.5 (P1.2) : sol juste sous le joueur, même x et z : premier bloc à forme de collision non vide (ou fluide) en
|
||||
* descendant, au plus 64 blocs, avec la place pour la boîte du joueur. Null sinon (vide, hors du monde).
|
||||
*/
|
||||
static double[] solSous(ServerPlayer p) {
|
||||
net.minecraft.world.level.Level l = p.level();
|
||||
BlockPos.MutableBlockPos q = p.blockPosition().mutable();
|
||||
for (int i = 0; i <= SOL_SOUS_MAX_BLOCS && q.getY() >= l.getMinBuildHeight(); i++, q.move(0, -1, 0)) {
|
||||
if (!l.hasChunkAt(q)) return null;
|
||||
BlockState s = l.getBlockState(q);
|
||||
double y;
|
||||
if (!l.getFluidState(q).isEmpty()) {
|
||||
y = q.getY(); // eau / lave : dans le fluide, la chute s'arrête ou ralentit
|
||||
} else {
|
||||
net.minecraft.world.phys.shapes.VoxelShape forme = s.getCollisionShape(l, q);
|
||||
if (forme.isEmpty()) continue;
|
||||
y = q.getY() + forme.max(net.minecraft.core.Direction.Axis.Y);
|
||||
}
|
||||
if (y > p.getY() + 1e-6) return null; // jamais vers le haut
|
||||
net.minecraft.world.phys.AABB b = p.getBoundingBox().move(0, y - p.getY(), 0);
|
||||
if (!l.noCollision(p, b)) return null;
|
||||
return new double[] {p.getX(), y, p.getZ(), p.getYRot(), p.getXRot()};
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
|
||||
Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts);
|
||||
}
|
||||
@@ -998,6 +1042,7 @@ public final class Garde {
|
||||
}
|
||||
@Override public void deconnecter(String message) { p.connection.disconnect(Component.literal(message)); }
|
||||
@Override public void journal(String ligne) { ecrireJournal(ligne); }
|
||||
@Override public double[] solSous() { return Garde.solSous(p); }
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -171,7 +171,7 @@ public final class GardeEvents {
|
||||
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
|
||||
if (event.getEntity() instanceof ServerPlayer p) {
|
||||
Garde.moteur().oublierExpulsion(p.getUUID()); // C4 : la marque d'expulsion vaut jusqu'à la reconnexion
|
||||
Garde.noterTeleport(p);
|
||||
Garde.noterConnexion(p); // téléportation + 0.5 (P1.2) grâce de connexion
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -22,7 +22,8 @@ public final class GardeSpec {
|
||||
private static final ModConfigSpec.DoubleValue SEUIL_EXPULSION;
|
||||
private static final ModConfigSpec.EnumValue<Sanction> SANCTION_MAX;
|
||||
|
||||
private static final ModConfigSpec.BooleanValue JOURNAL_TOUJOURS;
|
||||
private static final ModConfigSpec.BooleanValue JOURNAL_TOUJOURS, SETBACK_SOL;
|
||||
private static final ModConfigSpec.IntValue GRACE_CONNEXION, GRACE_APRES_EXPULSION;
|
||||
private static final ModConfigSpec.IntValue JOURNAL_LIMITE;
|
||||
|
||||
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
|
||||
@@ -246,6 +247,16 @@ public final class GardeSpec {
|
||||
.define("combatMesureEnVehicule", false);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 : grâces à la connexion (reconnexion en l'air, expulsion récente).").push("graces");
|
||||
GRACE_CONNEXION = b.comment("Ticks sans contrôle de mouvement ni timer après la connexion (la téléportation de connexion en donne déjà graceTeleportTicks).")
|
||||
.defineInRange("graceConnexionTicks", 100, 0, 1200);
|
||||
GRACE_APRES_EXPULSION = b.comment("Idem si le joueur a été expulsé il y a moins de 10 minutes.")
|
||||
.defineInRange("graceApresExpulsionTicks", 200, 0, 2400);
|
||||
SETBACK_SOL = b.comment("Sans position de retour valide (reconnexion en l'air), le SETBACK ramène au sol juste sous le joueur.",
|
||||
"Jamais de déplacement horizontal. false = ancien comportement (setback impossible, seulement journalisé).")
|
||||
.define("setbackSolSiPasDePosition", true);
|
||||
b.pop();
|
||||
|
||||
b.push("exemptions");
|
||||
GRACE_TELEPORT = b.defineInRange("graceTeleportTicks", 40, 0, 600);
|
||||
GRACE_RECUL = b.defineInRange("graceReculTicks", 20, 0, 600);
|
||||
@@ -390,6 +401,9 @@ public final class GardeSpec {
|
||||
c.serieFenetreMs = SERIE_FENETRE_MS.get();
|
||||
c.seriePoints = SERIE_POINTS.get();
|
||||
c.graceTeleportTicks = GRACE_TELEPORT.get();
|
||||
c.graceConnexionTicks = GRACE_CONNEXION.get();
|
||||
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
|
||||
c.setbackSolSiPasDePosition = SETBACK_SOL.get();
|
||||
c.graceReculTicks = GRACE_RECUL.get();
|
||||
c.graceGelTicks = GRACE_GEL.get();
|
||||
c.tpsLag = TPS_LAG.get();
|
||||
|
||||
@@ -21,7 +21,8 @@ public record EtatJoueur(
|
||||
int ticksDepuisGel,
|
||||
double tps,
|
||||
int pingMs,
|
||||
boolean propulsionRecente) {
|
||||
boolean propulsionRecente,
|
||||
boolean connexionRecente) {
|
||||
|
||||
public static final int JAMAIS = Integer.MAX_VALUE;
|
||||
|
||||
@@ -41,6 +42,7 @@ public record EtatJoueur(
|
||||
private double tps = 20.0;
|
||||
private int pingMs = 30;
|
||||
private boolean propulsionRecente;
|
||||
private boolean connexionRecente;
|
||||
|
||||
public Builder creatif(boolean v) { creatif = v; return this; }
|
||||
public Builder spectateur(boolean v) { spectateur = v; return this; }
|
||||
@@ -62,10 +64,13 @@ public record EtatJoueur(
|
||||
/** 0.4.0 : fusée de feu d'artifice (ou autre poussée connue du serveur) récente : plané non contrôlé. */
|
||||
public Builder propulsionRecente(boolean v) { propulsionRecente = v; return this; }
|
||||
|
||||
/** 0.5 (P1.2) : connexion récente (graceConnexionTicks, plus long après une expulsion récente). */
|
||||
public Builder connexionRecente(boolean v) { connexionRecente = v; return this; }
|
||||
|
||||
public EtatJoueur build() {
|
||||
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
|
||||
enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect, ticksDepuisTeleport, ticksDepuisRecul,
|
||||
ticksDepuisGel, tps, pingMs, propulsionRecente);
|
||||
ticksDepuisGel, tps, pingMs, propulsionRecente, connexionRecente);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -44,6 +44,8 @@ public final class Exemptions {
|
||||
if (e.pocheContraption()) raisons.add("contraption");
|
||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
|
||||
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul");
|
||||
// 0.5 (P1.2) : reconnexion (souvent en l'air, sans position de retour) : grâce plus longue.
|
||||
if (e.connexionRecente()) raisons.add("connexion");
|
||||
}
|
||||
case VEHICULE -> {
|
||||
// F20 : le véhicule piloté. Pas d'exemption « véhicule » ici, évidemment.
|
||||
@@ -51,9 +53,11 @@ public final class Exemptions {
|
||||
if (e.pocheContraption()) raisons.add("contraption");
|
||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
|
||||
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul");
|
||||
if (e.connexionRecente()) raisons.add("connexion");
|
||||
}
|
||||
case TIMER -> {
|
||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
|
||||
if (e.connexionRecente()) raisons.add("connexion"); // rafale de paquets du chargement
|
||||
if (e.ticksDepuisGel() <= cfg.graceGelTicks) raisons.add("gel-serveur");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -164,6 +164,11 @@ public final class GardeConfig {
|
||||
|
||||
// --- Exemptions ---
|
||||
public int graceTeleportTicks = 40;
|
||||
/** 0.5 (P1.2) : grâce de mouvement / timer après la connexion (ticks) ; plus longue après une expulsion récente. */
|
||||
public int graceConnexionTicks = 100;
|
||||
public int graceApresExpulsionTicks = 200;
|
||||
/** 0.5 (P1.2) : sans position de retour valide, le SETBACK ramène au sol juste sous le joueur (jamais à côté). */
|
||||
public boolean setbackSolSiPasDePosition = true;
|
||||
public int graceReculTicks = 20;
|
||||
public int graceGelTicks = 100;
|
||||
public double tpsLag = 18.0;
|
||||
|
||||
@@ -431,7 +431,7 @@ public final class Moteur {
|
||||
*/
|
||||
static boolean sortieDEtat(List<String> raisons) {
|
||||
for (String r : raisons) {
|
||||
if (!r.equals("teleportation") && !r.equals("recul")) return true;
|
||||
if (!r.equals("teleportation") && !r.equals("recul") && !r.equals("connexion")) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -566,7 +566,25 @@ public final class Moteur {
|
||||
* jusqu'à sa reconnexion ({@link #oublierExpulsion}). La marque survit à {@link #retirer} (C6).
|
||||
*/
|
||||
public boolean expulser(UUID joueur, long nowMs) {
|
||||
return expulses.add(joueur);
|
||||
boolean premiere = expulses.add(joueur);
|
||||
if (premiere) derniereExpulsionMs.put(joueur, nowMs);
|
||||
return premiere;
|
||||
}
|
||||
|
||||
/** 0.5 (P1.2) : une expulsion compte comme « récente » pour la grâce de reconnexion pendant cette durée. */
|
||||
public static final long EXPULSION_RECENTE_MS = 10 * 60_000L;
|
||||
/** Instant (ms, horloge des ticks) de la dernière expulsion de chaque joueur ; survit à la reconnexion. */
|
||||
private final Map<UUID, Long> derniereExpulsionMs = new HashMap<>();
|
||||
|
||||
/**
|
||||
* 0.5 (P1.2) : durée de la grâce de connexion (ticks) : {@code graceApresExpulsionTicks} si le joueur a été
|
||||
* expulsé il y a moins de {@link #EXPULSION_RECENTE_MS}, sinon {@code graceConnexionTicks}.
|
||||
*/
|
||||
public int graceConnexionTicks(UUID joueur, long nowMs) {
|
||||
derniereExpulsionMs.values().removeIf(t -> nowMs - t > EXPULSION_RECENTE_MS || nowMs < t);
|
||||
Long t = derniereExpulsionMs.get(joueur);
|
||||
int base = Math.max(0, cfg.graceConnexionTicks);
|
||||
return t != null ? Math.max(base, cfg.graceApresExpulsionTicks) : base;
|
||||
}
|
||||
|
||||
public boolean estExpulse(UUID joueur) {
|
||||
|
||||
@@ -26,11 +26,11 @@ import org.junit.jupiter.api.Test;
|
||||
*/
|
||||
class CablageTest {
|
||||
|
||||
private static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
|
||||
static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
|
||||
private static final String MONDE = "minecraft:overworld";
|
||||
|
||||
/** Doublure de ServerPlayer : enregistre ce que la sanction lui fait, dans l'ordre. */
|
||||
static final class FauxJoueur implements Cablage.Joueur {
|
||||
static class FauxJoueur implements Cablage.Joueur {
|
||||
final List<String> actions = new ArrayList<>();
|
||||
String dimension = MONDE;
|
||||
int tick = 1000;
|
||||
|
||||
@@ -0,0 +1,112 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import com.gastinelgarde.core.Controle;
|
||||
import com.gastinelgarde.core.EtatJoueur;
|
||||
import com.gastinelgarde.core.EtatMouvement;
|
||||
import com.gastinelgarde.core.Exemptions;
|
||||
import com.gastinelgarde.core.GardeConfig;
|
||||
import com.gastinelgarde.core.Mode;
|
||||
import com.gastinelgarde.core.Moteur;
|
||||
import com.gastinelgarde.core.Sanction;
|
||||
import com.gastinelgarde.core.Verdict;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P1.2 : grâce de connexion, plus longue après une expulsion récente ; setback au sol sans position. */
|
||||
class ReconnexionP1Test {
|
||||
|
||||
private static Verdict verdict(Controle c, Sanction s) {
|
||||
return new Verdict(c, Mode.ENFORCE, 1, 15, s, s, false, "", List.of());
|
||||
}
|
||||
|
||||
@Test
|
||||
void dureeDeLaGraceSelonLExpulsionRecente() {
|
||||
Moteur m = new Moteur(new GardeConfig());
|
||||
UUID id = UUID.randomUUID();
|
||||
assertEquals(100, m.graceConnexionTicks(id, 0));
|
||||
assertTrue(m.expulser(id, 1_000));
|
||||
m.oublierExpulsion(id); // reconnexion
|
||||
assertEquals(200, m.graceConnexionTicks(id, 2_000), "expulsé il y a 1 s");
|
||||
assertEquals(200, m.graceConnexionTicks(id, 1_000 + Moteur.EXPULSION_RECENTE_MS));
|
||||
assertEquals(100, m.graceConnexionTicks(id, 2_000 + Moteur.EXPULSION_RECENTE_MS), "plus de 10 min après");
|
||||
}
|
||||
|
||||
@Test
|
||||
void connexionRecenteExempteMouvementVehiculeEtTimerPasLeCombat() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
EtatJoueur e = EtatJoueur.builder().connexionRecente(true).build();
|
||||
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.MOUVEMENT).raisons().contains("connexion"));
|
||||
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.VEHICULE).raisons().contains("connexion"));
|
||||
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.TIMER).raisons().contains("connexion"));
|
||||
assertTrue(!Exemptions.evaluer(e, cfg, Exemptions.Famille.COMBAT).exempt(), "le combat reste mesuré");
|
||||
}
|
||||
|
||||
@Test
|
||||
void suiviNeufEnLAirPasDExpulsionPendantLaGrace() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.mode(Controle.VOL, Mode.ENFORCE);
|
||||
Moteur m = new Moteur(cfg);
|
||||
UUID id = UUID.randomUUID();
|
||||
EtatJoueur enGrace = EtatJoueur.builder().connexionRecente(true).build();
|
||||
// Flottement immobile en l'air (dy = 0) pendant 100 ticks : en vrai, vol ; ici, grâce de connexion.
|
||||
for (int t = 0; t < 100; t++) {
|
||||
EtatMouvement em = new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
assertTrue(m.mouvement(id, t * 50L, enGrace, em).isEmpty(), "tick " + t);
|
||||
}
|
||||
// Après la grâce, le contrôle reprend (référence remise à zéro, puis infraction).
|
||||
boolean vu = false;
|
||||
for (int t = 100; t < 400 && !vu; t++) {
|
||||
EtatMouvement em = new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
vu = !m.mouvement(id, t * 50L, EtatJoueur.normal(), em).isEmpty();
|
||||
}
|
||||
assertTrue(vu, "le vol est de nouveau contrôlé après la grâce");
|
||||
}
|
||||
|
||||
/** Doublure qui trouve le sol 12 blocs plus bas. */
|
||||
static final class JoueurAuDessusDuSol extends CablageTest.FauxJoueur {
|
||||
double[] sol = {10.5, 52.0, -3.5, 90, 0};
|
||||
@Override public double[] solSous() { return sol; }
|
||||
}
|
||||
|
||||
@Test
|
||||
void setbackAuSolSansPositionDeRetour() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals("annonce SETBACK", p.actions.get(0));
|
||||
assertEquals("teleport 10.5 52.0 -3.5 90 0", p.actions.get(1));
|
||||
assertEquals("journal Tricheur SETBACK au sol (vol) : pas de position de retour, y=52.00", p.actions.get(2));
|
||||
assertEquals(0.0, moteur.suivi(p.id()).vl.valeur(Controle.VOL, p.tick() * 50L), 1e-9, "VL de vol remis à zéro");
|
||||
}
|
||||
|
||||
@Test
|
||||
void setbackAuSolDesactiveOuSolIntrouvable() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.setbackSolSiPasDePosition = false;
|
||||
Moteur moteur = new Moteur(cfg);
|
||||
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals(0, p.compte("teleport"));
|
||||
assertEquals(1, p.compte("journal Tricheur SETBACK impossible"));
|
||||
|
||||
Moteur m2 = new Moteur(new GardeConfig());
|
||||
JoueurAuDessusDuSol vide = new JoueurAuDessusDuSol();
|
||||
vide.sol = null; // vide sous le joueur
|
||||
Cablage.appliquerSanction(m2, vide, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals(0, vide.compte("teleport"));
|
||||
assertEquals(1, vide.compte("journal Tricheur SETBACK impossible"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void autreDimensionJamaisDeSetbackAuSol() {
|
||||
Moteur moteur = new Moteur(new GardeConfig());
|
||||
moteur.suivi(CablageTest.ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
|
||||
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
|
||||
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
|
||||
assertEquals(0, p.compte("teleport"), "une position existe (autre dimension) : pas de secours au sol");
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur