Fichiers

Brut Lien permanent Annotations Historique

Étape 2 : failles de détection de GastinelGarde 0.2.0

Audit du 2026-10-14. Lecture seule. Tests : audit/tests-proposes/AuditFaillesTest.java, 17 tests verts lancés dans une copie jetable (hors src/). Un test « BYPASS » ou « FAUX_POSITIF » est vert tant que la faille existe, et passera au rouge une fois corrigée. Vanilla cité : net/minecraft/server/network/ServerGamePacketListenerImpl.java du jar build/moddev/artifacts/neoforge-21.1.234-sources.jar (lignes de ce fichier).

Chemins : core/ = src/main/java/com/gastinelgarde/core/.

Résumé par gravité

Id Contrôle Gravité Type
F01 timer (mixin) critique bug + faux positif
F04 riptide / vitesse vanilla critique contournement
F07 tous (ping) élevée contournement
F05 vitesse, vol, timer (grâce téléportation) élevée contournement
F08 vol élevée contournement
F11 killaura-angle élevée contournement
F14 vitesse (atterrissage élytres) élevée faux positif
F19 vitesse, vol, combat (Create) élevée faux positif [À VÉRIFIER]
F20 véhicules élevée trou de couverture
F02 timer moyenne contournement
F03 timer moyenne contournement
F06 vitesse, vol (grâce dégâts) moyenne contournement
F09 vitesse moyenne contournement
F10 vitesse moyenne contournement
F12 cadence moyenne contournement
F18 attaque-impossible moyenne faux positif
F21 état par joueur moyenne bug (concurrence, fuite)
F22 no-fall moyenne contournement [À VÉRIFIER]
F15 traces moyenne bug
F13 killaura-cibles faible contournement
F16 VL faible bug
F17 vitesse faible contournement
F23 configuration faible bug (concurrence)
F24 mixins moyenne fragilité
F25 Aeronautics élevée faux positif [À VÉRIFIER]

F01 : le mixin tourne aussi sur le thread réseau, chaque paquet est compté deux fois

  • Contrôle : timer (et tout ce que avantMouvement touche).
  • Gravité : critique. Type : bug (concurrence) + faux positif.
  • Description : MovePacketMixin.gastinelgarde$avantMouvement est injecté en HEAD de handleMovePlayer. La première instruction vanilla est PacketUtils.ensureRunningOnSameThread(...) (ServerGamePacketListenerImpl:858). Sur le thread réseau, cet appel replanifie le paquet sur le thread serveur puis lance une exception : le HEAD s'est donc déjà exécuté une première fois sur le thread Netty, puis une seconde fois sur le thread serveur (PacketUtils.java:21-38). Conséquences :
    1. TimerPaquets voit 40 paquets/s pour un joueur honnête à 20/s (seuil 22 sur 3 s) : une infraction à chaque paquet, +1 à +3,8 points, VL 20 en quelques secondes, expulsion en ENFORCE, alertes aux ops en continu en OBSERVE.
    2. Moteur, Suivi, Fenetre (non thread-safe, Moteur.java:15) et Garde.MARQUES (HashMap.computeIfAbsent) sont modifiés par deux threads : corruption possible, ConcurrentModificationException.
    3. appliquerSanctionMouvement (connection.teleport, disconnect) peut partir du thread réseau.
  • Preuve : test F01_timer_paquet_compte_deux_fois_faux_positif (compter deux fois = infraction ; une fois = rien). Le fait que le HEAD s'exécute sur Netty vient du code vanilla ci-dessus (non testable sans le jeu : [À VÉRIFIER] en jeu, voir synthèse essai 1). La ligne de journal attendue : timer ... vl=... dès 3 s de marche.
  • Correction proposée : dans gastinelgarde$avantMouvement, sortir si !player.server.isSameThread() (ou injecter @At(value="INVOKE", target="...PacketUtils;ensureRunningOnSameThread", shift=AFTER)). Ajouter un assert de thread dans Moteur en développement.
  • Risque : faible ; le temps mesuré devient celui du thread serveur (traitement groupé après un gel), déjà géré par la grâce de gel.

F02 : inondation de paquets, le timer devient aveugle

  • Contrôle : timer. Gravité : moyenne. Type : contournement.
  • Description : TimerPaquets utilise Fenetre(512) (core/TimerPaquets.java:9). Au-delà d'environ 512 paquets/s, 512 entrées ne couvrent plus 2 s : le compte de la seconde k=1 vaut 0 et enregistrer renvoie 0 (ligne 20). Plus on envoie de paquets, moins on est vu.
  • Preuve : F02_timer_inondation_BYPASS (1000 paquets/s : aucune infraction ; 100/s : vu).
  • Correction : compter par compteur de seconde (tableau de 4 entiers par tranche de 250 ms) au lieu d'un tampon d'événements ; ou plafonner : tout débit > capacité/2 = infraction maximale immédiate.
  • Risque : faible.
  • Contrôle : timer. Gravité : moyenne. Type : contournement.
  • Description : le seuil est strictement > 22 paquets/s (soit 1,10x). Un timer à 1,05-1,10x gagne 10 % de vitesse et de cadence sans infraction. Une rafale après un silence (blink, lag switch) n'est jamais soutenue 3 s. Grim utilise une balance cumulée (checks/impl/timer/Timer, NegativeTimer).
  • Preuve : F03_timer_faible_et_blink_BYPASS.
  • Correction : balance : solde += 50 ms - delta_réel par paquet, plafonnée ; infraction si solde > +150 ms (paquets en avance sur l'horloge). Remise à zéro sur gel, déconnexion, téléportation. Test rejouable en JUnit.
  • Risque : moyen (lag réseau honnête : les rafales de rattrapage). Démarrer en OBSERVE avec les traces.

F04 : tenir un trident Impulsion neutralise tout le mouvement

  • Contrôle : RiptideMoveMixin, vitesse, vol, no-fall. Gravité : critique. Type : contournement.
  • Description : gastinelgarde$seuil passe riptide=true dès qu'un trident Impulsion est en main (RiptideMoveMixin.java:211-214). Le seuil vanilla « moved too quickly » (100, soit 10 blocs/paquet) devient 10 000 (100 blocs/paquet, 2 000 blocs/s). En plus Garde.etat (Garde.java:193) positionne riptide, ce qui exempte toute la famille mouvement pendant 2 s après. Tenir un trident = téléportation, vol et vitesse libres. Le seuil élytres (300) est relevé de la même façon.
  • Preuve : F04_riptide_tenu_seuil_vanilla_neutralise_BYPASS (la partie « en main » est dans le mixin, non testable sans le jeu ; le calcul est testé).
  • Correction : ne relever le seuil qu'après une utilisation réelle : suivre LivingEntityUseItemEvent.Stop (trident Impulsion, charge ≥ 10 ticks) ou isAutoSpinAttack(), puis une fenêtre de 40 ticks. Remplacer 10 000 par la distance maximale physique (élan 3 blocs/tick × 20 ticks = 60) ou par une vérification a posteriori.
  • Risque : moyen. Le serveur ne lance la vrille que s'il juge l'eau ou la pluie (commentaire du mixin) : bien tester les retours en arrière du 13/10.

F05 : toute téléportation vanilla ouvre 2 s d'exemption, déclenchable par le client

  • Contrôle : vitesse, vol, timer, no-fall. Gravité : élevée. Type : contournement.
  • Description : MovePacketMixin marque une téléportation à chaque teleport() (ligne 153). Vanilla appelle teleport() pour « moved too quickly » (:904) et pour « moved wrongly » (:~963). Un client envoie un paquet volontairement trop rapide toutes les 1,9 s : vanilla le ramène (aucun gain pour lui), et GastinelGarde l'exempte 40 ticks de mouvement et de timer. Idem pour le setback du mod lui-même.
  • Preuve : F05_grace_teleportation_rechargee_en_boucle_BYPASS (20 blocs/s soutenus pendant 30 s, aucune infraction).
  • Correction : ne marquer que les téléportations non provoquées par le client : distinguer par l'appelant (teleport appelé depuis handleMovePlayer = refus vanilla, ne pas marquer ; ou ne marquer que si le déplacement serveur est > 4 blocs depuis la dernière position acceptée). Raccourcir la grâce à 10 ticks pour les téléportations internes.
  • Risque : moyen (téléportation légitime non marquée = fausse alerte ; garder le marquage pour /tp, perle, TPA, dimension).

F06 : tout dégât exempte le mouvement

  • Contrôle : vitesse, vol. Gravité : moyenne. Type : contournement.
  • Description : LivingDamageEvent.Post (GardeEvents.java:82-85) marque un « recul » pour tout dégât, 20 ticks de grâce (<=, borne incluse). Feu, cactus, baies, faim, poison, wither : un dégât par seconde suffit à être exempté en permanence. Aussi, l'événement ne dit pas si un recul a eu lieu.
  • Preuve : F06_grace_degats_BYPASS.
  • Correction : marquer seulement si une vélocité a été envoyée au joueur (ClientboundSetEntityMotionPacket pour lui, ou LivingKnockBackEvent/explosion), et mesurer la vélocité attendue (anti-knockback).
  • Risque : faible à moyen.

F07 : le ping falsifié multiplie tous les seuils par 1,5

  • Contrôle : tous (Exemptions.java:51-53). Gravité : élevée. Type : contournement.
  • Description : lag = tps < 18 || ping > 250 ms → facteur 1,5. Le ping vient de connection.latency() (réponses aux keep-alive), donc retardé par le client (module PingSpoof de LiquidBounce, ModulePingSpoof.kt). 1,5 s de réponse tardive = seuils élargis en continu : vitesse 0,45 au sol, 30 coups/s, 4 cibles, 90° d'angle, 33 paquets/s.
  • Preuve : F07_ping_spoof_elargit_les_seuils_BYPASS.
  • Correction : ne pas accorder de facteur sur le ping seul : exiger un ping élevé et un TPS serveur bas, ou ne tolérer que les rafales ; plafonner le facteur à 1,15 pour le ping, 1,5 pour le TPS. Journaliser la variance du ping (ping très élevé constant sans perte = suspect).
  • Risque : faible (plus de fausses alertes pour un joueur honnête en wifi médiocre : à mesurer dans les traces).

F08 : le contrôle de vol ne s'évalue que si ticks == 1

  • Contrôle : vol (core/VolVertical.java:28-31). Gravité : élevée. Type : contournement.
  • Description : if (e.ticks() != 1) { aVitesse=false; return 0; }. Un client qui envoie un paquet tous les 2 ticks (ou 2 par tick) n'est jamais évalué. Sur le thread serveur, le jitter honnête (paquets traités à cheval sur deux ticks) rend aussi l'évaluation intermittente.
  • Preuve : F08_vol_aveugle_si_ticks_different_de_1_BYPASS.
  • Correction : modéliser sur le temps cumulé : appliquer la prédiction ticks fois (vy' = (vy-0,08)*0,98 itéré), et accepter une tolérance proportionnelle à ticks.
  • Risque : moyen (recalibrer avec les traces).

F09 : rester sous le tampon de vitesse

  • Contrôle : vitesse. Gravité : moyenne. Type : contournement.
  • Description : bornes : 0,30 sprint au sol (vanilla ~0,28), 0,42 en l'air ; tampon de 1,5 bloc sur 20 ticks = +0,075 bloc/tick. Soutenu : 0,375 au sol (+34 %) ou 0,495 en l'air (+18 % sur COURSE_SAUT) sans infraction. Ajouté au facteur ping (F07) : 0,56/0,74.
  • Preuve : F09_vitesse_sous_le_tampon_BYPASS (0,37 au sol et 0,49 en l'air, 60 s).
  • Correction : après les traces honnêtes, resserrer COURSE à 0,29, COURSE_SAUT à 0,37 ; passer le tampon à 0,5-0,8 bloc et accumuler sur 40 ticks avec décroissance plus lente que 0,5/s.
  • Risque : élevé (fausses alertes) : seulement avec les traces du joueur honnête et de la glace.

F10 : milieux spéciaux et friction anormale ignorés totalement

  • Contrôle : vitesse (core/VitesseHorizontale.java:41-45), Garde.milieuSpecial/frictionAnormale. Gravité : moyenne. Type : contournement.
  • Description : dans l'eau, sur glace, âmes, slime, miel, échelle, ou vol créatif : excès = 0, quelle que soit la vitesse (3 blocs/tick passe). Jesus, Speed sur glace et marche aquatique sont invisibles. Aussi, « sous le joueur » utilise le bloc à 0,5 sous la position : un bloc de glace posé sous soi permet d'être exempté.
  • Preuve : F10_milieux_exemptes_totalement_BYPASS.
  • Correction : au lieu d'ignorer, appliquer un plafond absolu par milieu (eau : 0,2 ; glace : 0,9 ; bulle : 0,6) et ne pas exempter le premier contact (poser de la glace). Vérifier que l'état est vrai sur plusieurs ticks.
  • Risque : moyen.

F11 : killaura à rotation silencieuse

  • Contrôle : killaura-angle. Gravité : élevée. Type : contournement.
  • Description : l'angle est mesuré avec le regard serveur à la réception du coup. Un client qui envoie un paquet de rotation vers la cible juste avant chaque attaque (« server-side rotation ») donne un excédent de 0°. Le seuil est en outre large : centre de boîte à 60° + demi-angle de la sphère englobante (jusqu'à ~20° à 3 blocs pour un joueur) ≈ 80°.
  • Preuve : F11_killaura_rotation_silencieuse_BYPASS.
  • Correction : ajouter un contrôle de rotation : écart d'angle entre deux paquets > 60° en un tick puis retour (snap) + coup dans le même tick ; vitesse de rotation avant le coup ; coups sur deux cibles espacées de > 90° en < 3 ticks. Utiliser aussi l'écart avec le dernier regard vu avant le paquet de rotation.
  • Risque : moyen (les joueurs honnêtes font des tours rapides : seuils à régler avec les traces).

F12 : cadence saturée

  • Contrôle : cadence (core/Cadence.java:14,21-23). Gravité : moyenne. Type : contournement.
  • Description : Fenetre(128) : à plus de 128 coups/s, les 128 entrées tiennent dans moins d'une seconde, precedent vaut 0. 200 coups/s ne lèvent rien. Paradoxe : plus c'est rapide, moins c'est vu. Vanilla ne limite pas le nombre de paquets d'attaque par tick.
  • Preuve : F12_cadence_saturation_BYPASS (40/s vu, 200/s non).
  • Correction : compteurs par tranche de 50 ms (ticks) sur 40 ticks ; plafond absolu > 3 coups/tick = infraction immédiate.
  • Risque : faible.

F13 : la fenêtre des cibles est saturable

  • Contrôle : killaura-cibles (core/CiblesMultiples.java:6). Gravité : faible. Type : contournement.
  • Description : Fenetre(32). 8 coups/tick sur une cible chassent les autres cibles de la fenêtre : 5 entités par seconde passent. Peu réaliste face à un vrai killaura (qui respecte le recharge), mais prouvé.
  • Preuve : F13_cibles_multiples_fenetre_saturable_BYPASS.
  • Correction : mémoriser les identifiants distincts par seconde (ensemble de taille bornée) au lieu des 32 derniers coups.
  • Risque : faible.

F14 : atterrissage rapide après élytres : faux positif

  • Contrôle : vitesse. Gravité : élevée. Type : faux positif.
  • Description : elytres exempte tant que isFallFlying(). Dès l'atterrissage, l'élan (1,0-1,7 bloc/tick) est jugé contre COURSE 0,30 : excès cumulé > 1,5 en quelques ticks. Pas de grâce après les élytres (contrairement au riptide, 40 ticks). Même chose après Wind Charge, mace, piston, slime, explosion sans dégâts (non gérés, README).
  • Preuve : F14_atterrissage_elytres_faux_positif (1,7 bloc/tick amorti de 0,546 par tick au sol).
  • Correction : grâce de 20-40 ticks après isFallFlying passé à faux, et après toute vélocité reçue (voir F06).
  • Risque : faible.

F15 : plafond de taille des traces non appliqué dans la journée

  • Contrôle : traces (core/TraceFichier.java:44-49, 82-109). Gravité : moyenne. Type : bug.
  • Description : la purge n'a lieu qu'à l'ouverture d'un nouveau fichier (changement de jour UTC) et elle saute le fichier du jour (ligne 104). Avec environ 10 Mo par heure et par joueur, 5 joueurs et enregistrement continu, le fichier du jour atteint 1 Go en 20 h sans purge. Aucune alerte disque.
  • Preuve : F15_traces_plafond_non_applique_dans_la_journee (plafond 1 Ko, fichier de 2 Mo).
  • Correction : purger toutes les 5 min (ou tous les 10 000 écritures) et permettre la rotation par taille (trace-JJ-1.jsonl) ; couper les traces proprement si l'espace libre du disque est < 5 Go.
  • Risque : faible.

F16 : décroissance des VL figée à la création du suivi

  • Contrôle : VlCompteur. Gravité : faible. Type : bug.
  • Description : Suivi(cfg.vlDecroissanceParSeconde) copie la valeur à la création (Moteur.java:34). /garde reload ou le fichier ne l'appliquent qu'aux joueurs qui se reconnectent (documenté dans GardeSpec, mais surprenant).
  • Preuve : F16_decroissance_figee_a_la_creation.
  • Correction : passer cfg au compteur et lire la valeur à chaque calcul.
  • Risque : nul.

F17 : une rafale par seconde sous le tampon

  • Contrôle : vitesse. Gravité : faible. Type : contournement.
  • Description : un déplacement de 1,7 bloc en un tick toutes les secondes (1,4 de dépassement) reste sous 1,5 : +25 blocs/min gratuits, soit un « blink » discret ou un petit teleport régulier. Combiné à F05 (grâce rechargée par vanilla), non limité.
  • Preuve : F17_tampon_vitesse_rafale_isolee_BYPASS.
  • Correction : plafond par tick absolu (ex. 1,0 bloc/tick hors exemption = infraction directe) en plus du tampon.
  • Risque : moyen (téléportations non marquées).

Failles non testables sans le jeu

F18 : attaque-impossible utilise une ligne de vue œil à œil

  • Contrôle : attaque-impossible (GardeEvents.java:65, p.hasLineOfSight(cible)). Gravité : moyenne. Type : faux positif.
  • Description : hasLineOfSight trace œil du joueur → œil de la cible. Un coup légitime sur le corps ou les pieds d'un mob derrière une clôture, une trappe, un demi-bloc, ou sur un mob dont l'œil est bas (araignée, slime, bébé, poisson, ver d'argent) est refusé alors que la boîte est visible. 1 point par coup, 5 coups = alerte, 10 = annulation des coups en ENFORCE. Le test existant ne couvre que le calcul des points.
  • Preuve : non testable sans le jeu (lancer de rayon, boîtes de collision). Essai en jeu n° 5.
  • Correction : tester la visibilité vers 3 points de la boîte (œil, centre, pieds) et déclarer invisible seulement si les trois sont bloqués ; poids 0,5.
  • Risque : faible.

F19 : contraption plus grande que 3 blocs : exemption manquée

  • Contrôle : exemptions pocheContraption (Garde.java:242-255). Gravité : élevée. Type : faux positif [À VÉRIFIER].
  • Description : la détection cherche une entité dont le nom de classe commence par un préfixe, dans boundingBox.inflate(3) du joueur. La boîte d'une entité de contraption n'est pas celle de sa structure (probable : petite, au point d'ancrage). Un joueur à l'autre bout d'un train ou d'un dirigeable est à plus de 3 blocs : non exempté, et porté à plusieurs blocs/tick.
  • Preuve : non testable (dépend de Create). Essai n° 6.
  • Correction : tester si le joueur est sur la contraption (passager, ou collision avec la structure via l'API Create ContraptionCollider), ou augmenter distanceContraptionBlocs (max 16) ; ajouter un mode « exempté tant que la contraption bouge (vitesse de l'entité > 0) ».
  • Risque : moyen (une exemption large est exploitable : un tricheur reste près d'une contraption, voir F25).

F20 : les véhicules ne sont jamais contrôlés

  • Contrôle : mixins (seul handleMovePlayer est accroché). Gravité : élevée. Type : trou de couverture.
  • Description : handleMoveVehicle (ServerGamePacketListenerImpl:389) n'est pas accroché. Boat fly, vitesse de cheval, minecart, boat jesus : seuls 10 blocs/paquet vanilla (:410, seuil fixe 100 sans i). La famille enVehicule exempte aussi handleMovePlayer. Un joueur dans un bateau est un tricheur libre.
  • Preuve : lecture du code (mixin et vanilla).
  • Correction : mixin handleMoveVehicle (mêmes vitesse et vol, bornes par type d'entité : bateau 0,4 sur l'eau, cheval 0,45 ; vol : bateau hors de l'eau sans bloc = infraction).
  • Risque : moyen (Create, Aeronautics et montures modifiées).

F21 : état par joueur recréé après la déconnexion, concurrence

  • Contrôle : Garde.MARQUES, Moteur.suivis. Gravité : moyenne. Type : bug (fuite, concurrence).
  • Description : en plus de F01, un paquet de mouvement déjà en file après PlayerLoggedOutEvent rappelle marques(uuid)/suivi(uuid) (computeIfAbsent) : l'entrée du joueur parti est recréée et ne sera plus jamais libérée (une par déconnexion). Petit, mais cumulatif sur un serveur qui reste des semaines. Garde.arreter() ne vide pas ALERTES_COUPEES. Les Suivi de /garde status <joueur> hors ligne ne sont pas créés (joueur en ligne uniquement : ok).
  • Preuve : lecture du code. joueurParti (Garde.java:142-146) retire, mais rien n'empêche la recréation.
  • Correction : ne pas créer d'entrée si le joueur n'est plus dans PlayerList ; purge périodique des UUID hors ligne ; vider ALERTES_COUPEES à l'arrêt.
  • Risque : faible.

F22 : no-fall : la chute se réinitialise sur une montée vanilla

  • Contrôle : no-fall. Gravité : moyenne. Type : contournement [À VÉRIFIER].
  • Description : vanilla fait if (flag4) this.player.resetFallDistance() quand le paquet monte de la dernière position valide (ServerGamePacketListenerImpl:960-961). Un client qui intercale un paquet qui monte de 0,01 bloc juste avant l'impact remet la distance de chute à 0 sans passer par onGround. no-fall (core/NoFall.java) ne regarde que onGround client contre serveur, et ne corrige qu'en ENFORCE (désactivé).
  • Preuve : non testable sans le jeu. Essai n° 7.
  • Correction : contrôler dy positif en chute libre (la vitesse verticale serveur précédente est < -0,5 puis un paquet monte) = infraction + conserver la distance de chute côté mod.
  • Risque : moyen.

F23 : configuration modifiée depuis un autre thread

  • Contrôle : GardeConfig, GardeSpec.onConfig. Gravité : faible. Type : bug (concurrence).
  • Description : ModConfigEvent est déclenché par l'observateur de fichiers ; appliquer modifie les champs publics non volatils lus par le thread serveur. Course bénigne (pas de verrou), mais des lectures obsolètes ou un seuilSetback < seuilAlerte transitoire sont possibles pendant la recopie.
  • Preuve : lecture du code.
  • Correction : construire une GardeConfig neuve et l'échanger d'un coup (référence volatile).
  • Risque : nul.

F24 : mixins fragiles

  • Contrôle : RiptideMoveMixin, MovePacketMixin. Gravité : moyenne. Type : fragilité.
  • Description :
    • @ModifyConstant(100.0F) et 300.0F visent des constantes de handleMovePlayer : un autre mod (Lithium, ServerCore, Aeronautics) ou une mise à jour de NeoForge qui touche cette méthode peut empêcher l'application ou doubler l'injection. defaultRequire=1 fait planter le démarrage du serveur si une injection est absente.
    • GastinelClaims 1.1.6 contient le même mixin ; les deux relèvent le seuil (le README dit « sans danger », mais deux @ModifyConstant sur la même constante : le deuxième reçoit la valeur déjà modifiée, d'où seuil max : ok) ; le getMaximumFlyingTicks est injecté deux fois.
    • @ModifyArg ... doCheckFallDamage(DDDZ)V correspond à deux appels (succès et rejet), et le second reçoit aussi le drapeau corrigé.
    • required: true sans repli : un échec d'injection empêche le serveur de démarrer.
  • Preuve : lecture. MixinsAppliquesTest ne charge que la classe vanilla (pas les autres mods).
  • Correction : retirer le mixin de GastinelClaims (tâche 79) avant le déploiement ; utiliser require = 0 pour le riptide et journaliser l'échec ; test d'intégration avec les vrais mods (Lithium, ServerCore).
  • Risque : faible.

F25 : Aeronautics (Sable) : comportement du joueur inconnu

  • Contrôle : exemptions contraption. Gravité : élevée. Type : faux positif [À VÉRIFIER].
  • Description : Aeronautics s'appuie sur Sable (« sub-levels ») selon https://modrinth.com/mod/aeroclaims. On ne sait pas si le joueur est passager, déplacé par la physique, ou téléporté dans un plan séparé. Les préfixes par défaut dev.simulated_team,dev.ryanhcode sont des suppositions. Si le joueur se trouve dans un plan avec des coordonnées décalées, la proximité d'une entité ne le reconnaît pas. Inversement, l'exemption par proximité est un blanc-seing : n'importe quel tricheur à 3 blocs d'une entité Create est exempté de tout (combat compris, Famille.COMBAT aussi).
  • Preuve : non testable. Essais n° 6 et 8.
  • Correction : relever les noms de classe en jeu (/garde : ajouter une commande de diagnostic qui liste les entités à 5 blocs), et limiter l'exemption aux joueurs réellement passagers/sur la structure, jamais au combat sans condition.
  • Risque : moyen.

Ce qui est bon (pour ne pas casser)

  • Cœur pur testable, 98 tests, pas d'allocation par paquet.
  • OBSERVE par défaut, jamais de bannissement.
  • Plafond de VL et paliers cohérents (Paliers.java), seuilSetback/seuilExpulsion ramenés au minimum (GardeSpec.java:135-136).
  • Dimension vérifiée avant le setback (Garde.java:422).
  • Journal limité à 1 ligne/s/contrôle, alertes à 5 s.