Fichiers
gastinel-garde/src/main/java/com/gastinelgarde/GardeEvents.java
T
gastineltetClaude Opus 5.5 a88e4409e4 P2.6 inventaire (OBSERVE par defaut) + socle 0.6 des controles scaffold, blink, phase
- Nouveau controle inventaire (mixin ContainerClickMixin apres
  ensureRunningOnSameThread, PlayerContainerEvent.Open/Close) :
  vol-de-coffre (reaction apres ouverture ping retire plafonne, prises
  d'objets differents a <= 1,5 tick en moyenne, double-clic shift exclu),
  regard-conteneur (rotation avec conteneur ouvert apres grace + ping :
  contre le stealer "silencieux" et l'InventoryMove), clic-en-rotation
  (InvCleaner / AutoArmor), clics sur conteneur ferme (journal seulement).
- Seuils de VL propres par controle (Paliers), sections de configuration
  [inventaire], [scaffold], [blink], [phase].
- Ce commit contient deja le cablage (Garde, Moteur, mixins) des trois
  autres controles 0.6 (fichiers partages) ; leurs tests suivent dans
  les commits suivants.
- Tests : InventaireP06Test (18), MixinsThreadTest etendu.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:05:53 +02:00

278 lignes
15 KiB
Java
Brut Annotations Historique

Ce fichier contient des caractères Unicode ambigus.
Ce fichier contient des caractères Unicode qui peuvent être confondus avec d'autres caractères. Si vous pensez que c'est intentionnel, vous pouvez ignorer cet avertissement. Utilisez le bouton Échappe pour les dévoiler.
package com.gastinelgarde;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.KillauraAngle;
import com.gastinelgarde.core.PorteeHitbox;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.TraceLigne;
import com.gastinelgarde.core.Verdict;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.Vec3;
import net.neoforged.bus.api.EventPriority;
import net.neoforged.bus.api.SubscribeEvent;
import net.neoforged.neoforge.common.util.FakePlayer;
import net.neoforged.neoforge.event.entity.living.LivingKnockBackEvent;
import net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent;
import net.neoforged.neoforge.event.entity.player.AttackEntityEvent;
import net.neoforged.neoforge.event.entity.player.PlayerEvent;
import net.neoforged.neoforge.event.level.ExplosionKnockbackEvent;
import net.neoforged.neoforge.event.server.ServerStartingEvent;
import net.neoforged.neoforge.event.server.ServerStoppedEvent;
import net.neoforged.neoforge.event.tick.ServerTickEvent;
/** Collecte des faits côté serveur (D3) : coups, déconnexions, téléportations, reculs réels, durée des ticks. */
public final class GardeEvents {
private static long debutTickNs;
private GardeEvents() { }
@SubscribeEvent
public static void onServerStarting(ServerStartingEvent event) {
Garde.demarrer();
}
@SubscribeEvent
public static void onServerStopped(ServerStoppedEvent event) {
Garde.arreter();
}
@SubscribeEvent
public static void onTickPre(ServerTickEvent.Pre event) {
debutTickNs = System.nanoTime();
Garde.enregistrerHistoriques(event.getServer()); // #92 : boîtes des cibles possibles
}
@SubscribeEvent
public static void onTickPost(ServerTickEvent.Post event) {
long duree = System.nanoTime() - debutTickNs;
Garde.noterTickServeur(event.getServer(), duree);
if (event.getServer().getTickCount() % 20 == 0) Garde.flushTraces();
}
@SubscribeEvent
public static void onAttaque(AttackEntityEvent event) {
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
Garde.autrePaquet(p); // 0.6 (blink) : un coup est un paquet traité sur le thread serveur
switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) {
case ANNULER -> { // C4 : expulsion en cours
event.setCanceled(true);
return;
}
case IGNORER -> {
return;
}
case EVALUER -> { }
}
Entity cible = event.getTarget();
int tick = p.server.getTickCount();
EtatJoueur etat = Garde.etat(p, true);
AABB bb = cible.getBoundingBox();
Vec3 oeil = p.getEyePosition();
Vec3 regard = p.getLookAngle();
double excedent = KillauraAngle.excedentDegres(oeil.x, oeil.y, oeil.z, regard.x, regard.y, regard.z,
bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ);
boolean visible = p.hasLineOfSight(cible);
List<Verdict> verdicts = new ArrayList<>(
Garde.moteur().attaque(p.getUUID(), tick * 50L, etat, -1, cible.getId(), visible)); // angle : différé
// Portée et hitbox (test de Rednixxu, 14/10). Cible sur une contraption ou un vaisseau Sable : ses
// coordonnées et sa boîte ne sont pas fiables pour cette géométrie, on ne mesure pas.
// 16/10 : cible assise sur une contraption (siège Create) ; mesure terminée au paquet de mouvement suivant
// (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere).
// L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
Entity racine = cible.getRootVehicle();
boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> Garde.estContraption(cible),
() -> SableAcces.surSousNiveau(cible), racine == cible, () -> Garde.estContraption(racine),
() -> SableAcces.surSousNiveau(racine));
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
+ Math.pow(cible.getZ() - cible.zo, 2));
// #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge
// « vitesse × ticks » dans toutes les directions. Null (pas de mesure) si l'historique est incomplet ou si
// la cible est sur ou près d'une contraption / d'un vaisseau.
double[][] vues = mesurerPH && !Garde.cibleProcheContraption(cible, tick) ? Garde.boitesVues(cible, p, tick) : null;
verdicts.addAll(Garde.moteur().coupDiffere(p.getUUID(), tick * 50L, etat,
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z},
new double[] {bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ}, p.entityInteractionRange(),
vitesseCible, mesurerPH, true, Garde.oeilAvant(p), vues));
if (Garde.tracesEnCours()) {
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
0, 0, 0, p.onGround(), p.onGround(), TraceLigne.masque(etat), cible.getId(), excedent,
visible ? null : "non-visible"));
}
// 0.5 (P3.1) : cristal de l'End frappé (auto-cristal), âge vu à son apparition.
if (cible instanceof net.minecraft.world.entity.boss.enderdragon.EndCrystal) {
verdicts.addAll(Garde.moteur().frappeCristal(p.getUUID(), tick * 50L, etat, Garde.ageCristal(cible, tick)));
}
Sanction s = Garde.traiter(p, verdicts);
// portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé
if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true);
if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
}
/** 0.5 (P1.10) : coup critique vanilla (Criticals) ; en ENFORCE au palier SETBACK, le critique est annulé. */
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onCritique(net.neoforged.neoforge.event.entity.player.CriticalHitEvent event) {
if (!event.isVanillaCritical()) return;
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.noterCritique(p)) {
event.setCriticalHit(false);
event.setDamageMultiplier(1.0F);
}
}
/** 0.5 (P1.13) : diagnostic « Mismatch in destroy block pos » (vu après les autres mods, même annulé). */
@SubscribeEvent(priority = EventPriority.LOWEST, receiveCanceled = true)
public static void onClicGaucheBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock event) {
if (event.getLevel().isClientSide()) return;
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
var a = event.getAction();
Garde.autrePaquet(p); // 0.6 (blink)
// 0.5 (P2.3) : début de la mesure fast-break (START accepté par les autres mods).
if (a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START && !event.isCanceled()) {
Garde.noterDebutCasse(p, event.getPos(), event.getFace());
}
Garde.noterActionBloc(p, a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START,
a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.ABORT,
event.getPos(), event.isCanceled());
}
/**
* 0.5 (P2.3) : bloc cassé par un joueur (fast-break). En ENFORCE au palier SETBACK, la casse est annulée (le bloc
* reste) ; l'expulsion s'applique comme ailleurs. Câblage non testé en jeu.
*/
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onCasse(net.neoforged.neoforge.event.level.BlockEvent.BreakEvent event) {
if (event.getLevel().isClientSide()) return;
if (!(event.getPlayer() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.noterCasse(p, event.getPos(), event.getState())) event.setCanceled(true);
}
/**
* 0.5 (P2.5) : clic droit sur un bloc, les deux mains (un client forgé peut n'envoyer que la main secondaire). Le
* client vanilla envoie main principale puis secondaire au même tick sur le même bloc : compté une fois par le
* moteur, la main secondaire reprenant la décision (annulation) de la principale.
*/
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onClicDroitBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.RightClickBlock event) {
if (event.getLevel().isClientSide()) return;
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.noterInteractionBloc(p, event.getPos(), event.getFace(), event.getHitVec().getLocation(),
event.getHand() == net.minecraft.world.InteractionHand.MAIN_HAND)) {
event.setCanceled(true);
}
}
/** 0.5 (P2.4) : bloc posé par un joueur (fast-place). En ENFORCE au palier SETBACK, la pose est annulée. */
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onPose(net.neoforged.neoforge.event.level.BlockEvent.EntityPlaceEvent event) {
if (event.getLevel().isClientSide()) return;
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.noterPose(p, event.getPos())) event.setCanceled(true);
}
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
@SubscribeEvent
public static void onRelache(LivingEntityUseItemEvent.Stop event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
Garde.noterRelache(p, event.getItem(), event.getDuration());
}
}
/**
* F06 : la grâce de recul ne s'ouvre que si une vitesse est réellement donnée au joueur. Un dégât sans recul
* (feu, cactus, poison, wither, faim, chute : tag vanilla no_knockback) ne déclenche pas knockback().
*/
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onRecul(LivingKnockBackEvent event) {
if (event.isCanceled() || event.getStrength() <= 0.0F) return;
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
Garde.noterRecul(p, false);
// Vanilla retire (ratioX, ratioZ) x force à la vitesse du joueur : il part à l'opposé.
Garde.noterVelocite(p, -event.getRatioX(), -event.getRatioZ(), event.getStrength());
}
}
/** Explosion, charge de vent (Wind Charge) : poussée vers le joueur. Celle qu'il s'inflige est limitée (GraceRecul). */
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onPousseeExplosion(ExplosionKnockbackEvent event) {
if (event.getKnockbackVelocity().lengthSqr() <= 1.0E-6) return;
if (!(event.getAffectedEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
boolean auto = event.getExplosion().getIndirectSourceEntity() == p || event.getExplosion().getDirectSourceEntity() == p;
Garde.noterRecul(p, auto);
Vec3 v = event.getKnockbackVelocity();
Garde.noterVelocite(p, v.x, v.z, Math.hypot(v.x, v.z));
}
/** Fusée de feu d'artifice tirée par un joueur : propulsion en plané, donc plané non contrôlé un moment. */
@SubscribeEvent
public static void onFusee(net.neoforged.neoforge.event.entity.EntityJoinLevelEvent event) {
if (!(event.getEntity() instanceof net.minecraft.world.entity.projectile.FireworkRocketEntity f)) return;
// Champ privé attachedToEntity lu via l'Access Transformer (META-INF/accesstransformer.cfg) : seule une fusée
// attachée au joueur le propulse (FireworkRocketEntity.tick), jamais une fusée d'arbalète ou posée au sol.
if (f.attachedToEntity instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
int ticks = Cablage.graceFusee(true, p.isFallFlying(), event.loadedFromDisk(), f.life, f.lifetime);
if (ticks > 0) Garde.noterFusee(p, ticks);
}
}
/** 0.5 (P3.1) : apparition d'un cristal de l'End (pas un rechargement depuis le disque) : début de son âge. */
@SubscribeEvent
public static void onCristal(net.neoforged.neoforge.event.entity.EntityJoinLevelEvent event) {
if (event.getLevel().isClientSide() || event.loadedFromDisk()) return;
if (event.getEntity() instanceof net.minecraft.world.entity.boss.enderdragon.EndCrystal c && c.getServer() != null) {
Garde.noterCristal(c, c.getServer().getTickCount());
}
}
/** Totem éclaté : début de la mesure du délai de remise (auto-totem). */
@SubscribeEvent
public static void onTotem(net.neoforged.neoforge.event.entity.living.LivingUseTotemEvent event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
Garde.noterTotem(p, event.getHandHolding());
}
}
/** 0.6 (P2.6) : conteneur ouvert / fermé côté serveur (inventaire : réaction, rotation écran ouvert). */
@SubscribeEvent
public static void onOuvertureConteneur(net.neoforged.neoforge.event.entity.player.PlayerContainerEvent.Open event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterConteneur(p, true);
}
@SubscribeEvent
public static void onFermetureConteneur(net.neoforged.neoforge.event.entity.player.PlayerContainerEvent.Close event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterConteneur(p, false);
}
@SubscribeEvent
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.noterConnexion(p); // téléportation + 0.5 (P1.2) grâce de connexion
}
}
@SubscribeEvent
public static void onDeconnexion(PlayerEvent.PlayerLoggedOutEvent event) {
Garde.joueurParti(event.getEntity().getUUID());
}
@SubscribeEvent
public static void onChangementDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
if (event.getEntity() instanceof ServerPlayer p) Garde.noterTeleport(p);
}
@SubscribeEvent
public static void onReapparition(PlayerEvent.PlayerRespawnEvent event) {
if (event.getEntity() instanceof ServerPlayer p) Garde.noterTeleport(p);
}
}