GastinelGarde : vitesse heritee (elytres, vehicules, recul), no-fall au bord des blocs, ventilateurs et tapis Create

Corrige les faux positifs vitesse du 15/10 (196 tests). Deploye le 15/10.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Theo GastineletClaude Opus 5.5 a révisé 2026-10-15 17:04:35 +02:00
1 Parent b5e53a4d85
révision b793282e76
11 fichiers modifiés
+1175 -37

Aucun fichier ne correspond à votre recherche

+121 -14
Voir le fichier
@@ -78,6 +78,10 @@ public final class Garde {
int contraptionTick = Integer.MIN_VALUE;
int contraptionVuTick = Integer.MIN_VALUE;
boolean contraptionProche;
// 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;
boolean courantProche;
}
private static final GardeConfig CONFIG = new GardeConfig();
@@ -441,7 +445,7 @@ public final class Garde {
if (!surThreadServeur(p)) return;
int tick = p.server.getTickCount();
Marques m = marques(p.getUUID());
boolean solServeur = auSolServeur(p);
boolean solServeur = auSolServeur(p, m);
// Phase 2 : no-fall (divergence), vitesse horizontale, vol.
boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID());
@@ -453,7 +457,7 @@ public final class Garde {
em = new EtatMouvement(Math.sqrt(dx * dx + dz * dz), p.getY() - m.mouvementY,
tick - m.mouvementTick, p.onGround(), solServeur, p.isSprinting(), p.isShiftKeyDown(),
p.isUsingItem(), niveau(p, MobEffects.MOVEMENT_SPEED), niveau(p, MobEffects.MOVEMENT_SLOWDOWN),
milieuSpecial(p), frictionAnormale(p));
milieuSpecial(p, m, tick), frictionAnormale(p), facteurVitesse(p), facteurFurtif(p));
etatMouvement = etat(p, true);
}
if (controler && em != null) {
@@ -484,7 +488,9 @@ public final class Garde {
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
p.level().dimension().location().toString());
}
if (tracesEnCours() && m.dernierTraceTick != tick) {
// 15/10 : une ligne par paquet (avant : une par tick, et le paquet suivant du même tick était compté dans la
// ligne suivante, deux déplacements pour un tick au rejeu). Deux lignes au même tick : 1 tick chacune (Rejeu).
if (tracesEnCours()) {
m.dernierTraceTick = tick;
double vx = m.aDernierePosition ? p.getX() - m.dernierX : 0;
double vy = m.aDernierePosition ? p.getY() - m.dernierY : 0;
@@ -496,7 +502,7 @@ public final class Garde {
EtatJoueur etatTrace = etatMouvement != null ? etatMouvement : etat(p, true);
tracer(new TraceLigne(tick, p.getGameProfile().getName(), "move", p.getX(), p.getY(), p.getZ(),
vx, vy, vz, p.onGround(), solServeur, TraceLigne.masqueMouvement(etatTrace, em, CONFIG),
-1, Double.NaN, null));
-1, Double.NaN, TraceLigne.messageFacteurs(em)));
}
}
@@ -609,7 +615,7 @@ public final class Garde {
if (!surThreadServeur(p)) return auSolClient;
if (CONFIG.mode(Controle.NO_FALL) != Mode.ENFORCE) return auSolClient;
if (estExempteManuellement(p.getUUID())) return auSolClient;
return MOTEUR.auSolPourDegatsDeChute(etat(p, true), auSolClient, auSolServeur(p));
return MOTEUR.auSolPourDegatsDeChute(etat(p, true), auSolClient, auSolServeur(p, marques(p.getUUID())));
}
private static boolean mouvementControlesActifs() {
@@ -617,9 +623,41 @@ public final class Garde {
|| CONFIG.mode(Controle.VOL) != Mode.OFF;
}
/** Bloc solide sous la boîte du joueur, vu par le serveur (0,05 bloc de marge). */
private static boolean auSolServeur(ServerPlayer p) {
return !p.level().noCollision(p, p.getBoundingBox().move(0.0, -0.05, 0.0));
/**
* Bloc solide sous la boîte du joueur, vu par le serveur (0,05 bloc de marge).
*
* 15/10/2026 (faux no-fall de totoche10 à y = 114,0 et 110,5) : vanilla résout la collision verticale AVANT le
* déplacement horizontal du même tick. Un joueur qui atterrit au bord d'un bloc puis glisse au-delà dans le même
* tick est « au sol » pour le client, sans bloc sous sa position finale. On regarde donc aussi sous le trajet
* horizontal du paquet (tranche des pieds seulement, voir NoFall.trancheBalayee).
*/
private static boolean auSolServeur(ServerPlayer p, Marques m) {
net.minecraft.world.phys.AABB b = p.getBoundingBox();
if (!p.level().noCollision(p, b.move(0.0, -0.05, 0.0))) return true;
if (m == null || m.mouvementTick == Integer.MIN_VALUE) return false;
double dx = p.getX() - m.mouvementX;
double dz = p.getZ() - m.mouvementZ;
if (dx * dx + dz * dz > com.gastinelgarde.core.NoFall.BALAYAGE_MAX * com.gastinelgarde.core.NoFall.BALAYAGE_MAX
|| (dx == 0 && dz == 0)) return false;
double[] t = com.gastinelgarde.core.NoFall.trancheBalayee(b.minX, b.minY, b.minZ, b.maxX, b.maxZ, dx, dz);
return !p.level().noCollision(p, new net.minecraft.world.phys.AABB(t[0], t[1], t[2], t[3], t[4], t[5]));
}
/** Attribut de vitesse / sa base, hors bonus de course (Vitesse, Lenteur, Agilité des âmes, mods). NaN si inconnu. */
private static double facteurVitesse(ServerPlayer p) {
net.minecraft.world.entity.ai.attributes.AttributeInstance a =
p.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.MOVEMENT_SPEED);
if (a == null || a.getBaseValue() <= 0) return Double.NaN;
double v = a.getValue() / a.getBaseValue();
if (a.hasModifier(net.minecraft.resources.ResourceLocation.withDefaultNamespace("sprinting"))) v /= 1.3;
return v;
}
/** Vitesse accroupi / 0,3 (Furtivité rapide). NaN si inconnu. */
private static double facteurFurtif(ServerPlayer p) {
net.minecraft.world.entity.ai.attributes.AttributeInstance a =
p.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.SNEAKING_SPEED);
return a == null ? Double.NaN : a.getValue() / 0.3;
}
private static int niveau(ServerPlayer p, Holder<MobEffect> effet) {
@@ -627,14 +665,83 @@ public final class Garde {
return e == null ? 0 : e.getAmplifier() + 1;
}
/** Eau, lave, échelle, vol créatif, toile, neige poudreuse, miel, slime, lit : la vitesse et le vol vanilla ne s'appliquent pas. */
private static boolean milieuSpecial(ServerPlayer p) {
/**
* Eau, lave, échelle, vol créatif, toile, neige poudreuse, baie sucrée, miel, colonne à bulles, slime, lit, tapis
* roulant et courant d'air Create : la vitesse et le vol vanilla ne s'appliquent pas.
*
* 15/10/2026 (vol en ENFORCE) : toile, baies, neige poudreuse, miel et colonne à bulles sont cherchés dans toute la
* boîte du joueur (+0,1 bloc de côté : glissade le long d'un bloc de miel), plus seulement au niveau des pieds :
* une toile à hauteur de tête freine la chute pendant plus de 10 ticks.
*/
private static boolean milieuSpecial(ServerPlayer p, Marques m, int tick) {
if (p.isInWater() || p.isInLava() || p.onClimbable() || p.isSwimming() || p.getAbilities().flying) return true;
if (p.isInPowderSnow || p.wasInPowderSnow) return true;
net.minecraft.world.level.Level l = p.level();
BlockPos pos = p.blockPosition();
BlockState pied = p.level().getBlockState(pos);
BlockState sous = p.level().getBlockState(pos.below());
return pied.is(Blocks.COBWEB) || pied.is(Blocks.POWDER_SNOW) || pied.is(Blocks.SWEET_BERRY_BUSH)
|| sous.is(Blocks.SLIME_BLOCK) || sous.is(BlockTags.BEDS);
BlockState pied = l.getBlockState(pos);
BlockState sous = l.getBlockState(pos.below());
if (sous.is(Blocks.SLIME_BLOCK) || sous.is(BlockTags.BEDS)) return true;
net.minecraft.world.phys.AABB b = p.getBoundingBox().inflate(0.1, 0.0, 0.1);
for (BlockPos q : BlockPos.betweenClosed(net.minecraft.util.Mth.floor(b.minX), net.minecraft.util.Mth.floor(b.minY),
net.minecraft.util.Mth.floor(b.minZ), net.minecraft.util.Mth.floor(b.maxX),
net.minecraft.util.Mth.floor(b.maxY), net.minecraft.util.Mth.floor(b.maxZ))) {
BlockState s = l.getBlockState(q);
if (s.is(Blocks.COBWEB) || s.is(Blocks.SWEET_BERRY_BUSH) || s.is(Blocks.POWDER_SNOW)
|| s.is(Blocks.HONEY_BLOCK) || s.is(Blocks.BUBBLE_COLUMN)) return true;
}
Set<String> tapis = GardeSpec.blocsEntrainement();
if (!tapis.isEmpty() && (tapis.contains(idBloc(pied)) || tapis.contains(idBloc(sous))
|| tapis.contains(idBloc(l.getBlockState(p.getBlockPosBelowThatAffectsMyMovement()))))) return true;
return courantAirEnCache(p, m, tick);
}
private static String idBloc(BlockState s) {
return net.minecraft.core.registries.BuiltInRegistries.BLOCK.getKey(s.getBlock()).toString();
}
/** Grâce après avoir quitté un courant d'air (élan, retard d'état) : comme les contraptions. */
private static final int GRACE_COURANT_TICKS = 40;
/** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */
private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) {
if (m.courantTick == Integer.MIN_VALUE || tick - m.courantTick >= 10 || tick < m.courantTick) {
m.courantProche = courantAir(p);
m.courantTick = tick;
if (m.courantProche) m.courantVuTick = tick;
}
return m.courantProche || DetectionContraption.dansLaGrace(tick, m.courantVuTick, GRACE_COURANT_TICKS);
}
/**
* Un ventilateur Create (réglage blocsCourantAir) dans l'un des 6 axes partant des pieds ou de la tête, à au plus
* distanceCourantAirBlocs, sans bloc plein entre les deux. Le courant d'air de Create pousse le joueur côté client
* seulement (AirCurrent remet même à zéro le compteur anti-vol vanilla) : sans ça, un ascenseur à ventilateur
* serait pris pour du vol (contrôle en ENFORCE depuis le 15/10).
*/
private static boolean courantAir(ServerPlayer p) {
int dist = GardeSpec.distanceCourantAir();
Set<String> ventilateurs = GardeSpec.blocsCourantAir();
if (dist <= 0 || ventilateurs.isEmpty()) return false;
net.minecraft.world.level.Level l = p.level();
BlockPos pieds = p.blockPosition();
BlockPos tete = BlockPos.containing(p.getX(), p.getEyeY(), p.getZ());
for (net.minecraft.core.Direction d : net.minecraft.core.Direction.values()) {
// vers le bas depuis les pieds, vers le haut depuis la tête, à l'horizontale depuis les deux
BlockPos[] departs = d == net.minecraft.core.Direction.DOWN ? new BlockPos[] {pieds}
: d == net.minecraft.core.Direction.UP ? new BlockPos[] {tete} : new BlockPos[] {pieds, tete};
for (BlockPos depart : departs) {
BlockPos.MutableBlockPos q = depart.mutable();
for (int i = 1; i <= dist; i++) {
q.move(d);
if (!l.hasChunkAt(q)) break;
BlockState s = l.getBlockState(q);
if (s.isAir()) continue;
if (ventilateurs.contains(idBloc(s))) return true;
if (s.isCollisionShapeFullBlock(l, q)) break; // le courant ne traverse pas un bloc plein
}
}
}
return false;
}
/** Glace, slime, âmes, miel : friction ou facteur de vitesse du bloc différents de la normale. */