diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index 27c1f95..566da0b 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -17,7 +17,7 @@ Base avant corrections : 98 tests verts. | F02 timer inondation | corrigée | `git log --grep F02` | `AuditFaillesTest.F02_*` (2) ; 116 verts | rien (F03, balance de timer, reste une évolution) | | F12 cadence saturée | corrigée | `git log --grep F12` | `AuditFaillesTest.F12_*` (2), `ControlesTest.cadenceFolleSoutenue` (1,8 au lieu de 2,0 : bord de tranche) ; 118 verts | essai en jeu n° 10 (combat honnête contre plusieurs zombies, aucune ligne `cadence`) | | F13 cibles saturées | corrigée | `git log --grep F13` | `AuditFaillesTest.F13_*` (rouge avant) ; 119 verts | essai en jeu n° 10 | -| F20 véhicules | à faire | | | | +| F20 véhicules | corrigée (bornes [À VÉRIFIER]) | `git log --grep F20` | `AuditFaillesTest.F20_*` (3) ; `MixinsAppliquesTest` couvre la nouvelle injection ; 122 verts | essai en jeu n° 14 + bateau sur glace bleue, cheval rapide, chameau (dash), cochon, arpenteur : aucune fausse alerte ; rejeu des lignes `veh` non écrit | | F11 rotation silencieuse | à faire | | | | | F19, F22, F25 | essais en jeu seulement | | | `audit/ESSAIS-EN-JEU.md` | | Version 0.3.0, jar, README, script | à faire | | | | @@ -66,3 +66,11 @@ Base avant corrections : 98 tests verts. ### F13 - `CiblesMultiples` : ensemble borné (64) des cibles distinctes avec l'heure de leur dernier coup, au lieu des 32 derniers coups. Frapper une même entité en boucle met à jour une entrée, sans chasser les autres. Quand l'ensemble est plein, la cible la plus ancienne est remplacée (il faudrait 64 cibles dans la fenêtre pour saturer, ce qui est vu). + +### F20 +- Nouveaux contrôles `vehicule-vitesse` et `vehicule-vol` (OBSERVE par défaut, clés de configuration créées automatiquement). Cœur pur : `core/EtatVehicule`, `core/VehiculeMouvement`, `Moteur.vehicule`, famille d'exemptions `VEHICULE` (peut voler, contraption, téléportation, recul ; pas « véhicule »). +- Mixin : `@Inject(method="handleMoveVehicle", at=@At("TAIL"))` dans `MovePacketMixin`. javap (NeoForge 21.1.234) : `ensureRunningOnSameThread` à l'offset 9, returns à 316 (« moved too quickly »), 638 (« moved wrongly »), 811 (fin) : TAIL = 811, donc jamais sur le thread réseau et jamais pour un paquet refusé. `Garde.apresVehicule` ne contrôle que si le joueur pilote son véhicule racine (comme vanilla) ; changement de véhicule ou téléportation : on repart de zéro. +- Vitesse : bateau 0,45 bloc/tick (vanilla 0,36 sur l'eau), monture max(0,4 ; 2,12 × attribut × 1,25) (cheval le plus rapide : 0,71 → 0,89). Glace ou bloc de friction > 0,6 : non borné. Élan gardé à × 0,95 par tick (bateau lancé de la glace). Tampon d'excès de 1,5 bloc sur 20 ticks (comme `vitesse`). Véhicule de mod inconnu : vitesse et vol non contrôlés. +- Vol : en l'air (ni sol, ni fluide, ni colonne à bulles, ni échelle, ni lévitation/chute lente de la monture) plus de 40 ticks sans tomber d'au moins 0,2 bloc/tick. Vanilla : un bateau en l'air prend −0,04/tick sans frein vertical, un saut de cheval dure ~25 ticks. +- ENFORCE : un setback fait d'abord descendre le joueur (`stopRiding`) puis le ramène à sa dernière position valide. +- [À VÉRIFIER] : chameau (dash), cochon/arpenteur boostés, courant d'eau, bateau poussé par une entité ; vitesse des montures de mods. Le rejeu (`Rejeu`) ignore encore les lignes de trace `veh`. diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 5b5af85..43fe3f6 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -3,6 +3,7 @@ package com.gastinelgarde; import com.gastinelgarde.core.Controle; import com.gastinelgarde.core.EtatJoueur; import com.gastinelgarde.core.EtatMouvement; +import com.gastinelgarde.core.EtatVehicule; import com.gastinelgarde.core.GardeConfig; import com.gastinelgarde.core.GraceRecul; import com.gastinelgarde.core.GraceTeleport; @@ -68,6 +69,10 @@ public final class Garde { // Mouvement (phase 2) int mouvementTick = Integer.MIN_VALUE; double mouvementX, mouvementY, mouvementZ; + // Véhicule piloté (F20) + int vehiculeId = -1; + int vehiculeTick; + double vehiculeX, vehiculeY, vehiculeZ; // Cache de la détection de contraption (la requête d'entités coûte plus que le reste) int contraptionTick = Integer.MIN_VALUE; boolean contraptionProche; @@ -158,6 +163,7 @@ public final class Garde { Marques m = marques(p.getUUID()); m.teleportTick = p.server.getTickCount(); m.mouvementTick = Integer.MIN_VALUE; + m.vehiculeId = -1; } /** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */ @@ -175,6 +181,7 @@ public final class Garde { Marques m = marques(p.getUUID()); if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount(); m.mouvementTick = Integer.MIN_VALUE; + m.vehiculeId = -1; } /** Recul réel (F06). Auto-infligé (charge de vent à ses pieds) : grâce limitée, voir GraceRecul. */ @@ -456,6 +463,83 @@ public final class Garde { } } + // --- Paquet de mouvement de véhicule (F20, appelé par le mixin à la fin de handleMoveVehicle) --- + + /** + * Fin du traitement d'un paquet de véhicule. Vanilla n'applique le paquet que si le joueur pilote son + * véhicule racine ; sinon (ou au changement de véhicule) on repart de zéro. Un paquet refusé (« moved too + * quickly », « moved wrongly ») ne passe pas ici : la position de référence reste la dernière acceptée. + */ + public static void apresVehicule(ServerPlayer p) { + if (!surThreadServeur(p)) return; + Marques m = marques(p.getUUID()); + Entity v = p.getRootVehicle(); + if (v == p || v.getControllingPassenger() != p) { + m.vehiculeId = -1; + return; + } + int tick = p.server.getTickCount(); + if (v.getId() != m.vehiculeId) { + m.vehiculeId = v.getId(); + MOTEUR.nouveauVehicule(p.getUUID()); + } else { + boolean controler = (CONFIG.mode(Controle.VEHICULE_VITESSE) != Mode.OFF + || CONFIG.mode(Controle.VEHICULE_VOL) != Mode.OFF) && !estExempteManuellement(p.getUUID()); + if (controler || tracesEnCours()) { + double dx = v.getX() - m.vehiculeX; + double dz = v.getZ() - m.vehiculeZ; + EtatVehicule ev = etatVehicule(v, Math.sqrt(dx * dx + dz * dz), v.getY() - m.vehiculeY, + tick - m.vehiculeTick); + EtatJoueur etat = etat(p, true); + if (controler) { + List verdicts = MOTEUR.vehicule(p.getUUID(), tick * 50L, etat, ev); + Sanction s = traiter(p, verdicts); + if (s.ordinal() >= Sanction.SETBACK.ordinal()) { + p.stopRiding(); // le retour arrière ramène le joueur, pas le véhicule + appliquerSanctionMouvement(p, s, verdicts); + } + } + if (tracesEnCours()) { + int f = TraceLigne.masque(etat); + if (ev.milieuSpecial()) f |= TraceLigne.F_MILIEU; + if (ev.frictionAnormale()) f |= TraceLigne.F_FRICTION; + tracer(new TraceLigne(tick, p.getGameProfile().getName(), "veh", v.getX(), v.getY(), v.getZ(), + dx, ev.dy(), dz, v.onGround(), ev.auSolServeur(), f, -1, Double.NaN, + ev.type() + " " + v.getType().builtInRegistryHolder().key().location())); + } + } + } + m.vehiculeTick = tick; + m.vehiculeX = v.getX(); + m.vehiculeY = v.getY(); + m.vehiculeZ = v.getZ(); + } + + private static EtatVehicule etatVehicule(Entity v, double dxz, double dy, int ticks) { + EtatVehicule.Type type; + double attribut = 0; + if (v instanceof net.minecraft.world.entity.vehicle.Boat) { + type = EtatVehicule.Type.BATEAU; // bateaux, bateaux à coffre, radeaux + } else if (v instanceof net.minecraft.world.entity.LivingEntity l) { + type = EtatVehicule.Type.MONTURE; + attribut = l.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.MOVEMENT_SPEED); + } else { + type = EtatVehicule.Type.AUTRE; + } + net.minecraft.world.level.Level l = v.level(); + BlockPos pos = v.blockPosition(); + boolean auSol = !l.noCollision(v, v.getBoundingBox().move(0.0, -0.05, 0.0)); + boolean milieu = v.isInWater() || v.isInLava() || !l.getFluidState(pos.below()).isEmpty() + || l.getBlockState(pos).is(Blocks.BUBBLE_COLUMN) || l.getBlockState(pos.below()).is(Blocks.BUBBLE_COLUMN) + || l.getBlockState(pos).is(Blocks.COBWEB); + if (v instanceof net.minecraft.world.entity.LivingEntity le) { + milieu |= le.onClimbable() || le.hasEffect(MobEffects.LEVITATION) || le.hasEffect(MobEffects.SLOW_FALLING); + } + BlockState sous = l.getBlockState(v.getBlockPosBelowThatAffectsMyMovement()); + boolean friction = sous.getBlock().getFriction() > 0.6F || sous.getBlock().getSpeedFactor() > 1.0F; + return new EtatVehicule(type, dxz, dy, ticks, auSol, milieu, friction, attribut, v.isNoGravity()); + } + /** * Drapeau « au sol » à donner aux dégâts de chute (appelé par le mixin). En OBSERVE ou hors exemption * inapplicable, c'est celui du client : comportement vanilla. diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index c2cf0c5..a60725c 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -10,7 +10,9 @@ public enum Controle { TIMER("timer"), NO_FALL("no-fall"), VITESSE("vitesse"), - VOL("vol"); + VOL("vol"), + VEHICULE_VITESSE("vehicule-vitesse"), + VEHICULE_VOL("vehicule-vol"); private final String id; diff --git a/src/main/java/com/gastinelgarde/core/EtatVehicule.java b/src/main/java/com/gastinelgarde/core/EtatVehicule.java new file mode 100644 index 0000000..86ade1f --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/EtatVehicule.java @@ -0,0 +1,28 @@ +package com.gastinelgarde.core; + +/** + * Un mouvement de véhicule piloté par le joueur, tel que le serveur l'a accepté (F20). Tout vient du serveur. + * + * @param type famille du véhicule (bornes de vitesse) + * @param dxz déplacement horizontal du véhicule depuis le paquet précédent accepté (blocs) + * @param dy déplacement vertical (blocs) + * @param ticks ticks serveur écoulés depuis le paquet précédent (0 : deux paquets dans le même tick) + * @param auSolServeur bloc solide sous la boîte du véhicule, vu par le serveur + * @param milieuSpecial eau, lave, colonne à bulles, échelle, toile, lévitation ou chute lente de la monture : + * le contrôle de vol ne s'applique pas + * @param frictionAnormale glace (ou bloc de friction différente) sous le véhicule : vitesse non bornée + * @param vitesseAttribut attribut de vitesse de la monture (0 si non vivante) + * @param sansGravite entité sans gravité (le contrôle de vol ne s'applique pas) + */ +public record EtatVehicule(Type type, double dxz, double dy, int ticks, boolean auSolServeur, boolean milieuSpecial, + boolean frictionAnormale, double vitesseAttribut, boolean sansGravite) { + + public enum Type { + /** Bateau, bateau à coffre, radeau. */ + BATEAU, + /** Monture vivante pilotée (cheval, âne, mule, chameau, cochon, arpenteur). */ + MONTURE, + /** Véhicule inconnu (mods) : seul le vol est contrôlé. */ + AUTRE + } +} diff --git a/src/main/java/com/gastinelgarde/core/Exemptions.java b/src/main/java/com/gastinelgarde/core/Exemptions.java index b3c837a..7ee7eb5 100644 --- a/src/main/java/com/gastinelgarde/core/Exemptions.java +++ b/src/main/java/com/gastinelgarde/core/Exemptions.java @@ -9,7 +9,7 @@ import java.util.List; */ public final class Exemptions { - public enum Famille { COMBAT, MOUVEMENT, TIMER } + public enum Famille { COMBAT, MOUVEMENT, TIMER, VEHICULE } /** * @param exempt le contrôle ne doit pas s'appliquer @@ -42,6 +42,13 @@ public final class Exemptions { if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation"); if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul"); } + case VEHICULE -> { + // F20 : le véhicule piloté. Pas d'exemption « véhicule » ici, évidemment. + if (e.peutVoler()) raisons.add("peut-voler"); + if (e.pocheContraption()) raisons.add("contraption"); + if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation"); + if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul"); + } case TIMER -> { if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation"); if (e.ticksDepuisGel() <= cfg.graceGelTicks) raisons.add("gel-serveur"); diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 211d145..b364e55 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -137,6 +137,40 @@ public final class Moteur { return verdicts; } + /** + * Un mouvement de véhicule piloté par le joueur, accepté par le serveur (F20) : vitesse et vol du véhicule. + */ + public List vehicule(UUID joueur, long nowMs, EtatJoueur etat, EtatVehicule m) { + boolean vitesse = cfg.mode(Controle.VEHICULE_VITESSE) != Mode.OFF; + boolean vol = cfg.mode(Controle.VEHICULE_VOL) != Mode.OFF; + if (!vitesse && !vol) return List.of(); + + Suivi s = suivi(joueur); + Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.VEHICULE); + if (ex.exempt()) { + s.vehicule.vider(); + return List.of(); + } + List verdicts = new ArrayList<>(2); + double ptsVitesse = s.vehicule.vitesse(m, ex.facteur(), cfg.excesVitesseBlocs); + double ptsVol = s.vehicule.vol(m); + if (vitesse) { + ajouter(verdicts, s, Controle.VEHICULE_VITESSE, ptsVitesse, nowMs, ex, + String.format(Locale.ROOT, "%s dxz=%.3f base=%.3f", m.type(), m.dxz(), VehiculeMouvement.vitesseBase(m))); + } + if (vol) { + ajouter(verdicts, s, Controle.VEHICULE_VOL, ptsVol, nowMs, ex, + String.format(Locale.ROOT, "%s dy=%.3f en l'air", m.type(), m.dy())); + } + return verdicts; + } + + /** Le joueur change de véhicule (ou en descend) : l'élan et le temps en l'air repartent de zéro. */ + public void nouveauVehicule(UUID joueur) { + Suivi s = suivis.get(joueur); + if (s != null) s.vehicule.vider(); + } + /** * Drapeau « au sol » à donner aux dégâts de chute : celui du serveur en ENFORCE (sauf exemption), celui du * client sinon. diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 643c162..dcffc8e 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -12,6 +12,7 @@ public final class Suivi { public final TimerPaquets timer = new TimerPaquets(); public final VitesseHorizontale vitesse = new VitesseHorizontale(); public final VolVertical vol = new VolVertical(); + public final VehiculeMouvement vehicule = new VehiculeMouvement(); // Dernière position jugée valide (retour en arrière). private boolean positionValide; diff --git a/src/main/java/com/gastinelgarde/core/VehiculeMouvement.java b/src/main/java/com/gastinelgarde/core/VehiculeMouvement.java new file mode 100644 index 0000000..cd76279 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/VehiculeMouvement.java @@ -0,0 +1,89 @@ +package com.gastinelgarde.core; + +/** + * Contrôles des véhicules (F20) : avant, seul vanilla bornait handleMoveVehicle (10 blocs par paquet), et la + * famille « véhicule » exemptait le joueur de tout contrôle de mouvement. + * + *

Vitesse : borne par type, tampon d'excès sur 20 ticks comme {@link VitesseHorizontale}. L'élan est gardé : + * la borne d'un tick vaut au moins l'élan admis du tick précédent × {@link #DECROISSANCE_ELAN} (un bateau lancé + * sur la glace garde sa vitesse en l'air, × 0,9 par tick en vanilla). Un tricheur ne peut pas se constituer + * d'élan : seul un déplacement admis en compte, et sur la glace (vitesse non bornée) seulement. + * + *

Vol : en l'air (sans sol ni fluide) plus de {@link #TICKS_EN_AIR_MAX} ticks, un véhicule soumis à la gravité + * tombe à plus de {@link #CHUTE_MIN} bloc par tick (bateau : vitesse limite 0,36 ; cheval : bien plus). Un + * saut de cheval dure environ 25 ticks, un tremplin de glace une trentaine. + * + *

Toutes les bornes sont à confirmer avec les traces [À VÉRIFIER] : les montures et véhicules de mods + * (Create, Aeronautics) ne sont pas modélisés. + */ +public final class VehiculeMouvement { + + /** Bateau sur l'eau : vitesse limite vanilla 0,36 bloc par tick (accélération 0,04, frottement 0,9). */ + public static final double BATEAU = 0.45; + /** + * Monture au sol : vitesse limite vanilla environ 2,12 × attribut (frottement 0,546) ; cheval le plus rapide + * 0,3375 → 0,71 bloc par tick. Marge de 25 %. + */ + public static final double FACTEUR_MONTURE = 2.12 * 1.25; + public static final double MONTURE_MIN = 0.4; + public static final double DECROISSANCE_ELAN = 0.95; + public static final int TICKS_EN_AIR_MAX = 40; + public static final double CHUTE_MIN = 0.2; + + private final double[] exces = new double[VitesseHorizontale.FENETRE_TICKS]; + private int index; + private double elan; + private int ticksEnAir; + + /** Vitesse de base permise (blocs par tick) ; infinie si non bornée. */ + public static double vitesseBase(EtatVehicule e) { + if (e.frictionAnormale()) return Double.POSITIVE_INFINITY; + return switch (e.type()) { + case BATEAU -> BATEAU; + case MONTURE -> Math.max(MONTURE_MIN, e.vitesseAttribut() * FACTEUR_MONTURE); + case AUTRE -> Double.POSITIVE_INFINITY; + }; + } + + /** @return points de vitesse (0 si rien) */ + public double vitesse(EtatVehicule e, double facteur, double seuilBlocs) { + int ticks = Math.max(1, e.ticks()); + double parTick = e.dxz() / ticks; + double permis = Math.max(vitesseBase(e) * facteur, elan * DECROISSANCE_ELAN); + double depasse = Math.max(0, e.dxz() - permis * ticks); + elan = Math.min(parTick, permis); + if (Double.isInfinite(permis)) elan = parTick; + + exces[index] = depasse; + index = (index + 1) % exces.length; + double total = 0; + for (double v : exces) total += v; + if (total <= seuilBlocs) return 0; + return 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0); + } + + /** @return points de vol (0 si rien) */ + public double vol(EtatVehicule e) { + // Véhicule de mod inconnu (dirigeable Aeronautics…) : peut voler légitimement, non contrôlé. + if (e.sansGravite() || e.type() == EtatVehicule.Type.AUTRE) { + ticksEnAir = 0; + return 0; + } + if (e.auSolServeur() || e.milieuSpecial()) { + ticksEnAir = 0; + return 0; + } + int ticks = Math.max(1, e.ticks()); + ticksEnAir += ticks; + if (ticksEnAir <= TICKS_EN_AIR_MAX) return 0; + if (e.dy() / ticks <= -CHUTE_MIN) return 0; + return 1.0 + Math.min(3.0, (ticksEnAir - TICKS_EN_AIR_MAX) / 20.0); + } + + public void vider() { + java.util.Arrays.fill(exces, 0); + index = 0; + elan = 0; + ticksEnAir = 0; + } +} diff --git a/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java b/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java index 2104345..883ff1d 100644 --- a/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java +++ b/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java @@ -42,6 +42,14 @@ public abstract class MovePacketMixin { if (player != null) Garde.apresMouvement(player); } + // F20 : véhicules pilotés. TAIL = le dernier return de handleMoveVehicle (javap NeoForge 21.1.234 : offset + // 811, après ensureRunningOnSameThread à l'offset 9) ; les refus vanilla sortent avant (316, 638). + @Inject(method = "handleMoveVehicle", at = @At("TAIL")) + private void gastinelgarde$apresVehicule(net.minecraft.network.protocol.game.ServerboundMoveVehiclePacket packet, + CallbackInfo ci) { + if (player != null) Garde.apresVehicule(player); + } + /** * No-fall : le drapeau « au sol » transmis aux dégâts de chute. Inchangé (comportement vanilla) tant que le * contrôle no-fall n'est pas en ENFORCE ; sinon le serveur exige un bloc sous le joueur. diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index 8e9730d..2ef076d 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -330,4 +330,89 @@ class AuditFaillesTest { } assertTrue(vu, "5 entités touchées par seconde : vu"); } + + // ---------------------------------------------------------------- F20 + static EtatVehicule bateau(double dxz, double dy, boolean sol, boolean eau, boolean glace) { + return new EtatVehicule(EtatVehicule.Type.BATEAU, dxz, dy, 1, sol, eau, glace, 0, false); + } + + static EtatVehicule cheval(double dxz, double dy, boolean sol, double attribut) { + return new EtatVehicule(EtatVehicule.Type.MONTURE, dxz, dy, 1, sol, false, false, attribut, false); + } + + /** Boat fly et vitesse en bateau : avant, aucun contrôle sur handleMoveVehicle. */ + @Test + void F20_bateau_volant_et_rapide_vus() { + boolean vol = false, vitesse = false; + for (int tick = 0; tick < 100; tick++) { + List v = moteur.vehicule(j, tick * 50L, EtatJoueur.normal(), bateau(0.3, 0.05, false, false, false)); + vol |= contient(v, Controle.VEHICULE_VOL); + } + UUID k = UUID.randomUUID(); + for (int tick = 0; tick < 100; tick++) { + List v = moteur.vehicule(k, tick * 50L, EtatJoueur.normal(), bateau(1.2, 0, false, true, false)); + vitesse |= contient(v, Controle.VEHICULE_VITESSE); + } + assertTrue(vol, "bateau qui monte en l'air pendant 5 s : vu"); + assertTrue(vitesse, "bateau à 1,2 bloc/tick sur l'eau : vu"); + } + + /** Cheval trop rapide, cheval qui plane : vus. */ + @Test + void F20_monture_trop_rapide_ou_planante_vue() { + boolean vitesse = false, vol = false; + for (int tick = 0; tick < 100; tick++) { + vitesse |= contient(moteur.vehicule(j, tick * 50L, EtatJoueur.normal(), cheval(1.4, 0, true, 0.3375)), Controle.VEHICULE_VITESSE); + } + UUID k = UUID.randomUUID(); + for (int tick = 0; tick < 100; tick++) { + vol |= contient(moteur.vehicule(k, tick * 50L, EtatJoueur.normal(), cheval(0.5, -0.02, false, 0.3375)), Controle.VEHICULE_VOL); + } + assertTrue(vitesse, "cheval à 1,4 bloc/tick : vu"); + assertTrue(vol, "cheval qui descend de 0,02 bloc/tick pendant 5 s : vu"); + } + + /** Usages honnêtes : bateau sur l'eau, sur la glace puis tremplin, cheval rapide qui saute, chute de falaise. */ + @Test + void F20_usages_honnetes_sans_alerte() { + boolean vu = false; + long now = 0; + for (int tick = 0; tick < 200; tick++, now += 50) { + vu |= !moteur.vehicule(j, now, EtatJoueur.normal(), bateau(0.36, 0, false, true, false)).isEmpty(); + } + // glace bleue à 3,6 blocs/tick, puis tremplin : 30 ticks en l'air (bateau : ×0,9 par tick, gravité 0,04) + double v = 3.6, vy = 0.3; + for (int tick = 0; tick < 100; tick++, now += 50) vu |= !moteur.vehicule(j, now, EtatJoueur.normal(), bateau(v, 0, true, false, true)).isEmpty(); + for (int tick = 0; tick < 30; tick++, now += 50) { + vu |= !moteur.vehicule(j, now, EtatJoueur.normal(), bateau(v, vy, false, false, false)).isEmpty(); + v *= 0.9; + vy = (vy - 0.04) * 0.9; + } + for (int tick = 0; tick < 40; tick++, now += 50) { + vu |= !moteur.vehicule(j, now, EtatJoueur.normal(), bateau(v, 0, true, false, false)).isEmpty(); + v *= 0.5; + } + assertFalse(vu, "bateau honnête : rien"); + + UUID c = UUID.randomUUID(); + boolean vuCheval = false; + now = 0; + for (int saut = 0; saut < 10; saut++) { + for (int tick = 0; tick < 10; tick++, now += 50) vuCheval |= !moteur.vehicule(c, now, EtatJoueur.normal(), cheval(0.71, 0, true, 0.3375)).isEmpty(); + double y = 0, dy = 0.95; // saut de cheval à pleine charge : environ 5 blocs, 25 ticks en l'air + do { + y += dy; + vuCheval |= !moteur.vehicule(c, now, EtatJoueur.normal(), cheval(0.71, dy, false, 0.3375)).isEmpty(); + dy = (dy - 0.08) * 0.98; + now += 50; + } while (y > 0); + } + // chute d'une falaise de 60 blocs + double dy = 0; + for (int tick = 0; tick < 40; tick++, now += 50) { + dy = (dy - 0.08) * 0.98; + vuCheval |= !moteur.vehicule(c, now, EtatJoueur.normal(), cheval(0.3, dy, false, 0.3375)).isEmpty(); + } + assertFalse(vuCheval, "cheval honnête : rien"); + } }